diff --git a/epiphany-core/src/bin/epiphany-repo-tool-request-family-smoke.rs b/epiphany-core/src/bin/epiphany-repo-tool-request-family-smoke.rs new file mode 100644 index 00000000..8774e76d --- /dev/null +++ b/epiphany-core/src/bin/epiphany-repo-tool-request-family-smoke.rs @@ -0,0 +1,407 @@ +use anyhow::Context; +use anyhow::Result; +use anyhow::anyhow; +use chrono::Utc; +use serde_json::Value; +use serde_json::json; +use std::env; +use std::fs; +use std::path::Path; +use std::path::PathBuf; +use std::process::Command; + +fn main() -> Result<()> { + let args = Args::parse()?; + let result = run_smoke(args)?; + println!("{}", serde_json::to_string_pretty(&result)?); + Ok(()) +} + +#[derive(Clone, Debug)] +struct Args { + root: PathBuf, + smoke_root: PathBuf, +} + +impl Args { + fn parse() -> Result { + let mut root = env::current_dir().context("failed to resolve current directory")?; + let mut smoke_root = root.join(".epiphany-smoke"); + let mut args = env::args().skip(1).peekable(); + while let Some(arg) = args.next() { + match arg.as_str() { + "--root" => root = take_path(&mut args, "--root")?, + "--smoke-root" => smoke_root = take_path(&mut args, "--smoke-root")?, + other => return Err(anyhow!("unexpected argument {other:?}")), + } + } + Ok(Self { root, smoke_root }) + } +} + +fn run_smoke(args: Args) -> Result { + let root = args + .root + .canonicalize() + .with_context(|| format!("failed to resolve {}", args.root.display()))?; + let manifest = root.join("epiphany-core").join("Cargo.toml"); + if !manifest.exists() { + return Err(anyhow!( + "could not find epiphany-core manifest at {}", + manifest.display() + )); + } + fs::create_dir_all(&args.smoke_root) + .with_context(|| format!("failed to create {}", args.smoke_root.display()))?; + let stamp = Utc::now().format("%Y%m%d-%H%M%S").to_string(); + let smoke_dir = args + .smoke_root + .join(format!("repo-tool-request-family-{stamp}")); + if smoke_dir.exists() { + fs::remove_dir_all(&smoke_dir) + .with_context(|| format!("failed to clear {}", smoke_dir.display()))?; + } + fs::create_dir_all(&smoke_dir) + .with_context(|| format!("failed to create {}", smoke_dir.display()))?; + + let repo = smoke_dir.join("repo-body"); + fs::create_dir_all(&repo).with_context(|| format!("failed to create {}", repo.display()))?; + git(["init"], &repo)?; + git( + ["config", "user.email", "epiphany-smoke@example.invalid"], + &repo, + )?; + git(["config", "user.name", "Epiphany Smoke"], &repo)?; + fs::write( + repo.join("README.md"), + "# Repo Tool Request Family Smoke\n\nThis repository proves branch-local Epiphany daemon tool request cargo.\n", + ) + .with_context(|| format!("failed to seed {}", repo.join("README.md").display()))?; + git(["add", "README.md"], &repo)?; + git(["commit", "-m", "Seed repo tool request smoke body"], &repo)?; + git(["switch", "-c", "epiphany/repo-tool-request-family"], &repo)?; + + let item = "repo-tool-request-family"; + let target_path = ".epiphany/tool-requests/repo-tool-request-family.toml"; + let local_verse = repo.join(".epiphany").join("local-verse.ccmp"); + cargo_json( + &manifest, + "epiphany-repo", + &[ + "init", + "--workspace", + path_str(&repo)?, + "--epiphany-root", + path_str(&root)?, + "--swarm-id", + "repo-tool-request-family-smoke", + "--topic", + "repo-tool-request-family", + ], + &root, + )?; + cargo_json( + &manifest, + "epiphany-swarm", + &[ + "online", + "--workspace", + path_str(&repo)?, + "--epiphany-root", + path_str(&root)?, + "--runtime-id", + "repo-tool-request-family-smoke", + "--local-verse-store", + path_str(&local_verse)?, + ], + &root, + )?; + cargo_json( + &manifest, + "epiphany-work", + &[ + "accept", + "--workspace", + path_str(&repo)?, + "--from", + "persona", + "--item", + item, + "--summary", + "Request a daemon-hosted tool through CultMesh typed intent and receipt contracts without granting direct execution authority.", + "--candidate-action-ref", + "candidate-action://repo-tool-request-family/daemon-intent", + "--public-discussion-ref", + "eve://epiphany/persona/repo-tool-request-family", + ], + &root, + )?; + let plan = cargo_json( + &manifest, + "epiphany-work", + &[ + "derive-plan", + "--workspace", + path_str(&repo)?, + "--item", + item, + "--action-family", + "repo-tool-request", + "--model-ref", + "repo-tool-request-family-smoke-imagination-v1", + "--model-authored", + ], + &root, + )?; + for _ in 0..4 { + cargo_json( + &manifest, + "epiphany-work", + &[ + "tick", + "--workspace", + path_str(&repo)?, + "--epiphany-root", + path_str(&root)?, + "--item", + item, + "--cooldown-seconds", + "0", + ], + &root, + )?; + } + let close_path = repo + .join(".epiphany") + .join("work") + .join(format!("work-close-{item}.json")); + let close = read_json(&close_path)?; + let request_text = fs::read_to_string(repo.join(target_path)) + .with_context(|| format!("failed to read {}", repo.join(target_path).display()))?; + + require_eq( + &plan, + &["derivation", "safeActionFamily"], + "repo.tool_request", + )?; + require_eq(&close, &["status"], "closed")?; + require_eq(&close, &["soul", "verdict"], "passed")?; + require_eq( + &close, + &["closureReview", "familyAssertions", "status"], + "passed", + )?; + require_bool( + &close, + &["closureReview", "sourceGrounding", "pathScopeMatched"], + true, + )?; + require_bool(&close, &["privateStateExposed"], false)?; + + require_text( + &request_text, + "schema_version = \"epiphany.repo_tool_request.v0\"", + )?; + require_text(&request_text, "safe_action_family = \"repo.tool_request\"")?; + require_text(&request_text, "[request]")?; + require_text( + &request_text, + "target_directory = \"gamecult-local/daemon-tool-directory\"", + )?; + require_text( + &request_text, + "target_capability = \"daemon-tool-capability:selected-by-review\"", + )?; + require_text(&request_text, "operation = \"submitTypedToolIntent\"")?; + require_text(&request_text, "[cultmesh]")?; + require_text( + &request_text, + "intent_contract = \"epiphany.cultmesh.daemon_tool_invocation_intent.v0\"", + )?; + require_text( + &request_text, + "receipt_contract = \"epiphany.cultmesh.daemon_tool_invocation_receipt.v0\"", + )?; + require_text(&request_text, "host_daemon_owns_execution = true")?; + require_text(&request_text, "requester_owns_request = false")?; + require_text(&request_text, "requires_host_liveness_ready = true")?; + require_text(&request_text, "requires_cultmesh_receipts = true")?; + require_text(&request_text, "[odin]")?; + require_text(&request_text, "discoverable = true")?; + require_text(&request_text, "preserves_provider_ownership = true")?; + require_text(&request_text, "private_verse_passthrough = false")?; + require_text(&request_text, "[authority]")?; + require_text(&request_text, "direct_tool_execution = false")?; + require_text(&request_text, "arbitrary_shell_authority = false")?; + require_text(&request_text, "hands_action_authority = false")?; + require_text(&request_text, "state_commit_authority = false")?; + require_text(&request_text, "publication_authority = false")?; + require_text(&request_text, "service_lifecycle_authority = false")?; + require_text(&request_text, "cross_body_mutation_authority = false")?; + require_text(&request_text, "private_verse_rummaging = false")?; + require_text(&request_text, "private_state_exposed = false")?; + + let summary = json!({ + "schemaVersion": "epiphany.repo_work_tool_request_family_smoke.v0", + "status": "ok", + "smokeDir": smoke_dir, + "repo": repo, + "branch": git_output(["branch", "--show-current"], &repo)?, + "item": item, + "safeActionFamily": plan["derivation"]["safeActionFamily"], + "targetPath": target_path, + "closeStatus": close["status"], + "soulVerdict": close["soul"]["verdict"], + "familyAssertionsStatus": close["closureReview"]["familyAssertions"]["status"], + "pathScopeMatched": close["closureReview"]["sourceGrounding"]["pathScopeMatched"], + "hasCultMeshContracts": true, + "hostDaemonOwnsExecution": true, + "odinPreservesProviderOwnership": true, + "directToolExecution": false, + "arbitraryShellAuthority": false, + "handsActionAuthority": false, + "stateCommitAuthority": false, + "publicationAuthority": false, + "serviceLifecycleAuthority": false, + "crossBodyMutationAuthority": false, + "privateVerseRummaging": false, + "privateStateExposed": false, + }); + write_json(&smoke_dir.join("summary.json"), &summary)?; + Ok(summary) +} + +fn cargo_json(manifest: &Path, bin: &str, args: &[&str], cwd: &Path) -> Result { + let output = Command::new("cargo") + .arg("run") + .arg("--quiet") + .arg("--manifest-path") + .arg(manifest) + .arg("--bin") + .arg(bin) + .arg("--") + .args(args) + .current_dir(cwd) + .output() + .with_context(|| format!("failed to run cargo bin {bin}"))?; + if !output.status.success() { + return Err(anyhow!( + "{bin} failed with status {:?}\nstdout:\n{}\nstderr:\n{}", + output.status.code(), + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + )); + } + serde_json::from_slice(&output.stdout).with_context(|| { + format!( + "{bin} did not emit JSON on stdout:\n{}", + String::from_utf8_lossy(&output.stdout) + ) + }) +} + +fn git(args: [&str; N], cwd: &Path) -> Result<()> { + let output = Command::new("git") + .args(args) + .current_dir(cwd) + .output() + .with_context(|| format!("failed to run git in {}", cwd.display()))?; + if output.status.success() { + Ok(()) + } else { + Err(anyhow!( + "git failed in {} with status {:?}\nstdout:\n{}\nstderr:\n{}", + cwd.display(), + output.status.code(), + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + )) + } +} + +fn git_output(args: [&str; N], cwd: &Path) -> Result { + let output = Command::new("git") + .args(args) + .current_dir(cwd) + .output() + .with_context(|| format!("failed to run git in {}", cwd.display()))?; + if output.status.success() { + Ok(String::from_utf8_lossy(&output.stdout).trim().to_string()) + } else { + Err(anyhow!( + "git failed in {} with status {:?}\nstdout:\n{}\nstderr:\n{}", + cwd.display(), + output.status.code(), + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + )) + } +} + +fn read_json(path: &Path) -> Result { + let bytes = fs::read(path).with_context(|| format!("failed to read {}", path.display()))?; + serde_json::from_slice(&bytes).with_context(|| format!("failed to parse {}", path.display())) +} + +fn write_json(path: &Path, value: &Value) -> Result<()> { + if let Some(parent) = path.parent() { + fs::create_dir_all(parent) + .with_context(|| format!("failed to create {}", parent.display()))?; + } + fs::write(path, serde_json::to_vec_pretty(value)?) + .with_context(|| format!("failed to write {}", path.display())) +} + +fn require_eq(value: &Value, path: &[&str], expected: &str) -> Result<()> { + let actual = path + .iter() + .try_fold(value, |current, key| current.get(*key)) + .and_then(Value::as_str) + .unwrap_or(""); + if actual == expected { + Ok(()) + } else { + Err(anyhow!( + "expected {} to be {expected:?}, got {actual:?}", + path.join(".") + )) + } +} + +fn require_bool(value: &Value, path: &[&str], expected: bool) -> Result<()> { + let actual = path + .iter() + .try_fold(value, |current, key| current.get(*key)) + .and_then(Value::as_bool); + if actual == Some(expected) { + Ok(()) + } else { + Err(anyhow!( + "expected {} to be {expected}, got {:?}", + path.join("."), + actual + )) + } +} + +fn require_text(haystack: &str, needle: &str) -> Result<()> { + if haystack.contains(needle) { + Ok(()) + } else { + Err(anyhow!("expected tool request text to contain {needle:?}")) + } +} + +fn take_path( + args: &mut std::iter::Peekable>, + flag: &str, +) -> Result { + args.next() + .map(PathBuf::from) + .with_context(|| format!("missing value for {flag}")) +} + +fn path_str(path: &Path) -> Result<&str> { + path.to_str() + .ok_or_else(|| anyhow!("path is not valid UTF-8: {}", path.display())) +} diff --git a/epiphany-core/src/bin/epiphany-work.rs b/epiphany-core/src/bin/epiphany-work.rs index 81acb316..ef2b4cfd 100644 --- a/epiphany-core/src/bin/epiphany-work.rs +++ b/epiphany-core/src/bin/epiphany-work.rs @@ -1933,6 +1933,10 @@ fn derive_safe_plan_family(input: DeriveSafePlanInput<'_>) -> Result { derive_repo_tool_capabilities_plan(input, &action_family) } + "repo-tool-request" + | "tool-request" + | "daemon-tool-request" + | "repo-daemon-tool-request" => derive_repo_tool_request_plan(input, &action_family), "repo-eve-surface" | "eve-surface" | "cultui-surface" | "tui-surface" => { derive_repo_eve_surface_plan(input, &action_family) } @@ -1984,7 +1988,7 @@ fn derive_safe_plan_family(input: DeriveSafePlanInput<'_>) -> Result Err(anyhow!( - "unsupported derive-plan action family {other:?}; supported families are append-worklog, planning-note, checklist-note, section-note, repo-status-section, task-card, repo-manifest, repo-tool-capabilities, repo-eve-surface, repo-collaboration-policy, repo-collaboration-topic, repo-consensus-brief, repo-objective-draft, repo-adoption-request, repo-scheduling-request, repo-work-order, repo-verification-request, repo-publication-request, repo-sync-request, repo-maintainer-review-request, repo-pr-request, repo-credit-request, repo-artifact-acceptance-request, and repo-metrics-request" + "unsupported derive-plan action family {other:?}; supported families are append-worklog, planning-note, checklist-note, section-note, repo-status-section, task-card, repo-manifest, repo-tool-capabilities, repo-tool-request, repo-eve-surface, repo-collaboration-policy, repo-collaboration-topic, repo-consensus-brief, repo-objective-draft, repo-adoption-request, repo-scheduling-request, repo-work-order, repo-verification-request, repo-publication-request, repo-sync-request, repo-maintainer-review-request, repo-pr-request, repo-credit-request, repo-artifact-acceptance-request, and repo-metrics-request" )), } } @@ -2600,6 +2604,123 @@ fn derive_repo_tool_capabilities_plan( }) } +fn derive_repo_tool_request_plan( + input: DeriveSafePlanInput<'_>, + action_family: &str, +) -> Result { + let item_slug = sanitize(input.item); + let default_target = format!(".epiphany/tool-requests/{item_slug}.toml"); + let target_path = validate_toml_target_path(input.target_path.unwrap_or(&default_target))?; + let candidate_refs = + string_array_from_json(input.accept_receipt, &["feedback", "candidateActionRefs"]); + let public_refs = + string_array_from_json(input.accept_receipt, &["feedback", "publicDiscussionRefs"]); + let now = Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true); + let request_id = format!("repo-tool-request:{item_slug}"); + let requester_body = format!("repo:{item_slug}"); + let intent_contract = "epiphany.cultmesh.daemon_tool_invocation_intent.v0"; + let receipt_contract = "epiphany.cultmesh.daemon_tool_invocation_receipt.v0"; + let lines = vec![ + "# Epiphany repo daemon tool request.".to_string(), + "# Branch-local request cargo; CultMesh carries intent and receipts, host daemons own execution.".to_string(), + format!( + "schema_version = {}", + toml_basic_string("epiphany.repo_tool_request.v0") + ), + format!("item = {}", toml_basic_string(input.item)), + format!("created_at = {}", toml_basic_string(&now)), + format!("source = {}", toml_basic_string(input.source)), + format!("summary = {}", toml_basic_string(&compact_line(input.summary))), + format!( + "safe_action_family = {}", + toml_basic_string("repo.tool_request") + ), + format!("model_authored = {}", input.model_authored), + format!( + "model_ref = {}", + toml_basic_string(input.model_ref.unwrap_or("deterministic-fallback")) + ), + "operator_authored_shell_details = false".to_string(), + "hands_authority_granted = false".to_string(), + "durable_state_admitted = false".to_string(), + "publication_authorized = false".to_string(), + "merge_authorized = false".to_string(), + "service_lifecycle_authority = false".to_string(), + "cross_repo_mutation = false".to_string(), + "private_state_exposed = false".to_string(), + format!("candidate_action_refs = {}", toml_array(&candidate_refs)), + format!("public_discussion_refs = {}", toml_array(&public_refs)), + String::new(), + "[request]".to_string(), + format!("id = {}", toml_basic_string(&request_id)), + format!("requester_body = {}", toml_basic_string(&requester_body)), + "requesting_agent = \"repo Persona/Self\"".to_string(), + "target_directory = \"gamecult-local/daemon-tool-directory\"".to_string(), + "target_capability = \"daemon-tool-capability:selected-by-review\"".to_string(), + "operation = \"submitTypedToolIntent\"".to_string(), + String::new(), + "[cultmesh]".to_string(), + format!( + "intent_contract = {}", + toml_basic_string(intent_contract) + ), + format!( + "receipt_contract = {}", + toml_basic_string(receipt_contract) + ), + "host_daemon_owns_execution = true".to_string(), + "requester_owns_request = false".to_string(), + "requires_host_liveness_ready = true".to_string(), + "requires_cultmesh_receipts = true".to_string(), + String::new(), + "[odin]".to_string(), + "discoverable = true".to_string(), + "preserves_provider_ownership = true".to_string(), + "private_verse_passthrough = false".to_string(), + String::new(), + "[authority]".to_string(), + "direct_tool_execution = false".to_string(), + "arbitrary_shell_authority = false".to_string(), + "hands_action_authority = false".to_string(), + "state_commit_authority = false".to_string(), + "publication_authority = false".to_string(), + "service_lifecycle_authority = false".to_string(), + "cross_body_mutation_authority = false".to_string(), + "private_verse_rummaging = false".to_string(), + String::new(), + "[verification]".to_string(), + "asks = [".to_string(), + " \"Soul verifies the tool request path changed and contains the accepted pressure summary.\",".to_string(), + " \"Soul verifies the request names CultMesh intent and receipt contracts without executing the tool.\",".to_string(), + " \"Soul verifies host daemon ownership, Odin provider ownership, and private-state seals remain intact.\"".to_string(), + "]".to_string(), + String::new(), + "[rollback]".to_string(), + "hints = [\"Remove the repo tool request if the accepted pressure was misderived or targets the wrong daemon capability.\"]".to_string(), + String::new(), + ]; + let command = powershell_set_lines_command(&target_path, &lines); + Ok(DerivedSafePlan { + safe_action_family: "repo.tool_request".to_string(), + target_path, + plan_summary: format!( + "Imagination derived a daemon-hosted tool request from accepted {} pressure.", + input.source + ), + command, + commit_message: format!("Add repo tool request for work item {}", input.item), + verification_asks: vec![ + "Soul verifies the repo tool request path changed and contains the accepted pressure summary.".to_string(), + "Soul verifies the request names CultMesh typed invocation contracts while leaving execution with host daemons.".to_string(), + "Soul verifies no execution, lifecycle, publication, cross-body, or private-rummaging authority was granted.".to_string(), + ], + rollback_hints: vec![ + "Remove the generated repo tool request if the accepted pressure was misinterpreted or targets the wrong daemon capability.".to_string(), + ], + derivation: plan_derivation_receipt(input, action_family, "repo.tool_request"), + }) +} + fn derive_repo_eve_surface_plan( input: DeriveSafePlanInput<'_>, action_family: &str, @@ -4992,6 +5113,84 @@ fn closure_family_assertions( "Committed tool capability manifest preserves the private-state seal.".to_string(), ); } + "repo.tool_request" => { + push_assertion( + &mut assertions, + "tool-request-schema-present", + content.contains("schema_version = \"epiphany.repo_tool_request.v0\""), + "Committed tool request carries the schema version.".to_string(), + ); + push_assertion( + &mut assertions, + "tool-request-family-present", + content.contains("safe_action_family = \"repo.tool_request\""), + "Committed tool request carries the safe action family.".to_string(), + ); + push_assertion( + &mut assertions, + "tool-request-summary-present", + content.contains(&compact_summary), + "Committed tool request contains the accepted pressure summary.".to_string(), + ); + push_assertion( + &mut assertions, + "tool-request-section-present", + content.contains("[request]") + && content.contains("target_directory = \"gamecult-local/daemon-tool-directory\"") + && content.contains( + "target_capability = \"daemon-tool-capability:selected-by-review\"", + ) + && content.contains("operation = \"submitTypedToolIntent\""), + "Committed tool request names the daemon tool directory and typed intent operation." + .to_string(), + ); + push_assertion( + &mut assertions, + "tool-request-cultmesh-contracts", + content.contains("[cultmesh]") + && content.contains( + "intent_contract = \"epiphany.cultmesh.daemon_tool_invocation_intent.v0\"", + ) + && content.contains( + "receipt_contract = \"epiphany.cultmesh.daemon_tool_invocation_receipt.v0\"", + ) + && content.contains("host_daemon_owns_execution = true") + && content.contains("requester_owns_request = false") + && content.contains("requires_host_liveness_ready = true") + && content.contains("requires_cultmesh_receipts = true"), + "Committed tool request names typed CultMesh contracts, host liveness, and host execution ownership.".to_string(), + ); + push_assertion( + &mut assertions, + "tool-request-odin-provider-ownership", + content.contains("[odin]") + && content.contains("discoverable = true") + && content.contains("preserves_provider_ownership = true") + && content.contains("private_verse_passthrough = false"), + "Committed tool request preserves Odin discovery and provider ownership boundaries." + .to_string(), + ); + push_assertion( + &mut assertions, + "tool-request-authority-seals", + content.contains("[authority]") + && content.contains("direct_tool_execution = false") + && content.contains("arbitrary_shell_authority = false") + && content.contains("hands_action_authority = false") + && content.contains("state_commit_authority = false") + && content.contains("publication_authority = false") + && content.contains("service_lifecycle_authority = false") + && content.contains("cross_body_mutation_authority = false") + && content.contains("private_verse_rummaging = false"), + "Committed tool request denies direct execution, shell, Hands, state, publication, lifecycle, cross-body, and private-rummaging authority.".to_string(), + ); + push_assertion( + &mut assertions, + "tool-request-private-seal", + content.contains("private_state_exposed = false"), + "Committed tool request preserves the private-state seal.".to_string(), + ); + } "repo.eve_surface" => { push_assertion( &mut assertions, @@ -10509,7 +10708,7 @@ fn print_usage() { "usage: epiphany-work ...\n\ persona-intake --workspace --item --message [--topic ] [--store ] [--runtime-id ]\n\ accept --workspace --from --item [--summary ] [--topic ] [--store ] [--runtime-id ] [--online-receipt ] [--public-discussion-ref ] [--candidate-action-ref ]\n\ - derive-plan --workspace [--item ] [--accept-receipt ] [--action-family append-worklog|planning-note|checklist-note|section-note|repo-status-section|task-card|repo-manifest|repo-tool-capabilities|repo-eve-surface|repo-collaboration-policy|repo-collaboration-topic|repo-consensus-brief|repo-objective-draft|repo-adoption-request|repo-scheduling-request|repo-work-order|repo-verification-request|repo-publication-request|repo-sync-request|repo-maintainer-review-request|repo-pr-request|repo-credit-request|repo-artifact-acceptance-request|repo-metrics-request] [--target-path ] [--model-ref ] [--model-authored] [--action-summary ] [--verification-ask ] [--stop-condition ] [--escalation-reason ] [--assumption ] [--constraint ] [--non-goal ] [--open-question ] [--decision-point ] [--evidence-need ]\n\ + derive-plan --workspace [--item ] [--accept-receipt ] [--action-family append-worklog|planning-note|checklist-note|section-note|repo-status-section|task-card|repo-manifest|repo-tool-capabilities|repo-tool-request|repo-eve-surface|repo-collaboration-policy|repo-collaboration-topic|repo-consensus-brief|repo-objective-draft|repo-adoption-request|repo-scheduling-request|repo-work-order|repo-verification-request|repo-publication-request|repo-sync-request|repo-maintainer-review-request|repo-pr-request|repo-credit-request|repo-artifact-acceptance-request|repo-metrics-request] [--target-path ] [--model-ref ] [--model-authored] [--action-summary ] [--verification-ask ] [--stop-condition ] [--escalation-reason ] [--assumption ] [--constraint ] [--non-goal ] [--open-question ] [--decision-point ] [--evidence-need ]\n\ plan --workspace [--item ] --objective --plan-summary --command --changed-path --commit-message [--adoption-evidence-ref ]\n\ run --workspace [--item ] [--accept-receipt ] [--runtime-store ] [--requested-path ]\n\ adopt --workspace [--item ] [--run-receipt ] [--from-plan ] [--plan-summary ] [--adoption-evidence-ref ] [--mind-adoption-rationale ]\n\ diff --git a/notes/epiphany-repo-swarm-mvp-contract.md b/notes/epiphany-repo-swarm-mvp-contract.md index 7a7e48af..c7f0ee6b 100644 --- a/notes/epiphany-repo-swarm-mvp-contract.md +++ b/notes/epiphany-repo-swarm-mvp-contract.md @@ -267,6 +267,13 @@ capability manifest, defaulting to `.epiphany/repo-tool-capabilities.toml`, with local CultMesh/Odin discovery flags, typed daemon tool invocation intent/receipt contracts, expected repo-swarm capability ids, host-daemon execution ownership, Idunn lifecycle ownership, and authority seals; and +`--action-family repo-tool-request` writes a structured daemon-hosted tool +request under `.epiphany/tool-requests/.toml`, naming the local +CultMesh/Odin tool directory, selected daemon capability, typed invocation +intent/receipt contracts, host-daemon execution ownership, host liveness/readiness +requirements, and authority seals that forbid direct execution, shell, Hands, +state, publication, service lifecycle, cross-body, and private-rummaging +authority; and `--action-family repo-collaboration-policy` writes a structured repo collaboration policy, defaulting to `.epiphany/collaboration-policy.toml`, with private/local/public Verse boundaries, Odin discovery, Eve connection @@ -340,7 +347,7 @@ or cross-body authority. Its receipt includes `epiphany.repo_work_plan_derivation.v0`, mode `append-worklog`, `planning-note`, `checklist-note`, `section-note`, `repo-status-section`, or `task-card`, `repo-manifest`, `repo-tool-capabilities`, -`repo-collaboration-policy`, or `repo-collaboration-topic`, +`repo-tool-request`, `repo-collaboration-policy`, or `repo-collaboration-topic`, `repo-consensus-brief`, `repo-objective-draft`, or `repo-adoption-request`, `repo-scheduling-request`, `repo-work-order`, or `repo-verification-request`, `repo-publication-request`, `repo-sync-request`, or @@ -1394,7 +1401,7 @@ temptation wearing clean robes. | Repo Body birth | `epiphany-repo init` exists and writes repo-local stores plus branch workbench intent. | Keep birth startup-only, review-gated, and branch-oriented. | | Local Verse online | `epiphany-swarm online` seeds repo-local CultMesh, standing-faculty SoA, topology, liveness, Eve, and tool sight. | Keep private Verse sealed while exposing operator-safe repo status. | | Persona/Bifrost intake | `epiphany-work accept` records pressure and candidate action refs without Hands authority. `epiphany-work persona-intake` now invokes the Persona bubble speech-audit path, records public discussion and candidate-action refs, then delegates to `accept`; wrapper mode `repo-persona-intake` exposes the operator mouth. | Deepen the intake-to-Imagination interpreter so richer model-authored action items can be proposed without granting Hands, publication, or durable-state authority at the mouth edge. | -| Imagination planning | `derive-plan` now writes a typed `epiphany.repo_work_imagination_action_items_receipt.v0` before the executable plan receipt. The action-item receipt can carry model provenance, allowed safe family, requested paths, verification asks, stop conditions, escalation reasons, planning facets (assumptions, constraints, non-goals, open questions, decision points, and evidence needs), and private-state seals; command text remains deterministic safe-family lowering for `append-worklog`, `planning-note`, `checklist-note`, `section-note` / `repo.markdown_managed_section`, `repo-status-section` / `repo.status_section`, `task-card` / `repo.task_card`, `repo-manifest` / `repo.body_manifest`, `repo-tool-capabilities` / `repo.tool_capabilities`, `repo-eve-surface` / `repo.eve_surface`, `repo-collaboration-policy` / `repo.collaboration_policy`, `repo-collaboration-topic` / `repo.collaboration_topic`, `repo-consensus-brief` / `repo.consensus_brief`, `repo-objective-draft` / `repo.objective_draft`, `repo-adoption-request` / `repo.adoption_request`, `repo-scheduling-request` / `repo.scheduling_request`, `repo-work-order` / `repo.work_order`, `repo-verification-request` / `repo.verification_request`, `repo-publication-request` / `repo.publication_request`, `repo-sync-request` / `repo.sync_request`, `repo-maintainer-review-request` / `repo.maintainer_review_request`, `repo-pr-request` / `repo.pr_request`, `repo-credit-request` / `repo.credit_request`, `repo-artifact-acceptance-request` / `repo.artifact_acceptance_request`, and `repo-metrics-request` / `repo.metrics_request`. `adopt` now writes `epiphany.repo_work_mind_adoption_decision.v0` before the main adoption receipt cites the decision and grants branch-local Hands authority. `plan` remains manual quarantine scaffolding. | Deepen further interpreter behavior and useful repo-owned configuration/action classes without turning model text into arbitrary shell authority. | +| Imagination planning | `derive-plan` now writes a typed `epiphany.repo_work_imagination_action_items_receipt.v0` before the executable plan receipt. The action-item receipt can carry model provenance, allowed safe family, requested paths, verification asks, stop conditions, escalation reasons, planning facets (assumptions, constraints, non-goals, open questions, decision points, and evidence needs), and private-state seals; command text remains deterministic safe-family lowering for `append-worklog`, `planning-note`, `checklist-note`, `section-note` / `repo.markdown_managed_section`, `repo-status-section` / `repo.status_section`, `task-card` / `repo.task_card`, `repo-manifest` / `repo.body_manifest`, `repo-tool-capabilities` / `repo.tool_capabilities`, `repo-tool-request` / `repo.tool_request`, `repo-eve-surface` / `repo.eve_surface`, `repo-collaboration-policy` / `repo.collaboration_policy`, `repo-collaboration-topic` / `repo.collaboration_topic`, `repo-consensus-brief` / `repo.consensus_brief`, `repo-objective-draft` / `repo.objective_draft`, `repo-adoption-request` / `repo.adoption_request`, `repo-scheduling-request` / `repo.scheduling_request`, `repo-work-order` / `repo.work_order`, `repo-verification-request` / `repo.verification_request`, `repo-publication-request` / `repo.publication_request`, `repo-sync-request` / `repo.sync_request`, `repo-maintainer-review-request` / `repo.maintainer_review_request`, `repo-pr-request` / `repo.pr_request`, `repo-credit-request` / `repo.credit_request`, `repo-artifact-acceptance-request` / `repo.artifact_acceptance_request`, and `repo-metrics-request` / `repo.metrics_request`. `adopt` now writes `epiphany.repo_work_mind_adoption_decision.v0` before the main adoption receipt cites the decision and grants branch-local Hands authority. `plan` remains manual quarantine scaffolding. | Deepen further interpreter behavior and useful repo-owned configuration/action classes without turning model text into arbitrary shell authority. | | Self scheduling | `tick` and `serve` prove one-step branch-local advancement, brake refusal, active-turn refusal, cooldown, and stale-turn recovery; `tick` now routes executed branch-local work through the existing Soul/Modeling/Mind `close` gate; `queue-run` selects tick-actionable rows from the typed repo-work queue and delegates to `tick`; `epiphany-swarm run` is the bounded operator mouth over that queue/tick physiology; `repo-work-service-plan` and `repo-work-service-runbook` write Idunn lifecycle receipts/artifacts for the same queue-run command without launching it. | Keep any future queue-run service launch/install behind Idunn and explicit operator authority. | | Branch-local Hands work | `adopt` and `execute` create approved Hands gates, run planned commands, stage declared paths, commit on `epiphany/*`, and write receipts. | Keep mutation branch-contained and receipt-backed; broaden only through typed plan families, not ad hoc shell freedom. | | Soul/Modeling/Mind closure | `close` verifies the Hands commit, writes `epiphany.repo_work_closure_review.v0`, refuses path-scope mismatches, and writes Soul, Modeling, and Mind receipts. | Deepen model-authored closure review beyond the first structured closure-review packet while preserving deterministic local closure for simple mechanical work. | @@ -1676,6 +1683,11 @@ Required organs before MVP: tool capability cargo with CultMesh/Odin discovery, typed daemon tool invocation intent/receipt contracts, expected capability ids, host-daemon execution ownership, Idunn lifecycle ownership, and authority seals. + `repo-tool-request` now proves daemon-hosted tool request cargo with CultMesh + typed invocation intent/receipt contracts, host-daemon execution ownership, + host liveness/readiness requirements, Odin provider ownership, and denied + direct execution, shell, Hands, state, publication, service lifecycle, + cross-body, and private-rummaging authority. `repo-collaboration-topic` now proves public collaboration cargo with public Persona room, Eve surface, Imagination consensus route, non-authoritative candidate actions, Mind/Bifrost gates, and denied action/cross-body authority. @@ -1761,6 +1773,14 @@ Required organs before MVP: rummaging, or private-state exposure authority. Smoke `.epiphany-smoke\repo-collaboration-policy-family-20260620-172808` proved the policy closes through Soul with family assertions and path scope passing. + `repo-tool-request` now proves daemon-hosted request cargo under + `.epiphany/tool-requests/.toml`, with CultMesh invocation + intent/receipt contracts, host liveness/readiness requirements, Odin provider + ownership, and no direct tool execution, shell, Hands, state, publication, + service lifecycle, cross-body mutation, private Verse rummaging, or + private-state exposure authority. Smoke + `.epiphany-smoke\repo-tool-request-family-20260620-174500` proved the request + closes through Soul with family assertions and path scope passing. Remaining work is later model-authored action classes that can change more useful repo-owned configuration, plus deeper interpreter semantics after Mind adoption, without arbitrary shell authority. diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 3756de13..3b7a0608 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -122,6 +122,7 @@ remembers doctrine; the branch remembers the blade. - 2026-06-20: Mind adoption/interpreter depth now has a concrete receipt. `epiphany-work adopt` writes `epiphany.repo_work_mind_adoption_decision.v0` before the main adoption receipt, records Self presentation, Mind evidence review, safe-family requirement, branch-local scope, Bifrost publication gate, Soul closure requirement, and no Hands/durable-state/publication/merge/service/cross-body/private authority inside the Mind decision; the main adoption receipt cites that decision before granting branch-local Hands authority. Focused smoke `.epiphany-smoke\repo-planning-facets-20260620-171324` proves model-authored planning facets survive into Imagination, plan derivation, Mind decision, and adoption, while close still passes Soul/family/path checks with `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter semantics beyond the first Mind decision packet, more useful repo-owned configuration/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. - 2026-06-20: `repo-manifest` is now the next non-planning safe family. `epiphany-work derive-plan --action-family repo-manifest` lowers accepted pressure into a structured `epiphany.toml` Body manifest with safe family `repo.body_manifest`, body domain, private/local/public Verse ids, Eve surface id, receipt-required capability hints, arbitrary shell sealed false, and private-state seals. Soul closure assertions now inspect the committed manifest for schema, safe family, summary, body domain, Verse ids, Eve surface, receipt requirement, no arbitrary shell, and private-state seals. Focused smoke `.epiphany-smoke\repo-manifest-family-20260620-141552` ran a disposable repo through init -> online -> accept -> repo-manifest derive-plan -> tick run/adopt/execute/close; Hands committed only `epiphany.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter/adoption semantics, additional useful repo-owned config/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. - 2026-06-20: `repo-tool-capabilities` is now live as repo-owned tool capability configuration cargo. `epiphany-work derive-plan --action-family repo-tool-capabilities` writes `.epiphany/repo-tool-capabilities.toml` with safe family `repo.tool_capabilities`, local CultMesh/Odin discovery flags, daemon tool invocation intent/receipt contracts, expected repo-swarm capability ids, host-daemon execution ownership, Idunn lifecycle ownership, and authority seals for no shell/deploy/service/private-rummaging authority. Soul closure assertions inspect schema, family, summary, tool directory, contracts, expected capability ids, host receipt requirement, authority seals, and private-state seal. Focused smoke `.epiphany-smoke\repo-tool-capabilities-family-20260620-142430` ran init -> online -> accept -> repo-tool-capabilities derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/repo-tool-capabilities.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `hostDaemonOwnsExecution=true`, `idunnOwnsLifecycle=true`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter/adoption semantics, more useful repo-owned configuration/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. +- 2026-06-20: `repo-tool-request` is now live as daemon-hosted tool request cargo. `epiphany-work derive-plan --action-family repo-tool-request` writes `.epiphany/tool-requests/.toml` with safe family `repo.tool_request`, local CultMesh/Odin daemon tool directory, selected-by-review target capability, typed daemon tool invocation intent/receipt contracts, host-daemon execution ownership, host liveness/readiness requirements, Odin provider ownership, and seals denying direct tool execution, arbitrary shell, Hands action, state commit, publication, service lifecycle, cross-body mutation, private Verse rummaging, and private-state exposure. Focused smoke `.epiphany-smoke\repo-tool-request-family-20260620-174500` ran init -> online -> accept -> repo-tool-request derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/tool-requests/repo-tool-request-family.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `hostDaemonOwnsExecution=true`, `odinPreservesProviderOwnership=true`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter semantics, more useful repo-owned configuration/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. - 2026-06-20: `repo-collaboration-topic` is now live as public collaboration planning cargo. `epiphany-work derive-plan --action-family repo-collaboration-topic` writes `.epiphany/collaboration-topics/.toml` with safe family `repo.collaboration_topic`, public Persona collaboration room, Eve surface, Imagination consensus route, non-authoritative candidate action semantics, Mind/Bifrost gates, and seals against adoption/action/publication/cross-body/private-rummaging authority. Soul closure assertions inspect schema, family, summary, topic surface, Imagination route, authority seals, and private-state seal. Focused smoke `.epiphany-smoke\repo-collaboration-topic-family-20260620-143342` ran init -> online -> accept -> repo-collaboration-topic derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/collaboration-topics/repo-collaboration-topic-family.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `candidateActionsNonAuthoritative=true`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter/adoption semantics, more useful repo-owned configuration/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. - 2026-06-20: `repo-consensus-brief` is now live as draft Imagination consensus cargo. `epiphany-work derive-plan --action-family repo-consensus-brief` writes `.epiphany/consensus-briefs/.toml` with safe family `repo.consensus_brief`, draft consensus state, public discussion refs, candidate action refs, non-authoritative candidate action semantics, review requirement, Mind/Bifrost gates, and seals against objective adoption, Hands action, publication, cross-body mutation, and private Verse rummaging. Soul closure assertions inspect schema, family, summary, draft state, Imagination route, public/candidate inputs, authority gates, and private-state seal. Focused smoke `.epiphany-smoke\repo-consensus-brief-family-20260620-144212` ran init -> online -> accept -> repo-consensus-brief derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/consensus-briefs/repo-consensus-brief-family.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `candidateActionsNonAuthoritative=true`, `mindAdoptionRequired=true`, `bifrostPublicationRequired=true`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter/adoption semantics, more useful repo-owned configuration/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. - 2026-06-20: `repo-objective-draft` is now live as review-required Objective Draft cargo. `epiphany-work derive-plan --action-family repo-objective-draft` writes `.epiphany/objective-drafts/.toml` with safe family `repo.objective_draft`, draft status `review-required`, `objective_adopted=false`, objective statement, acceptance criteria, public/candidate refs, and Mind/Self/Bifrost gates before adoption, scheduling, or publication. Soul closure assertions inspect schema, family, summary, draft review state, acceptance criteria, inputs, authority gates, and private-state seal. Focused smoke `.epiphany-smoke\repo-objective-draft-family-20260620-145012` ran init -> online -> accept -> repo-objective-draft derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/objective-drafts/repo-objective-draft-family.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `draftReviewRequired=true`, `objectiveAdopted=false`, `mindAdoptionRequired=true`, `selfSchedulingAuthorized=false`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter/adoption semantics, more useful repo-owned configuration/action families, and Idunn-owned queue-run service lifecycle under explicit operator authority. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 88e6656c..03ffd0de 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index 92c19f3b..afcfbdc9 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -88,7 +88,7 @@ active_subgoals: - Keep the landed Phase 6 coordinator, limited safe-boundary CRRC automation, and pre-compaction checkpoint intervention ready for the next bridge-equipped dogfood run. - Preserve the Ghostlight-derived heartbeat initiative seam: every lane, including coordinator/Self and Persona, has a organ-state record and competes for heartbeat slots through readiness/reaction timing; initiative heat can raise or cool global, group, arena, role, and agent tempo through typed heartbeat policy; active thinking freezes initiative until completion, so heat never queues a lane already mid-turn; idle winners ruminate instead of inventing project work, and sleep windows distill the accumulated thought pressure into reviewed self-memory or doctrine. - Use `notes/epiphany-swarm-readiness-plan.md` as the live-fire direction gate. The local run path is a compass, not launch clearance: before unattended swarm operation, Epiphany needs typed pause/brake enforcement, one initiative scheduler, completion-gated cooldown, stale active-turn recovery receipts, parent-side Persona speech eligibility, memory lifecycle operations, and CultNet-first operator snapshots/intents/receipts. The local Verse brake document exists, `epiphany-verse-query swarm-brake` can engage/release it, `tools/epiphany_local_run.ps1` refuses live `plan`/`run`/`mvp` modes when the brake is engaged while leaving `status` readable, `epiphany-mvp-coordinator` checks the local Verse brake before app-server startup, and `epiphany-heartbeat-store` guards tick/pump/heat/queue-mention/routine when given `--local-verse-store`. Daemon liveness is now a typed local Verse authority: `epiphany-verse-query daemon-status` writes one daemon status without repainting the table, local Verse seeding preserves existing daemon statuses and swarm brakes, `invoke-tool` refuses when the host daemon is not ready or lacks `submitTypedToolIntent`, and both daemon tool invocation and lifecycle poke fail closed under an engaged matching brake. `epiphany-daemon-supervisor policy` writes durable per-daemon restart policy with command/args/cwd/cooldown/backoff/attempt state plus reconcile cadence and stale-heartbeat threshold; `epiphany-daemon-supervisor reconcile` loads that policy when no override command is supplied, refuses under a matching lifecycle brake, refuses during cooldown/backoff, writes daemon poke intent/receipt, updates daemon status, and updates policy attempt state; `epiphany-daemon-supervisor tick` is an explicit scheduler pulse that scans durable policies, records ready/noop pulses, skips before the configured reconcile interval, marks stale heartbeat status degraded, routes restarts through the same brake/cooldown/poke receipt path, and writes a latest `epiphany.cultmesh.daemon_scheduler_receipt.v0`; `epiphany-daemon-supervisor serve` runs that same pulse on a configurable cadence with bounded `--max-iterations` proof mode or unbounded service mode. `epiphany-daemon-supervisor service-plan`/`install-service` now writes a planned `epiphany.cultmesh.daemon_service_lifecycle_receipt.v0` for the `serve` command, while `service-launch`/`start-service` spawns that `serve` loop through the current executable or `--service-command`, can `--wait-child` for bounded proof, and records command/args/cwd, scheduler id, daemon selector, pid/exit/status, artifact ref, and private-state guard. `service-runbook`, `windows-service-install`/`service-install-plan`, `windows-service-status`, `windows-service-reconcile`, `windows-service-execution-readiness`, and `windows-service-start`/`stop` now record service lifecycle receipts through the same local Verse; the read-only status path has been proved against the real Windows `EventLog` service with receipt `daemon-service-lifecycle-receipt-windows-eventlog-proof-windows-service-status`, status `running`, exit code `0`, and `privateStateExposed=false`; the read-only service-policy reconciliation path has been proved for missing service, real-service drift against `EventLog`, lifecycle-brake refusal, and wrapper/local-Verse receipt `daemon-service-lifecycle-receipt-windows-eventlog-reconcile-proof-windows-service-reconcile`; execution readiness has been proved as a non-mutating `not-elevated` receipt through direct and wrapper paths; start/stop now produce non-mutating `start-planned`/`stop-planned` receipts unless `--execute-control`/`--execute-service-control` is passed, and wrapper `service-start-plan`/`service-stop-plan` proves those receipts against `EventLog`; explicit install/control execution now refuses as `execution-refused-not-elevated` with `executed=false` when the shell lacks Windows administrator authority, and wrapper `service-install-execute`, `service-start-execute`, and `service-stop-execute` prove those refusal receipts without mutation. Service lifecycle actions check the local Verse swarm brake before process launch, artifact writes, service-manager queries, service-policy reconciliation, execution-readiness checks, control planning, elevation-gated execution, or start/stop execution. The local wrapper builds/checks this binary. - - Use `notes/epiphany-repo-swarm-mvp-contract.md` as the repo-swarm autonomy authority map. Autonomous branch-local work inside an Epiphany-owned repo Body is in scope and desired; the safety boundary is typed authority, branch containment, interruption, receipts, private-state sealing, and Bifrost-gated publication/merge/escalation, not asking a human before every local edit. Current safe-family cargo includes repo manifest, tool capability manifest, Eve/CultUI surface contract, repo collaboration policy, collaboration topics, consensus/objective/adoption/scheduling/work-order/verification/publication/sync/review/PR/credit/artifact/metrics requests, action-item receipts, Mind adoption decision receipts, overview/public-proof/Gjallar/Eve readbacks, Idunn non-mutating queue-run lifecycle receipts, and fresh-repo upstream-main proof. Latest repo collaboration policy proof `.epiphany-smoke\repo-collaboration-policy-family-20260620-172808` shows `.epiphany/collaboration-policy.toml` closes with Verse boundaries, Odin discovery, Eve connection receipts, Persona discussion, Imagination feedback routing, candidate actions non-authoritative, Soul `passed`, `familyAssertions.status=passed`, `pathScopeMatched=true`, and `privateStateExposed=false`. + - Use `notes/epiphany-repo-swarm-mvp-contract.md` as the repo-swarm autonomy authority map. Autonomous branch-local work inside an Epiphany-owned repo Body is in scope and desired; the safety boundary is typed authority, branch containment, interruption, receipts, private-state sealing, and Bifrost-gated publication/merge/escalation, not asking a human before every local edit. Current safe-family cargo includes repo manifest, tool capability manifest, daemon-hosted tool request cargo, Eve/CultUI surface contract, repo collaboration policy, collaboration topics, consensus/objective/adoption/scheduling/work-order/verification/publication/sync/review/PR/credit/artifact/metrics requests, action-item receipts, Mind adoption decision receipts, overview/public-proof/Gjallar/Eve readbacks, Idunn non-mutating queue-run lifecycle receipts, and fresh-repo upstream-main proof. Latest repo tool request proof `.epiphany-smoke\repo-tool-request-family-20260620-174500` shows `.epiphany/tool-requests/repo-tool-request-family.toml` closes with CultMesh daemon invocation intent/receipt contracts, host daemon execution ownership, host liveness/readiness requirements, Odin provider ownership, denied direct tool execution/shell/Hands/state/publication/service/cross-body/private-rummaging authority, Soul `passed`, `familyAssertions.status=passed`, `pathScopeMatched=true`, and `privateStateExposed=false`. - Gjallar/swarm-overview now projects typed repo-work overview history into the compact global sight report, Persona's public Eve surface lowers the same queue for peers, and Self has a first runnable queue surface over it. `epiphany-verse-query gjallar` reads all `epiphany.cultmesh.repo_work_overview.v0` event documents from local Verse, excludes the `latest` mirror, preserves latest scalar fields, emits multi-item `repoWorkOverviewRows`/TUI rows, and publishes bounded priority 35-39 non-mutating `repo-work-overview` action rows with `owner=Gjallar`, `hostedBody=repo-work`, `authorityGate=repo.work.overview`, `mutatesState=false`, `requiresElevatedAuthority=false`, proof-bundle refs, current gate/blocker/next-safe-move, and `privateStateExposed=false`. `epiphany-verse-query eve-surfaces`, `connect-eve`, and globally invokable Persona `eve-connect` tool readbacks expose compact `REPO-WORK-PEER` rows with item, gate, blocker, next safe move, branch, publication/sync state, and private seal for the public Persona surface only. `epiphany-work queue-run` selects current-repo rows at `ready-to-run`, `ready-to-adopt`, or `ready-to-execute`, delegates action to `tick`, refreshes overview after real advancement, and writes `epiphany.repo_work_queue_run_receipt.v0`; wrapper mode `tools/epiphany_local_run.ps1 -Mode repo-work-queue-run` exposes the same surface. Disposable proofs `.epiphany-smoke\gjallar-repo-work-queue-20260620-012027`, `.epiphany-smoke\eve-repo-work-queue-20260620-013322`, `.epiphany-smoke\queue-run-20260620-014314`, and wrapper artifact `local-20260620-014627-174-aada0241` showed two-item queues through sight, public Eve, direct queue-run, and wrapper dry-run without publication, merge, service lifecycle mutation, elevation, cross-repo mutation, or private-state exposure. - Agent memory lifecycle now has a first typed v0 operation surface in `epiphany-core::agent_memory`: `AgentMemoryLifecycleOperation` can revise, retire, crystallize, prune, and merge bounded memory records after role/agent review, and `epiphany-agent-memory-store review-lifecycle|apply-lifecycle` exposes the path at the operator edge. This closes the first explicit lifecycle-operation slice from the swarm-readiness gate; it does not yet make sleep silently mutate identity or project truth. - Persona public speech now has a parent-side eligibility receipt at the Discord/Aquarium mouth edge. `epiphany.persona_speech_audit.v0` records action kind, content fingerprint, opening/topic keys, recent-window counts, repeated opening/topic counts, channel saturation, and allow/block reasons. `epiphany-persona-discord post` blocks repeated public openings before token/webhook work; draft and bubble still emit audit receipts for operator inspection. The compatibility JSON artifact remains for display, but the durable witness is now `epiphany.cultmesh.persona_speech_audit.v0` in CultMesh with latest-key projection through local Verse context. Local MVP Persona bubbles now write that durable witness to `.epiphany-run/cultmesh/local-verse.ccmp`, not a separate mouth-side store. This is posting-edge policy, not a Persona prompt wish. @@ -634,4 +634,4 @@ current_status: - `tools/epiphany_local_run.ps1 -Mode swarm-online-runbook` now emits an explicit Idunn preflight summary before the operator elevation boundary. Its JSON and one-line summary report `preflightStatus`, child artifact present/hash-verified/mismatch/missing counts, aggregate service execution failed/missing check counts, child preflight rows with expected/actual SHA-256s, and private-state exposure. Live proof `local-20260619-025627-410-9724e2f6` generated the non-mutating parent artifact with `preflightStatus=ready-for-elevated-operator`, two child runbooks present, two hashes verified, zero mismatches, zero missing artifacts, eleven failed sealed service checks, zero missing checks, explicit aftercare audits, and `privateStateExposed=false`. The remaining scar is still explicit elevated operator execution followed by complete Idunn audits, not missing parent/child artifact readiness. - Service lifecycle receipt history is now event-only: `load_epiphany_cultmesh_daemon_service_lifecycle_receipts` filters out the `epiphany-local/daemon-service-lifecycle-receipt/latest` mirror, while `load_latest_epiphany_cultmesh_daemon_service_lifecycle_receipt` remains the latest-state reader. Focused unit test `service_lifecycle_receipt_history_excludes_latest_mirror` proves two per-receipt writes return exactly two history records and latest points at the second. Fresh smoke `verse-query-lifecycle-history-filter-smoke` and live overview/triage `local-20260618-145632-497-efac6f0d` / `local-20260618-145632-321-867947af` prove compact swarm sights still expose service lifecycle attention plus the present elevated runbook artifact without daemon pokes or service mutation. Do not use a broad unscoped cargo test filter for this check on Windows; it fans out across bin harnesses and hit a broken pipe during this pass. - `epiphany-verse-query seed-compact` is the compact seed receipt for wrappers and read-only rites. The older `seed` command still prints the full local Verse context for explicit debugging, but compact wrapper modes now avoid full `seed`/final `query` readback after the combined overview proof exposed Windows debug stack overflow from full-context serialization pressure. - next_action: Continue repo-swarm MVP work from the documented Epiphany Online cut order in `notes/epiphany-repo-swarm-mvp-contract.md`. Typed Gjallar repo-work history/queue sight, peer-readable Persona Eve lowering, Self-owned `epiphany-work queue-run`, bounded `epiphany-swarm run`, execute-to-close scheduler handoff through `close-from-execute`, deterministic `derive-plan` families `append-worklog`, `planning-note`, `checklist-note`, `section-note` / `repo.markdown_managed_section`, `task-card` / `repo.task_card`, `repo-status-section` / `repo.status_section`, `repo-manifest` / `repo.body_manifest`, `repo-tool-capabilities` / `repo.tool_capabilities`, `repo-eve-surface` / `repo.eve_surface`, `repo-collaboration-policy` / `repo.collaboration_policy`, `repo-collaboration-topic` / `repo.collaboration_topic`, `repo-consensus-brief` / `repo.consensus_brief`, `repo-objective-draft` / `repo.objective_draft`, `repo-adoption-request` / `repo.adoption_request`, `repo-scheduling-request` / `repo.scheduling_request`, `repo-work-order` / `repo.work_order`, `repo-verification-request` / `repo.verification_request`, `repo-publication-request` / `repo.publication_request`, `repo-sync-request` / `repo.sync_request`, `repo-maintainer-review-request` / `repo.maintainer_review_request`, `repo-pr-request` / `repo.pr_request`, `repo-credit-request` / `repo.credit_request`, `repo-artifact-acceptance-request` / `repo.artifact_acceptance_request`, and `repo-metrics-request` / `repo.metrics_request`, typed Imagination action-item receipts over allowlisted safe families, `epiphany.repo_work_mind_adoption_decision.v0` Mind interpreter receipts before branch-local Hands authority, hash-backed local proof bundles with Bifrost/GitHub/credit/PR/upstream-main publication rows, redacted `epiphany-work export-proof` public bundles plus local Verse `epiphany.cultmesh.repo_work_public_proof.v0` Gjallar readback, Bifrost-owned `gamecult.bifrost.public_proof_publication_receipt.v0` closure plus wrapper `bifrost-public-proof` for redacted public proofs, Idunn-hosted non-mutating queue-run lifecycle plan/runbook receipts, and the speech-audited `epiphany-work persona-intake` mouth plus wrapper `repo-persona-intake` are live with `privateStateExposed=false`; proof `.epiphany-smoke\repo-collaboration-policy-family-20260620-172808` shows repo collaboration policy cargo closes with Verse boundaries, Odin discovery, Eve connection receipts, Persona discussion, Imagination feedback routing, and sealed authority. The contract note now explicitly answers that Epiphany is headed toward a functional repo swarm but is not fully online until the typed artery runs as a living repo organism. The next cut is deeper interpreter semantics beyond the first Mind decision packet, more useful repo-owned config/action families, or Idunn-owned queue-run service lifecycle under explicit operator authority. Preserve Idunn service lifecycle ownership and existing CultMesh/Odin/Eve tool directories; service install/start execution still requires explicit elevated operator authority. + next_action: Continue repo-swarm MVP work from the documented Epiphany Online cut order in `notes/epiphany-repo-swarm-mvp-contract.md`. Typed Gjallar repo-work history/queue sight, peer-readable Persona Eve lowering, Self-owned `epiphany-work queue-run`, bounded `epiphany-swarm run`, execute-to-close scheduler handoff through `close-from-execute`, deterministic `derive-plan` families `append-worklog`, `planning-note`, `checklist-note`, `section-note` / `repo.markdown_managed_section`, `task-card` / `repo.task_card`, `repo-status-section` / `repo.status_section`, `repo-manifest` / `repo.body_manifest`, `repo-tool-capabilities` / `repo.tool_capabilities`, `repo-tool-request` / `repo.tool_request`, `repo-eve-surface` / `repo.eve_surface`, `repo-collaboration-policy` / `repo.collaboration_policy`, `repo-collaboration-topic` / `repo.collaboration_topic`, `repo-consensus-brief` / `repo.consensus_brief`, `repo-objective-draft` / `repo.objective_draft`, `repo-adoption-request` / `repo.adoption_request`, `repo-scheduling-request` / `repo.scheduling_request`, `repo-work-order` / `repo.work_order`, `repo-verification-request` / `repo.verification_request`, `repo-publication-request` / `repo.publication_request`, `repo-sync-request` / `repo.sync_request`, `repo-maintainer-review-request` / `repo.maintainer_review_request`, `repo-pr-request` / `repo.pr_request`, `repo-credit-request` / `repo.credit_request`, `repo-artifact-acceptance-request` / `repo.artifact_acceptance_request`, and `repo-metrics-request` / `repo.metrics_request`, typed Imagination action-item receipts over allowlisted safe families, `epiphany.repo_work_mind_adoption_decision.v0` Mind interpreter receipts before branch-local Hands authority, hash-backed local proof bundles with Bifrost/GitHub/credit/PR/upstream-main publication rows, redacted `epiphany-work export-proof` public bundles plus local Verse `epiphany.cultmesh.repo_work_public_proof.v0` Gjallar readback, Bifrost-owned `gamecult.bifrost.public_proof_publication_receipt.v0` closure plus wrapper `bifrost-public-proof` for redacted public proofs, Idunn-hosted non-mutating queue-run lifecycle plan/runbook receipts, and the speech-audited `epiphany-work persona-intake` mouth plus wrapper `repo-persona-intake` are live with `privateStateExposed=false`; proof `.epiphany-smoke\repo-tool-request-family-20260620-174500` shows repo tool request cargo closes with CultMesh daemon invocation intent/receipt contracts, host daemon execution ownership, host liveness/readiness requirements, Odin provider ownership, and sealed no-execution authority. The contract note now explicitly answers that Epiphany is headed toward a functional repo swarm but is not fully online until the typed artery runs as a living repo organism. The next cut is deeper interpreter semantics beyond the first Mind decision packet, more useful repo-owned config/action families, or Idunn-owned queue-run service lifecycle under explicit operator authority. Preserve Idunn service lifecycle ownership and existing CultMesh/Odin/Eve tool directories; service install/start execution still requires explicit elevated operator authority.