diff --git a/epiphany-core/src/bin/epiphany-repo-interpreter-brief-family-smoke.rs b/epiphany-core/src/bin/epiphany-repo-interpreter-brief-family-smoke.rs new file mode 100644 index 00000000..5f2352b2 --- /dev/null +++ b/epiphany-core/src/bin/epiphany-repo-interpreter-brief-family-smoke.rs @@ -0,0 +1,438 @@ +use anyhow::anyhow; +use anyhow::Context; +use anyhow::Result; +use chrono::Utc; +use serde_json::json; +use serde_json::Value; +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-interpreter-brief-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 Interpreter Brief Family Smoke\n\nThis repository proves branch-local Mind-owned interpretation briefs.\n", + ) + .with_context(|| format!("failed to seed {}", repo.join("README.md").display()))?; + git(["add", "README.md"], &repo)?; + git( + ["commit", "-m", "Seed repo interpreter brief smoke body"], + &repo, + )?; + git( + ["switch", "-c", "epiphany/repo-interpreter-brief-family"], + &repo, + )?; + + let item = "repo-interpreter-brief-family"; + let target_path = ".epiphany/interpreter-briefs/repo-interpreter-brief-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-interpreter-brief-family-smoke", + "--topic", + "repo-interpreter-brief-family", + ], + &root, + )?; + cargo_json( + &manifest, + "epiphany-swarm", + &[ + "online", + "--workspace", + path_str(&repo)?, + "--epiphany-root", + path_str(&root)?, + "--runtime-id", + "repo-interpreter-brief-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", + "Turn rough Persona and Imagination consensus into a Mind-owned interpreter brief before any work item receives Hands authority.", + "--candidate-action-ref", + "candidate-action://repo-interpreter-brief-family/interpret-action-semantics", + "--candidate-action-ref", + "candidate-action://repo-interpreter-brief-family/request-soul-grounding", + "--public-discussion-ref", + "epiphany-global/persona-collaboration/repo-interpreter-brief-family", + ], + &root, + )?; + let plan = cargo_json( + &manifest, + "epiphany-work", + &[ + "derive-plan", + "--workspace", + path_str(&repo)?, + "--item", + item, + "--action-family", + "repo-interpreter-brief", + "--model-ref", + "repo-interpreter-brief-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 brief_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.interpreter_brief", + )?; + 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( + &brief_text, + "schema_version = \"epiphany.repo_interpreter_brief.v0\"", + )?; + require_text(&brief_text, "safe_action_family = \"repo.interpreter_brief\"")?; + require_text(&brief_text, "[interpreter]")?; + require_text(&brief_text, "status = \"draft\"")?; + require_text(&brief_text, "owner = \"Mind\"")?; + require_text(&brief_text, "source = \"Imagination\"")?; + require_text( + &brief_text, + "purpose = \"public-pressure-to-action-semantics\"", + )?; + require_text(&brief_text, "requires_consensus_readback = true")?; + require_text(&brief_text, "requires_safe_family_choice = true")?; + require_text(&brief_text, "requires_requested_paths = true")?; + require_text(&brief_text, "requires_verification_asks = true")?; + require_text(&brief_text, "requires_evidence_needs = true")?; + require_text(&brief_text, "candidate_actions_non_authoritative = true")?; + require_text(&brief_text, "[semantic_checks]")?; + require_text(&brief_text, "intent_summary_required = true")?; + require_text(&brief_text, "scope_boundary_required = true")?; + require_text(&brief_text, "requested_paths_required = true")?; + require_text(&brief_text, "verification_required = true")?; + require_text(&brief_text, "evidence_required = true")?; + require_text(&brief_text, "rollback_required = true")?; + require_text(&brief_text, "non_goals_required = true")?; + require_text(&brief_text, "open_questions_required = true")?; + require_text(&brief_text, "consensus_alignment_required = true")?; + require_text(&brief_text, "[allowed_outputs]")?; + require_text(&brief_text, "\"repo.consensus_brief\"")?; + require_text(&brief_text, "\"repo.objective_draft\"")?; + require_text(&brief_text, "\"repo.adoption_request\"")?; + require_text(&brief_text, "\"repo.work_order\"")?; + require_text(&brief_text, "\"repo.verification_request\"")?; + require_text(&brief_text, "\"repo.publication_request\"")?; + require_text(&brief_text, "may_request_replanning = true")?; + require_text(&brief_text, "may_request_more_consensus = true")?; + require_text(&brief_text, "may_adopt_objective = false")?; + require_text(&brief_text, "may_schedule_work = false")?; + require_text(&brief_text, "may_touch_substrate = false")?; + require_text(&brief_text, "may_publish = false")?; + require_text(&brief_text, "may_deploy = false")?; + require_text(&brief_text, "[required_gates]")?; + require_text(&brief_text, "imagination_consensus_required = true")?; + require_text(&brief_text, "mind_review_required = true")?; + require_text(&brief_text, "soul_source_grounding_required = true")?; + require_text(&brief_text, "bifrost_publication_review_required = true")?; + require_text( + &brief_text, + "hands_receipt_required_before_state_change = true", + )?; + require_text( + &brief_text, + "substrate_receipt_required_before_mutation = true", + )?; + require_text(&brief_text, "idunn_receipt_required_before_deployment = true")?; + require_text(&brief_text, "direct_state_commit_authorized = false")?; + require_text(&brief_text, "objective_adoption_authorized = false")?; + require_text(&brief_text, "self_scheduling_authorized = false")?; + require_text(&brief_text, "substrate_access_authorized = false")?; + require_text(&brief_text, "hands_action_authorized = false")?; + require_text(&brief_text, "shell_command_authorized = false")?; + require_text(&brief_text, "commit_authorized = false")?; + require_text(&brief_text, "publication_authorized = false")?; + require_text(&brief_text, "deployment_execution_authority = false")?; + require_text(&brief_text, "cross_body_mutation_authorized = false")?; + require_text(&brief_text, "private_worker_transcripts_allowed = false")?; + require_text(&brief_text, "raw_result_payloads_allowed = false")?; + require_text(&brief_text, "private_state_exposed = false")?; + + let summary = json!({ + "schemaVersion": "epiphany.repo_work_interpreter_brief_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"], + "interpreterIsDraft": true, + "mindOwnsInterpretation": true, + "candidateActionsNonAuthoritative": true, + "directStateCommitAuthorized": false, + "handsActionAuthorized": 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 interpreter brief 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 c3c45480..9bc23a80 100644 --- a/epiphany-core/src/bin/epiphany-work.rs +++ b/epiphany-core/src/bin/epiphany-work.rs @@ -2159,6 +2159,9 @@ fn derive_safe_plan_family(input: DeriveSafePlanInput<'_>) -> Result { derive_repo_planning_brief_plan(input, &action_family) } + "repo-interpreter-brief" | "interpreter-brief" | "mind-interpreter-brief" => { + derive_repo_interpreter_brief_plan(input, &action_family) + } "repo-objective-draft" | "objective-draft" | "imagination-objective" => { derive_repo_objective_draft_plan(input, &action_family) } @@ -2214,7 +2217,7 @@ fn derive_safe_plan_family(input: DeriveSafePlanInput<'_>) -> Result derive_repo_deployment_request_plan(input, &action_family), other => 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-tool-request, repo-eve-surface, repo-collaboration-policy, repo-collaboration-topic, repo-consensus-brief, repo-planning-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, repo-doctrine-update-request, repo-secret-policy-request, repo-deployment-config, and repo-deployment-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-planning-brief, repo-interpreter-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, repo-doctrine-update-request, repo-secret-policy-request, repo-deployment-config, and repo-deployment-request" )), } } @@ -3570,6 +3573,161 @@ fn derive_repo_planning_brief_plan( }) } +fn derive_repo_interpreter_brief_plan( + input: DeriveSafePlanInput<'_>, + action_family: &str, +) -> Result { + let item_slug = sanitize(input.item); + let default_target = format!(".epiphany/interpreter-briefs/{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 brief_id = format!("repo-interpreter-brief:{item_slug}"); + let candidate_families = vec![ + "repo.consensus_brief".to_string(), + "repo.objective_draft".to_string(), + "repo.adoption_request".to_string(), + "repo.work_order".to_string(), + "repo.verification_request".to_string(), + "repo.publication_request".to_string(), + ]; + let lines = vec![ + "# Epiphany repo interpreter brief.".to_string(), + "# Branch-local Mind interpretation cargo; not objective adoption, scheduling, Hands authority, or publication.".to_string(), + format!( + "schema_version = {}", + toml_basic_string("epiphany.repo_interpreter_brief.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.interpreter_brief") + ), + 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(), + "deployment_execution_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(), + "[interpreter]".to_string(), + format!("id = {}", toml_basic_string(&brief_id)), + "status = \"draft\"".to_string(), + "owner = \"Mind\"".to_string(), + "source = \"Imagination\"".to_string(), + "purpose = \"public-pressure-to-action-semantics\"".to_string(), + "requires_consensus_readback = true".to_string(), + "requires_safe_family_choice = true".to_string(), + "requires_requested_paths = true".to_string(), + "requires_verification_asks = true".to_string(), + "requires_evidence_needs = true".to_string(), + "candidate_actions_non_authoritative = true".to_string(), + String::new(), + "[inputs]".to_string(), + format!("summary = {}", toml_basic_string(&compact_line(input.summary))), + format!("public_discussion_refs = {}", toml_array(&public_refs)), + format!("candidate_action_refs = {}", toml_array(&candidate_refs)), + "private_worker_transcripts_allowed = false".to_string(), + "raw_result_payloads_allowed = false".to_string(), + String::new(), + "[semantic_checks]".to_string(), + "intent_summary_required = true".to_string(), + "scope_boundary_required = true".to_string(), + "requested_paths_required = true".to_string(), + "verification_required = true".to_string(), + "evidence_required = true".to_string(), + "rollback_required = true".to_string(), + "non_goals_required = true".to_string(), + "open_questions_required = true".to_string(), + "consensus_alignment_required = true".to_string(), + String::new(), + "[allowed_outputs]".to_string(), + format!("candidate_safe_families = {}", toml_array(&candidate_families)), + "may_request_replanning = true".to_string(), + "may_request_more_consensus = true".to_string(), + "may_adopt_objective = false".to_string(), + "may_schedule_work = false".to_string(), + "may_touch_substrate = false".to_string(), + "may_publish = false".to_string(), + "may_deploy = false".to_string(), + String::new(), + "[required_gates]".to_string(), + "imagination_consensus_required = true".to_string(), + "mind_review_required = true".to_string(), + "soul_source_grounding_required = true".to_string(), + "bifrost_publication_review_required = true".to_string(), + "hands_receipt_required_before_state_change = true".to_string(), + "substrate_receipt_required_before_mutation = true".to_string(), + "idunn_receipt_required_before_deployment = true".to_string(), + String::new(), + "[authority]".to_string(), + "branch_local_only = true".to_string(), + "direct_state_commit_authorized = false".to_string(), + "objective_adoption_authorized = false".to_string(), + "self_scheduling_authorized = false".to_string(), + "substrate_access_authorized = false".to_string(), + "hands_action_authorized = false".to_string(), + "shell_command_authorized = false".to_string(), + "commit_authorized = false".to_string(), + "publication_authorized = false".to_string(), + "merge_authorized = false".to_string(), + "service_lifecycle_authority = false".to_string(), + "deployment_execution_authority = false".to_string(), + "cross_body_mutation_authorized = false".to_string(), + "private_worker_transcripts_allowed = false".to_string(), + "raw_result_payloads_allowed = false".to_string(), + "private_state_exposed = false".to_string(), + String::new(), + "[verification]".to_string(), + "asks = [".to_string(), + " \"Soul verifies the interpreter brief path changed and contains the accepted pressure summary.\",".to_string(), + " \"Soul verifies Mind owns interpretation while candidate actions remain non-authoritative.\",".to_string(), + " \"Soul verifies semantic checks, required gates, and authority denials are present.\",".to_string(), + " \"Soul verifies no paths outside the declared interpreter brief changed.\"".to_string(), + "]".to_string(), + String::new(), + "[rollback]".to_string(), + "hints = [\"Remove the interpreter brief if Mind misread Imagination consensus or the semantic checks are incomplete.\"]".to_string(), + String::new(), + ]; + let command = powershell_set_lines_command(&target_path, &lines); + Ok(DerivedSafePlan { + safe_action_family: "repo.interpreter_brief".to_string(), + target_path, + plan_summary: format!( + "Mind derived a repo interpreter brief from accepted {} pressure.", + input.source + ), + command, + commit_message: format!("Add interpreter brief for work item {}", input.item), + verification_asks: vec![ + "Soul verifies the repo interpreter brief path changed and contains the accepted pressure summary.".to_string(), + "Soul verifies the brief keeps interpretation non-authoritative and requires consensus, semantic checks, Mind review, Soul grounding, and downstream receipts.".to_string(), + "Soul verifies no paths outside the declared interpreter brief changed.".to_string(), + ], + rollback_hints: vec![ + "Remove the generated interpreter brief if Mind misinterpreted Imagination consensus.".to_string(), + ], + derivation: plan_derivation_receipt(input, action_family, "repo.interpreter_brief"), + }) +} + fn derive_repo_objective_draft_plan( input: DeriveSafePlanInput<'_>, action_family: &str, @@ -6455,6 +6613,119 @@ fn closure_family_assertions( ); safe_family_planning = planning_brief_safe_family_readback(&content); } + "repo.interpreter_brief" => { + push_assertion( + &mut assertions, + "interpreter-brief-schema-present", + content.contains("schema_version = \"epiphany.repo_interpreter_brief.v0\""), + "Committed interpreter brief carries the schema version.".to_string(), + ); + push_assertion( + &mut assertions, + "interpreter-brief-family-present", + content.contains("safe_action_family = \"repo.interpreter_brief\""), + "Committed interpreter brief carries the safe action family.".to_string(), + ); + push_assertion( + &mut assertions, + "interpreter-brief-summary-present", + content.contains(&compact_summary), + "Committed interpreter brief contains the accepted pressure summary.".to_string(), + ); + push_assertion( + &mut assertions, + "interpreter-brief-draft-state", + content.contains("[interpreter]") + && content.contains("status = \"draft\"") + && content.contains("owner = \"Mind\"") + && content.contains("source = \"Imagination\"") + && content.contains("purpose = \"public-pressure-to-action-semantics\"") + && content.contains("requires_consensus_readback = true") + && content.contains("requires_safe_family_choice = true") + && content.contains("requires_requested_paths = true") + && content.contains("requires_verification_asks = true") + && content.contains("requires_evidence_needs = true") + && content.contains("candidate_actions_non_authoritative = true"), + "Committed interpreter brief stays draft, Mind-owned, and non-authoritative." + .to_string(), + ); + push_assertion( + &mut assertions, + "interpreter-brief-semantic-checks", + content.contains("[semantic_checks]") + && content.contains("intent_summary_required = true") + && content.contains("scope_boundary_required = true") + && content.contains("requested_paths_required = true") + && content.contains("verification_required = true") + && content.contains("evidence_required = true") + && content.contains("rollback_required = true") + && content.contains("non_goals_required = true") + && content.contains("open_questions_required = true") + && content.contains("consensus_alignment_required = true"), + "Committed interpreter brief names semantic checks before action adoption." + .to_string(), + ); + push_assertion( + &mut assertions, + "interpreter-brief-allowed-outputs", + content.contains("[allowed_outputs]") + && content.contains("\"repo.consensus_brief\"") + && content.contains("\"repo.objective_draft\"") + && content.contains("\"repo.adoption_request\"") + && content.contains("\"repo.work_order\"") + && content.contains("\"repo.verification_request\"") + && content.contains("\"repo.publication_request\"") + && content.contains("may_request_replanning = true") + && content.contains("may_request_more_consensus = true") + && content.contains("may_adopt_objective = false") + && content.contains("may_schedule_work = false") + && content.contains("may_touch_substrate = false") + && content.contains("may_publish = false") + && content.contains("may_deploy = false"), + "Committed interpreter brief limits outputs to candidate families or more planning." + .to_string(), + ); + push_assertion( + &mut assertions, + "interpreter-brief-gates", + content.contains("[required_gates]") + && content.contains("imagination_consensus_required = true") + && content.contains("mind_review_required = true") + && content.contains("soul_source_grounding_required = true") + && content.contains("bifrost_publication_review_required = true") + && content.contains("hands_receipt_required_before_state_change = true") + && content.contains("substrate_receipt_required_before_mutation = true") + && content.contains("idunn_receipt_required_before_deployment = true"), + "Committed interpreter brief names consensus, Mind, Soul, Bifrost, Hands, Substrate, and Idunn gates." + .to_string(), + ); + push_assertion( + &mut assertions, + "interpreter-brief-authority-seals", + content.contains("[authority]") + && content.contains("direct_state_commit_authorized = false") + && content.contains("objective_adoption_authorized = false") + && content.contains("self_scheduling_authorized = false") + && content.contains("substrate_access_authorized = false") + && content.contains("hands_action_authorized = false") + && content.contains("shell_command_authorized = false") + && content.contains("commit_authorized = false") + && content.contains("publication_authorized = false") + && content.contains("deployment_execution_authority = false") + && content.contains("cross_body_mutation_authorized = false"), + "Committed interpreter brief denies state/adoption/scheduling/substrate/action/shell/commit/publication/deployment/cross-body authority." + .to_string(), + ); + push_assertion( + &mut assertions, + "interpreter-brief-private-seal", + content.contains("private_state_exposed = false") + && content.contains("private_worker_transcripts_allowed = false") + && content.contains("raw_result_payloads_allowed = false"), + "Committed interpreter brief preserves private-state and transcript seals." + .to_string(), + ); + } "repo.objective_draft" => { push_assertion( &mut assertions, @@ -13443,6 +13714,7 @@ fn repo_work_safe_family_is_recognized(safe_family: &str) -> bool { | "repo.collaboration_topic" | "repo.consensus_brief" | "repo.planning_brief" + | "repo.interpreter_brief" | "repo.objective_draft" | "repo.adoption_request" | "repo.scheduling_request" @@ -13590,7 +13862,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-tool-request|repo-eve-surface|repo-collaboration-policy|repo-collaboration-topic|repo-consensus-brief|repo-planning-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|repo-doctrine-update-request|repo-secret-policy-request|repo-deployment-config|repo-deployment-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-planning-brief|repo-interpreter-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|repo-doctrine-update-request|repo-secret-policy-request|repo-deployment-config|repo-deployment-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 04ec3f9c..ca607d05 100644 --- a/notes/epiphany-repo-swarm-mvp-contract.md +++ b/notes/epiphany-repo-swarm-mvp-contract.md @@ -563,6 +563,24 @@ access, Hands action, shell, commit, publication, deployment execution, cross-body mutation, private transcript/raw-result access, and `privateStateExposed=false`. +The next Mind-owned interpreter smoke proved public-pressure-to-action-semantics +cargo between Imagination consensus and any downstream action family: +`.epiphany-smoke\repo-interpreter-brief-family-20260621-010858` ran init -> +online -> accept -> `derive-plan --action-family repo-interpreter-brief +--model-ref repo-interpreter-brief-family-smoke-imagination-v1 --model-authored` +-> tick through run/adopt/execute/close on a fresh repo. The plan carried +`safeActionFamily=repo.interpreter_brief`; Hands committed only +`.epiphany/interpreter-briefs/repo-interpreter-brief-family.toml`; Soul passed +with `pathScopeMatched=true` and `familyAssertions.status=passed`; the committed +brief carried `schema_version = "epiphany.repo_interpreter_brief.v0"`, draft +Mind ownership, Imagination as source, consensus/safe-family/path/verification / +evidence requirements, semantic checks for intent/scope/paths/verification / +evidence/rollback/non-goals/questions/consensus, candidate next safe families, +Mind/Soul/Bifrost/Hands/Substrate/Idunn gates, denied objective adoption, +scheduling, substrate access, Hands action, shell, commit, publication, +deployment execution, cross-body mutation, private transcript/raw-result access, +and `privateStateExposed=false`. + The next Imagination adoption-boundary smoke proved Objective Draft cargo: `.epiphany-smoke\repo-objective-draft-family-20260620-145012` ran init -> online -> accept -> `derive-plan --action-family repo-objective-draft @@ -1737,7 +1755,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-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-planning-brief` / `repo.planning_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`, `repo-metrics-request` / `repo.metrics_request`, `repo-doctrine-update-request` / `repo.doctrine_update_request`, `repo-secret-policy-request` / `repo.secret_policy_request`, `repo-deployment-config` / `repo.deployment_config`, and `repo-deployment-request` / `repo.deployment_request`. `repo.planning_brief` is the rough-pressure decomposition family: it names candidate next safe families, requested-path / verification-ask / evidence-need requirements, and Mind/Self/Substrate/Hands/Soul/Bifrost/Idunn gates while granting no action authority; Soul closure now emits `epiphany.repo_work_safe_family_planning_readback.v0` for that family with candidate-family counts, gate/readiness flags, authority denials, and private-state seal. `adopt` writes `epiphany.repo_work_mind_adoption_decision.v0` before the main adoption receipt cites the decision and grants branch-local Hands authority, and refuses plan-derived items that lack explicit verification asks or planning evidence needs. `plan` remains manual quarantine scaffolding. | Deepen further interpreter behavior and semantic closure/map readback 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-planning-brief` / `repo.planning_brief`, `repo-interpreter-brief` / `repo.interpreter_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`, `repo-metrics-request` / `repo.metrics_request`, `repo-doctrine-update-request` / `repo.doctrine_update_request`, `repo-secret-policy-request` / `repo.secret_policy_request`, `repo-deployment-config` / `repo.deployment_config`, and `repo-deployment-request` / `repo.deployment_request`. `repo.planning_brief` is the rough-pressure decomposition family: it names candidate next safe families, requested-path / verification-ask / evidence-need requirements, and Mind/Self/Substrate/Hands/Soul/Bifrost/Idunn gates while granting no action authority; Soul closure now emits `epiphany.repo_work_safe_family_planning_readback.v0` for that family with candidate-family counts, gate/readiness flags, authority denials, and private-state seal. `repo.interpreter_brief` is the Mind-owned semantic interpretation family: it turns public Persona/Imagination pressure into draft action semantics with consensus, path, verification, evidence, rollback, non-goal, open-question, and gate checks while granting no adoption, scheduling, substrate, Hands, shell, commit, publication, deployment, cross-body, or private-state authority. `adopt` writes `epiphany.repo_work_mind_adoption_decision.v0` before the main adoption receipt cites the decision and grants branch-local Hands authority, and refuses plan-derived items that lack explicit verification asks or planning evidence needs. `plan` remains manual quarantine scaffolding. | Deepen closure/map readback and Bifrost-first external-work accounting 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`, `repo-work-service-runbook`, `repo-work-service-launch`, and `repo-work-service-audit` write Idunn lifecycle receipts/artifacts for the same queue-run command and prove non-mutating launch/readiness closure. | Keep any future queue-run service install/start mutation behind Idunn and explicit elevated 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, refuses missing/tampered/non-affirmative Mind adoption proof, runs known safe-family content assertions, optionally gates on model-authored closure verdicts, can require verification output to cite declared changed paths with `--require-source-grounding`, writes Soul/Modeling/Mind receipts, admits a compact typed repo map entry into `.epiphany/state/repo-work-map.msgpack`, and mirrors that admitted fact into local Verse as `epiphany.cultmesh.repo_work_map_entry.v0`. | Keep extending closure toward source-grounded semantic review and richer semantic map lenses, while preserving deterministic local closure for simple mechanical work. | diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index dbca3766..39090f98 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -157,6 +157,7 @@ remembers doctrine; the branch remembers the blade. - 2026-06-20: `repo-deployment-config` is now live as repo-owned Idunn deployment configuration cargo. `epiphany-work derive-plan --action-family repo-deployment-config` writes `.epiphany/deployment.toml` with safe family `repo.deployment_config`, `enabled=false`, owner `Idunn`, trigger `git-push-observed-by-idunn`, watched ref `refs/heads/main`, deployment script ref, script hash/review requirement, host policy, secret policy, rollback, aftercare checks, Idunn CultMesh intent/receipt/aftercare contracts, daemon-owned execution, and denials for direct deployment, SSH, git push, service lifecycle, Hands, publication, merge, cross-body mutation, private Verse rummaging, and private-state exposure. Focused smoke `.epiphany-smoke\repo-deployment-config-family-20260620-211809` ran init -> online -> accept -> repo-deployment-config derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/deployment.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `deploymentConfigEnabled=false`, `daemonOwnsExecution=true`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter semantics, richer closure depth, and explicit Idunn deployment execution/audit under operator authority. - 2026-06-20: `derive-plan` action-item receipts now carry richer model-authored planning facets without widening command authority, and `adopt --from-plan` now preserves the chosen Imagination action item in the Mind adoption receipt. New CLI fields `--assumption`, `--constraint`, `--non-goal`, `--open-question`, `--decision-point`, and `--evidence-need` are recorded under `planningFacets` in `epiphany.repo_work_imagination_action_items_receipt.v0`, mirrored into the plan derivation's `actionItemReceipt`, then copied into `epiphany.repo_work_adoption_receipt.v0` as `adoptedActionItem`; deterministic defaults are emitted when a model does not supply them. Focused smoke `.epiphany-smoke\repo-planning-facets-20260620-164958` ran init -> online -> accept -> model-authored `derive-plan --action-family planning-note` with all facet fields -> tick run/adopt/execute/close; the action-item receipt preserved assumptions, constraints, non-goals, open questions, decision points, and evidence needs while `handsAuthorityGranted=false`, `durableStateAdmitted=false`, `handsCommandAuthority=false`, `durableStateAuthority=false`, and `privateStateExposed=false`; the adoption receipt preserved `adoptedActionItem.safeActionFamily=repo.markdown_planning_note`, planning facets, `adoptedActionItem.handsCommandAuthority=false`, `adoptedActionItem.durableStateAuthority=false`, `adoptedActionItem.publicationAuthorized=false`, `authority.handsAuthorityGranted=true`, `authority.durableStateAdmitted=false`, and `privateStateExposed=false`; Soul closure passed with family assertions and path scope matched. 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-planning-brief` is live as the family-friendly Imagination decomposition cargo, and Soul closure now emits a typed safe-family planning readback for it. `epiphany-work derive-plan --action-family repo-planning-brief` writes `.epiphany/planning-briefs/.toml` with safe family `repo.planning_brief`, status `draft`, candidate next safe families, requested-path / verification-ask / evidence-need requirements, and Mind/Self/Substrate/Hands/Soul/Bifrost/Idunn gate ordering while denying objective adoption, scheduling, substrate access, Hands action, shell, commit, publication, deployment execution, service lifecycle, cross-body mutation, private transcripts, raw-result payloads, and private-state exposure. Closure `familyAssertions.safeFamilyPlanning` now carries `epiphany.repo_work_safe_family_planning_readback.v0` with candidate-family rows/count, planning requirement flags, gate flags, authority-denial flags, and the private-state seal. Focused smoke `.epiphany-smoke\repo-planning-brief-family-20260620-235939` ran init -> online -> accept -> repo-planning-brief derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/planning-briefs/repo-planning-brief-family.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `candidateNextSafeFamilyCount=6`, `allExpectedCandidateFamiliesPresent=true`, `allRequiredGatesPresent=true`, `authorityDenied=true`, and `privateStateExposed=false`. Current remaining repo-swarm MVP organs are deeper interpreter semantics, richer closure/map readback, and Idunn-owned queue-run service lifecycle under explicit operator authority. +- 2026-06-21: `repo-interpreter-brief` is live as Mind-owned interpretation cargo between Imagination consensus and downstream action-family adoption. `epiphany-work derive-plan --action-family repo-interpreter-brief` writes `.epiphany/interpreter-briefs/.toml` with safe family `repo.interpreter_brief`, status `draft`, owner `Mind`, source `Imagination`, consensus/safe-family/path/verification/evidence requirements, semantic checks for intent/scope/paths/verification/evidence/rollback/non-goals/questions/consensus, candidate next safe families, and Mind/Soul/Bifrost/Hands/Substrate/Idunn gates while denying direct state commit, objective adoption, scheduling, substrate access, Hands action, shell, commit, publication, deployment execution, service lifecycle, cross-body mutation, private transcripts, raw-result payloads, and private-state exposure. Focused smoke `.epiphany-smoke\repo-interpreter-brief-family-20260621-010858` ran init -> online -> accept -> repo-interpreter-brief derive-plan -> tick run/adopt/execute/close; Hands committed only `.epiphany/interpreter-briefs/repo-interpreter-brief-family.toml`, Soul passed with `pathScopeMatched=true`, `familyAssertions.status=passed`, `mindOwnsInterpretation=true`, `candidateActionsNonAuthoritative=true`, `directStateCommitAuthorized=false`, `handsActionAuthorized=false`, and `privateStateExposed=false`. - 2026-06-20: Gjallar repo-work map sight now includes semantic stage lenses. `epiphany-verse-query gjallar`, swarm overview, and swarm triage expose `repoWorkMapStageLensRows` plus `REPO-WORK-MAP-STAGE` rows derived from Mind-admitted local Verse map entries, grouping safe families into stages and owning organs such as `imagination-planning` / `Imagination`, `hands-execution-request` / `Hands`, `soul-verification-request` / `Soul`, `bifrost-publication-accounting` / `Bifrost`, and `idunn-deployment` / `Idunn`. Focused smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-232414` proves the stage lens for accepted `repo.markdown_planning_note` work reports `stage=imagination-planning`, `owner=Imagination`, latest item/commit/Mind commit receipt, Bifrost gate, and `privateStateExposed=false`. This is sight only; Gjallar still does not schedule, publish, merge, deploy, keep daemons alive, or admit Mind state. - 2026-06-20: Gjallar repo-work map sight now includes next-publication-gate lenses. `epiphany-verse-query gjallar`, swarm overview, and swarm triage expose `repoWorkMapGateLensRows` plus `REPO-WORK-MAP-GATE` rows derived from the same Mind-admitted local Verse map entries, grouping accepted consequences by publication gate and naming the owning gate organ. Focused smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-233353` proves accepted `repo.markdown_planning_note` work reports `gate=Bifrost`, `owner=Bifrost`, latest item/commit/Mind commit receipt, `sightOnly=true`, `publicationAuthorized=false`, and `privateStateExposed=false`. This is sight only; Bifrost still owns publication/credit/upstream review and Gjallar does not schedule, publish, merge, deploy, keep daemons alive, or admit Mind state. - 2026-06-20: Gjallar repo-work map sight now includes per-entry semantic readback rows. `epiphany-verse-query gjallar`, swarm overview, and swarm triage expose `repoWorkMapSemanticRows` plus `REPO-WORK-MAP-SEMANTIC` rows derived from Mind-admitted local Verse map entries, combining durable modeling summary, safe family, stage owner, publication gate owner, latest commit, and Mind commit receipt for each accepted item. Focused smoke `.epiphany-smoke\repo-close-mind-adoption-guard-20260620-234131` proves accepted `repo.markdown_planning_note` work reports `stage=imagination-planning`, `stageOwner=Imagination`, `gateOwner=Bifrost`, the durable modeling summary, `sightOnly=true`, `publicationAuthorized=false`, and `privateStateExposed=false` while counterfeit Mind adoption is still refused. This is compact meaning readback only; Gjallar still does not schedule, publish, merge, deploy, keep daemons alive, or admit Mind state. diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 2926b9d4..6ab210b1 100644 Binary files a/state/ledgers.msgpack and b/state/ledgers.msgpack differ diff --git a/state/map.yaml b/state/map.yaml index c80b5639..65327237 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -89,6 +89,7 @@ active_subgoals: - 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, 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/doctrine-update/secret-policy/deployment requests, repo deployment config, action-item receipts, Mind adoption interpretation/decision receipts, explicit Mind safe-family refusal proof `.epiphany-smoke\repo-mind-safe-family-guard-20260620-194425`, explicit Mind requested-path/plan changed-path refusal proof `.epiphany-smoke\repo-mind-path-guard-20260620-194239`, overview/public-proof/Gjallar/Eve readbacks, typed swarm-run stop classification, Idunn non-mutating queue-run lifecycle receipts, and fresh-repo upstream-main proof. Latest deployment proof `.epiphany-smoke\repo-deployment-config-family-20260620-221205` shows `repo.deployment_config` closes through Soul, `deployment-config-audit` reports `ready-for-idunn-review`, `deployment-execution-runbook` reports `ready-for-operator-git-push`, and `deployment-aftercare-audit` ingests local Verse/CultMesh Idunn deployment/aftercare receipt refs with source `cultmesh`, status `complete`, `deploymentComplete=true`, `daemonOwnsExecution=true`, no repo-agent execution/deployment/SSH/git-push/service/Hands/publication/merge/cross-body authority, and `privateStateExposed=false`; explicit Idunn receipt files remain only compatibility reliquaries. Latest deployment request proof `.epiphany-smoke\repo-deployment-request-family-20260620-195605` shows `repo.deployment_request` closes through Soul while requesting reviewed git-push-observed-by-Idunn deployment with script/host/secret/rollback/aftercare requirements and no deployment/SSH/git-push/service authority. Latest security cargo proof `.epiphany-smoke\repo-secret-policy-request-family-20260620-193046` shows `repo.secret_policy_request` closes through Soul while requesting reviewed secret/write/export/deployment policy without exposing secrets or granting write/deployment/publication authority. Governance proof `.epiphany-smoke\repo-doctrine-update-request-family-20260620-192140` shows `repo.doctrine_update_request` closes through Soul while requesting reviewed `AGENTS.md` doctrine work without mutating doctrine or granting Hands/service/publication authority. Swarm-run stop proofs now include `.epiphany-smoke\fresh-repo-mvp-20260620-180024` for `iteration-limit` / Self / `self.scheduler-iteration-limit` with upstream-main sync and public-proof export, plus `.epiphany-smoke\swarm-stop-classification-20260620-184717` for `queue-empty` / Gjallar / `repo.work.overview`, `dry-run-preview` / Self / `ready-to-run`, `authority-gated` / Bifrost / `awaiting-publication`, and `authority-gated` / Bifrost/GitHub / `awaiting-upstream-sync`; all stop packets are non-mutating, non-elevated, and `privateStateExposed=false`. Native proof `.epiphany-smoke\repo-work-service-lifecycle-20260620-185853` now proves Idunn-owned non-mutating repo-work queue-run service plan/runbook receipts for exact service id `epiphany-repo-work-queue-runner`, receipt-directory readback, runbook SHA-256 `f2ec67c4f8243a3ebc2f9e915b6b9f5ae2ac2d99d2cdb86905b54667adc456f8`, `hostedBody=repo-work`, no service-manager mutation, no launch, no elevation, and `privateStateExposed=false`. + - Repo-swarm Mind interpretation cargo is live. `repo-interpreter-brief` lowers to safe family `repo.interpreter_brief` and writes `.epiphany/interpreter-briefs/.toml` as draft Mind-owned interpretation from Imagination consensus, with semantic checks, candidate safe families, required Mind/Soul/Bifrost/Hands/Substrate/Idunn gates, and explicit denials for direct state commit, objective adoption, scheduling, substrate access, Hands action, shell, commit, publication, deployment execution, service lifecycle, cross-body mutation, private transcripts/raw results, and private-state exposure. Proof `.epiphany-smoke\repo-interpreter-brief-family-20260621-010858` closes through Soul with `familyAssertions.status=passed`, `mindOwnsInterpretation=true`, `candidateActionsNonAuthoritative=true`, `directStateCommitAuthorized=false`, `handsActionAuthorized=false`, and `privateStateExposed=false`. - Idunn-hosted repo-work queue-run lifecycle now has plan/runbook/launch/audit closure under explicit operator authority. `epiphany-daemon-supervisor repo-work-service-audit` reads all typed service lifecycle receipts for `epiphany-repo-work-queue-runner`, requires planned install-plan, written local runbook artifact, completed launch with exit code `0`, and no private-state exposure, then writes a `repo-work-service-audit` receipt with `status=complete` or `incomplete`. Native proof `.epiphany-smoke\repo-work-service-lifecycle-20260621-004202` proves plan/runbook/launch/audit with `auditStatus=complete`, `auditRunbookArtifactStatus=present`, `auditLaunchExitCode=0`, `mutatesServiceManager=false`, `requiresElevatedAuthority=false`, and `privateStateExposed=false`. Wrapper proofs `local-20260621-014302-362-31bbef47`, `local-20260621-014337-108-cbd99615`, `local-20260621-014413-125-09e183c5`, and `local-20260621-014558-197-f6951806` prove operator plan/runbook/launch/audit ergonomics, with audit reporting no missing or failed checks. Basic queue-run service lifecycle readiness is sealed; remaining Idunn work is optional elevated install/start execution under explicit operator authority, not Self scheduling authority. - Gjallar/Odin sight now exposes Idunn deployment receipt refs without taking Idunn's execution throne. `EpiphanyLocalVerseContext`, `receipt-directory`, `swarm-overview`, `swarm-triage`, and `gjallar` surface latest `gamecult.idunn.deployment_receipt.v0` and `gamecult.idunn.deployment_aftercare_audit.v0` as compact `idunnDeploymentReceiptRows` / `IDUNN-DEPLOYMENT` rows with owner `Idunn`, watched/checked refs, source/result refs, aftercare ids, follow-up readback command, and `privateStateExposed=false`. Smoke `.epiphany-smoke\repo-deployment-config-family-20260620-223203` proves the aftercare audit still ingests CultMesh refs and Gjallar reports `gjallarIdunnDeploymentReceiptCount=2`, latest deployment receipt `fixture-idunn-deployment`, latest aftercare receipt `fixture-idunn-aftercare`, and no private-state exposure. This is citeable discovery only; deployment still happens by explicit operator `git push` observed by Idunn. - Mind adoption now has an explicit evidence-readiness refusal gate for plan-derived repo work. `derive-plan` carries verification asks into the Imagination action-item receipt; `adopt --from-plan` records verification asks and planning evidence needs in `epiphany.repo_work_mind_interpretation.v0` and refuses empty verification asks or evidence needs as `refused-missing-evidence-needs`, with next gate `imagination.replan_with_explicit_soul_evidence_needs`. Proof `.epiphany-smoke\repo-mind-evidence-guard-20260620-224426` grants no Hands/durable/service/publication/cross-body/private authority and writes no adoption receipt after tampering both arrays empty; regression `.epiphany-smoke\repo-planning-facets-20260620-224428` shows normal planning facets still close through Soul/Modeling/Mind. @@ -644,4 +645,4 @@ current_status: - 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. last_completed_repo_swarm_cut: Idunn-hosted repo-work queue-run lifecycle now includes bounded launch proof, not only plan/runbook artifacts. `tools/epiphany_local_run.ps1 -Mode repo-work-service-launch` routes the same `epiphany-work queue-run` command vector through `epiphany-daemon-supervisor service-launch --wait-child`, records an Idunn service lifecycle launch receipt, and does not install a Windows service, elevate, publish, merge, cross repos, or expose private state. Native proof `.epiphany-smoke\repo-work-service-lifecycle-20260621-002707` shows plan `planned`, runbook `written`, launch `completed`, launch exit code `0`, runbook directory readback before launch, launch directory readback after launch, `mutatesServiceManager=false`, `launchesService=true`, `waitChild=true`, and `privateStateExposed=false`; wrapper proof `local-20260621-012741-653-dd4fdae2` printed the same bounded launch mouth with owner `Idunn` and hosted body `repo-work`. - next_action: Continue repo-swarm MVP work from the documented Epiphany Online cut order in `notes/epiphany-repo-swarm-mvp-contract.md`. The next useful cut is deeper Persona-to-Imagination interpreter behavior, richer Soul/Modeling/Mind closure depth and map readback, or another useful repo-owned safe action family. The repo-work queue-run plan/runbook/launch/audit lifecycle is sealed; preserve Idunn service lifecycle ownership, Bifrost publication/upstream-main ownership, Mind durable-state admission, and existing CultMesh/Odin/Eve tool directories. Windows service install/start/deployment 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`. The next useful cut is richer Soul/Modeling/Mind closure depth and map readback, deeper Bifrost-first external work accounting, or another useful repo-owned safe action family. Persona-to-Imagination consensus readback and Mind-owned interpreter brief cargo are sealed; preserve Idunn service lifecycle ownership, Bifrost publication/upstream-main ownership, Mind durable-state admission, and existing CultMesh/Odin/Eve tool directories. Windows service install/start/deployment execution still requires explicit elevated operator authority.