From 51ae5e0ae831376979ae398ed60f9bfe70cd70bd Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sat, 20 Jun 2026 18:47:01 +0100 Subject: [PATCH] Add repo tool request safe family --- ...epiphany-repo-tool-request-family-smoke.rs | 407 ++++++++++++++++++ epiphany-core/src/bin/epiphany-work.rs | 203 ++++++++- notes/epiphany-repo-swarm-mvp-contract.md | 24 +- notes/fresh-workspace-handoff.md | 1 + state/ledgers.msgpack | Bin 343534 -> 344869 bytes state/map.yaml | 4 +- 6 files changed, 633 insertions(+), 6 deletions(-) create mode 100644 epiphany-core/src/bin/epiphany-repo-tool-request-family-smoke.rs 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 88e6656c1e99a2566fa4bd09db3f2943477c72d1..03ffd0de897c900268758fb08669276286c2f163 100644 GIT binary patch delta 720 zcmZXSJ!lj`6vw^Y9Ze#dMDDHvr2W?$8_zD_xg1~$qb|=T3N6j#V5KBl! zMGL`AV+<9?aa%~-k|d!~g$qi!NxwS9QxduvD2*wR9brCCqSEOqq%4g{(wpsPf4qpw zqpKO$H$g=>BoK?l?2WkPQ7RHG3DwHSkx<&aA92s`<`(8`2NF1#5GiH0*8#Z6&(TvwubZG{iL$!tFVA(W^=$5%L zEZx5RfWpwjSoREi=pM0OxJn>)L>5y={40 x7m+Py7b<(3IpAidBO#gY4czuigz8}I|9trpPQa>&W2Vi!MYLz!Z|+2)`VV$>{5Jpq delta 53 zcmZ45Ci?ET$OZ{UZes&0BlD