Share release build graph per source commit

epiphany-core/src/packaged_release.rs

@@ -340,7 +340,7 @@ fn build_required_release_siblings(
                 manifest.display()
             );
         }
-        let target_dir = release_manifest_target_dir(target_root, source_commit_sha, manifest_dir);
+        let target_dir = release_commit_target_dir(target_root, source_commit_sha);
         let mut command = std::process::Command::new(cargo);
         command
             .arg("build")
@@ -403,12 +403,8 @@ fn verify_owned_release_lock(
     Ok(())
 }
 
-fn release_manifest_target_dir(
-    target_root: &Path,
-    source_commit_sha: &str,
-    manifest_dir: &str,
-) -> PathBuf {
-    target_root.join(source_commit_sha).join(manifest_dir)
+fn release_commit_target_dir(target_root: &Path, source_commit_sha: &str) -> PathBuf {
+    target_root.join(source_commit_sha)
 }
 
 fn required_release_build_target(role: &str) -> Result<(&'static str, &'static str)> {
@@ -870,31 +866,22 @@ mod tests {
     }
 
     #[test]
-    fn owning_manifests_have_isolated_build_roots() {
-        let root = Path::new("isolated-release-build");
+    fn owning_manifests_share_the_exact_commit_build_root() {
+        let root = Path::new("release-build-cache");
         let commit = "0123456789abcdef0123456789abcdef01234567";
-        let core = release_manifest_target_dir(root, commit, "epiphany-core");
-        let model = release_manifest_target_dir(root, commit, "epiphany-openai-runtime");
-        let tools = release_manifest_target_dir(root, commit, "epiphany-tool-mcp-runtime");
-        assert_ne!(core, model);
-        assert_ne!(core, tools);
-        assert_ne!(model, tools);
-        assert!(core.starts_with(root) && model.starts_with(root) && tools.starts_with(root));
+        let core = release_commit_target_dir(root, commit);
+        let model = release_commit_target_dir(root, commit);
+        let tools = release_commit_target_dir(root, commit);
+        assert_eq!(core, model);
+        assert_eq!(core, tools);
+        assert_eq!(core, root.join(commit));
     }
 
     #[test]
     fn source_commits_have_isolated_build_roots() {
         let root = Path::new("isolated-release-build");
-        let first = release_manifest_target_dir(
-            root,
-            "0123456789abcdef0123456789abcdef01234567",
-            "epiphany-core",
-        );
-        let second = release_manifest_target_dir(
-            root,
-            "89abcdef0123456789abcdef0123456789abcdef",
-            "epiphany-core",
-        );
+        let first = release_commit_target_dir(root, "0123456789abcdef0123456789abcdef01234567");
+        let second = release_commit_target_dir(root, "89abcdef0123456789abcdef0123456789abcdef");
         assert_ne!(first, second);
     }
 

notes/fresh-workspace-handoff.md

@@ -44,16 +44,29 @@ to project `imaginationRunning`. The source cause is in
 worker errors out of the process without calling `fail_worker_for_runtime_error`.
 The unbounded branch already sealed the same error correctly.
 
-The local cut routes bounded and unbounded completion through
-`seal_worker_runtime_result`. Success remains success; every ordinary error
+Exact pushed commit `b8c76fd0d955e4d540e9caf2b73a2abbf784dc14` routes bounded
+and unbounded completion through `seal_worker_runtime_result`. Success remains
+success; every ordinary error
 writes the typed failed outer worker and inner OpenAI job before exit. All six
-model-runtime tests and all fourteen coordinator tests pass. v28 is sealed
-failure evidence; do not repair its runtime state manually.
+model-runtime tests and all fourteen coordinator tests pass. It packaged 21
+binaries as `sha256-f5a78dc6153edadb25b00717cee0c42df58663cdf7dde1fcd21354e87cb6b763`
+with witness `sha256-7a0b060f3351cdb9dc0be09a903fd09d9e437fda89eea51ab88d8bafcb91f9e5`.
+It has not been published into v28; v28 is sealed failure evidence and must not
+be repaired or mutated manually.
+
+That package run exposed a release-forge ownership fault. One exact commit was
+split across manifest-specific Cargo target directories, so `epiphany-core`,
+`epiphany-openai-runtime`, and `epiphany-tool-mcp-runtime` rebuilt overlapping
+dependency graphs independently. The third manifest alone took 8m45s. The
+working cut gives the exact commit one shared target root while retaining
+separate lockfile validation, sequential builds, detached clean source, and
+byte-level release witnessing. All fourteen packaged-release tests pass.
 
 ## Next action
 
-Commit and push the terminalization cut, then package and publish that exact
-commit. Cold-start a clean generation. Without overrides, prove:
+Commit and push the release build-graph collapse, package that exact commit,
+and compare elapsed time against the three-root b8c76fd0 baseline. Publish the
+result only into a clean successor generation. Without overrides, prove:
 
 1. Self derives proposal-bound Modeling and canonical Imagination.
 2. Self selects and launches canonical Imagination.

state/map.yaml

@@ -34,9 +34,9 @@ invariants:
   - Evidence and git retain history; this map retains only state that changes future decisions.
 
 current_status:
-  summary: Epiphany is a supervised engineering alpha on Starfire, not deployment-ready. Exact pushed 17d4ae47 is authenticated and published as sha256-0afab25c with witness sha256-2e9e8a53. v27 proved generic proposal-to-Hands routing but not the repaired adopted-plan binding. Clean v28 then proved resident release-store separation, raw Bifrost trust-anchor startup, live proposal-bound Modeling admission, canonical Imagination selection, and native Imagination launch without overrides. Imagination PID 11132 exited, but the runtime remained permanently imaginationRunning with no result or failure. The cause is exact: the bounded run-worker branch propagated ordinary runtime errors through `Ok(result) => result?`, bypassing the failure commit used by the unbounded branch. The local cut gives both branches one terminalization primitive; all 6 model-runtime tests and all 14 coordinator tests pass. v28 is sealed Continuity failure evidence until the fixed commit is packaged and replayed. Persona consequence, Continuity recovery/closure, retention, long-duration pacing, and Linux/Yggdrasil cognition remain open.
+  summary: Epiphany is a supervised engineering alpha on Starfire, not deployment-ready. Exact pushed b8c76fd0 seals ordinary bounded worker errors and is packaged as sha256-f5a78dc6 with witness sha256-7a0b060f; v28 remains sealed Continuity failure evidence and has not been mutated by publication. Packaging exposed a build-graph fault: three manifest-specific target directories rebuilt shared dependencies three times, with the third compile alone taking 8m45s. The tested cut makes the exact source commit the single target-cache owner while preserving separate lock validation, sequential Cargo invocations, clean detached source, and byte-level witnessing. A clean successor generation still must prove the repaired Modeling-to-Imagination-to-Mind path, adopted-plan Hands authority, deliberate worker failure/restart/closure, Persona consequence, retention, endurance, and Linux/Yggdrasil cognition.
   operational_state:
-    local_worktree: bounded_worker_runtime_terminalization_repair
+    local_worktree: release_build_graph_cache_collapse
     operator_wireguard: restored
     yggdrasil: canonical_small_public_crossing_body
     starfire: temporary_epiphany_cognition_body
@@ -52,8 +52,8 @@ current_status:
     bifrost_feedback_crossing: authenticated_transport_only
     yggdrasil_epiphany_services: absent
     resident_physiology: heartbeat_and_self_running
-  unresolved_authority: Exact 17d4ae47 still has not proved adopted-plan Hands identity live. v28 reached native Imagination but exposed a stronger prerequisite: bounded worker errors could exit without terminalizing their runtime jobs, leaving Self in an endless wait. The owner-aligned repair is test-proven but unpublished. Persona consequence, restart/closure, retention, long-duration behavior, and Linux/Yggdrasil cognition remain open.
-  next_action: Commit, push, package, and publish the bounded worker terminalization repair. Preserve v28 as failure evidence. Cold-start a clean generation, replay Modeling-to-Imagination-to-Mind without overrides, prove exact adopted-plan Hands authority, then kill one bounded worker path deliberately and prove typed failure, restart, and Soul-verifiable closure.
+  unresolved_authority: Exact b8c76fd0 packages the worker-terminalization repair but has not been published or replayed. The release forge also partitions one exact commit into three redundant dependency graphs; the shared commit-root cut is test-proven but still needs an exact timed package. Persona consequence, restart/closure, retention, long-duration behavior, and Linux/Yggdrasil cognition remain open.
+  next_action: Commit and push the tested release build-graph collapse, package that exact commit, and compare its elapsed time with the three-root b8c76fd0 baseline. Publish only into a clean successor generation, then replay Modeling-to-Imagination-to-Mind, prove adopted-plan Hands authority, and deliberately prove typed worker failure, restart, and Soul-verifiable closure.
 
 active_subgoals:
   - Prove Persona, Self, Eyes, Modeling, Imagination, Hands, Soul, Mind, Continuity, and nervous-system behavior individually.