Delete false provider catalogs

This commit is contained in:
Meta Vens 2026-07-13 04:05:23 +01:00
commit 16538ae378
10 changed files with 29 additions and 1192 deletions

View file

@ -1,382 +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-eve-surface-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 Eve Surface Family Smoke\n\nThis repository proves branch-local Eve surface contracts.\n",
)
.with_context(|| format!("failed to seed {}", repo.join("README.md").display()))?;
git(["add", "README.md"], &repo)?;
git(["commit", "-m", "Seed repo Eve surface smoke body"], &repo)?;
git(["switch", "-c", "epiphany/repo-eve-surface-family"], &repo)?;
let item = "repo-eve-surface-family";
let target_path = ".epiphany/eve-surfaces/repo-eve-surface-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-eve-surface-family-smoke",
"--topic",
"repo-eve-surface-family",
],
&root,
)?;
cargo_json(
&manifest,
"epiphany-swarm",
&[
"online",
"--workspace",
path_str(&repo)?,
"--epiphany-root",
path_str(&root)?,
"--runtime-id",
"repo-eve-surface-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",
"Expose a compact agent-friendly Eve surface contract for repo collaboration over CultMesh.",
"--candidate-action-ref",
"candidate-action://repo-eve-surface-family/eve-contract",
"--public-discussion-ref",
"epiphany-global/persona-collaboration/repo-eve-surface-family",
],
&root,
)?;
let plan = cargo_json(
&manifest,
"epiphany-work",
&[
"derive-plan",
"--workspace",
path_str(&repo)?,
"--item",
item,
"--action-family",
"repo-eve-surface",
"--model-ref",
"repo-eve-surface-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 = read_json(
&repo
.join(".epiphany")
.join("work")
.join(format!("work-close-{item}.json")),
)?;
let surface_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.eve_surface",
)?;
require_eq(&close, &["status"], "closed")?;
require_eq(&close, &["soul", "verdict"], "passed")?;
require_eq(
&close,
&["closureReview", "familyAssertions", "status"],
"passed",
)?;
require_bool(
&close,
&["closureReview", "sourceGrounding", "pathScopeMatched"],
true,
)?;
require_bool(&close, &["privateStateExposed"], false)?;
require_text(
&surface_text,
"schema_version = \"epiphany.repo_eve_surface.v0\"",
)?;
require_text(&surface_text, "safe_action_family = \"repo.eve_surface\"")?;
require_text(&surface_text, "[surface]")?;
require_text(&surface_text, "id = \"eve://epiphany/repo/")?;
require_text(&surface_text, "renderer_owns_truth = false")?;
require_text(&surface_text, "[verses]")?;
require_text(&surface_text, "local = \"gamecult-local\"")?;
require_text(&surface_text, "public = \"epiphany-global\"")?;
require_text(&surface_text, "private_projection_allowed = false")?;
require_text(&surface_text, "odin_discoverable = true")?;
require_text(&surface_text, "[cultui]")?;
require_text(
&surface_text,
"tui_contract = \"epiphany.eve.tui_surface.v0\"",
)?;
require_text(
&surface_text,
"gui_contract = \"epiphany.eve.gui_surface.v0\"",
)?;
require_text(&surface_text, "compact_agent_tui = true")?;
require_text(&surface_text, "[collaboration]")?;
require_text(&surface_text, "feedback_routes_to_imagination = true")?;
require_text(&surface_text, "candidate_actions_non_authoritative = true")?;
require_text(&surface_text, "[authority]")?;
require_text(&surface_text, "rendering_authority = false")?;
require_text(&surface_text, "state_authority = false")?;
require_text(&surface_text, "publication_authority = false")?;
require_text(&surface_text, "service_lifecycle_authority = false")?;
require_text(&surface_text, "cross_body_mutation_authority = false")?;
require_text(&surface_text, "private_verse_rummaging = false")?;
require_text(&surface_text, "requires_cultmesh_receipts = true")?;
require_text(&surface_text, "private_state_exposed = false")?;
Ok(json!({
"schemaVersion": "epiphany.repo_eve_surface_family_smoke.v0",
"status": "ok",
"smokeDir": smoke_dir,
"repo": repo,
"branch": git_output(["branch", "--show-current"], &repo)?,
"item": item,
"safeActionFamily": "repo.eve_surface",
"targetPath": target_path,
"closeStatus": "closed",
"soulVerdict": "passed",
"familyAssertionsStatus": "passed",
"pathScopeMatched": true,
"hasCultUiContracts": true,
"hasVerseRouting": true,
"odinDiscoverable": true,
"feedbackRoutesToImagination": true,
"rendererOwnsTruth": false,
"renderingAuthority": false,
"stateAuthority": false,
"publicationAuthority": false,
"serviceLifecycleAuthority": false,
"crossBodyMutationAuthority": false,
"privateVerseRummaging": false,
"privateStateExposed": false
}))
}
fn cargo_json(manifest_path: &Path, bin_name: &str, args: &[&str], cwd: &Path) -> Result<Value> {
let output = Command::new("cargo")
.arg("run")
.arg("--quiet")
.arg("--manifest-path")
.arg(manifest_path)
.arg("--bin")
.arg(bin_name)
.arg("--")
.args(args)
.current_dir(cwd)
.output()
.with_context(|| format!("failed to spawn cargo run --bin {bin_name}"))?;
if !output.status.success() {
return Err(anyhow!(
"cargo run --bin {bin_name} failed:\n{}",
String::from_utf8_lossy(&output.stderr)
));
}
serde_json::from_slice(&output.stdout)
.with_context(|| format!("{bin_name} returned invalid JSON"))
}
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 spawn git in {}", cwd.display()))?;
if output.status.success() {
Ok(())
} else {
Err(anyhow!(
"git failed in {}:\n{}",
cwd.display(),
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 spawn git in {}", cwd.display()))?;
if !output.status.success() {
return Err(anyhow!(
"git failed in {}:\n{}",
cwd.display(),
String::from_utf8_lossy(&output.stderr)
));
}
Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
}
fn read_json(path: &Path) -> Result<Value> {
let raw =
fs::read_to_string(path).with_context(|| format!("failed to read {}", path.display()))?;
serde_json::from_str(&raw).with_context(|| format!("failed to decode {}", path.display()))
}
fn require_eq(value: &Value, path: &[&str], expected: &str) -> Result<()> {
let actual = value_at_path(value, path)
.and_then(Value::as_str)
.ok_or_else(|| anyhow!("missing string at {}", path.join(".")))?;
if actual == expected {
Ok(())
} else {
Err(anyhow!(
"expected {} to be {:?}, got {:?}",
path.join("."),
expected,
actual
))
}
}
fn require_bool(value: &Value, path: &[&str], expected: bool) -> Result<()> {
let actual = value_at_path(value, path)
.and_then(Value::as_bool)
.ok_or_else(|| anyhow!("missing bool at {}", path.join(".")))?;
if actual == expected {
Ok(())
} else {
Err(anyhow!(
"expected {} to be {}, got {}",
path.join("."),
expected,
actual
))
}
}
fn require_text(haystack: &str, needle: &str) -> Result<()> {
if haystack.contains(needle) {
Ok(())
} else {
Err(anyhow!("expected text to contain {:?}", needle))
}
}
fn value_at_path<'a>(value: &'a Value, path: &[&str]) -> Option<&'a Value> {
let mut cursor = value;
for segment in path {
if let Ok(index) = segment.parse::<usize>() {
cursor = cursor.as_array()?.get(index)?;
} else {
cursor = cursor.get(*segment)?;
}
}
Some(cursor)
}
fn path_str(path: &Path) -> Result<&str> {
path.to_str()
.ok_or_else(|| anyhow!("path is not valid UTF-8: {}", path.display()))
}
fn take_path(args: &mut impl Iterator<Item = String>, name: &str) -> Result<PathBuf> {
Ok(PathBuf::from(
args.next()
.ok_or_else(|| anyhow!("missing value for {name}"))?,
))
}

View file

@ -1,395 +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-tool-capabilities-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 Tool Capabilities Family Smoke\n\nThis repository proves branch-local Epiphany tool capability manifests.\n",
)
.with_context(|| format!("failed to seed {}", repo.join("README.md").display()))?;
git(["add", "README.md"], &repo)?;
git(
["commit", "-m", "Seed repo tool capabilities smoke body"],
&repo,
)?;
git(
["switch", "-c", "epiphany/repo-tool-capabilities-family"],
&repo,
)?;
let item = "repo-tool-capabilities-family";
let target_path = ".epiphany/repo-tool-capabilities.toml";
let local_verse = repo.join(".epiphany").join("local-verse.ccmp");
cargo_json(
&manifest,
"epiphany-repo",
&[
"init",
"--workspace",
path_str(&repo)?,
"--epiphany-root",
path_str(&root)?,
"--swarm-id",
"repo-tool-capabilities-family-smoke",
"--topic",
"repo-tool-capabilities-family",
],
&root,
)?;
cargo_json(
&manifest,
"epiphany-swarm",
&[
"online",
"--workspace",
path_str(&repo)?,
"--epiphany-root",
path_str(&root)?,
"--runtime-id",
"repo-tool-capabilities-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",
"Publish a branch-local repo tool capability manifest with CultMesh intent and receipt contracts for authorized agents.",
"--candidate-action-ref",
"candidate-action://repo-tool-capabilities-family/tool-directory",
"--public-discussion-ref",
"eve://epiphany/persona/repo-tool-capabilities-family",
],
&root,
)?;
let plan = cargo_json(
&manifest,
"epiphany-work",
&[
"derive-plan",
"--workspace",
path_str(&repo)?,
"--item",
item,
"--action-family",
"repo-tool-capabilities",
"--model-ref",
"repo-tool-capabilities-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 manifest_text = fs::read_to_string(repo.join(target_path))
.with_context(|| format!("failed to read {}", repo.join(target_path).display()))?;
require_eq(
&plan,
&["derivation", "safeActionFamily"],
"repo.tool_capabilities",
)?;
require_eq(&close, &["status"], "closed")?;
require_eq(&close, &["soul", "verdict"], "passed")?;
require_eq(
&close,
&["closureReview", "familyAssertions", "status"],
"passed",
)?;
require_bool(
&close,
&["closureReview", "sourceGrounding", "pathScopeMatched"],
true,
)?;
require_bool(&close, &["privateStateExposed"], false)?;
require_text(
&manifest_text,
"schema_version = \"epiphany.repo_tool_capabilities.v0\"",
)?;
require_text(
&manifest_text,
"safe_action_family = \"repo.tool_capabilities\"",
)?;
require_text(&manifest_text, "[tool_directory]")?;
require_text(&manifest_text, "verse = \"gamecult-local\"")?;
require_text(&manifest_text, "odin_discoverable = true")?;
require_text(&manifest_text, "available_to_authorized_agents = true")?;
require_text(&manifest_text, "[contracts]")?;
require_text(
&manifest_text,
"intent = \"epiphany.cultmesh.daemon_tool_invocation_intent.v0\"",
)?;
require_text(
&manifest_text,
"receipt = \"epiphany.cultmesh.daemon_tool_invocation_receipt.v0\"",
)?;
require_text(&manifest_text, "host_daemon_owns_execution = true")?;
require_text(&manifest_text, "idunn_owns_lifecycle = true")?;
require_text(&manifest_text, "[expected_capabilities]")?;
require_text(&manifest_text, "\"repo-work-overview\"")?;
require_text(&manifest_text, "\"repo-work-queue-run\"")?;
require_text(&manifest_text, "\"repo-work-public-proof\"")?;
require_text(&manifest_text, "\"bifrost-public-proof\"")?;
require_text(&manifest_text, "arbitrary_shell_authority = false")?;
require_text(&manifest_text, "deployment_authority = false")?;
require_text(&manifest_text, "service_start_stop_authority = false")?;
require_text(&manifest_text, "private_verse_rummaging = false")?;
require_text(
&manifest_text,
"tool_invocation_requires_host_receipt = true",
)?;
require_text(&manifest_text, "private_state_exposed = false")?;
let summary = json!({
"schemaVersion": "epiphany.repo_work_tool_capabilities_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"],
"manifestHasToolDirectory": true,
"manifestHasContracts": true,
"manifestHasExpectedCapabilities": true,
"hostDaemonOwnsExecution": true,
"idunnOwnsLifecycle": 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_text(haystack: &str, needle: &str) -> Result<()> {
if haystack.contains(needle) {
Ok(())
} else {
Err(anyhow!(
"expected capability manifest 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()))
}

View file

@ -5057,9 +5057,7 @@ fn repo_work_stage_for_family(safe_action_family: &str) -> (String, String) {
| "repo.consensus_brief"
| "repo.objective_draft" => "imagination-planning",
"repo.body_manifest"
| "repo.tool_capabilities"
| "repo.tool_request"
| "repo.eve_surface"
| "repo.collaboration_policy"
| "repo.collaboration_topic" => "repo-body-collaboration",
"repo.adoption_request" => "mind-adoption-request",

View file

@ -2202,16 +2202,10 @@ fn derive_safe_plan_family(input: DeriveSafePlanInput<'_>) -> Result<DerivedSafe
"repo-manifest" | "body-manifest" | "epiphany-manifest" => {
derive_repo_manifest_plan(input, &action_family)
}
"repo-tool-capabilities" | "tool-capabilities" | "capability-manifest" => {
derive_repo_tool_capabilities_plan(input, &action_family)
}
"repo-tool-request"
| "tool-request"
| "daemon-tool-request"
| "repo-daemon-tool-request" => derive_repo_tool_request_plan(input, &action_family),
"repo-eve-surface" | "eve-surface" | "cultui-surface" | "tui-surface" => {
derive_repo_eve_surface_plan(input, &action_family)
}
"repo-collaboration-policy" | "collaboration-policy" | "repo-collab-policy" => {
derive_repo_collaboration_policy_plan(input, &action_family)
}
@ -2289,7 +2283,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-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-request, 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"
)),
}
}
@ -2792,126 +2786,6 @@ fn derive_repo_manifest_plan(
})
}
fn derive_repo_tool_capabilities_plan(
input: DeriveSafePlanInput<'_>,
action_family: &str,
) -> Result<DerivedSafePlan> {
let item_slug = sanitize(input.item);
let target_path = validate_toml_target_path(
input
.target_path
.unwrap_or(".epiphany/repo-tool-capabilities.toml"),
)?;
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 tool_surface_id = format!("epiphany.repo.{item_slug}.tool-capabilities");
let intent_contract = "epiphany.cultmesh.daemon_tool_invocation_intent.v0";
let receipt_contract = "epiphany.cultmesh.daemon_tool_invocation_receipt.v0";
let lines = vec![
"# Epiphany repo tool capability manifest.".to_string(),
"# Branch-local capability discovery cargo; the hosting daemon owns execution.".to_string(),
format!(
"schema_version = {}",
toml_basic_string("epiphany.repo_tool_capabilities.v0")
),
format!("item = {}", toml_basic_string(input.item)),
format!("created_at = {}", toml_basic_string(&now)),
format!("source = {}", toml_basic_string(input.source)),
format!("summary = {}", toml_basic_string(&compact_line(input.summary))),
format!(
"safe_action_family = {}",
toml_basic_string("repo.tool_capabilities")
),
format!("model_authored = {}", input.model_authored),
format!(
"model_ref = {}",
toml_basic_string(input.model_ref.unwrap_or("deterministic-fallback"))
),
"operator_authored_shell_details = false".to_string(),
"hands_authority_granted = false".to_string(),
"durable_state_admitted = false".to_string(),
"publication_authorized = false".to_string(),
"merge_authorized = false".to_string(),
"service_lifecycle_authority = false".to_string(),
"cross_repo_mutation = false".to_string(),
"private_state_exposed = false".to_string(),
format!("candidate_action_refs = {}", toml_array(&candidate_refs)),
format!("public_discussion_refs = {}", toml_array(&public_refs)),
String::new(),
"[tool_directory]".to_string(),
format!("surface_id = {}", toml_basic_string(&tool_surface_id)),
"verse = \"gamecult-local\"".to_string(),
"odin_discoverable = true".to_string(),
"available_to_authorized_agents = true".to_string(),
"agent_friendly_tui = true".to_string(),
String::new(),
"[contracts]".to_string(),
format!(
"intent = {}",
toml_basic_string(intent_contract)
),
format!(
"receipt = {}",
toml_basic_string(receipt_contract)
),
"requires_receipts = true".to_string(),
"host_daemon_owns_execution = true".to_string(),
"idunn_owns_lifecycle = true".to_string(),
String::new(),
"[expected_capabilities]".to_string(),
"ids = [".to_string(),
" \"repo-work-overview\"," .to_string(),
" \"repo-work-queue-run\"," .to_string(),
" \"repo-work-public-proof\"," .to_string(),
" \"bifrost-public-proof\"".to_string(),
"]".to_string(),
String::new(),
"[authority]".to_string(),
"arbitrary_shell_authority = false".to_string(),
"deployment_authority = false".to_string(),
"service_start_stop_authority = false".to_string(),
"private_verse_rummaging = false".to_string(),
"tool_invocation_requires_host_receipt = true".to_string(),
String::new(),
"[verification]".to_string(),
"asks = [".to_string(),
" \"Soul verifies the capability manifest path changed and contains the accepted pressure summary.\"," .to_string(),
" \"Soul verifies the manifest names tool intent and receipt contracts without granting execution authority.\"," .to_string(),
" \"Soul verifies no paths outside the declared tool capability manifest changed.\"".to_string(),
"]".to_string(),
String::new(),
"[rollback]".to_string(),
"hints = [\"Remove the repo tool capability manifest if the accepted pressure was misderived.\"]".to_string(),
String::new(),
];
let command = powershell_set_lines_command(&target_path, &lines);
Ok(DerivedSafePlan {
safe_action_family: "repo.tool_capabilities".to_string(),
target_path,
plan_summary: format!(
"Imagination derived a repo tool capability manifest from accepted {} pressure.",
input.source
),
command,
commit_message: format!(
"Add repo tool capability manifest for work item {}",
input.item
),
verification_asks: vec![
"Soul verifies the repo tool capability manifest path changed and contains the accepted pressure summary.".to_string(),
"Soul verifies the manifest advertises typed tool intent/receipt contracts while leaving execution with host daemons.".to_string(),
"Soul verifies no paths outside the declared capability manifest changed.".to_string(),
],
rollback_hints: vec![
"Remove the generated repo tool capability manifest if the accepted pressure was misinterpreted.".to_string(),
],
derivation: plan_derivation_receipt(input, action_family, "repo.tool_capabilities"),
})
}
fn derive_repo_tool_request_plan(
input: DeriveSafePlanInput<'_>,
action_family: &str,
@ -3029,131 +2903,6 @@ fn derive_repo_tool_request_plan(
})
}
fn derive_repo_eve_surface_plan(
input: DeriveSafePlanInput<'_>,
action_family: &str,
) -> Result<DerivedSafePlan> {
let item_slug = sanitize(input.item);
let default_target = format!(".epiphany/eve-surfaces/{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 surface_id = format!("eve://epiphany/repo/{item_slug}/surface");
let local_verse_id = "gamecult-local";
let public_verse_id = "epiphany-global";
let owner = format!("repo:{item_slug}");
let lines = vec![
"# Epiphany repo Eve surface contract.".to_string(),
"# Branch-local CultUI projection cargo; not renderer ownership or private-state authority.".to_string(),
format!(
"schema_version = {}",
toml_basic_string("epiphany.repo_eve_surface.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.eve_surface")
),
format!("model_authored = {}", input.model_authored),
format!(
"model_ref = {}",
toml_basic_string(input.model_ref.unwrap_or("deterministic-fallback"))
),
"operator_authored_shell_details = false".to_string(),
"hands_authority_granted = false".to_string(),
"durable_state_admitted = false".to_string(),
"publication_authorized = false".to_string(),
"merge_authorized = false".to_string(),
"service_lifecycle_authority = false".to_string(),
"cross_repo_mutation = false".to_string(),
"private_state_exposed = false".to_string(),
format!("candidate_action_refs = {}", toml_array(&candidate_refs)),
format!("public_discussion_refs = {}", toml_array(&public_refs)),
String::new(),
"[surface]".to_string(),
format!("id = {}", toml_basic_string(&surface_id)),
format!("owner_body = {}", toml_basic_string(&owner)),
"owner = \"repo Persona/Self\"".to_string(),
"renderer_owns_truth = false".to_string(),
"branch_local_only = true".to_string(),
String::new(),
"[verses]".to_string(),
format!("local = {}", toml_basic_string(local_verse_id)),
format!("public = {}", toml_basic_string(public_verse_id)),
"private_projection_allowed = false".to_string(),
"public_projection_allowed = true".to_string(),
"odin_discoverable = true".to_string(),
String::new(),
"[cultui]".to_string(),
"tui_contract = \"epiphany.eve.tui_surface.v0\"".to_string(),
"gui_contract = \"epiphany.eve.gui_surface.v0\"".to_string(),
"compact_agent_tui = true".to_string(),
"human_gui_lowering_allowed = true".to_string(),
"lowering_targets = [\"tui\", \"gui\", \"browser\", \"future-room\"]".to_string(),
String::new(),
"[rows]".to_string(),
"ids = [".to_string(),
" \"repo-work-queue\"," .to_string(),
" \"repo-work-next-action\"," .to_string(),
" \"repo-public-proof\"," .to_string(),
" \"persona-collaboration-topic\"".to_string(),
"]".to_string(),
String::new(),
"[collaboration]".to_string(),
"persona_discussion_allowed = true".to_string(),
"human_discussion_allowed = true".to_string(),
"feedback_routes_to_imagination = true".to_string(),
"candidate_actions_non_authoritative = true".to_string(),
"mind_adoption_required = true".to_string(),
String::new(),
"[authority]".to_string(),
"rendering_authority = false".to_string(),
"state_authority = false".to_string(),
"publication_authority = false".to_string(),
"service_lifecycle_authority = false".to_string(),
"cross_body_mutation_authority = false".to_string(),
"private_verse_rummaging = false".to_string(),
"requires_cultmesh_receipts = true".to_string(),
String::new(),
"[verification]".to_string(),
"asks = [".to_string(),
" \"Soul verifies the Eve surface contract path changed and contains the accepted pressure summary.\",".to_string(),
" \"Soul verifies the surface names CultUI TUI/GUI contracts, Verse routing, Odin discovery, and collaboration feedback routing without granting renderer or mutation authority.\",".to_string(),
" \"Soul verifies no paths outside the declared Eve surface contract changed.\"".to_string(),
"]".to_string(),
String::new(),
"[rollback]".to_string(),
"hints = [\"Remove the repo Eve surface contract if the accepted pressure was misderived.\"]".to_string(),
String::new(),
];
let command = powershell_set_lines_command(&target_path, &lines);
Ok(DerivedSafePlan {
safe_action_family: "repo.eve_surface".to_string(),
target_path,
plan_summary: format!(
"Imagination derived a repo Eve surface contract from accepted {} pressure.",
input.source
),
command,
commit_message: format!("Add repo Eve surface contract for work item {}", input.item),
verification_asks: vec![
"Soul verifies the repo Eve surface contract path changed and contains the accepted pressure summary.".to_string(),
"Soul verifies the contract exposes compact TUI/GUI lowering through CultMesh/Odin while preserving provider ownership and private-state seals.".to_string(),
"Soul verifies no paths outside the declared Eve surface contract changed.".to_string(),
],
rollback_hints: vec![
"Remove the generated repo Eve surface contract if the accepted pressure was misinterpreted.".to_string(),
],
derivation: plan_derivation_receipt(input, action_family, "repo.eve_surface"),
})
}
fn derive_repo_collaboration_policy_plan(
input: DeriveSafePlanInput<'_>,
action_family: &str,
@ -6321,79 +6070,6 @@ fn closure_family_assertions(
.to_string(),
);
}
"repo.tool_capabilities" => {
push_assertion(
&mut assertions,
"tool-capabilities-schema-present",
content.contains("schema_version = \"epiphany.repo_tool_capabilities.v0\""),
"Committed tool capability manifest carries the schema version.".to_string(),
);
push_assertion(
&mut assertions,
"tool-capabilities-family-present",
content.contains("safe_action_family = \"repo.tool_capabilities\""),
"Committed tool capability manifest carries the safe action family.".to_string(),
);
push_assertion(
&mut assertions,
"tool-capabilities-summary-present",
content.contains(&compact_summary),
"Committed tool capability manifest contains the accepted pressure summary."
.to_string(),
);
push_assertion(
&mut assertions,
"tool-directory-present",
content.contains("[tool_directory]")
&& content.contains("verse = \"gamecult-local\"")
&& content.contains("odin_discoverable = true")
&& content.contains("available_to_authorized_agents = true"),
"Committed tool capability manifest exposes local CultMesh/Odin discovery."
.to_string(),
);
push_assertion(
&mut assertions,
"tool-contracts-present",
content.contains("[contracts]")
&& content.contains(
"intent = \"epiphany.cultmesh.daemon_tool_invocation_intent.v0\"",
)
&& content.contains(
"receipt = \"epiphany.cultmesh.daemon_tool_invocation_receipt.v0\"",
)
&& content.contains("requires_receipts = true")
&& content.contains("host_daemon_owns_execution = true"),
"Committed tool capability manifest names typed invocation contracts and host execution ownership.".to_string(),
);
push_assertion(
&mut assertions,
"tool-capabilities-ids-present",
content.contains("[expected_capabilities]")
&& content.contains("\"repo-work-overview\"")
&& content.contains("\"repo-work-queue-run\"")
&& content.contains("\"repo-work-public-proof\"")
&& content.contains("\"bifrost-public-proof\""),
"Committed tool capability manifest lists expected repo-swarm capability ids."
.to_string(),
);
push_assertion(
&mut assertions,
"tool-capabilities-authority-seals",
content.contains("[authority]")
&& content.contains("arbitrary_shell_authority = false")
&& content.contains("deployment_authority = false")
&& content.contains("service_start_stop_authority = false")
&& content.contains("private_verse_rummaging = false")
&& content.contains("tool_invocation_requires_host_receipt = true"),
"Committed tool capability manifest denies shell/deploy/service/private-rummaging authority and requires host receipts.".to_string(),
);
push_assertion(
&mut assertions,
"tool-capabilities-private-seal",
content.contains("private_state_exposed = false"),
"Committed tool capability manifest preserves the private-state seal.".to_string(),
);
}
"repo.tool_request" => {
let request = parse_repo_tool_request(&content).ok();
push_assertion(
@ -6463,85 +6139,6 @@ fn closure_family_assertions(
"Committed tool request preserves the private-state seal.".to_string(),
);
}
"repo.eve_surface" => {
push_assertion(
&mut assertions,
"eve-surface-schema-present",
content.contains("schema_version = \"epiphany.repo_eve_surface.v0\""),
"Committed Eve surface contract carries the schema version.".to_string(),
);
push_assertion(
&mut assertions,
"eve-surface-family-present",
content.contains("safe_action_family = \"repo.eve_surface\""),
"Committed Eve surface contract carries the safe action family.".to_string(),
);
push_assertion(
&mut assertions,
"eve-surface-summary-present",
content.contains(&compact_summary),
"Committed Eve surface contract contains the accepted pressure summary."
.to_string(),
);
push_assertion(
&mut assertions,
"eve-surface-routing-present",
content.contains("[surface]")
&& content.contains("id = \"eve://epiphany/repo/")
&& content.contains("renderer_owns_truth = false"),
"Committed Eve surface contract names the provider-owned surface.".to_string(),
);
push_assertion(
&mut assertions,
"eve-surface-verses-present",
content.contains("[verses]")
&& content.contains("local = \"gamecult-local\"")
&& content.contains("public = \"epiphany-global\"")
&& content.contains("private_projection_allowed = false")
&& content.contains("odin_discoverable = true"),
"Committed Eve surface contract names Verse routing and Odin discovery."
.to_string(),
);
push_assertion(
&mut assertions,
"eve-surface-cultui-contracts",
content.contains("[cultui]")
&& content.contains("tui_contract = \"epiphany.eve.tui_surface.v0\"")
&& content.contains("gui_contract = \"epiphany.eve.gui_surface.v0\"")
&& content.contains("compact_agent_tui = true"),
"Committed Eve surface contract names compact TUI and GUI lowering contracts."
.to_string(),
);
push_assertion(
&mut assertions,
"eve-surface-collaboration-route",
content.contains("[collaboration]")
&& content.contains("persona_discussion_allowed = true")
&& content.contains("human_discussion_allowed = true")
&& content.contains("feedback_routes_to_imagination = true")
&& content.contains("candidate_actions_non_authoritative = true"),
"Committed Eve surface contract routes collaboration feedback to Imagination without authorizing actions.".to_string(),
);
push_assertion(
&mut assertions,
"eve-surface-authority-seals",
content.contains("[authority]")
&& content.contains("rendering_authority = false")
&& content.contains("state_authority = false")
&& content.contains("publication_authority = false")
&& content.contains("service_lifecycle_authority = false")
&& content.contains("cross_body_mutation_authority = false")
&& content.contains("private_verse_rummaging = false")
&& content.contains("requires_cultmesh_receipts = true"),
"Committed Eve surface contract denies renderer/state/publication/service/cross-body/private-rummaging authority.".to_string(),
);
push_assertion(
&mut assertions,
"eve-surface-private-seal",
content.contains("private_state_exposed = false"),
"Committed Eve surface contract preserves the private-state seal.".to_string(),
);
}
"repo.collaboration_policy" => {
let policy = parse_repo_collaboration_policy(&content).ok();
push_assertion(
@ -15200,9 +14797,7 @@ fn repo_work_safe_family_is_recognized(safe_family: &str) -> bool {
| "repo.status_section"
| "repo.task_card"
| "repo.body_manifest"
| "repo.tool_capabilities"
| "repo.tool_request"
| "repo.eve_surface"
| "repo.collaboration_policy"
| "repo.collaboration_topic"
| "repo.consensus_brief"
@ -15344,7 +14939,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-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-request|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\

View file

@ -1194,6 +1194,23 @@ cannot conceal a live publication claim.
Twenty-two high-authority closure families are typed. Direct source inventory
now reports 124 substring occurrences across ten remaining families.
## Expected tool and Eve catalogs as provider publication
`repo.tool_capabilities` marked a deterministic list of four expected tools as
Odin-discoverable and available without a host advertisement.
`repo.eve_surface` invented a surface URI, row catalog, lowering targets, and
Odin discovery without a provider-published composition graph. Both duplicated
real typed provider paths already present in the machine.
Both safe families are deleted end to end: dispatch, generators, closure arms,
Verse classification, CLI help, and their 395/382-line dedicated smokes. The
cut removed 1,188 source lines without adapters. `repo.tool_request`, host
receipts, Odin discovery, Eve connection receipts, and provider-owned surface
publication remain the live paths. Downstream composition remains downstream.
Direct source inventory now reports 71 substring occurrences across eight
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.

View file

@ -54,6 +54,7 @@
- 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 collaboration policy/topic files are proposals, not live social or renderer contracts. Imagination authors them, Persona owns discussion, Persona/Mind review policy, Mind admits repo policy, Bifrost owns publication, and requested public-room/Eve-surface identifiers remain unpublished until provider receipts exist. Epiphany does not own downstream Eve/TUI/GUI composition.
- The deterministic `repo.tool_capabilities` and `repo.eve_surface` safe families are deleted. Expected tool ids and invented surface/row/lowering catalogs cannot substitute for host advertisements or provider-published composition graphs. Live paths are typed tool requests/host receipts, Odin discovery, Eve connection receipts, and provider-owned publication.
- `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.

View file

@ -297,11 +297,6 @@ operator-safe status section in the repo Body, defaulting to `README.md`; and
`--action-family repo-manifest` writes a structured Epiphany Body manifest,
defaulting to `epiphany.toml`, with body domain, private/local/public Verse ids,
Eve surface id, capability hints, and authority seals; and
`--action-family repo-tool-capabilities` writes a structured repo tool
capability manifest, defaulting to `.epiphany/repo-tool-capabilities.toml`,
with local CultMesh/Odin discovery flags, typed daemon tool invocation
intent/receipt contracts, expected repo-swarm capability ids, host-daemon
execution ownership, Idunn lifecycle ownership, and authority seals; and
`--action-family repo-tool-request` writes a structured daemon-hosted tool
request under `.epiphany/tool-requests/<item>.toml`, naming the local
CultMesh/Odin tool directory, selected daemon capability, typed invocation

View file

@ -389,6 +389,14 @@ downstream rendering is explicitly irrelevant. A new typed collaboration
closure domain protects both families. Twenty-two high-authority families are
typed; direct inventory reports 124 substring occurrences across ten families.
The fake provider catalogs are deleted. `repo.tool_capabilities` advertised
expected tools without a host receipt; `repo.eve_surface` invented a live
surface/rows/lowering catalog without provider publication. Dispatch,
generators, closure, Verse classification, CLI help, and both dedicated smokes
are gone—1,188 source lines, no adapters. Real tool requests/host receipts,
Odin discovery, Eve connection receipts, and provider-owned composition remain.
Direct inventory is 71 occurrences across eight 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.

View file

@ -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: Continue the conceptual-substitution pass. Twenty-two high-authority closure families are typed and guarded; direct source inventory reports 124 content.contains occurrences across ten families. Collaboration policy/topic are now explicit Imagination-authored proposals: Persona owns discussion, Persona/Mind review policy, Mind admits policy, Bifrost publishes, requested public-room/Eve-surface ids remain unpublished pending provider receipts, and downstream renderer composition is irrelevant. Next inspect repo.eve_surface and repo.tool_capabilities for the same requested-versus-live provider substitution. External governance should converge on tooling plus publication/accounting; operations retains policy/deployment.
next_action: Continue the conceptual-substitution pass. The deterministic repo.tool_capabilities and repo.eve_surface families are deleted end to end because expected tool ids and invented surface/row/lowering catalogs substituted for provider publication. Real typed tool requests/host receipts, Odin discovery, Eve connection receipts, and provider-owned composition remain; downstream rendering remains downstream. Direct source inventory reports 71 content.contains occurrences across eight families. Next inspect repo.body_manifest and repo.doctrine_update_request; distinguish honest body modeling/doctrine proposals from files that claim admission or ownership they do not possess. External governance should converge on tooling plus publication/accounting; operations retains policy/deployment.