Delete catalog-shaped planning witness
This commit is contained in:
parent
c8a5efd3cb
commit
c04b5f1a31
9 changed files with 24 additions and 1395 deletions
|
|
@ -1,679 +0,0 @@
|
|||
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,
|
||||
}
|
||||
|
||||
impl Args {
|
||||
fn parse() -> Result<Self> {
|
||||
let mut root = env::current_dir().context("failed to resolve current directory")?;
|
||||
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")?,
|
||||
other => return Err(anyhow!("unexpected argument {other:?}")),
|
||||
}
|
||||
}
|
||||
Ok(Self { root })
|
||||
}
|
||||
}
|
||||
|
||||
fn run_smoke(args: Args) -> Result<Value> {
|
||||
let root = args
|
||||
.root
|
||||
.canonicalize()
|
||||
.with_context(|| format!("failed to resolve {}", args.root.display()))?;
|
||||
let smoke_root = root.join(".epiphany-smoke");
|
||||
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(&smoke_root)
|
||||
.with_context(|| format!("failed to create {}", smoke_root.display()))?;
|
||||
let stamp = Utc::now().format("%Y%m%d-%H%M%S").to_string();
|
||||
let smoke_dir = smoke_root.join(format!("repo-planning-brief-family-{stamp}"));
|
||||
fs::create_dir(&smoke_dir)
|
||||
.with_context(|| format!("failed to claim fresh smoke dir {}", 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 Planning Brief Family Smoke\n\nThis repository proves branch-local Imagination safe-family planning briefs.\n",
|
||||
)
|
||||
.with_context(|| format!("failed to seed {}", repo.join("README.md").display()))?;
|
||||
git(["add", "README.md"], &repo)?;
|
||||
git(
|
||||
["commit", "-m", "Seed repo planning brief smoke body"],
|
||||
&repo,
|
||||
)?;
|
||||
git(
|
||||
["switch", "-c", "epiphany/repo-planning-brief-family"],
|
||||
&repo,
|
||||
)?;
|
||||
|
||||
let item = "repo-planning-brief-family";
|
||||
let target_path = ".epiphany/planning-briefs/repo-planning-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-planning-brief-family-smoke",
|
||||
"--topic",
|
||||
"repo-planning-brief-family",
|
||||
],
|
||||
&root,
|
||||
)?;
|
||||
cargo_json(
|
||||
&manifest,
|
||||
"epiphany-swarm",
|
||||
&[
|
||||
"online",
|
||||
"--workspace",
|
||||
path_str(&repo)?,
|
||||
"--epiphany-root",
|
||||
path_str(&root)?,
|
||||
"--runtime-id",
|
||||
"repo-planning-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 a rough Persona request into a safe-family planning brief before any work item receives Hands authority.",
|
||||
"--candidate-action-ref",
|
||||
"candidate-action://repo-planning-brief-family/decompose-safe-families",
|
||||
"--candidate-action-ref",
|
||||
"candidate-action://repo-planning-brief-family/request-mind-review",
|
||||
"--public-discussion-ref",
|
||||
"epiphany-global/persona-collaboration/repo-planning-brief-family",
|
||||
],
|
||||
&root,
|
||||
)?;
|
||||
let plan = cargo_json(
|
||||
&manifest,
|
||||
"epiphany-work",
|
||||
&[
|
||||
"derive-plan",
|
||||
"--workspace",
|
||||
path_str(&repo)?,
|
||||
"--item",
|
||||
item,
|
||||
"--action-family",
|
||||
"repo-planning-brief",
|
||||
"--model-ref",
|
||||
"repo-planning-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.planning_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_eq(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"schemaVersion",
|
||||
],
|
||||
"epiphany.repo_work_safe_family_planning_readback.v0",
|
||||
)?;
|
||||
require_eq(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"sourceSafeFamily",
|
||||
],
|
||||
"repo.planning_brief",
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"allExpectedCandidateFamiliesPresent",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"allPlanningRequirementsPresent",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"allRequiredGatesPresent",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"authorityDenied",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"privateStateExposed",
|
||||
],
|
||||
false,
|
||||
)?;
|
||||
require_u64(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"candidateNextSafeFamilyCount",
|
||||
],
|
||||
21,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"allMatrixGroupsComplete",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"matrixControlsPresent",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"candidateActionTemplatePresent",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"allClosureProofsPresent",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(
|
||||
&close,
|
||||
&[
|
||||
"closureReview",
|
||||
"familyAssertions",
|
||||
"safeFamilyPlanning",
|
||||
"closureLadderPresent",
|
||||
],
|
||||
true,
|
||||
)?;
|
||||
require_bool(&close, &["privateStateExposed"], false)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"schema_version = \"epiphany.repo_planning_brief.v0\"",
|
||||
)?;
|
||||
require_text(&brief_text, "safe_action_family = \"repo.planning_brief\"")?;
|
||||
require_text(&brief_text, "[planning_brief]")?;
|
||||
require_text(&brief_text, "status = \"draft\"")?;
|
||||
require_text(&brief_text, "owner = \"Imagination\"")?;
|
||||
require_text(&brief_text, "candidate_actions_non_authoritative = true")?;
|
||||
require_text(&brief_text, "requires_mind_interpretation = true")?;
|
||||
require_text(&brief_text, "requires_soul_evidence_needs = true")?;
|
||||
require_text(&brief_text, "[decomposition]")?;
|
||||
require_text(&brief_text, "\"repo.consensus_brief\"")?;
|
||||
require_text(&brief_text, "\"repo.interpreter_brief\"")?;
|
||||
require_text(&brief_text, "\"repo.objective_draft\"")?;
|
||||
require_text(&brief_text, "\"repo.adoption_request\"")?;
|
||||
require_text(&brief_text, "\"repo.scheduling_request\"")?;
|
||||
require_text(&brief_text, "\"repo.task_card\"")?;
|
||||
require_text(&brief_text, "\"repo.work_order\"")?;
|
||||
require_text(&brief_text, "\"repo.verification_request\"")?;
|
||||
require_text(&brief_text, "\"repo.maintainer_review_request\"")?;
|
||||
require_text(&brief_text, "\"repo.artifact_acceptance_request\"")?;
|
||||
require_text(&brief_text, "\"repo.publication_request\"")?;
|
||||
require_text(&brief_text, "\"repo.sync_request\"")?;
|
||||
require_text(&brief_text, "\"repo.pr_request\"")?;
|
||||
require_text(&brief_text, "\"repo.credit_request\"")?;
|
||||
require_text(&brief_text, "\"repo.metrics_request\"")?;
|
||||
require_text(&brief_text, "\"repo.readiness_review_request\"")?;
|
||||
require_text(&brief_text, "\"repo.doctrine_update_request\"")?;
|
||||
require_text(&brief_text, "\"repo.secret_policy_request\"")?;
|
||||
require_text(&brief_text, "\"repo.dependency_policy_request\"")?;
|
||||
require_text(&brief_text, "\"repo.deployment_config\"")?;
|
||||
require_text(&brief_text, "\"repo.deployment_request\"")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"candidate_items_must_name_requested_paths = true",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"candidate_items_must_name_verification_asks = true",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"candidate_items_must_name_evidence_needs = true",
|
||||
)?;
|
||||
require_text(&brief_text, "candidate_items_must_name_owner = true")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"candidate_items_must_name_authority_denials = true",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"candidate_items_must_name_closure_proofs = true",
|
||||
)?;
|
||||
require_text(&brief_text, "[candidate_action_template]")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"required_fields = [\"id\", \"safe_action_family\", \"owner\", \"status\", \"requested_paths\", \"verification_asks\", \"evidence_needs\", \"closure_proofs\", \"authority_denials\", \"next_gate\"]",
|
||||
)?;
|
||||
require_text(&brief_text, "\"ready-for-mind-review\"")?;
|
||||
require_text(&brief_text, "\"ready-for-self-queue\"")?;
|
||||
require_text(&brief_text, "\"blocked-needs-evidence\"")?;
|
||||
require_text(&brief_text, "status_must_be_explicit = true")?;
|
||||
require_text(&brief_text, "owner_must_match_safe_family_stage = true")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"closure_proofs_must_name_receipt_family = true",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"authority_denials_must_be_carried_forward = true",
|
||||
)?;
|
||||
require_text(&brief_text, "next_gate_must_name_owner = true")?;
|
||||
require_text(&brief_text, "candidate_items_are_not_queue_entries = true")?;
|
||||
require_text(&brief_text, "[safe_family_matrix]")?;
|
||||
require_text(&brief_text, "preparation = [")?;
|
||||
require_text(&brief_text, "adoption_and_queue = [")?;
|
||||
require_text(&brief_text, "execution_and_review = [")?;
|
||||
require_text(&brief_text, "publication_and_accounting = [")?;
|
||||
require_text(&brief_text, "policy_and_deployment = [")?;
|
||||
require_text(&brief_text, "matrix_is_planning_only = true")?;
|
||||
require_text(&brief_text, "families_may_not_inherit_authority = true")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"family_choice_requires_mind_or_self_review = true",
|
||||
)?;
|
||||
require_text(&brief_text, "[closure_proofs]")?;
|
||||
require_text(&brief_text, "soul_family_assertions_required = true")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"modeling_map_update_required_after_verified_consequence = true",
|
||||
)?;
|
||||
require_text(&brief_text, "mind_gateway_review_required = true")?;
|
||||
require_text(&brief_text, "mind_state_commit_required = true")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"bifrost_publication_gate_required_for_upstream = true",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"upstream_main_sync_required_after_publication = true",
|
||||
)?;
|
||||
require_text(&brief_text, "private_state_redaction_required = true")?;
|
||||
require_text(&brief_text, "[closure_ladder]")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"draft_closed_by = \"explicit Mind or human selection of one candidate family\"",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"queued_closed_by = \"Self queue-run receipt for the adopted item\"",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"execution_closed_by = \"Hands patch, command, and commit receipts\"",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"verification_closed_by = \"Soul closure review and verdict receipt\"",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"map_closed_by = \"Modeling map update plus Mind gateway review and state commit\"",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"publication_closed_by = \"Bifrost public proof publication or explicit non-publication decision\"",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"deployment_closed_by = \"Idunn deployment config or lifecycle receipt when deployment is in scope\"",
|
||||
)?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"private_state_closed_by = \"redaction report proving sealed worker/operator/private Verse payloads stayed sealed\"",
|
||||
)?;
|
||||
require_text(&brief_text, "closure_ladder_is_planning_only = true")?;
|
||||
require_text(&brief_text, "[gates]")?;
|
||||
require_text(&brief_text, "mind_interpreter_required = true")?;
|
||||
require_text(&brief_text, "self_queue_selection_required = true")?;
|
||||
require_text(&brief_text, "substrate_gate_required_before_hands = true")?;
|
||||
require_text(&brief_text, "hands_receipts_required_before_soul = true")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"soul_verdict_required_before_mind_map_admission = true",
|
||||
)?;
|
||||
require_text(&brief_text, "bifrost_required_before_publication = true")?;
|
||||
require_text(
|
||||
&brief_text,
|
||||
"idunn_required_before_deployment_execution = true",
|
||||
)?;
|
||||
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_planning_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"],
|
||||
"safeFamilyPlanningSchema": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["schemaVersion"],
|
||||
"candidateNextSafeFamilyCount": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["candidateNextSafeFamilyCount"],
|
||||
"allExpectedCandidateFamiliesPresent": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["allExpectedCandidateFamiliesPresent"],
|
||||
"allMatrixGroupsComplete": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["allMatrixGroupsComplete"],
|
||||
"matrixControlsPresent": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["matrixControlsPresent"],
|
||||
"candidateActionTemplatePresent": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["candidateActionTemplatePresent"],
|
||||
"allClosureProofsPresent": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["allClosureProofsPresent"],
|
||||
"closureLadderPresent": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["closureLadderPresent"],
|
||||
"allRequiredGatesPresent": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["allRequiredGatesPresent"],
|
||||
"authorityDenied": close["closureReview"]["familyAssertions"]["safeFamilyPlanning"]["authorityDenied"],
|
||||
"briefIsDraft": true,
|
||||
"candidateActionsNonAuthoritative": true,
|
||||
"mindInterpreterRequired": true,
|
||||
"soulEvidenceNeedsRequired": true,
|
||||
"idunnDeploymentExecutionRequired": true,
|
||||
"privateStateExposed": false,
|
||||
});
|
||||
write_json(&smoke_dir.join("summary.json"), &summary)?;
|
||||
Ok(summary)
|
||||
}
|
||||
|
||||
fn cargo_json(manifest: &Path, bin: &str, args: &[&str], cwd: &Path) -> Result<Value> {
|
||||
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<const N: usize>(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<const N: usize>(args: [&str; N], cwd: &Path) -> Result<String> {
|
||||
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<Value> {
|
||||
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("<missing>");
|
||||
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_u64(value: &Value, path: &[&str], expected: u64) -> Result<()> {
|
||||
let actual = path
|
||||
.iter()
|
||||
.try_fold(value, |current, key| current.get(*key))
|
||||
.and_then(Value::as_u64);
|
||||
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 planning brief text to contain {needle:?}"
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
fn take_path(
|
||||
args: &mut std::iter::Peekable<impl Iterator<Item = String>>,
|
||||
flag: &str,
|
||||
) -> Result<PathBuf> {
|
||||
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()))
|
||||
}
|
||||
|
|
@ -5055,7 +5055,6 @@ fn repo_work_stage_for_family(safe_action_family: &str) -> (String, String) {
|
|||
| "repo.status_section"
|
||||
| "repo.task_card"
|
||||
| "repo.consensus_brief"
|
||||
| "repo.planning_brief"
|
||||
| "repo.objective_draft" => "imagination-planning",
|
||||
"repo.body_manifest"
|
||||
| "repo.tool_capabilities"
|
||||
|
|
|
|||
|
|
@ -2221,9 +2221,6 @@ fn derive_safe_plan_family(input: DeriveSafePlanInput<'_>) -> Result<DerivedSafe
|
|||
"repo-consensus-brief" | "consensus-brief" | "imagination-consensus" => {
|
||||
derive_repo_consensus_brief_plan(input, &action_family)
|
||||
}
|
||||
"repo-planning-brief" | "planning-brief" | "safe-family-plan" => {
|
||||
derive_repo_planning_brief_plan(input, &action_family)
|
||||
}
|
||||
"repo-interpreter-brief" | "interpreter-brief" | "mind-interpreter-brief" => {
|
||||
derive_repo_interpreter_brief_plan(input, &action_family)
|
||||
}
|
||||
|
|
@ -2292,7 +2289,7 @@ fn derive_safe_plan_family(input: DeriveSafePlanInput<'_>) -> Result<DerivedSafe
|
|||
| "idunn-deployment-request"
|
||||
| "repo-deploy-request" => 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-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-readiness-review-request, repo-doctrine-update-request, repo-secret-policy-request, repo-dependency-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-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-readiness-review-request, repo-doctrine-update-request, repo-secret-policy-request, repo-dependency-policy-request, repo-deployment-config, and repo-deployment-request"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
|
@ -3497,221 +3494,6 @@ fn derive_repo_consensus_brief_plan(
|
|||
})
|
||||
}
|
||||
|
||||
fn derive_repo_planning_brief_plan(
|
||||
input: DeriveSafePlanInput<'_>,
|
||||
action_family: &str,
|
||||
) -> Result<DerivedSafePlan> {
|
||||
let item_slug = sanitize(input.item);
|
||||
let default_target = format!(".epiphany/planning-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-planning-brief:{item_slug}");
|
||||
let recommended_families = vec![
|
||||
"repo.consensus_brief".to_string(),
|
||||
"repo.interpreter_brief".to_string(),
|
||||
"repo.objective_draft".to_string(),
|
||||
"repo.adoption_request".to_string(),
|
||||
"repo.scheduling_request".to_string(),
|
||||
"repo.task_card".to_string(),
|
||||
"repo.work_order".to_string(),
|
||||
"repo.verification_request".to_string(),
|
||||
"repo.maintainer_review_request".to_string(),
|
||||
"repo.artifact_acceptance_request".to_string(),
|
||||
"repo.publication_request".to_string(),
|
||||
"repo.sync_request".to_string(),
|
||||
"repo.pr_request".to_string(),
|
||||
"repo.credit_request".to_string(),
|
||||
"repo.metrics_request".to_string(),
|
||||
"repo.readiness_review_request".to_string(),
|
||||
"repo.doctrine_update_request".to_string(),
|
||||
"repo.secret_policy_request".to_string(),
|
||||
"repo.dependency_policy_request".to_string(),
|
||||
"repo.deployment_config".to_string(),
|
||||
"repo.deployment_request".to_string(),
|
||||
];
|
||||
let lines = vec![
|
||||
"# Epiphany repo planning brief.".to_string(),
|
||||
"# Branch-local Imagination decomposition cargo; not objective adoption, scheduling, Hands authority, or publication.".to_string(),
|
||||
format!(
|
||||
"schema_version = {}",
|
||||
toml_basic_string("epiphany.repo_planning_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.planning_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(),
|
||||
"[planning_brief]".to_string(),
|
||||
format!("id = {}", toml_basic_string(&brief_id)),
|
||||
"status = \"draft\"".to_string(),
|
||||
"owner = \"Imagination\"".to_string(),
|
||||
"purpose = \"decompose rough Persona or operator pressure into bounded safe-family work items\"".to_string(),
|
||||
"candidate_actions_non_authoritative = true".to_string(),
|
||||
"requires_mind_interpretation = true".to_string(),
|
||||
"requires_soul_evidence_needs = true".to_string(),
|
||||
"requires_explicit_human_or_mind_adoption = true".to_string(),
|
||||
format!(
|
||||
"recommended_next_safe_families = {}",
|
||||
toml_array(&recommended_families)
|
||||
),
|
||||
String::new(),
|
||||
"[decomposition]".to_string(),
|
||||
"sequence = [".to_string(),
|
||||
" \"repo.consensus_brief\",".to_string(),
|
||||
" \"repo.interpreter_brief\",".to_string(),
|
||||
" \"repo.objective_draft\",".to_string(),
|
||||
" \"repo.adoption_request\",".to_string(),
|
||||
" \"repo.scheduling_request\",".to_string(),
|
||||
" \"repo.task_card\",".to_string(),
|
||||
" \"repo.work_order\",".to_string(),
|
||||
" \"repo.verification_request\",".to_string(),
|
||||
" \"repo.maintainer_review_request\",".to_string(),
|
||||
" \"repo.artifact_acceptance_request\",".to_string(),
|
||||
" \"repo.publication_request\"".to_string(),
|
||||
"]".to_string(),
|
||||
"max_candidate_work_items = 6".to_string(),
|
||||
"one_safe_family_per_action_item = true".to_string(),
|
||||
"candidate_items_must_name_requested_paths = true".to_string(),
|
||||
"candidate_items_must_name_verification_asks = true".to_string(),
|
||||
"candidate_items_must_name_evidence_needs = true".to_string(),
|
||||
"candidate_items_must_name_owner = true".to_string(),
|
||||
"candidate_items_must_name_authority_denials = true".to_string(),
|
||||
"candidate_items_must_name_closure_proofs = true".to_string(),
|
||||
"shell_commands_must_be_deterministic_lowerings = true".to_string(),
|
||||
String::new(),
|
||||
"[candidate_action_template]".to_string(),
|
||||
"required_fields = [\"id\", \"safe_action_family\", \"owner\", \"status\", \"requested_paths\", \"verification_asks\", \"evidence_needs\", \"closure_proofs\", \"authority_denials\", \"next_gate\"]".to_string(),
|
||||
"allowed_statuses = [\"idea\", \"ready-for-mind-review\", \"ready-for-self-queue\", \"blocked-needs-evidence\", \"closed\"]".to_string(),
|
||||
"status_must_be_explicit = true".to_string(),
|
||||
"owner_must_match_safe_family_stage = true".to_string(),
|
||||
"requested_paths_may_be_empty_only_for_readback_or_policy_requests = true".to_string(),
|
||||
"closure_proofs_must_name_receipt_family = true".to_string(),
|
||||
"authority_denials_must_be_carried_forward = true".to_string(),
|
||||
"next_gate_must_name_owner = true".to_string(),
|
||||
"candidate_items_are_not_queue_entries = true".to_string(),
|
||||
String::new(),
|
||||
"[safe_family_matrix]".to_string(),
|
||||
"preparation = [\"repo.consensus_brief\", \"repo.interpreter_brief\", \"repo.objective_draft\", \"repo.task_card\"]".to_string(),
|
||||
"adoption_and_queue = [\"repo.adoption_request\", \"repo.scheduling_request\"]".to_string(),
|
||||
"execution_and_review = [\"repo.work_order\", \"repo.verification_request\", \"repo.maintainer_review_request\", \"repo.artifact_acceptance_request\"]".to_string(),
|
||||
"publication_and_accounting = [\"repo.publication_request\", \"repo.sync_request\", \"repo.pr_request\", \"repo.credit_request\", \"repo.metrics_request\", \"repo.readiness_review_request\"]".to_string(),
|
||||
"policy_and_deployment = [\"repo.doctrine_update_request\", \"repo.secret_policy_request\", \"repo.dependency_policy_request\", \"repo.deployment_config\", \"repo.deployment_request\"]".to_string(),
|
||||
"matrix_is_planning_only = true".to_string(),
|
||||
"families_may_not_inherit_authority = true".to_string(),
|
||||
"family_choice_requires_mind_or_self_review = true".to_string(),
|
||||
String::new(),
|
||||
"[closure_proofs]".to_string(),
|
||||
"soul_family_assertions_required = true".to_string(),
|
||||
"modeling_map_update_required_after_verified_consequence = true".to_string(),
|
||||
"mind_gateway_review_required = true".to_string(),
|
||||
"mind_state_commit_required = true".to_string(),
|
||||
"bifrost_publication_gate_required_for_upstream = true".to_string(),
|
||||
"upstream_main_sync_required_after_publication = true".to_string(),
|
||||
"private_state_redaction_required = true".to_string(),
|
||||
String::new(),
|
||||
"[closure_ladder]".to_string(),
|
||||
"draft_closed_by = \"explicit Mind or human selection of one candidate family\"".to_string(),
|
||||
"queued_closed_by = \"Self queue-run receipt for the adopted item\"".to_string(),
|
||||
"execution_closed_by = \"Hands patch, command, and commit receipts\"".to_string(),
|
||||
"verification_closed_by = \"Soul closure review and verdict receipt\"".to_string(),
|
||||
"map_closed_by = \"Modeling map update plus Mind gateway review and state commit\"".to_string(),
|
||||
"publication_closed_by = \"Bifrost public proof publication or explicit non-publication decision\"".to_string(),
|
||||
"deployment_closed_by = \"Idunn deployment config or lifecycle receipt when deployment is in scope\"".to_string(),
|
||||
"private_state_closed_by = \"redaction report proving sealed worker/operator/private Verse payloads stayed sealed\"".to_string(),
|
||||
"closure_ladder_is_planning_only = true".to_string(),
|
||||
String::new(),
|
||||
"[gates]".to_string(),
|
||||
"mind_interpreter_required = true".to_string(),
|
||||
"mind_adoption_required = true".to_string(),
|
||||
"self_queue_selection_required = true".to_string(),
|
||||
"substrate_gate_required_before_hands = true".to_string(),
|
||||
"hands_receipts_required_before_soul = true".to_string(),
|
||||
"soul_verdict_required_before_mind_map_admission = true".to_string(),
|
||||
"bifrost_required_before_publication = true".to_string(),
|
||||
"idunn_required_before_deployment_execution = true".to_string(),
|
||||
String::new(),
|
||||
"[inputs]".to_string(),
|
||||
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(),
|
||||
"[authority]".to_string(),
|
||||
"branch_local_only = true".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_verse_rummaging = false".to_string(),
|
||||
"mind_adoption_required = true".to_string(),
|
||||
"soul_verification_required = true".to_string(),
|
||||
"bifrost_publication_required = true".to_string(),
|
||||
String::new(),
|
||||
"[verification]".to_string(),
|
||||
"asks = [".to_string(),
|
||||
" \"Soul verifies the planning brief path changed and contains the accepted pressure summary.\",".to_string(),
|
||||
" \"Soul verifies the brief names the safe-family matrix, requested-path/evidence/closure requirements, and gate order without granting action authority.\",".to_string(),
|
||||
" \"Soul verifies the brief preserves private-state seals and forbids deployment execution authority.\",".to_string(),
|
||||
" \"Soul verifies no paths outside the declared planning brief changed.\"".to_string(),
|
||||
"]".to_string(),
|
||||
String::new(),
|
||||
"[rollback]".to_string(),
|
||||
"hints = [\"Remove the planning brief if the rough pressure was misread or the decomposition is not ready for Mind review.\"]".to_string(),
|
||||
String::new(),
|
||||
];
|
||||
let command = powershell_set_lines_command(&target_path, &lines);
|
||||
Ok(DerivedSafePlan {
|
||||
safe_action_family: "repo.planning_brief".to_string(),
|
||||
target_path,
|
||||
plan_summary: format!(
|
||||
"Imagination derived a repo planning brief from accepted {} pressure.",
|
||||
input.source
|
||||
),
|
||||
command,
|
||||
commit_message: format!("Add planning brief for work item {}", input.item),
|
||||
verification_asks: vec![
|
||||
"Soul verifies the repo planning brief path changed and contains the accepted pressure summary.".to_string(),
|
||||
"Soul verifies the brief names allowed next safe-family groups, path/evidence/closure requirements, and Mind/Self/Substrate/Hands/Soul/Bifrost/Idunn gates without authorizing action.".to_string(),
|
||||
"Soul verifies no paths outside the declared planning brief changed.".to_string(),
|
||||
],
|
||||
rollback_hints: vec![
|
||||
"Remove the generated planning brief if Imagination decomposed the pressure incorrectly.".to_string(),
|
||||
],
|
||||
derivation: plan_derivation_receipt(input, action_family, "repo.planning_brief"),
|
||||
})
|
||||
}
|
||||
|
||||
fn derive_repo_interpreter_brief_plan(
|
||||
input: DeriveSafePlanInput<'_>,
|
||||
action_family: &str,
|
||||
|
|
@ -6343,7 +6125,6 @@ fn closure_family_assertions(
|
|||
let item_slug = sanitize(item);
|
||||
let committed_content = read_committed_file(workspace, commit_sha, &target_path)?;
|
||||
let mut assertions = Vec::new();
|
||||
let mut safe_family_planning = Value::Null;
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"target-blob-present",
|
||||
|
|
@ -6961,183 +6742,6 @@ fn closure_family_assertions(
|
|||
"Committed consensus brief preserves the private-state seal.".to_string(),
|
||||
);
|
||||
}
|
||||
"repo.planning_brief" => {
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-schema-present",
|
||||
content.contains("schema_version = \"epiphany.repo_planning_brief.v0\""),
|
||||
"Committed planning brief carries the schema version.".to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-family-present",
|
||||
content.contains("safe_action_family = \"repo.planning_brief\""),
|
||||
"Committed planning brief carries the safe action family.".to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-summary-present",
|
||||
content.contains(&compact_summary),
|
||||
"Committed planning brief contains the accepted pressure summary.".to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-decomposition-contract",
|
||||
content.contains("[decomposition]")
|
||||
&& content.contains("\"repo.consensus_brief\"")
|
||||
&& content.contains("\"repo.interpreter_brief\"")
|
||||
&& content.contains("\"repo.objective_draft\"")
|
||||
&& content.contains("\"repo.adoption_request\"")
|
||||
&& content.contains("\"repo.scheduling_request\"")
|
||||
&& content.contains("\"repo.task_card\"")
|
||||
&& content.contains("\"repo.work_order\"")
|
||||
&& content.contains("\"repo.verification_request\"")
|
||||
&& content.contains("\"repo.maintainer_review_request\"")
|
||||
&& content.contains("\"repo.artifact_acceptance_request\"")
|
||||
&& content.contains("\"repo.publication_request\"")
|
||||
&& content.contains("candidate_items_must_name_requested_paths = true")
|
||||
&& content.contains("candidate_items_must_name_verification_asks = true")
|
||||
&& content.contains("candidate_items_must_name_evidence_needs = true")
|
||||
&& content.contains("candidate_items_must_name_owner = true")
|
||||
&& content.contains("candidate_items_must_name_authority_denials = true")
|
||||
&& content.contains("candidate_items_must_name_closure_proofs = true"),
|
||||
"Committed planning brief names the safe-family decomposition contract."
|
||||
.to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-candidate-action-template",
|
||||
content.contains("[candidate_action_template]")
|
||||
&& content.contains("\"id\"")
|
||||
&& content.contains("\"safe_action_family\"")
|
||||
&& content.contains("\"owner\"")
|
||||
&& content.contains("\"status\"")
|
||||
&& content.contains("\"requested_paths\"")
|
||||
&& content.contains("\"verification_asks\"")
|
||||
&& content.contains("\"evidence_needs\"")
|
||||
&& content.contains("\"closure_proofs\"")
|
||||
&& content.contains("\"authority_denials\"")
|
||||
&& content.contains("\"next_gate\"")
|
||||
&& content.contains("allowed_statuses = [")
|
||||
&& content.contains("\"ready-for-mind-review\"")
|
||||
&& content.contains("\"ready-for-self-queue\"")
|
||||
&& content.contains("\"blocked-needs-evidence\"")
|
||||
&& content.contains("candidate_items_are_not_queue_entries = true"),
|
||||
"Committed planning brief gives each candidate action an explicit status, owner, evidence, closure, denial, and next-gate shape without making it a queue entry."
|
||||
.to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-family-matrix",
|
||||
content.contains("[safe_family_matrix]")
|
||||
&& content.contains("preparation = [")
|
||||
&& content.contains("adoption_and_queue = [")
|
||||
&& content.contains("execution_and_review = [")
|
||||
&& content.contains("publication_and_accounting = [")
|
||||
&& content.contains("policy_and_deployment = [")
|
||||
&& content.contains("\"repo.sync_request\"")
|
||||
&& content.contains("\"repo.pr_request\"")
|
||||
&& content.contains("\"repo.credit_request\"")
|
||||
&& content.contains("\"repo.metrics_request\"")
|
||||
&& content.contains("\"repo.doctrine_update_request\"")
|
||||
&& content.contains("\"repo.secret_policy_request\"")
|
||||
&& content.contains("\"repo.dependency_policy_request\"")
|
||||
&& content.contains("\"repo.deployment_config\"")
|
||||
&& content.contains("\"repo.deployment_request\"")
|
||||
&& content.contains("matrix_is_planning_only = true")
|
||||
&& content.contains("families_may_not_inherit_authority = true")
|
||||
&& content.contains("family_choice_requires_mind_or_self_review = true"),
|
||||
"Committed planning brief carries the safe-family matrix without authority inheritance."
|
||||
.to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-closure-proof-contract",
|
||||
content.contains("[closure_proofs]")
|
||||
&& content.contains("soul_family_assertions_required = true")
|
||||
&& content.contains("modeling_map_update_required_after_verified_consequence = true")
|
||||
&& content.contains("mind_gateway_review_required = true")
|
||||
&& content.contains("mind_state_commit_required = true")
|
||||
&& content.contains("bifrost_publication_gate_required_for_upstream = true")
|
||||
&& content.contains("upstream_main_sync_required_after_publication = true")
|
||||
&& content.contains("private_state_redaction_required = true"),
|
||||
"Committed planning brief names Soul, Modeling, Mind, Bifrost, upstream-main, and redaction closure proofs."
|
||||
.to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-closure-ladder",
|
||||
content.contains("[closure_ladder]")
|
||||
&& content.contains(
|
||||
"draft_closed_by = \"explicit Mind or human selection of one candidate family\"",
|
||||
)
|
||||
&& content.contains(
|
||||
"queued_closed_by = \"Self queue-run receipt for the adopted item\"",
|
||||
)
|
||||
&& content.contains(
|
||||
"execution_closed_by = \"Hands patch, command, and commit receipts\"",
|
||||
)
|
||||
&& content.contains(
|
||||
"verification_closed_by = \"Soul closure review and verdict receipt\"",
|
||||
)
|
||||
&& content.contains(
|
||||
"map_closed_by = \"Modeling map update plus Mind gateway review and state commit\"",
|
||||
)
|
||||
&& content.contains(
|
||||
"publication_closed_by = \"Bifrost public proof publication or explicit non-publication decision\"",
|
||||
)
|
||||
&& content.contains(
|
||||
"deployment_closed_by = \"Idunn deployment config or lifecycle receipt when deployment is in scope\"",
|
||||
)
|
||||
&& content.contains(
|
||||
"private_state_closed_by = \"redaction report proving sealed worker/operator/private Verse payloads stayed sealed\"",
|
||||
)
|
||||
&& content.contains("closure_ladder_is_planning_only = true"),
|
||||
"Committed planning brief carries an explicit closure ladder from draft selection through Self, Hands, Soul, Modeling/Mind, Bifrost, Idunn, and redaction."
|
||||
.to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-gates-present",
|
||||
content.contains("[gates]")
|
||||
&& content.contains("mind_interpreter_required = true")
|
||||
&& content.contains("self_queue_selection_required = true")
|
||||
&& content.contains("substrate_gate_required_before_hands = true")
|
||||
&& content.contains("hands_receipts_required_before_soul = true")
|
||||
&& content.contains("soul_verdict_required_before_mind_map_admission = true")
|
||||
&& content.contains("bifrost_required_before_publication = true")
|
||||
&& content.contains("idunn_required_before_deployment_execution = true"),
|
||||
"Committed planning brief names the ordered Mind/Self/Substrate/Hands/Soul/Bifrost/Idunn gates."
|
||||
.to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-authority-seals",
|
||||
content.contains("[authority]")
|
||||
&& 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")
|
||||
&& content.contains("private_verse_rummaging = false"),
|
||||
"Committed planning brief denies adoption/scheduling/substrate/action/shell/commit/publication/deployment/cross-body authority."
|
||||
.to_string(),
|
||||
);
|
||||
push_assertion(
|
||||
&mut assertions,
|
||||
"planning-brief-private-seal",
|
||||
content.contains("private_state_exposed = false")
|
||||
&& content.contains("private_worker_transcripts_allowed = false")
|
||||
&& content.contains("raw_result_payloads_allowed = false"),
|
||||
"Committed planning brief preserves private-state and transcript seals."
|
||||
.to_string(),
|
||||
);
|
||||
safe_family_planning = planning_brief_safe_family_readback(&content);
|
||||
}
|
||||
"repo.interpreter_brief" => {
|
||||
let brief = parse_repo_interpreter_brief(&content).ok();
|
||||
push_assertion(
|
||||
|
|
@ -8572,249 +8176,12 @@ fn closure_family_assertions(
|
|||
"safeActionFamily": safe_family,
|
||||
"targetPath": target_path,
|
||||
"planReceiptPath": plan_receipt_path,
|
||||
"safeFamilyPlanning": safe_family_planning,
|
||||
"assertions": assertions
|
||||
}),
|
||||
passed,
|
||||
))
|
||||
}
|
||||
|
||||
fn planning_brief_safe_family_readback(content: &str) -> Value {
|
||||
let candidate_families = [
|
||||
"repo.consensus_brief",
|
||||
"repo.interpreter_brief",
|
||||
"repo.objective_draft",
|
||||
"repo.adoption_request",
|
||||
"repo.scheduling_request",
|
||||
"repo.task_card",
|
||||
"repo.work_order",
|
||||
"repo.verification_request",
|
||||
"repo.maintainer_review_request",
|
||||
"repo.artifact_acceptance_request",
|
||||
"repo.publication_request",
|
||||
"repo.sync_request",
|
||||
"repo.pr_request",
|
||||
"repo.credit_request",
|
||||
"repo.metrics_request",
|
||||
"repo.readiness_review_request",
|
||||
"repo.doctrine_update_request",
|
||||
"repo.secret_policy_request",
|
||||
"repo.dependency_policy_request",
|
||||
"repo.deployment_config",
|
||||
"repo.deployment_request",
|
||||
];
|
||||
let matrix_groups: Vec<(&str, Vec<&str>)> = vec![
|
||||
(
|
||||
"preparation",
|
||||
vec![
|
||||
"repo.consensus_brief",
|
||||
"repo.interpreter_brief",
|
||||
"repo.objective_draft",
|
||||
"repo.task_card",
|
||||
],
|
||||
),
|
||||
(
|
||||
"adoption_and_queue",
|
||||
vec!["repo.adoption_request", "repo.scheduling_request"],
|
||||
),
|
||||
(
|
||||
"execution_and_review",
|
||||
vec![
|
||||
"repo.work_order",
|
||||
"repo.verification_request",
|
||||
"repo.maintainer_review_request",
|
||||
"repo.artifact_acceptance_request",
|
||||
],
|
||||
),
|
||||
(
|
||||
"publication_and_accounting",
|
||||
vec![
|
||||
"repo.publication_request",
|
||||
"repo.sync_request",
|
||||
"repo.pr_request",
|
||||
"repo.credit_request",
|
||||
"repo.metrics_request",
|
||||
"repo.readiness_review_request",
|
||||
],
|
||||
),
|
||||
(
|
||||
"policy_and_deployment",
|
||||
vec![
|
||||
"repo.doctrine_update_request",
|
||||
"repo.secret_policy_request",
|
||||
"repo.dependency_policy_request",
|
||||
"repo.deployment_config",
|
||||
"repo.deployment_request",
|
||||
],
|
||||
),
|
||||
];
|
||||
let candidate_rows: Vec<Value> = candidate_families
|
||||
.iter()
|
||||
.map(|family| {
|
||||
json!({
|
||||
"safeActionFamily": family,
|
||||
"present": content.contains(&format!("\"{family}\"")),
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
let matrix_rows: Vec<Value> = matrix_groups
|
||||
.iter()
|
||||
.map(|(group, families)| {
|
||||
let families_present = families
|
||||
.iter()
|
||||
.filter(|family| content.contains(&format!("\"{family}\"")))
|
||||
.count();
|
||||
json!({
|
||||
"group": group,
|
||||
"familyCount": families.len(),
|
||||
"presentCount": families_present,
|
||||
"complete": families_present == families.len(),
|
||||
"families": families.iter().map(|family| json!({
|
||||
"safeActionFamily": family,
|
||||
"present": content.contains(&format!("\"{family}\"")),
|
||||
})).collect::<Vec<_>>(),
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
let gates = json!({
|
||||
"mindInterpreterRequired": content.contains("mind_interpreter_required = true"),
|
||||
"mindAdoptionRequired": content.contains("mind_adoption_required = true"),
|
||||
"selfQueueSelectionRequired": content.contains("self_queue_selection_required = true"),
|
||||
"substrateGateRequiredBeforeHands": content.contains("substrate_gate_required_before_hands = true"),
|
||||
"handsReceiptsRequiredBeforeSoul": content.contains("hands_receipts_required_before_soul = true"),
|
||||
"soulVerdictRequiredBeforeMindMapAdmission": content.contains("soul_verdict_required_before_mind_map_admission = true"),
|
||||
"bifrostRequiredBeforePublication": content.contains("bifrost_required_before_publication = true"),
|
||||
"idunnRequiredBeforeDeploymentExecution": content.contains("idunn_required_before_deployment_execution = true"),
|
||||
});
|
||||
let requirements = json!({
|
||||
"oneSafeFamilyPerActionItem": content.contains("one_safe_family_per_action_item = true"),
|
||||
"requestedPathsRequired": content.contains("candidate_items_must_name_requested_paths = true"),
|
||||
"verificationAsksRequired": content.contains("candidate_items_must_name_verification_asks = true"),
|
||||
"evidenceNeedsRequired": content.contains("candidate_items_must_name_evidence_needs = true"),
|
||||
"ownerRequired": content.contains("candidate_items_must_name_owner = true"),
|
||||
"authorityDenialsRequired": content.contains("candidate_items_must_name_authority_denials = true"),
|
||||
"closureProofsRequired": content.contains("candidate_items_must_name_closure_proofs = true"),
|
||||
"deterministicLoweringRequired": content.contains("shell_commands_must_be_deterministic_lowerings = true"),
|
||||
});
|
||||
let matrix_controls = json!({
|
||||
"matrixIsPlanningOnly": content.contains("matrix_is_planning_only = true"),
|
||||
"familiesMayNotInheritAuthority": content.contains("families_may_not_inherit_authority = true"),
|
||||
"familyChoiceRequiresMindOrSelfReview": content.contains("family_choice_requires_mind_or_self_review = true"),
|
||||
});
|
||||
let candidate_action_template = json!({
|
||||
"idRequired": content.contains("\"id\""),
|
||||
"safeActionFamilyRequired": content.contains("\"safe_action_family\""),
|
||||
"ownerRequired": content.contains("\"owner\""),
|
||||
"statusRequired": content.contains("\"status\""),
|
||||
"requestedPathsRequired": content.contains("\"requested_paths\""),
|
||||
"verificationAsksRequired": content.contains("\"verification_asks\""),
|
||||
"evidenceNeedsRequired": content.contains("\"evidence_needs\""),
|
||||
"closureProofsRequired": content.contains("\"closure_proofs\""),
|
||||
"authorityDenialsRequired": content.contains("\"authority_denials\""),
|
||||
"nextGateRequired": content.contains("\"next_gate\""),
|
||||
"readyForMindReviewStatus": content.contains("\"ready-for-mind-review\""),
|
||||
"readyForSelfQueueStatus": content.contains("\"ready-for-self-queue\""),
|
||||
"blockedNeedsEvidenceStatus": content.contains("\"blocked-needs-evidence\""),
|
||||
"notQueueEntry": content.contains("candidate_items_are_not_queue_entries = true"),
|
||||
});
|
||||
let closure_proofs = json!({
|
||||
"soulFamilyAssertionsRequired": content.contains("soul_family_assertions_required = true"),
|
||||
"modelingMapUpdateRequiredAfterVerifiedConsequence": content.contains("modeling_map_update_required_after_verified_consequence = true"),
|
||||
"mindGatewayReviewRequired": content.contains("mind_gateway_review_required = true"),
|
||||
"mindStateCommitRequired": content.contains("mind_state_commit_required = true"),
|
||||
"bifrostPublicationGateRequiredForUpstream": content.contains("bifrost_publication_gate_required_for_upstream = true"),
|
||||
"upstreamMainSyncRequiredAfterPublication": content.contains("upstream_main_sync_required_after_publication = true"),
|
||||
"privateStateRedactionRequired": content.contains("private_state_redaction_required = true"),
|
||||
});
|
||||
let closure_ladder = json!({
|
||||
"draftClosedBySelection": content.contains("draft_closed_by = \"explicit Mind or human selection of one candidate family\""),
|
||||
"queuedClosedBySelf": content.contains("queued_closed_by = \"Self queue-run receipt for the adopted item\""),
|
||||
"executionClosedByHands": content.contains("execution_closed_by = \"Hands patch, command, and commit receipts\""),
|
||||
"verificationClosedBySoul": content.contains("verification_closed_by = \"Soul closure review and verdict receipt\""),
|
||||
"mapClosedByModelingMind": content.contains("map_closed_by = \"Modeling map update plus Mind gateway review and state commit\""),
|
||||
"publicationClosedByBifrost": content.contains("publication_closed_by = \"Bifrost public proof publication or explicit non-publication decision\""),
|
||||
"deploymentClosedByIdunn": content.contains("deployment_closed_by = \"Idunn deployment config or lifecycle receipt when deployment is in scope\""),
|
||||
"privateStateClosedByRedaction": content.contains("private_state_closed_by = \"redaction report proving sealed worker/operator/private Verse payloads stayed sealed\""),
|
||||
"planningOnly": content.contains("closure_ladder_is_planning_only = true"),
|
||||
});
|
||||
let authority_denials = json!({
|
||||
"objectiveAdoptionAuthorized": content.contains("objective_adoption_authorized = true"),
|
||||
"selfSchedulingAuthorized": content.contains("self_scheduling_authorized = true"),
|
||||
"substrateAccessAuthorized": content.contains("substrate_access_authorized = true"),
|
||||
"handsActionAuthorized": content.contains("hands_action_authorized = true"),
|
||||
"shellCommandAuthorized": content.contains("shell_command_authorized = true"),
|
||||
"commitAuthorized": content.contains("commit_authorized = true"),
|
||||
"publicationAuthorized": content.contains("publication_authorized = true"),
|
||||
"deploymentExecutionAuthority": content.contains("deployment_execution_authority = true"),
|
||||
"crossBodyMutationAuthorized": content.contains("cross_body_mutation_authorized = true"),
|
||||
"privateVerseRummaging": content.contains("private_verse_rummaging = true"),
|
||||
"privateStateExposed": content.contains("private_state_exposed = true"),
|
||||
"privateWorkerTranscriptsAllowed": content.contains("private_worker_transcripts_allowed = true"),
|
||||
"rawResultPayloadsAllowed": content.contains("raw_result_payloads_allowed = true"),
|
||||
});
|
||||
let present_count = candidate_rows
|
||||
.iter()
|
||||
.filter(|row| row.get("present").and_then(Value::as_bool) == Some(true))
|
||||
.count();
|
||||
let all_required_gates_present = gates
|
||||
.as_object()
|
||||
.map(|fields| fields.values().all(|value| value.as_bool() == Some(true)))
|
||||
.unwrap_or(false);
|
||||
let all_requirements_present = requirements
|
||||
.as_object()
|
||||
.map(|fields| fields.values().all(|value| value.as_bool() == Some(true)))
|
||||
.unwrap_or(false);
|
||||
let all_matrix_groups_complete = matrix_rows
|
||||
.iter()
|
||||
.all(|row| row.get("complete").and_then(Value::as_bool) == Some(true));
|
||||
let matrix_controls_present = matrix_controls
|
||||
.as_object()
|
||||
.map(|fields| fields.values().all(|value| value.as_bool() == Some(true)))
|
||||
.unwrap_or(false);
|
||||
let candidate_action_template_present = candidate_action_template
|
||||
.as_object()
|
||||
.map(|fields| fields.values().all(|value| value.as_bool() == Some(true)))
|
||||
.unwrap_or(false);
|
||||
let all_closure_proofs_present = closure_proofs
|
||||
.as_object()
|
||||
.map(|fields| fields.values().all(|value| value.as_bool() == Some(true)))
|
||||
.unwrap_or(false);
|
||||
let closure_ladder_present = closure_ladder
|
||||
.as_object()
|
||||
.map(|fields| fields.values().all(|value| value.as_bool() == Some(true)))
|
||||
.unwrap_or(false);
|
||||
let authority_denied = authority_denials
|
||||
.as_object()
|
||||
.map(|fields| fields.values().all(|value| value.as_bool() == Some(false)))
|
||||
.unwrap_or(false);
|
||||
json!({
|
||||
"schemaVersion": "epiphany.repo_work_safe_family_planning_readback.v0",
|
||||
"owner": "Soul",
|
||||
"sourceSafeFamily": "repo.planning_brief",
|
||||
"candidateNextSafeFamilies": candidate_rows,
|
||||
"candidateNextSafeFamilyCount": present_count,
|
||||
"allExpectedCandidateFamiliesPresent": present_count == candidate_families.len(),
|
||||
"safeFamilyMatrix": matrix_rows,
|
||||
"allMatrixGroupsComplete": all_matrix_groups_complete,
|
||||
"requirements": requirements,
|
||||
"gates": gates,
|
||||
"allRequiredGatesPresent": all_required_gates_present,
|
||||
"matrixControls": matrix_controls,
|
||||
"matrixControlsPresent": matrix_controls_present,
|
||||
"candidateActionTemplate": candidate_action_template,
|
||||
"candidateActionTemplatePresent": candidate_action_template_present,
|
||||
"closureProofs": closure_proofs,
|
||||
"allClosureProofsPresent": all_closure_proofs_present,
|
||||
"closureLadder": closure_ladder,
|
||||
"closureLadderPresent": closure_ladder_present,
|
||||
"authorityDenials": authority_denials,
|
||||
"authorityDenied": authority_denied,
|
||||
"allPlanningRequirementsPresent": all_requirements_present,
|
||||
"privateStateExposed": false,
|
||||
"nextSafeMove": "Self or Mind may choose one candidate safe family as a separate reviewed action item; this readback grants no Hands, scheduling, publication, deployment, or state-admission authority."
|
||||
})
|
||||
}
|
||||
|
||||
fn push_assertion(assertions: &mut Vec<Value>, id: &str, passed: bool, summary: String) {
|
||||
assertions.push(json!({
|
||||
"assertionId": id,
|
||||
|
|
@ -11423,7 +10790,6 @@ fn run_readiness(args: ReadinessArgs) -> Result<Value> {
|
|||
modeling_map_admitted,
|
||||
"Modeling map update was admitted through Mind.",
|
||||
)?,
|
||||
safe_family_planning_readiness_row(&close_receipt_path, close_receipt.as_ref()),
|
||||
readiness_path_row(
|
||||
"public-proof",
|
||||
"Bifrost",
|
||||
|
|
@ -13985,80 +13351,6 @@ fn tool_directory_readiness_row(path: &Path) -> Result<Value> {
|
|||
}))
|
||||
}
|
||||
|
||||
fn safe_family_planning_readiness_row(
|
||||
close_receipt_path: &Path,
|
||||
close_receipt: Option<&Value>,
|
||||
) -> Value {
|
||||
let readback = close_receipt
|
||||
.and_then(|receipt| receipt.get("closureReview"))
|
||||
.and_then(|review| review.get("familyAssertions"))
|
||||
.and_then(|assertions| assertions.get("safeFamilyPlanning"));
|
||||
let Some(readback) = readback else {
|
||||
return readiness_missing_row(
|
||||
"safe-family-planning",
|
||||
"Imagination/Soul",
|
||||
"epiphany.repo_work_safe_family_planning_readback.v0",
|
||||
"Close a repo.planning_brief item so Soul can report the safe-family matrix before MVP readiness review.",
|
||||
);
|
||||
};
|
||||
|
||||
let schema_ok = string_from_json(readback, &["schemaVersion"]).as_deref()
|
||||
== Some("epiphany.repo_work_safe_family_planning_readback.v0");
|
||||
let source_ok =
|
||||
string_from_json(readback, &["sourceSafeFamily"]).as_deref() == Some("repo.planning_brief");
|
||||
let families_ok =
|
||||
bool_from_json(readback, &["allExpectedCandidateFamiliesPresent"]) == Some(true);
|
||||
let requirements_ok =
|
||||
bool_from_json(readback, &["allPlanningRequirementsPresent"]) == Some(true);
|
||||
let gates_ok = bool_from_json(readback, &["allRequiredGatesPresent"]) == Some(true);
|
||||
let matrix_ok = bool_from_json(readback, &["allMatrixGroupsComplete"]) == Some(true);
|
||||
let controls_ok = bool_from_json(readback, &["matrixControlsPresent"]) == Some(true);
|
||||
let closure_ok = bool_from_json(readback, &["allClosureProofsPresent"]) == Some(true);
|
||||
let authority_denied = bool_from_json(readback, &["authorityDenied"]) == Some(true);
|
||||
let private_sealed = bool_from_json(readback, &["privateStateExposed"]) == Some(false);
|
||||
let satisfied = schema_ok
|
||||
&& source_ok
|
||||
&& families_ok
|
||||
&& requirements_ok
|
||||
&& gates_ok
|
||||
&& matrix_ok
|
||||
&& controls_ok
|
||||
&& closure_ok
|
||||
&& authority_denied
|
||||
&& private_sealed;
|
||||
|
||||
json!({
|
||||
"kind": "safe-family-planning",
|
||||
"owner": "Imagination/Soul",
|
||||
"requiredSchema": "epiphany.repo_work_safe_family_planning_readback.v0",
|
||||
"evidenceRef": existing_path_value(close_receipt_path),
|
||||
"artifactStatus": if close_receipt_path.exists() { "present" } else { "missing" },
|
||||
"schemaVersion": string_from_json(readback, &["schemaVersion"]).unwrap_or_else(|| "missing".to_string()),
|
||||
"sourceSafeFamily": string_from_json(readback, &["sourceSafeFamily"]).unwrap_or_else(|| "missing".to_string()),
|
||||
"candidateNextSafeFamilyCount": readback
|
||||
.get("candidateNextSafeFamilyCount")
|
||||
.and_then(Value::as_u64)
|
||||
.unwrap_or(0),
|
||||
"allExpectedCandidateFamiliesPresent": families_ok,
|
||||
"allPlanningRequirementsPresent": requirements_ok,
|
||||
"allRequiredGatesPresent": gates_ok,
|
||||
"allMatrixGroupsComplete": matrix_ok,
|
||||
"matrixControlsPresent": controls_ok,
|
||||
"allClosureProofsPresent": closure_ok,
|
||||
"authorityDenied": authority_denied,
|
||||
"privateStateExposed": !private_sealed,
|
||||
"satisfied": satisfied,
|
||||
"status": if satisfied { "satisfied" } else { "missing" },
|
||||
"note": "Soul read back the repo.planning_brief safe-family matrix for MVP review sight without granting action authority.",
|
||||
"schedulingAuthorized": false,
|
||||
"handsActionAuthorized": false,
|
||||
"publicationAuthorized": false,
|
||||
"deploymentAuthority": false,
|
||||
"serviceLifecycleAuthority": false,
|
||||
"durableStateCommitAuthorized": false
|
||||
})
|
||||
}
|
||||
|
||||
fn read_json_if_exists(path: &Path) -> Result<Option<Value>> {
|
||||
if path.exists() {
|
||||
read_json(path).map(Some)
|
||||
|
|
@ -15913,7 +15205,6 @@ fn repo_work_safe_family_is_recognized(safe_family: &str) -> bool {
|
|||
| "repo.collaboration_policy"
|
||||
| "repo.collaboration_topic"
|
||||
| "repo.consensus_brief"
|
||||
| "repo.planning_brief"
|
||||
| "repo.interpreter_brief"
|
||||
| "repo.objective_draft"
|
||||
| "repo.adoption_request"
|
||||
|
|
@ -16052,7 +15343,7 @@ fn print_usage() {
|
|||
"usage: epiphany-work <persona-intake|accept|derive-plan|plan|run|adopt|execute|close|overview|readiness|deployment-config-audit|deployment-execution-runbook|deployment-aftercare-audit|export-proof|tick|queue-run|serve> ...\n\
|
||||
persona-intake --workspace <repo> --item <id> --message <text> [--topic <topic>] [--store <local-verse.ccmp>] [--runtime-id <id>]\n\
|
||||
accept --workspace <repo> --from <persona|bifrost|persona-or-bifrost> --item <id> [--summary <text>] [--topic <topic>] [--store <local-verse.ccmp>] [--runtime-id <id>] [--online-receipt <path>] [--public-discussion-ref <ref>] [--candidate-action-ref <ref>]\n\
|
||||
derive-plan --workspace <repo> [--item <id>] [--accept-receipt <path>] [--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-readiness-review-request|repo-doctrine-update-request|repo-secret-policy-request|repo-dependency-policy-request|repo-deployment-config|repo-deployment-request] [--target-path <path>] [--model-ref <ref>] [--model-authored] [--action-summary <text>] [--verification-ask <text>] [--stop-condition <text>] [--escalation-reason <text>] [--assumption <text>] [--constraint <text>] [--non-goal <text>] [--open-question <text>] [--decision-point <text>] [--evidence-need <text>]\n\
|
||||
derive-plan --workspace <repo> [--item <id>] [--accept-receipt <path>] [--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-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-readiness-review-request|repo-doctrine-update-request|repo-secret-policy-request|repo-dependency-policy-request|repo-deployment-config|repo-deployment-request] [--target-path <path>] [--model-ref <ref>] [--model-authored] [--action-summary <text>] [--verification-ask <text>] [--stop-condition <text>] [--escalation-reason <text>] [--assumption <text>] [--constraint <text>] [--non-goal <text>] [--open-question <text>] [--decision-point <text>] [--evidence-need <text>]\n\
|
||||
plan --workspace <repo> [--item <id>] --objective <text> --plan-summary <text> --command <command> --changed-path <path> --commit-message <text> [--adoption-evidence-ref <ref>]\n\
|
||||
run --workspace <repo> [--item <id>] [--accept-receipt <path>] [--runtime-store <path>] [--requested-path <path>]\n\
|
||||
adopt --workspace <repo> [--item <id>] [--run-receipt <path>] [--from-plan <path>] [--plan-summary <text>] [--adoption-evidence-ref <ref>] [--mind-adoption-rationale <text>]\n\
|
||||
|
|
|
|||
|
|
@ -1164,6 +1164,18 @@ Do not replace the family with another catalog-shaped document. If a later
|
|||
planning artifact is needed, it must contain actual candidate action records
|
||||
and reference a separately owned contract/catalog.
|
||||
|
||||
## Planning false witness deleted
|
||||
|
||||
The entire `repo.planning_brief` authority seam is gone: safe-family dispatch,
|
||||
generator, closure branch, `safeFamilyPlanning` readback, readiness row, Verse
|
||||
classification, CLI help, dedicated 679-line smoke, and all production source
|
||||
references. Readiness can no longer be satisfied by closing a file containing
|
||||
copied catalog constants. The cut removed 1,393 source lines and no replacement
|
||||
adapter.
|
||||
|
||||
Direct source inventory now reports 183 substring occurrences across twelve
|
||||
remaining families.
|
||||
|
||||
The same inspection found 33 consecutive duplicate `#[cfg(test)]` attributes
|
||||
on provider constructors/writers and their re-exports. One gate already makes
|
||||
each item test-only; the second owned nothing. The duplicates are removed.
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@
|
|||
- Bifrost artifact-acceptance and metrics requests remain open until actual Bifrost/Maintainer receipts are ingested. The stale response-closing request-family smokes, accounting bundle, wrapper mode, and aggregate green gate are deleted.
|
||||
- Repo-work readiness reports are sight only. The generic readiness-review approval command and writer are deleted because one caller supplied four unresolved reviewer labels. `repo.readiness_review_request` now assigns routing to Self, lists Maintainer/Soul/Mind/Bifrost as independent required reviewers, and names no readiness-approval owner; typed review readers await genuine multi-organ/provider evidence.
|
||||
- Interpreter Brief is preparation cargo authored by Imagination from accepted public pressure. It requests Mind interpretation and remains `interpretation_admitted=false`; it is not Mind-owned state until a genuine Mind path supplies and admits interpretation evidence.
|
||||
- `repo.planning_brief` is condemned pending one coherent deletion pass: it contains no candidate work-item records and currently lets copied global catalog/schema/closure constants self-attest as per-item `safeFamilyPlanning`. The real preparation chain is consensus draft -> interpretation request -> objective draft -> Mind adoption.
|
||||
- `repo.planning_brief` is deleted. It contained no candidate work-item records and let copied global catalog/schema/closure constants self-attest as per-item planning and readiness evidence. The live preparation chain is consensus draft -> interpretation request -> objective draft -> Mind adoption.
|
||||
- There is no aggregate repo-swarm MVP gate. The former smoke manually aggregated fixture summaries into green rows and `demoReady=true`; it and its wrapper are deleted. Whole-organism readiness requires a live-fire path whose claimed consequences are observed at their owning boundaries.
|
||||
- Persona owner: `collaboration-feedback` writes public, bounded feedback only after that provider receipt exists.
|
||||
- Imagination owner: consensus participant selection, packet reference, receipt status/id, and adoption gate.
|
||||
|
|
|
|||
|
|
@ -2022,7 +2022,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-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-readiness-review-request` / `repo.readiness_review_request`, `repo-doctrine-update-request` / `repo.doctrine_update_request`, `repo-secret-policy-request` / `repo.secret_policy_request`, `repo-dependency-policy-request` / `repo.dependency_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 now names twenty-one candidate next safe families grouped as preparation, adoption/queue, execution/review, publication/accounting, and policy/deployment; requires requested paths, verification asks, evidence needs, owner, authority denials, and closure proofs; and names Mind/Self/Substrate/Hands/Soul/Bifrost/Idunn gates while granting no action authority. Soul closure emits `epiphany.repo_work_safe_family_planning_readback.v0` for that family with candidate-family counts, grouped matrix completeness, matrix controls, closure proof flags, gate/readiness flags, authority denials, and private-state seal. `repo.readiness_review_request` asks Maintainer/Soul/Mind/Bifrost to review a redacted repo-swarm MVP proof bundle without granting readiness approval, durable state commit, publication, deployment, service lifecycle, Hands action, or cross-body authority. `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. |
|
||||
| Imagination planning | The catalog-shaped `repo.planning_brief` family is deleted because it had no candidate work-item records. Consensus Draft, Interpreter Brief request, and Objective Draft remain typed preparation cargo before Mind adoption. | Future plan artifacts must carry actual candidate records and reference separately owned catalog/contracts. |
|
||||
| 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. |
|
||||
|
|
|
|||
|
|
@ -375,6 +375,12 @@ Remove the family, generator, closure/readback, dedicated smoke, and readiness
|
|||
dependency together. Preserve consensus -> interpretation request -> objective
|
||||
draft -> Mind adoption. Do not replace it with another per-item catalog dump.
|
||||
|
||||
That deletion is complete. The generator, closure/readback, readiness row,
|
||||
Verse classification, CLI advertisement, and 679-line dedicated smoke are
|
||||
gone; 1,393 source lines were removed without an adapter. No production source
|
||||
references remain. Direct inventory now reports 183 substring occurrences
|
||||
across twelve families.
|
||||
|
||||
Consensus Brief keeps its honest draft/unconverged semantics but no longer
|
||||
proves them with substring presence. Preparation owns its typed consensus,
|
||||
Imagination route, inputs, authority, and privacy closure; a malicious comment
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -98,7 +98,7 @@ active_subgoals:
|
|||
- 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 provider-authored typed local Verse state. Read paths preserve absence as unknown, tool and lifecycle callers write requests only, and provider bodies own heartbeat and result receipts. `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 lifecycle intent, consumes provider evidence, and updates only supervisor-owned 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.
|
||||
- Repo deployment configuration remains pre-deployment cargo only: config audit and operator runbook may prepare a reviewed handoff, but only Idunn-authored deployment and aftercare receipts can close deployment. The former deployment-config family smoke and aggregate green gate were deleted because they fabricated those outcomes.
|
||||
- Repo dependency/supply-chain policy request cargo is live. `repo-dependency-policy-request` lowers to safe family `repo.dependency_policy_request` and writes `.epiphany/dependency-policy-requests/<item>.toml` with manifest inventory, lockfile policy, package-manager command review, network fetch policy, vulnerability/license/vendored-code/update-cadence requirements, Eyes/Soul/Mind/maintainer/Bifrost/dependency-audit receipt refs, and denials for dependency update, package install, lockfile mutation, network fetch, CI mutation, Hands, publication, merge, deployment, service lifecycle, cross-body mutation, private Verse rummaging, and private-state exposure. Proof `.epiphany-smoke\repo-dependency-policy-request-family-20260621-083433` closes through Soul with `familyAssertionsStatus=passed`, `pathScopeMatched=true`, `awaitingDependencyPolicyReview=true`, all direct dependency/package/network/CI authorities false, and `privateStateExposed=false`.
|
||||
- Repo planning brief cargo now carries the family-friendly safe-family matrix plus explicit candidate action and closure shapes. `repo-planning-brief` still lowers to safe family `repo.planning_brief` and writes `.epiphany/planning-briefs/<item>.toml`, but it now names twenty-one candidate next safe families across preparation, adoption/queue, execution/review, publication/accounting, and policy/deployment groups, including `repo.readiness_review_request` for redacted repo-swarm MVP proof-bundle review before readiness claims. Each candidate must name id, safe family, owner, status, requested paths, verification asks, evidence needs, closure proofs, authority denials, and next gate, with statuses such as `ready-for-mind-review`, `ready-for-self-queue`, `blocked-needs-evidence`, and `closed` while remaining non-queue entries. The closure ladder names draft selection, Self queue-run, Hands receipts, Soul verdict, Modeling/Mind map admission, Bifrost publication or non-publication, Idunn deployment/config when in scope, and redaction closure. Closure `safeFamilyPlanning` readback now reports grouped matrix completeness, matrix controls, candidate-action-template presence, closure proof presence, closure-ladder presence, and authority denials while granting no scheduling, substrate, Hands, shell, commit, publication, deployment, service lifecycle, cross-body, private-transcript, raw-result, or private-state authority. Proof `.epiphany-smoke\repo-planning-brief-family-20260621-114826` closes through Soul with `candidateNextSafeFamilyCount=21`, `candidateActionTemplatePresent=true`, `allMatrixGroupsComplete=true`, `matrixControlsPresent=true`, `allClosureProofsPresent=true`, `closureLadderPresent=true`, `authorityDenied=true`, and `privateStateExposed=false`; wrapper swarm overview proof `local-20260621-124924-844-17b352e7` reads the accepted `repo.planning_brief` closure/acceptance rows from the repo-local Verse without private-state exposure.
|
||||
- `repo.planning_brief` is deleted because it contained no candidate work-item records and let copied global catalog/schema/closure constants self-attest as item planning and readiness evidence. The live preparation chain is consensus draft -> interpretation request -> objective draft -> Mind adoption; any future plan artifact must carry actual candidate records and reference separately owned contracts.
|
||||
- Repo-work readiness is sight only: it may derive and mirror missing/satisfied rows, but it cannot approve readiness. The former generic readiness-review command, writer, smoke, wrapper mode, and aggregate Soul/Bifrost green gates are deleted because one caller supplied four unresolved reviewer labels. `repo.readiness_review_request` remains the request cargo; typed review readers await genuine evidence.
|
||||
- No aggregate smoke owns MVP readiness. The former repo-swarm MVP gate manually aggregated prior summaries and local fixtures into green rows plus `demoReady=true`; it and its wrapper are deleted. Whole-organism claims require live-fire evidence observed at the owning consequence boundaries.
|
||||
- Repo-swarm Mind interpretation cargo is live. `repo-interpreter-brief` lowers to safe family `repo.interpreter_brief` and writes `.epiphany/interpreter-briefs/<item>.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`.
|
||||
|
|
@ -660,4 +660,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: Huginn live-fire has crossed the first real repo Body from Persona pressure to branch-local Hands commit and Soul/Mind closure, and now has repeatable closure and redacted-public-proof mouths. On `E:\Projects\Huginn` branch `epiphany/huginn/first-awakening`, `tools/epiphany_local_run.ps1 -Mode repo-persona-intake` accepted item `huginn-inspection-readback-livefire`, Weksa/Persona intake remained sealed, and `epiphany-work derive-plan` lowered it to model-authored safe family `repo.status_section` for `README.md` only. `tools/epiphany_local_run.ps1 -Mode repo-swarm-run` advanced four bounded pulses: run-from-plan, adopt-from-plan, execute-from-plan, and close-from-execute. Huginn commit `e9b07c38fceabbdc89ea35c2156326c80c0393a2` updated only `README.md`; closure receipt `.epiphany\work\work-close-huginn-inspection-readback-livefire.json` records status `closed`, Soul verdict `passed`, Mind state commit `repo-work-close-huginn-inspection-readback-livefire-mind-commit`, safe family `repo.status_section`, path scope `README.md`, Bifrost publication gate, and `privateStateExposed=false`. Verification also ran Huginn's TypeScript compiler through concrete Node path: `C:\Program Files\nodejs\node.exe E:\Projects\Huginn\node_modules\typescript\bin\tsc -p tsconfig.json` passed. Native verifier `epiphany-repo-livefire-closure-smoke --workspace E:\Projects\Huginn --item huginn-inspection-readback-livefire --expected-path README.md --expected-family repo.status_section --expected-gate awaiting-publication --expected-blocker bifrost-publication-missing` checks closure receipt, Mind map entry, overview gate/blocker, authority seals, and `git show` changed paths, returning `status=ok`, `soulVerdict=passed`, `publicationGate=Bifrost`, and `privateStateExposed=false`. Wrapper `tools/epiphany_local_run.ps1 -Mode repo-livefire-closure -Workspace E:\Projects\Huginn -RepoWorkItem huginn-inspection-readback-livefire -SkipBuild` exposes the same read-only proof through the local operator mouth; artifact `local-20260621-190156-803-2f85ba15` printed commit, path, gate, blocker, Soul verdict, Mind commit receipt, and `privateStateExposed=False` without push, merge, publication, or target mutation. New wrapper `tools/epiphany_local_run.ps1 -Mode repo-work-public-proof -Workspace E:\Projects\Huginn -RepoWorkItem huginn-inspection-readback-livefire -SkipBuild` exports the redacted proof bundle and repo-local Verse index without publishing; artifact `local-20260621-190645-345-4555b1dc` wrote `.epiphany\public\proof-bundles\repo-work-public-proof-huginn-inspection-readback-livefire.json`, proof id `repo-work-public-proof-huginn-inspection-readback-livefire`, SHA-256 `857545b199f3e37eb06c2e757e5cfc201958e46667bb1f8403fd333a22620f63`, nine artifact rows, zero publication rows, and `privateStateExposed=False`. swarm overview readback `local-20260621-190701-140-b9519ec6` sees the `REPO-WORK-PUBLIC-PROOF` row and action row from Huginn's repo-local Verse with the same SHA-256 while Bifrost publication remains missing. Launcher compact modes are now named compact operator-context modes instead of read-only modes, and `bifrost-public-proof` summaries print item, target public Verse, room, proof SHA-256, review receipts, and credit receipts so publication receipts are auditable without claiming upstream sync.
|
||||
next_action: Execute the mapped Planning Brief deletion. repo.planning_brief has no candidate work-item records; it copies global candidate schema, safe-family catalog, closure policy, ladder, and gate doctrine into a per-item file, then safeFamilyPlanning readback lets catalog self-attestation impersonate actual planning. Remove the safe family, generator, closure arm, planning_brief_safe_family_readback, dedicated smoke, and readiness dependency in one authority cut. Preserve consensus -> interpretation request -> objective draft -> Mind adoption, and require any future plan artifact to contain actual candidates while referencing separately owned catalog/contracts. Twenty high-authority closure families remain typed; current direct source inventory before this deletion is 278 content.contains occurrences across thirteen families. External governance should converge on tooling plus publication/accounting; operations retains policy/deployment.
|
||||
next_action: Continue the conceptual-substitution pass after the complete Planning Brief deletion. repo.planning_brief, its generator, closure/readback, readiness row, Verse classification, CLI advertisement, and dedicated smoke are gone; no production source references remain and no adapter replaced them. The live preparation chain is consensus -> interpretation request -> objective draft -> Mind adoption. Direct source inventory now reports 183 content.contains occurrences across twelve remaining families. Next map the collaboration policy/topic pair: determine whether repo-local manifests are provider-owned public contracts or deterministic proposals falsely claiming Persona/Eve authority. External governance should converge on tooling plus publication/accounting; operations retains policy/deployment.
|
||||
|
|
|
|||
Reference in a new issue