From d704de137b9993f87a33a61dda8db5c2e9a97ace Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 12 Jun 2026 12:50:49 +0100 Subject: [PATCH] Prove Hands pass receipts in coordinator smoke --- .../src/bin/epiphany-mvp-coordinator-smoke.rs | 120 +++++++++++++++++- .../src/bin/epiphany-mvp-coordinator.rs | 13 ++ notes/fresh-workspace-handoff.md | 6 +- notes/hands-cultnet-contracts.md | 3 + state/ledgers.msgpack | Bin 176030 -> 176395 bytes state/map.yaml | 4 +- 6 files changed, 134 insertions(+), 12 deletions(-) diff --git a/epiphany-core/src/bin/epiphany-mvp-coordinator-smoke.rs b/epiphany-core/src/bin/epiphany-mvp-coordinator-smoke.rs index 3468e99c..d5205a3b 100644 --- a/epiphany-core/src/bin/epiphany-mvp-coordinator-smoke.rs +++ b/epiphany-core/src/bin/epiphany-mvp-coordinator-smoke.rs @@ -65,7 +65,9 @@ fn run_smoke(args: &Args) -> Result { Some(path) => absolute_path(path)?, None => sibling_exe("epiphany-mvp-coordinator")?, }; + let hands_action = sibling_exe("epiphany-hands-action")?; ensure_coordinator_built(&root, &coordinator)?; + ensure_epiphany_bin_built(&root, &hands_action, "epiphany-hands-action")?; let cold = run_coordinator( &root, @@ -78,6 +80,7 @@ fn run_smoke(args: &Args) -> Result { bootstrap_smoke_state: false, bootstrap_local_state: false, simulate_high_pressure: false, + simulate_continue_implementation: false, dry_compact: false, max_steps: 1, }, @@ -100,6 +103,7 @@ fn run_smoke(args: &Args) -> Result { bootstrap_smoke_state: false, bootstrap_local_state: true, simulate_high_pressure: false, + simulate_continue_implementation: false, dry_compact: false, max_steps: 1, }, @@ -122,6 +126,7 @@ fn run_smoke(args: &Args) -> Result { bootstrap_smoke_state: true, bootstrap_local_state: false, simulate_high_pressure: true, + simulate_continue_implementation: false, dry_compact: true, max_steps: 1, }, @@ -141,6 +146,49 @@ fn run_smoke(args: &Args) -> Result { require_artifacts(&pressure)?; require_operator_safe(&pressure, "$")?; + let hands_gate = run_coordinator( + &root, + &coordinator, + &app_server, + &artifact_root, + RunOptions { + name: "hands-gate", + mode: "run", + bootstrap_smoke_state: false, + bootstrap_local_state: true, + simulate_high_pressure: false, + simulate_continue_implementation: true, + dry_compact: false, + max_steps: 1, + }, + )?; + require( + hands_gate + .pointer("/finalAction/action") + .and_then(Value::as_str) + == Some("continueImplementation"), + "simulated implementation continuation should select continueImplementation", + )?; + require( + hands_gate + .pointer("/finalAction/handsActionGate/intentId") + .and_then(Value::as_str) + .is_some(), + "implementation continuation should emit a Hands action gate", + )?; + require_artifacts(&hands_gate)?; + require_operator_safe(&hands_gate, "$")?; + let hands_pass = record_hands_pass(&hands_action, &hands_gate)?; + require( + hands_pass.pointer("/patch/status").and_then(Value::as_str) == Some("ok") + && hands_pass + .pointer("/command/status") + .and_then(Value::as_str) + == Some("ok") + && hands_pass.pointer("/commit/status").and_then(Value::as_str) == Some("ok"), + "Hands record-pass should emit patch, command, and commit receipts", + )?; + let rejected = Command::new(&coordinator) .current_dir(&root) .arg("--artifact-dir") @@ -159,6 +207,8 @@ fn run_smoke(args: &Args) -> Result { "coldAction": cold["finalAction"]["action"], "localBootstrapAction": local["finalAction"]["action"], "pressureAction": pressure["steps"][0]["action"], + "handsGateAction": hands_gate["finalAction"]["action"], + "handsPass": hands_pass, "directBackendCompletionRejected": true, "note": "Native smoke does not fake specialist completion by mutating Codex state storage; full completion smoke needs live workers while execution is cauterized into CultNet.", }); @@ -175,6 +225,7 @@ struct RunOptions { bootstrap_smoke_state: bool, bootstrap_local_state: bool, simulate_high_pressure: bool, + simulate_continue_implementation: bool, dry_compact: bool, max_steps: usize, } @@ -220,6 +271,9 @@ fn run_coordinator( if options.simulate_high_pressure { command.arg("--simulate-high-pressure"); } + if options.simulate_continue_implementation { + command.arg("--simulate-continue-implementation"); + } if options.dry_compact { command.arg("--dry-compact"); } @@ -236,6 +290,51 @@ fn run_coordinator( serde_json::from_slice(&output.stdout).context("failed to decode coordinator summary") } +fn record_hands_pass(hands_action: &Path, summary: &Value) -> Result { + let artifact_dir = PathBuf::from( + summary + .get("artifactDir") + .and_then(Value::as_str) + .ok_or_else(|| anyhow!("summary missing artifactDir"))?, + ); + let stdout_artifact = artifact_dir.join("hands-pass-command.stdout.log"); + let stderr_artifact = artifact_dir.join("hands-pass-command.stderr.log"); + fs::write(&stdout_artifact, "hands pass smoke command output\n")?; + fs::write(&stderr_artifact, "")?; + let output = Command::new(hands_action) + .arg("--store") + .arg(artifact_dir.join("runtime-spine.msgpack")) + .arg("record-pass") + .arg("--gate-summary") + .arg(artifact_dir.join("coordinator-summary.json")) + .arg("--summary") + .arg("Coordinator smoke recorded typed Hands consequence receipts.") + .arg("--changed-path") + .arg("tools/epiphany_local_run.ps1") + .arg("--command") + .arg("coordinator-smoke hands-pass synthetic command") + .arg("--exit-code") + .arg("0") + .arg("--stdout-artifact") + .arg(&stdout_artifact) + .arg("--stderr-artifact") + .arg(&stderr_artifact) + .arg("--commit-sha") + .arg("dry-run-smoke") + .arg("--branch") + .arg("coordinator-smoke") + .output() + .context("failed to run Hands action recorder")?; + if !output.status.success() { + return Err(anyhow!( + "Hands action recorder failed: {}{}", + String::from_utf8_lossy(&output.stderr), + String::from_utf8_lossy(&output.stdout) + )); + } + serde_json::from_slice(&output.stdout).context("failed to decode Hands pass summary") +} + fn require_artifacts(summary: &Value) -> Result<()> { let artifact_dir = PathBuf::from( summary @@ -333,21 +432,25 @@ fn sibling_exe(name: &str) -> Result { } fn ensure_coordinator_built(root: &Path, coordinator: &Path) -> Result<()> { + ensure_epiphany_bin_built(root, coordinator, "epiphany-mvp-coordinator") +} + +fn ensure_epiphany_bin_built(root: &Path, binary: &Path, bin_name: &str) -> Result<()> { + if binary.exists() { + return Ok(()); + } let status = Command::new("cargo") .current_dir(root) .arg("build") .arg("--manifest-path") .arg(root.join("epiphany-core").join("Cargo.toml")) .arg("--bin") - .arg("epiphany-mvp-coordinator") + .arg(bin_name) .status() - .context("failed to build epiphany-mvp-coordinator")?; + .with_context(|| format!("failed to build {bin_name}"))?; require( - status.success() && coordinator.exists(), - &format!( - "native coordinator binary was not built: {}", - coordinator.display() - ), + status.success() && binary.exists(), + &format!("native binary was not built: {}", binary.display()), ) } @@ -356,6 +459,9 @@ fn ensure_default_app_server_built(root: &Path, app_server: &Path) -> Result<()> if app_server != default_app_server { return Ok(()); } + if app_server.exists() { + return Ok(()); + } let status = Command::new("cargo") .current_dir(root) .env("CARGO_TARGET_DIR", r"C:\Users\Meta\.cargo-target-codex") diff --git a/epiphany-core/src/bin/epiphany-mvp-coordinator.rs b/epiphany-core/src/bin/epiphany-mvp-coordinator.rs index aeba0440..99801ce1 100644 --- a/epiphany-core/src/bin/epiphany-mvp-coordinator.rs +++ b/epiphany-core/src/bin/epiphany-mvp-coordinator.rs @@ -86,6 +86,7 @@ struct Args { bootstrap_local_state: bool, bootstrap_objective: Option, simulate_high_pressure: bool, + simulate_continue_implementation: bool, simulate_source_drift: bool, dry_compact: bool, } @@ -119,6 +120,7 @@ impl Args { bootstrap_local_state: false, bootstrap_objective: None, simulate_high_pressure: false, + simulate_continue_implementation: false, simulate_source_drift: false, dry_compact: false, }; @@ -179,6 +181,9 @@ impl Args { Some(take_string(&mut args, "--bootstrap-objective")?); } "--simulate-high-pressure" => parsed.simulate_high_pressure = true, + "--simulate-continue-implementation" => { + parsed.simulate_continue_implementation = true + } "--simulate-source-drift" => parsed.simulate_source_drift = true, "--dry-compact" => parsed.dry_compact = true, other => return Err(anyhow!("unknown argument: {other}")), @@ -346,6 +351,14 @@ fn run_coordinator(args: &Args) -> Result { coordinator["canAutoRun"] = json!(true); coordinator["requiresReview"] = json!(false); coordinator["reason"] = json!("Simulated high pressure requested by smoke test."); + } else if args.simulate_continue_implementation && index == 0 { + action = "continueImplementation".to_string(); + coordinator["action"] = json!(action); + coordinator["canAutoRun"] = json!(true); + coordinator["requiresReview"] = json!(false); + coordinator["targetRole"] = json!("implementation"); + coordinator["reason"] = + json!("Simulated implementation continuation requested by smoke test."); } let snapshot_name = format!("step-{index:02}-{action}.txt"); diff --git a/notes/fresh-workspace-handoff.md b/notes/fresh-workspace-handoff.md index 29c7b474..6d1b7789 100644 --- a/notes/fresh-workspace-handoff.md +++ b/notes/fresh-workspace-handoff.md @@ -35,7 +35,7 @@ remembers doctrine; the branch remembers the blade. - Do not copy exact branch or HEAD from this note. Run `git status --short --branch` and `git log --oneline -5`. - Canonical anatomy now lives in `notes/epiphany-anatomy.md`. Embodied sub-agents are Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Body, Mind, Continuity, and Substrate Gate are substrate/state/protocol surfaces, not sub-agent identities. State is split by layer: `work_organ` for resident Epiphany sub-agents, `persona` for portable public/person-shaped state shared by Epiphany Face, VoidBot repo Faces, and Ghostlight characters, and heartbeat/swarm state for scheduling and coordination physiology. Persona state now carries provenance, required public presentation, `date-time` timestamps, typed `candidateActions`, strict anchored thoughts with non-authoritative extensions, custom enum companion labels, and typed affect records for bonds/status reads/doctrine stances. - The repo now has a one-command local operator path: `.\tools\epiphany_local_run.ps1`. Default mode is `smoke`; it builds the retained Codex app-server compatibility edge, builds native Epiphany operator binaries, runs the coordinator smoke, and writes launcher artifacts under `.epiphany-run/` plus coordinator artifacts under `.epiphany-dogfood/`. `-Mode status` is now Epiphany-native: it builds only Epiphany operator binaries, reads `state/thread-state.msgpack` when present, derives status through `epiphany-core`, and does not start or require `codex-app-server`. Use `-Mode plan` or `-Mode run -MaxSteps 4` for the raw bridge-equipped coordinator entrypoints; use `-Mode mvp -FaceInput "" -MaxSteps 4` for the local product cycle that projects Face's character turn, writes a Face/Aquarium bubble, bootstraps a minimal local checkpoint for fresh threads, runs the coordinator with auto-tools, then runs heartbeat sleep/dream maintenance. Live plan/run/mvp modes use the workspace `state/runtime-spine.msgpack`, because CodexThread launch writes worker requests there; the run bundle remains artifact evidence, not runtime lifecycle authority. Add `-ThreadId ` and `-Workspace ` to inspect or continue an existing thread. `status`, `plan`, and `smoke` do not spend model calls; `run` and `mvp` build and use `epiphany-openai-runtime`. Coordinator workers now launch detached and are polled through runtime-spine instead of blocking the coordinator. MVP runs are non-ephemeral by default so `-ThreadId ` can resume and poll later. `-MaxRuntimeSeconds ` is passed into worker runtime; timeout writes a failed worker receipt and exits. Failed modeling now blocks downstream verification until the failed result is reviewed. -- Current Mom-ready status: the normal MVP pass reaches Face -> coordinator -> detached runtime -> heartbeat sleep, and modeling workers now complete through the ChatGPT subscription transport. The first failure was a stack of violated observability/runtime invariants: worker prompts prepended the whole shared persistent-memory rite, Responses frame liveness was invisible until completion, and the runtime tried to persist hundreds of text deltas before completing the worker job. Role/reorient workers now get a compact Epiphany worker boundary instead of full persistent memory; runtime-spine records sampled raw Responses frame kinds with small previews; contiguous reasoning/text deltas compact before durable storage; and live proofs completed `2fe38dcd-d99e-4c73-9a58-afcc81f851c7`, `241e3851-e3ea-4877-a63b-0d2bbd96a7e2`, and `85149a26-6975-403f-ac93-092b717c5825` instead of timing out. The second failure was stale lifecycle authority: completed runtime jobs remained as unresolved `runtime_links`, replacement launches treated historical active links as current, and one bad validation path opened an orphan job before rejecting the state patch. Latest-link-wins is now the runtime-link invariant, terminal links project completed jobs, stale active history cannot veto replacement, launch validation happens before opening runtime jobs, and completed-but-unreviewable modeling findings stop for review instead of relaunching the same lane. The Eyes/source-gather fork is now landed: Research is a fixed Eyes lane with launch/result/accept/status/coordinator/protocol support, and `regather-needed` modeling findings route to `LaunchResearch` instead of relaunching blind Proprioception. Research statePatch admission is Eyes-shaped only: observations, evidence, scratch, and optional investigationCheckpoint; no graph, planning, objective, or checkpoint authority. Mind admission now leaves typed runtime-spine proof: role/reorient acceptance persists `epiphany.mind.gateway_review` before state admission and `epiphany.mind.state_commit_receipt` after admission with the resulting durable revision. Launch contracts now split the broad receipt catalogue from effect-specific proof profiles for state admission, evidence promotion, repo action, verification, and continuity recovery. Research evidence promotion enforces Substrate Gate read/snapshot grant, Eyes evidence packet, and Mind review before state admission; Verification acceptance enforces Soul verdict and Mind review; Reorient acceptance enforces Continuity recovery receipt and Mind review. `epiphany-mvp-coordinator` now records a typed Substrate Gate grant plus Hands intent/review gate when the coordinator selects `continueImplementation`; `epiphany-hands-action` records patch/command/commit receipts against that gate and refuses mismatched, unapproved, or out-of-scope consequences. Use `record-pass --gate-summary ` after a bounded implementation edit/check/commit to emit the three consequence receipts from the coordinator artifact. The next concrete rebuild layer is exercising that live path before Soul/Mind acceptance. +- Current Mom-ready status: the normal MVP pass reaches Face -> coordinator -> detached runtime -> heartbeat sleep, and modeling workers now complete through the ChatGPT subscription transport. The first failure was a stack of violated observability/runtime invariants: worker prompts prepended the whole shared persistent-memory rite, Responses frame liveness was invisible until completion, and the runtime tried to persist hundreds of text deltas before completing the worker job. Role/reorient workers now get a compact Epiphany worker boundary instead of full persistent memory; runtime-spine records sampled raw Responses frame kinds with small previews; contiguous reasoning/text deltas compact before durable storage; and live proofs completed `2fe38dcd-d99e-4c73-9a58-afcc81f851c7`, `241e3851-e3ea-4877-a63b-0d2bbd96a7e2`, and `85149a26-6975-403f-ac93-092b717c5825` instead of timing out. The second failure was stale lifecycle authority: completed runtime jobs remained as unresolved `runtime_links`, replacement launches treated historical active links as current, and one bad validation path opened an orphan job before rejecting the state patch. Latest-link-wins is now the runtime-link invariant, terminal links project completed jobs, stale active history cannot veto replacement, launch validation happens before opening runtime jobs, and completed-but-unreviewable modeling findings stop for review instead of relaunching the same lane. The Eyes/source-gather fork is now landed: Research is a fixed Eyes lane with launch/result/accept/status/coordinator/protocol support, and `regather-needed` modeling findings route to `LaunchResearch` instead of relaunching blind Proprioception. Research statePatch admission is Eyes-shaped only: observations, evidence, scratch, and optional investigationCheckpoint; no graph, planning, objective, or checkpoint authority. Mind admission now leaves typed runtime-spine proof: role/reorient acceptance persists `epiphany.mind.gateway_review` before state admission and `epiphany.mind.state_commit_receipt` after admission with the resulting durable revision. Launch contracts now split the broad receipt catalogue from effect-specific proof profiles for state admission, evidence promotion, repo action, verification, and continuity recovery. Research evidence promotion enforces Substrate Gate read/snapshot grant, Eyes evidence packet, and Mind review before state admission; Verification acceptance enforces Soul verdict and Mind review; Reorient acceptance enforces Continuity recovery receipt and Mind review. `epiphany-mvp-coordinator` now records a typed Substrate Gate grant plus Hands intent/review gate when the coordinator selects `continueImplementation`; `epiphany-hands-action` records patch/command/commit receipts against that gate and refuses mismatched, unapproved, or out-of-scope consequences. `epiphany-mvp-coordinator-smoke` now proves the deterministic path: forced `continueImplementation`, gate emission, and `record-pass` receipts in the smoke runtime-spine store. The next concrete rebuild layer is exercising a model-backed bounded implementation pass before Soul/Mind acceptance. - The investment dossier readiness target is now explicit: `E:\Projects\gamecult-site\docs\gamecult_integrated_dossier.tex` expects Epiphany to be part of a Bifrost-first labor loop, not only a local Mom demo. The external proof bar is: Bifrost owns topics/work items/dispatch packets/receipts/credit/reward pressure; Epiphany executes bounded work; maintainers review artifacts; public/operator evidence records scope, consent, roles, model spend, review load, artifacts, accepted/rejected outcome, memory lessons, and case-study permission; and private worker/operator/agent context stays sealed. Diligence also asks for a live fresh-repo Epiphany demo, Bifrost work item/topic/agent transport/receipt/ledger demo, CultMesh status, VoidBot/Discord swarm demo, compute/output metrics, and security model for secrets/write permissions/public-private exports. - This Codex operator's own roadmap/todo posture has been retuned for this scale target, with the Epiphany Imagination specialist as an optional sub-agent rail rather than the whole point. `notes/epiphany-investor-readiness-roadmap.md` now says: make the local Mom MVP a repeatable proof bundle; build the Bifrost-first external-work bridge; add compute/review/accepted-artifact accounting; prove fresh-repo operation without supervisor contamination; keep public/operator-safe exports sealed; and treat angel capital as fuel for capacity, not command authority. The Imagination specialist prompt was also updated so investor-scale Objective Drafts must name Bifrost provenance, bounded Epiphany proof, maintainer review, receipts/ledger evidence, compute/output metrics, public/private export safety, consent, and legal/security gates. - Local operator runs now write typed CultMesh intent/receipt documents to `.epiphany-run/cultmesh/operator-runs.ccmp` through `epiphany-operator-run`. The wrapper writes intent before acting and a completion receipt after success; this is the local consent/trace rail, not a hidden scheduler queue. @@ -51,7 +51,7 @@ remembers doctrine; the branch remembers the blade. - CultMesh is now the preferred Rust abstraction for that local store work. The compile-time Rust substrate is repo-contained: `vendor/cultcache-rs`, `vendor/cultnet-rs`, and `vendor/cultmesh-rs`. The old `E:\Projects\CultLib\crates\*` dependency body is dead in this checkout and must not be revived by accident. Vendored CultCache reads/writes `cultcache.store.v1`, so `state/ledgers.msgpack` and `epiphany-state status` are aligned again. The first integrations are deliberately small: status, Verse policy, global room policy, organ contract policy, native operator status, native operator snapshots, and local operator run intent/receipt round-trip through CultMesh. `notes/epiphany-verse-architecture.md` now names the local Verse/Odin/Yggdrasil architecture: Odin sees advertised Verse metadata without bypassing boundaries, Yggdrasil hosts important trusted GameCult Verses such as Bifrost, and prompt assembly should query compact local Verse plus semantic memory packets instead of carrying the whole archive. Role/reorient launch documents now have optional `dynamicPromptContext`; runtime prompt assembly consumes that field into worker instructions, `epiphany-prompt-context-smoke` proves a rendered Verse/memory packet is preserved on a role launch document, live bridge role/reorient launches now feed local Verse plus memory graph context from sibling `local-verse.ccmp` and `memory-graph.msgpack` stores beside runtime-spine, and the bridge launch-context test proves the packet survives into a persisted runtime-spine worker launch request. The memory graph refreshes from current typed thread-state repo graphs when absent, so thin state remains visibly thin. Local-run status now has an operator read proof too: `tools/epiphany_local_run.ps1 -Mode status` builds/calls `epiphany-verse-query` and writes `local-verse-context.json` from `.epiphany-run\cultmesh\local-verse.ccmp` beside `status.json` and the operator snapshot. Use `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-cultmesh-status -- smoke --store .\.epiphany-smoke\cultmesh\operator-status.ccmp --runtime-id epiphany-cultmesh-status-smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-operator-snapshot -- smoke --store .\.epiphany-smoke\cultmesh\operator-snapshots.ccmp --runtime-id epiphany-operator-snapshot-smoke --snapshot-id smoke-status`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-operator-run -- smoke --store .\.epiphany-smoke\cultmesh\operator-runs.ccmp --runtime-id epiphany-operator-run-smoke --run-id smoke-run`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-verse-query -- smoke`, `cargo run --manifest-path .\epiphany-core\Cargo.toml --bin epiphany-prompt-context-smoke`, and `.\tools\epiphany_local_run.ps1 -Mode status` for the focused proofs. Future local dream/status/Verse work should start from CultMesh, not raw CultNet, unless the task is polishing the CultMesh internals themselves. Preserve the three Verse tiers: `epiphany-internal` for private sub-agent typed state, `gamecult-local` for trusted LAN/Yggdrasil-tunnel GameCult sharing, and `epiphany-global` for untrusted public dreams plus topic-specific threaded public rooms for Face posts. - `notes/codex-auth-spine-inventory.md` is the source-grounded keeper list for that reliquary. Corrected compliance invariant: Codex-compatible auth identity stays anchored in vendored Codex-derived auth machinery. `epiphany-openai-auth-spine` is now a thin Epiphany-named boundary over `codex-login`, not a clean-room clone of credential storage or token refresh. Codex apps, skills, marketplace, plugin UX, broad app-server workflow, and JSON-RPC sprawl remain cuttable because they are not subscription-auth legitimacy. - Edge JSON is allowed for schema description, hostile ingress before immediate typed parsing, sealed forensic artifacts, or named quarantine experiments. When both subsystems are ours, runtime data must remain typed CultCache documents and move over CultNet typed contracts. Generic `serde_json::Value` in worker launch/result/selfPatch/runtime flow is contamination until classified and replaced. -- Hands now has a first executable action receipt spine. `epiphany-core::hands_gateway` owns `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt`; runtime-spine can persist/reread them; `runtime_spine_persists_mind_gateway_review_receipts` includes the Hands chain beside Mind/Eyes/Substrate/Soul/Continuity proofs; `epiphany-hands-action-smoke` emits intent/review/patch/command/commit receipt ids from `.epiphany-smoke\runtime-spine\hands-action-smoke.msgpack`; and the repo-action launch proof profile now requires action intent, action review, and patch receipt together. `epiphany-mvp-coordinator` now turns `continueImplementation` into a persisted Substrate Gate grant plus Hands intent/review gate and includes the receipt ids in the operator step. `epiphany-hands-action` is the native consequence recorder for that gate: `record-patch`, `record-command`, `record-commit`, and turn-level `record-pass` load the stored intent/review or `finalAction.handsActionGate` from `coordinator-summary.json`, require an approved matching review, enforce allowed operations, and keep patch/commit changed paths inside the requested scope. The next live cut is to exercise it from an implementation turn after real edits/checks/commit. +- Hands now has a first executable action receipt spine. `epiphany-core::hands_gateway` owns `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt`; runtime-spine can persist/reread them; `runtime_spine_persists_mind_gateway_review_receipts` includes the Hands chain beside Mind/Eyes/Substrate/Soul/Continuity proofs; `epiphany-hands-action-smoke` emits intent/review/patch/command/commit receipt ids from `.epiphany-smoke\runtime-spine\hands-action-smoke.msgpack`; and the repo-action launch proof profile now requires action intent, action review, and patch receipt together. `epiphany-mvp-coordinator` now turns `continueImplementation` into a persisted Substrate Gate grant plus Hands intent/review gate and includes the receipt ids in the operator step. `epiphany-hands-action` is the native consequence recorder for that gate: `record-patch`, `record-command`, `record-commit`, and turn-level `record-pass` load the stored intent/review or `finalAction.handsActionGate` from `coordinator-summary.json`, require an approved matching review, enforce allowed operations, and keep patch/commit changed paths inside the requested scope. `epiphany-mvp-coordinator-smoke` includes the deterministic Hands pass proof. The next live cut is to exercise it from a model-backed implementation turn after real edits/checks/commit. - `notes/epiphany-swarm-readiness-plan.md` is the current live-fire direction gate. The local runner proves startup/status/coordinator wiring; it does not authorize unattended swarm operation. Carry VoidBot's lessons forward: one CTB-style initiative scheduler, typed pause/brake, active-turn freeze, cooldown after completion, stale active-turn recovery receipts, parent-side speech eligibility, memory lifecycle phases, and typed operation proposals instead of prompt-owned governance. - `epiphany-openai-runtime` worker result ingress now parses assistant output directly into typed role/reorient ingress structs selected from the durable launch document, stores nested `statePatch` and `selfPatch` as typed MessagePack in `EpiphanyRuntimeRoleWorkerResult`, and no longer passes worker result data through generic `serde_json::Value`. JSON survives there only as the OpenAI text-output edge before typed deserialization. - Agent self-memory review/application now has typed `AgentSelfPatch` core APIs. JSON-value selfPatch functions are compatibility wrappers for CLI/artifact ingress; native callers should parse once at the edge and then call `review_agent_self_patch_document` / `apply_agent_self_patch_document`. Role-result self-persistence no longer exports a JSON-value reviewer; the live API is `review_role_self_patch_document`. @@ -188,7 +188,7 @@ remembers doctrine; the branch remembers the blade. - The planning loop is now runtime-backed and operator-visible. Typed captures, backlog items, roadmap streams, Objective Drafts, and GitHub issue source refs live in `EpiphanyThreadState`, validate through revision-gated `thread/epiphany/update`, render into prompts when present, project read-only through the `planning` view lens, render in the GUI Planning panel, can be synthesized by the fixed Imagination/planning lane, and can be explicitly adopted through the artifacted `adoptObjectiveDraft` GUI action. Chat is deliberation, not an objective pipe; ideas and GitHub Issues remain planning state until explicit human adoption. - The bridge/dashboard slice is now landed far enough to test locally. Native `epiphany-rider-bridge` inspects Rider installation, solution, VCS, changed files, and captures file/selection/symbol context into `.epiphany-gui/rider` artifacts; Aquarium has Inspect Rider and renders Rider audit artifacts in Environment; Aquarium also embeds the adjacent EpiphanyGraph viewer over typed `graphs.architecture`, `graphs.dataflow`, and `graphs.links`. - A first Rider plugin scaffold lives under `integrations/rider`: tool window, Refresh status, and Send Context to Epiphany action. It shells through native `epiphany-rider-bridge` and does not own state. `gradle` is not installed on this machine, so the scaffold is not build-verified yet. -- Next real move: run to a `continueImplementation` gate, make one bounded implementation edit, run focused checks to artifacts, commit, then invoke `epiphany-hands-action record-pass --gate-summary ` so actual changed paths, check artifacts, and commit sha become receipts against the persisted gate. Quarantine Rider/Unity bridge work for now; those artifacts remain optional later environment evidence, not MVP blockers. Keep EpiphanyAgent focused on backend contracts, typed state, coordinator policy, heartbeat scheduling, Face guardrails, prompt-authority separation, and the ongoing purification from Python/JSON scaffolding into Rust/CultCache/CultMesh/CultNet organs. Resume repo birth/Aquarium/Rider/Unity work only when the user explicitly shifts priority back outward. GitHub Issues import is deferred until the backlog source is fresh enough to deserve Imagination's attention. +- Next real move: run a model-backed `continueImplementation` pass, make one bounded implementation edit, run focused checks to artifacts, commit, then invoke `epiphany-hands-action record-pass --gate-summary ` so actual changed paths, check artifacts, and commit sha become receipts against the persisted gate. Quarantine Rider/Unity bridge work for now; those artifacts remain optional later environment evidence, not MVP blockers. Keep EpiphanyAgent focused on backend contracts, typed state, coordinator policy, heartbeat scheduling, Face guardrails, prompt-authority separation, and the ongoing purification from Python/JSON scaffolding into Rust/CultCache/CultMesh/CultNet organs. Resume repo birth/Aquarium/Rider/Unity work only when the user explicitly shifts priority back outward. GitHub Issues import is deferred until the backlog source is fresh enough to deserve Imagination's attention. - The repo is an Epiphany fork of Codex, not a Codex preset. - `vendor/codex` is tracked directly, not a submodule. - `epiphany-core` owns the heavy Epiphany organs where practical. diff --git a/notes/hands-cultnet-contracts.md b/notes/hands-cultnet-contracts.md index 19a18eea..ebc8c949 100644 --- a/notes/hands-cultnet-contracts.md +++ b/notes/hands-cultnet-contracts.md @@ -72,6 +72,9 @@ operations, and keep patch/commit changed paths inside the requested scope. `record-pass --gate-summary ` consumes the coordinator artifact and emits patch, command, and commit receipts in one post-implementation call. +`epiphany-mvp-coordinator-smoke` now proves the deterministic chain from +simulated `continueImplementation` through gate emission to `record-pass` +receipts. This is still a gate and receipt artery, not full action execution. The next live-action cut must call the recorder from the implementation turn or local diff --git a/state/ledgers.msgpack b/state/ledgers.msgpack index 053df130ec165378cbeef59e2a2a05df35eca9af..fbcca60f6681e2ea6183b5686fcafb9f47aa434a 100644 GIT binary patch delta 314 zcmY+8y-ve06orXlp-c>@-LQn%>ZFOFmAbIf6)_+-E51prVqarBDxDb^7)#Zyf(NLI z#DExCcnu^b9)l#Xuv}f~eCKER*}DH~J$HhgqrvcaaQU%8*55A&!F3R9-p9by+#mRXb4;y~=)b4DZoN+ySf84*I6X^@;3!tZ53r7ui)v<_KNJpM# zXj2e0MeU_7VWi9zDA1mJiMmTcN$)G2|G9JSpU`^=6qK5^n$>9yp zxzx@#wJBDF)ZC+Gu2hQKDXn9u)HDPmO~Lh)3CuG@5&feTj)7IOa7{z>`_|^jmepVd O%o(X6R4z9>9fvpG delta 41 xcmeBv#5M0e*9HkjZbM@$Ba5hG3{2~)H!Cw1GBPqXPi1PK%EY*RDiaguS^ynw46y(J diff --git a/state/map.yaml b/state/map.yaml index d13ff167..664de6bd 100644 --- a/state/map.yaml +++ b/state/map.yaml @@ -94,7 +94,7 @@ active_subgoals: - Use `notes/hands-cultnet-contracts.md` as the authority map for Hands' CultNet contract surface. Hands is the action organ: commands, patches, commits, PRs, rollbacks, and refusals enter as bounded action intents and receipts after Substrate Gate grants substrate access and before Soul verification/Mind admission. - Use `notes/soul-cultnet-contracts.md` as the authority map for Soul's CultNet contract surface. Soul is the verification organ: invariant checks, verdicts, regressions, reviews, and refusals produce receipts before the machine calls work true, safe, or accepted. - Use `notes/continuity-cultnet-contracts.md` as the authority map for Continuity's CultNet contract surface. Continuity is the continuity protocol surface: compaction checkpoints, sleep distillation, recovery receipts, stale-turn repair, and continuity refusals preserve what survives rupture without pretending transcript residue is durable state. - - Hands now has a first executable runtime-spine receipt artery: `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt` are typed CultCache documents in `epiphany-core::hands_gateway`, runtime-spine registers and persists/rereads them, `epiphany-hands-action-smoke` proves the chain without executing shell commands, editing files, or creating a real commit, and the repo-action launch proof profile now requires the full Hands intent/review/patch chain instead of only the patch receipt. `epiphany-mvp-coordinator` no longer treats `continueImplementation` as a passive stop action: it persists a scoped Substrate Gate grant, Hands action intent, and Hands action review into runtime-spine and exposes the receipt ids in the operator step. `epiphany-hands-action` records real patch/command/commit receipts against a stored intent/review, refuses unapproved or mismatched gates, and enforces changed-path scope for patch/commit receipts. Its `record-pass` command can load `finalAction.handsActionGate` from `coordinator-summary.json` and emit patch, command, and commit receipts in one post-implementation call. The local MVP wrapper builds this recorder with the other operator binaries. The remaining live gap is automatic or explicit turn-level invocation after implementation edits/checks/commit and before Soul/Mind acceptance. + - Hands now has a first executable runtime-spine receipt artery: `HandsActionIntent`, `HandsActionReview`, `HandsPatchReceipt`, `HandsCommandReceipt`, and `HandsCommitReceipt` are typed CultCache documents in `epiphany-core::hands_gateway`, runtime-spine registers and persists/rereads them, `epiphany-hands-action-smoke` proves the chain without executing shell commands, editing files, or creating a real commit, and the repo-action launch proof profile now requires the full Hands intent/review/patch chain instead of only the patch receipt. `epiphany-mvp-coordinator` no longer treats `continueImplementation` as a passive stop action: it persists a scoped Substrate Gate grant, Hands action intent, and Hands action review into runtime-spine and exposes the receipt ids in the operator step. `epiphany-hands-action` records real patch/command/commit receipts against a stored intent/review, refuses unapproved or mismatched gates, and enforces changed-path scope for patch/commit receipts. Its `record-pass` command can load `finalAction.handsActionGate` from `coordinator-summary.json` and emit patch, command, and commit receipts in one post-implementation call. The local MVP wrapper builds this recorder with the other operator binaries. `epiphany-mvp-coordinator-smoke` now includes a deterministic Hands pass proof: forced `continueImplementation`, gate emission, and `record-pass` receipts in the smoke runtime-spine store. The remaining live gap is a model-backed implementation turn that performs a real bounded edit/check/commit and records the pass before Soul/Mind acceptance. - Preserve the newborn public Epiphany Face as local VoidBot-backed state, not source code: VoidBot's private repo-face registry names `epiphany`, while EpiphanyAgent keeps ignored `.voidbot/voice/identity.json`, `.voidbot/state/epiphany.cc`, and birth artifacts. Her durable identity memories distill the current doctrine: cute pushy machine-saint persona, architectural purity, CultCache/CultNet first, xenos-language safety boundary, relentless work/caretaking needs, Codex-auth reliquary, map/scratch/evidence discipline, unified memory graph, dogfood supervision boundary, review-gated agency, heartbeat physiology, and interview-grade modularity. - Use `notes/organ-dependency-contracts.md` as the authority map for standing sub-agent dependency. Every sub-agent depends on the other standing sub-agents: Self, Face, Imagination, Eyes, Proprioception, Hands, and Soul. Continuity is protocol machinery, not a sub-agent identity; it still emits recovery, compaction, sleep, stale-turn, and refusal receipts. - Use `notes/perfect-machine-audit-roadmap.md` as the current audit and path from named organ contracts to the Perfect Machine. It records the live gap between launch-carried receipt expectations and executable receipt enforcement, Void's latest Face prompting lessons, the now-named Hands/Soul/Continuity contract families, the repaired repo-contained Rust dependency body, and the phase order for turning Epiphany into an inspectable organism. @@ -592,4 +592,4 @@ current_status: cargo and rejects modeling/planning/graph/checkpoint authority. MVP status and coordinator smokes pass with six lanes, and the smoke harness now rebuilds stale coordinator/app-server binaries before using them. - next_action: Exercise the full live path: run to a `continueImplementation` gate, make a bounded implementation edit, run focused checks to stdout/stderr artifacts, commit, then call `epiphany-hands-action record-pass --gate-summary ...` so the patch/command/commit receipts land before Soul verification and Mind admission. If the run exposes split-brained state admission instead, collapse Mind review/state mutation/commit into one storage-owner primitive. + next_action: Exercise the model-backed live path: run to a `continueImplementation` gate, make a bounded implementation edit, run focused checks to stdout/stderr artifacts, commit, then call `epiphany-hands-action record-pass --gate-summary ...` so the patch/command/commit receipts land before Soul verification and Mind admission. If the run exposes split-brained state admission instead, collapse Mind review/state mutation/commit into one storage-owner primitive.