@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/core/bind.js

@@ -1,22 +1,26 @@
 import * as crypto from "node:crypto";
+import { readdir } from "node:fs/promises";
+import * as path from "node:path";
 import { assertSettingsKnobUsable } from "../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { FlowError } from "../flow-error.js";
-import { lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
-import { repositoryDeliveryRef, } from "./repository-ledger/codec.js";
+import { advanceRepositorySnapshotWithBind, lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
+import { REPOSITORY_LEDGER_REF, repositoryDeliveryRef, } from "./repository-ledger/codec.js";
 import { publishBindTransaction, } from "./repository-ledger/write-transaction.js";
 import { bindEffectiveScope } from "./repository-ledger/fold.js";
 import { activeWorkspaceHereContracts } from "./repository-ledger/inventory.js";
+import { repositoryLedgerHead } from "./repository-ledger/identity.js";
 import { describeMissingBindSections, materializeBindDraft, mergeBindDraft, missingBindDraftSections, parseBindDraft, parsePartialBindDraft, renderBindDraft, renderMissingBindSectionsTemplate, } from "./draft.js";
-import { assertValidContractId, buildContractId, isCommissionId } from "./ids.js";
+import { buildContractId, isCommissionId } from "./ids.js";
 import { admitScopeRegistration, } from "./registry.js";
-import { resolveDefaultBranch } from "./status/drift.js";
 import { normalizeTargetRef } from "./target-ref.js";
-import { previewTaskBoardForBind, readTaskNamespaces, replayPreparedTaskBindLocked, withPreparedTaskBind, } from "./task/index.js";
+import { previewTaskBoardForBind, withPreparedTaskBindSnapshot, } from "./task/index.js";
 import { stableRepoRoot } from "./worktree-path.js";
 import { allocateWorktreePlaceFromRead, } from "./bind-workspace.js";
-import { committedOrThrow, reconcileCommittedBind, revalidateBindAuthority } from "./bind-reconciliation.js";
+import { committedOrThrow, reconcileBindContract, reconcileCommittedBindFromSnapshot, requiresBindRecovery } from "./bind-reconciliation.js";
 import { allocateTaskNamespace, taskNamespaceFromScope, taskNamespaceScope } from "./task/coordinate.js";
+import { resolveExactRefHeads } from "../git/refs.js";
+import { runGitProcess } from "../git/core.js";
 export { reconcileBindContract } from "./bind-reconciliation.js";
 function randomBytesDefault() {
     return [...crypto.randomBytes(10)];
@@ -29,6 +33,27 @@ function resolvedBootstrapPlan(settings) {
         timeoutMs: settings.timeoutMs,
     };
 }
+async function readPersistedTaskNamespaces(stableRoot) {
+    try {
+        const entries = await readdir(path.join(stableRoot, ".keiyaku", "tasks"), { withFileTypes: true });
+        return new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return new Set();
+        throw error;
+    }
+}
+async function observeBindRefs(stableRoot, defaultBranchOverride) {
+    const branches = defaultBranchOverride ? [defaultBranchOverride] : ["main", "master"];
+    const refs = [REPOSITORY_LEDGER_REF, ...branches.map((branch) => normalizeTargetRef(branch))];
+    const heads = await resolveExactRefHeads(stableRoot, refs);
+    const selected = branches.find((branch) => heads.get(normalizeTargetRef(branch)) !== null);
+    return {
+        ledgerHead: heads.get(REPOSITORY_LEDGER_REF) ?? null,
+        branch: selected ? { branch: selected, head: heads.get(normalizeTargetRef(selected)) } : null,
+    };
+}
 function bindDraftWithTaskNamespace(draft, read, persistedNamespaces) {
     const declared = draft.scope.flatMap((term) => {
         const namespace = taskNamespaceFromScope(term);
@@ -66,7 +91,7 @@ function makeBindEntry(input) {
         ...(input.taskIds ? { taskIds: [...input.taskIds] } : {}),
     };
     return {
-        v: 2,
+        v: 3,
         kind: "bind",
         contract: input.id,
         at: input.at,
@@ -108,24 +133,22 @@ export function composeTaskBindDraft(input) {
     return materializeBindDraft(merged);
 }
 function validateBindAfter(read, after) {
-    const unique = new Set();
     for (const contractId of after) {
-        if (unique.has(contractId)) {
-            throw new FlowError("INVALID_TARGET", `contract ${contractId} selected more than once by --after`);
-        }
-        unique.add(contractId);
         if (!isCommissionId(contractId)) {
             throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not a valid contract id`);
         }
         const outcome = lookupCurrentContract(read, contractId);
         if (outcome.status !== "healthy") {
-            throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not a healthy terminal contract`);
-        }
-        if (!["claimed", "forfeited"].includes(outcome.model.phase)) {
-            throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not terminal`);
+            throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not a healthy existing contract`);
         }
     }
 }
+function canonicalBindAfter(explicit, selected = []) {
+    return [...new Set([
+            ...explicit,
+            ...selected.flatMap((task) => task.needs.flatMap((need) => need.contractId === undefined ? [] : [need.contractId])),
+        ])];
+}
 function assertContractAbsent(read, contractId) {
     const outcome = lookupCurrentContract(read, contractId);
     if (outcome.status === "absent")
@@ -149,10 +172,9 @@ function admitWorkspaceOccupancy(read, workspace) {
  * facts and rendered the canonical draft.
  */
 async function admitBindCandidate(input, draft, read) {
-    draft = bindDraftWithTaskNamespace(draft, read, await readTaskNamespaces(input.cwd));
+    draft = bindDraftWithTaskNamespace(draft, read, await readPersistedTaskNamespaces(input.cwd));
     admitWorkspaceOccupancy(read, input.workspace);
     const id = buildContractId({ title: draft.title, nowMs: input.nowMs, randomBytes: input.randomBytes });
-    await assertValidContractId(input.cwd, id);
     assertContractAbsent(read, id);
     validateBindAfter(read, input.after);
     const provisionalEntry = makeBindEntry({
@@ -191,18 +213,20 @@ export async function previewBindContract(input) {
     const isTaskBound = input.taskIds !== undefined && input.taskIds.length > 0;
     const ordinaryDraft = !isTaskBound ? parseBindDraft(input.draft) : undefined;
     const workspace = input.workspace ?? "here";
-    const defaultBranch = await resolveDefaultBranch(input.cwd);
+    const loadedSettings = await loadKeiyakuSettings(input.cwd);
+    assertSettingsKnobUsable(loadedSettings, "defaultBranch");
+    const observed = await observeBindRefs(input.cwd, loadedSettings.knobs?.defaultBranch);
+    const defaultBranch = observed.branch;
     if (!defaultBranch) {
         throw new FlowError("INTERNAL_STATE", "cannot bind: no default branch");
     }
     const target = normalizeTargetRef(defaultBranch.branch);
-    const loadedSettings = await loadKeiyakuSettings(input.cwd);
     let bootstrapPlan;
     if (workspace === "worktree") {
         assertSettingsKnobUsable(loadedSettings, "worktreeBootstrap");
         bootstrapPlan = resolvedBootstrapPlan(loadedSettings.knobs?.worktreeBootstrap);
     }
-    const read = await readRepositoryLifecycle(input.cwd);
+    const read = await readRepositoryLifecycle(input.cwd, { observedHead: observed.ledgerHead, signal: input.signal });
     const randomBytes = input.randomBytes?.(0) ?? randomBytesDefault();
     const place = workspace === "worktree" ? allocateWorktreePlaceFromRead(read, randomBytes) : undefined;
     const taskAdmission = isTaskBound
@@ -233,18 +257,57 @@ export async function bindContract(input) {
     const workspace = input.workspace ?? "here";
     const at = new Date(input.nowMs).toISOString();
     const after = input.after ?? [];
-    const defaultBranch = await resolveDefaultBranch(stableRoot);
-    if (!defaultBranch)
-        throw new FlowError("INTERNAL_STATE", "cannot bind: no default branch");
-    const target = normalizeTargetRef(defaultBranch.branch);
     const publishBind = input.dependencies?.publishBind ?? publishBindTransaction;
-    const persistedTaskNamespaces = await readTaskNamespaces(stableRoot);
+    const persistedTaskNamespaces = await readPersistedTaskNamespaces(stableRoot);
     const loadedSettings = await loadKeiyakuSettings(stableRoot);
+    assertSettingsKnobUsable(loadedSettings, "defaultBranch");
     let bootstrapPlan;
     if (workspace === "worktree") {
         assertSettingsKnobUsable(loadedSettings, "worktreeBootstrap");
         bootstrapPlan = resolvedBootstrapPlan(loadedSettings.knobs?.worktreeBootstrap);
     }
+    const observeEntry = async () => {
+        const attemptedReplay = new Map();
+        for (;;) {
+            const observed = await observeBindRefs(stableRoot, loadedSettings.knobs?.defaultBranch);
+            if (!observed.branch) {
+                if (loadedSettings.knobs?.defaultBranch)
+                    throw new FlowError("INVALID_SETTINGS", `configured defaultBranch '${loadedSettings.knobs.defaultBranch}' does not resolve`);
+                throw new FlowError("INTERNAL_STATE", "cannot bind: no default branch");
+            }
+            const read = await readRepositoryLifecycle(stableRoot, { observedHead: observed.ledgerHead, signal: input.signal });
+            const outstanding = read.contracts.filter(requiresBindRecovery);
+            if (outstanding.length === 0)
+                return { branch: observed.branch, read };
+            for (const lifecycle of outstanding) {
+                const priorAttempt = attemptedReplay.get(lifecycle.contract);
+                if (priorAttempt) {
+                    if (priorAttempt.completion.status === "contained") {
+                        const cause = priorAttempt.completion.cause;
+                        const code = cause.code === "BIND_WORKTREE_PATH_OCCUPIED"
+                            || cause.code === "CARRIER_MATERIALIZATION_FAILED"
+                            || cause.code === "CARRIER_TARGET_UNAVAILABLE"
+                            ? cause.code
+                            : "INTERNAL_STATE";
+                        throw new FlowError(code, cause.message);
+                    }
+                    throw new FlowError("INTERNAL_STATE", `bind entry replay for ${lifecycle.contract} completed without advancing its pending lifecycle state`);
+                }
+                attemptedReplay.set(lifecycle.contract, await reconcileBindContract({
+                    cwd: stableRoot,
+                    contractId: lifecycle.contract,
+                    actor: input.actor,
+                    nowMs: input.nowMs,
+                    ...(input.signal ? { signal: input.signal } : {}),
+                    ...(input.createWorktree ? { createWorktree: input.createWorktree } : {}),
+                    ...(input.onProgress ? { onProgress: input.onProgress } : {}),
+                    ...(input.bootstrapRunner ? { bootstrapRunner: input.bootstrapRunner } : {}),
+                    ...(input.bootstrapDependencies ? { bootstrapDependencies: input.bootstrapDependencies } : {}),
+                    dependencies: input.dependencies,
+                }));
+            }
+        }
+    };
     let selectedDraft;
     let selectedPlace;
     let selectedId;
@@ -262,7 +325,6 @@ export async function bindContract(input) {
                 collided.push(id);
                 continue;
             }
-            await assertValidContractId(stableRoot, id);
             selectedDraft = bindDraftWithTaskNamespace(draft, read, persistedTaskNamespaces);
             selectedPlace = place;
             selectedId = id;
@@ -273,84 +335,100 @@ export async function bindContract(input) {
     let entry;
     let admittedScopeOverlaps = [];
     let preparedTask;
+    let preparedTaskProjectionSucceeded = false;
+    let committedHead;
+    let committedEntryObjectId;
+    let admittedRead;
     if (isTaskBound) {
-        let lockedRead;
-        const settled = await withPreparedTaskBind({
-            cwd: stableRoot,
-            taskIds: input.taskIds,
-            signal: input.signal,
-            prepare: async (tasks) => {
-                lockedRead = await readRepositoryLifecycle(stableRoot);
-                validateBindAfter(lockedRead, after);
-                return await selectCandidate(composeTaskBindDraft({ task: tasks[0], draft: input.draft }), lockedRead);
-            },
-            transact: async (prepared, taskTransaction) => {
-                if (prepared.boardRef !== target) {
-                    throw new FlowError("CONCURRENT_MODIFICATION", "locked task-board ref does not match the selected bind target");
-                }
-                let attemptRead = lockedRead;
-                let lastRefusal;
-                for (let attempt = 0; attempt < 4; attempt += 1) {
-                    admitWorkspaceOccupancy(attemptRead, workspace);
-                    validateBindAfter(attemptRead, after);
-                    assertContractAbsent(attemptRead, selectedId);
+        let settled;
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            let lockedRead;
+            let target;
+            const attempted = await withPreparedTaskBindSnapshot({
+                location: { mode: "git", root: stableRoot, surfaceRoot: stableRoot, gitDir: path.join(stableRoot, ".git") },
+                observeBoard: async () => {
+                    const observed = await observeEntry();
+                    target = normalizeTargetRef(observed.branch.branch);
+                    lockedRead = observed.read;
+                    admittedRead = lockedRead;
+                    return { ref: target, head: observed.branch.head };
+                },
+                taskIds: input.taskIds,
+                signal: input.signal,
+                prepare: async (tasks) => {
+                    return await selectCandidate(composeTaskBindDraft({ task: tasks[0], draft: input.draft }), lockedRead);
+                },
+                transact: async (prepared, taskTransaction) => {
+                    if (prepared.boardRef !== target) {
+                        throw new FlowError("CONCURRENT_MODIFICATION", "locked task-board ref does not match the selected bind target");
+                    }
+                    admitWorkspaceOccupancy(lockedRead, workspace);
+                    const canonicalAfter = canonicalBindAfter(after, prepared.selected);
+                    validateBindAfter(lockedRead, canonicalAfter);
+                    assertContractAbsent(lockedRead, selectedId);
                     selectedPlace = workspace === "worktree"
-                        ? allocateWorktreePlaceFromRead(attemptRead, input.randomBytes?.(attempt) ?? randomBytesDefault())
+                        ? allocateWorktreePlaceFromRead(lockedRead, input.randomBytes?.(attempt) ?? randomBytesDefault())
                         : undefined;
                     entry = makeBindEntry({
                         id: selectedId, at, actor: input.actor, draft: selectedDraft, base: prepared.entryBase,
-                        target, after, workspace, place: selectedPlace, bootstrap: bootstrapPlan, taskIds: prepared.taskIds,
+                        target, after: canonicalAfter, workspace, place: selectedPlace, bootstrap: bootstrapPlan, taskIds: prepared.taskIds,
                     });
                     admittedScopeOverlaps = await admitScopeRegistration(stableRoot, {
                         contractId: entry.contract,
                         scope: bindEffectiveScope(entry),
                         tree: entry.data.base,
                         ...(input.exclusive === undefined ? {} : { exclusive: input.exclusive }),
-                    }, attemptRead);
-                    await revalidateBindAuthority({
-                        cwd: stableRoot,
-                        target,
-                        targetHead: prepared.expectedHead,
-                        deliveryRef: repositoryDeliveryRef(entry.contract),
-                    });
+                    }, lockedRead);
                     const written = await publishBind({
                         cwd: stableRoot,
                         entry,
-                        expectedLedgerHead: attemptRead.observedLedgerHead,
+                        expectedLedgerHead: lockedRead.observedLedgerHead,
                         delivery: { ref: repositoryDeliveryRef(entry.contract), head: prepared.entryBase },
                         taskBoard: prepared.taskBoard,
                     });
                     if (written.family === "committed") {
                         try {
-                            await replayPreparedTaskBindLocked(taskTransaction, prepared);
+                            await taskTransaction.replace(prepared.taskIds.map((taskId) => {
+                                const source = prepared.replay.linkedSources.find((candidate) => candidate.path.endsWith(`/${taskId}.md`) || candidate.path.endsWith(`\\${taskId}.md`));
+                                if (!source)
+                                    throw new FlowError("INTERNAL_STATE", `prepared task bind has no source for ${taskId}`);
+                                return { id: taskId, text: source.text };
+                            }));
+                            const staged = await runGitProcess(stableRoot, ["add", "--", ...prepared.replay.paths]);
+                            if (staged.status !== 0 || staged.error)
+                                throw staged.error ?? new Error(staged.stderr);
+                            preparedTaskProjectionSucceeded = true;
                         }
                         catch {
                             // Authority is already committed. The ordinary derived replay
                             // below owns truthful retry/contained classification.
                         }
-                        return written;
                     }
                     if (written.family === "indeterminate")
                         committedOrThrow(written, "BIND_TRANSACTION");
-                    lastRefusal = written;
-                    attemptRead = await readRepositoryLifecycle(stableRoot);
-                }
-                return lastRefusal;
-            },
-        });
+                    return written;
+                },
+            });
+            if (attempted.result.family === "committed") {
+                settled = attempted;
+                break;
+            }
+        }
+        if (!settled)
+            throw new FlowError("CONCURRENT_MODIFICATION", "BIND_TRANSACTION_REFUSED: repository authority changed during four bind attempts");
         preparedTask = settled.preparation;
-        committedOrThrow(settled.result, "BIND_TRANSACTION");
+        const committed = committedOrThrow(settled.result, "BIND_TRANSACTION");
+        committedHead = committed.ledgerHead;
+        committedEntryObjectId = committed.entryObjectId;
     }
     else {
         let committed;
         for (let attempt = 0; attempt < 4; attempt += 1) {
-            const [read, branch] = await Promise.all([
-                readRepositoryLifecycle(stableRoot),
-                resolveDefaultBranch(stableRoot),
-            ]);
-            if (!branch || normalizeTargetRef(branch.branch) !== target) {
-                throw new FlowError("CONCURRENT_MODIFICATION", "bind target changed during admission");
-            }
+            const observed = await observeEntry();
+            const branch = observed.branch;
+            const target = normalizeTargetRef(branch.branch);
+            const read = observed.read;
+            admittedRead = read;
             validateBindAfter(read, after);
             await selectCandidate(ordinaryDraft, read);
             entry = makeBindEntry({
@@ -363,12 +441,6 @@ export async function bindContract(input) {
                 tree: entry.data.base,
                 ...(input.exclusive === undefined ? {} : { exclusive: input.exclusive }),
             }, read);
-            await revalidateBindAuthority({
-                cwd: stableRoot,
-                target,
-                targetHead: branch.head,
-                deliveryRef: repositoryDeliveryRef(entry.contract),
-            });
             const bindWrite = await publishBind({
                 cwd: stableRoot,
                 entry,
@@ -377,6 +449,8 @@ export async function bindContract(input) {
             });
             if (bindWrite.family === "committed") {
                 committed = bindWrite;
+                committedHead = bindWrite.ledgerHead;
+                committedEntryObjectId = bindWrite.entryObjectId;
                 break;
             }
             if (bindWrite.family === "indeterminate")
@@ -386,7 +460,33 @@ export async function bindContract(input) {
             throw new FlowError("CONCURRENT_MODIFICATION", "BIND_TRANSACTION_REFUSED: repository authority changed during four bind attempts");
         }
     }
-    return await reconcileCommittedBind({
+    const repository = advanceRepositorySnapshotWithBind({
+        repository: admittedRead,
+        ledgerHead: repositoryLedgerHead(committedHead),
+        entryObjectId: committedEntryObjectId,
+        entry: entry,
+    });
+    const committedContract = lookupCurrentContract(repository, entry.contract);
+    if (committedContract.status !== "healthy") {
+        throw new FlowError("INTERNAL_STATE", `committed bind ${entry.contract} is unavailable (${committedContract.status})`);
+    }
+    const carrierTarget = entry.data.workspace === "here"
+        ? { status: "available", root: stableRoot, path: `${stableRoot}/.keiyaku/KEIYAKU.md`, workspace: "here" }
+        : { status: "unavailable", workspace: "worktree", reason: `contract ${entry.contract} has no verified registered engine worktree` };
+    const snapshot = {
+        stableRoot,
+        observation: {
+            repository,
+            lifecycle: committedContract.model,
+            target: carrierTarget,
+            pins: {
+                repositoryLedgerHead: repositoryLedgerHead(committedHead),
+                target: { ref: entry.data.target, head: entry.data.base },
+                delivery: { ref: repositoryDeliveryRef(entry.contract), head: entry.data.base },
+            },
+        },
+    };
+    return await reconcileCommittedBindFromSnapshot({
         cwd: stableRoot,
         contractId: entry.contract,
         actor: input.actor,
@@ -397,6 +497,7 @@ export async function bindContract(input) {
         ...(input.bootstrapRunner ? { bootstrapRunner: input.bootstrapRunner } : {}),
         ...(input.bootstrapDependencies ? { bootstrapDependencies: input.bootstrapDependencies } : {}),
         ...(preparedTask ? { preparedTask } : {}),
+        ...(preparedTaskProjectionSucceeded ? { preparedTaskProjectionSucceeded } : {}),
         dependencies: input.dependencies,
-    }, admittedScopeOverlaps);
+    }, admittedScopeOverlaps, snapshot);
 }

package/build/core/call/call.js

@@ -8,7 +8,7 @@ import { ACTOR_IDENTITY } from "../../keiyaku.js";
 import { appendDebugBlock } from "../../telemetry/debug-log.js";
 import { logInfo } from "../../telemetry/logger.js";
 import { withResolvedAddress } from "../addressing.js";
-import { assertProjectionAlias, PROJECTION_ADOPTION_TIMEOUT_MS, observeProjectionLife, waitForProjection, } from "../projection/index.js";
+import { assertProjectionAlias, observeProjectionLife, waitForProjection, } from "../projection/index.js";
 import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
 import { requireResumableArtifact } from "../transcripts.js";
 import { stableRepoRoot } from "../worktree-path.js";
@@ -56,7 +56,7 @@ export async function runCall(input) {
         const artifactHome = await fs.realpath(reviveArtifact.storageRoot);
         const addressed = normalizeFilesystemCoordinate(input.repo ?? input.cwd);
         const observation = await observeGitRepository(addressed);
-        const coordinate = assertGitObservation(observation, "revive");
+        const coordinate = assertGitObservation(observation, "fork");
         if (coordinate === "repository") {
             const addressedRoot = await stableRepoRoot(addressed);
             if (addressedRoot !== artifactHome) {
@@ -74,7 +74,7 @@ export async function runCall(input) {
     const title = requireText("title", input.title);
     const task = requireText("task", input.task);
     if (input.incognito && reviveArtifact) {
-        throw new FlowError("EMPTY_PARAM", "Parameter 'incognito' cannot be used with 'reviveArtifact' — incognito calls cannot be revived or persist conversation history.");
+        throw new FlowError("EMPTY_PARAM", "Parameter 'incognito' cannot be used with a fork source artifact — incognito calls cannot be forked or persist conversation history.");
     }
     const keiyakuContext = await readCallKeiyakuContext(cwd, {
         bare: input.bare,
@@ -92,8 +92,8 @@ export async function runCall(input) {
             task,
             context: input.context,
             referenceFiles,
-            currentIntent: keiyakuContext.currentIntent,
             commissioned: keiyakuContext.address.binding.kind === "commission",
+            worktree: keiyakuContext.effectiveCwd,
         });
         const launchSnapshot = reviveArtifact
             ? input.effort !== undefined
@@ -134,6 +134,7 @@ export async function runCall(input) {
                 ? { kind: "repository" }
                 : { kind: "user" },
             binding: keiyakuContext.address.binding,
+            carrier: keiyakuContext.carrier,
             title,
             context: input.context,
             ...(input.mode === "call" && input.alias !== undefined ? { alias: assertProjectionAlias(input.alias) } : {}),
@@ -144,7 +145,6 @@ export async function runCall(input) {
                 id: launched.projection.id,
                 phase: observeProjectionLife(launched.projection.dir, {
                     nowMs: Date.now(),
-                    startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
                 }).phase,
                 ...(launched.projection.alias ? { alias: launched.projection.alias } : {}),
                 ...(launched.projection.previousAliasTarget ? { previousAliasTarget: launched.projection.previousAliasTarget } : {}),
@@ -206,7 +206,6 @@ export async function runCall(input) {
                     id: execution.projection.id,
                     phase: observeProjectionLife(execution.projection.dir, {
                         nowMs: Date.now(),
-                        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
                     }).phase,
                 };
             }
@@ -222,7 +221,7 @@ export async function runCall(input) {
             launchSnapshot: subagentOutcome.launchSnapshot,
             ...(responsePath ? { responsePath } : {}),
             ...(artifactId ? { artifactId } : {}),
-            ...(reviveArtifact ? { revivedArtifactId: reviveArtifact.artifactId } : {}),
+            ...(reviveArtifact ? { sourceArtifactId: reviveArtifact.artifactId } : {}),
             projectionOwnsResponsePersistence: execution.projection !== undefined,
             meta: {
                 ...(subagentOutcome.warnings.length > 0 ? { warnings: subagentOutcome.warnings.map(renderSubagentWarning) } : {}),

package/build/core/call/context.js

@@ -1,11 +1,39 @@
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { FlowError } from "../../flow-error.js";
 import { assertGitObservation, observeGitRepository } from "../../git/branches.js";
 import { AddressResolutionError, buildResolutionAttempt, buildUncommissionedAddress, buildUncommissionedRepositoryAddress, resolveCallWorktreeAddressFromRead, resolveExplicitContractAddressFromRead, withResolvedAddress, } from "../addressing.js";
 import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
 import { readRepositoryLifecycle, } from "../repository-ledger/read-model.js";
 import { isTerminalState } from "../status/lifecycle.js";
+import { verifyCarrier } from "../contract-carrier.js";
 import { findRegisteredContractWorktreePathFromModel, stableRepoRoot, } from "../worktree-path.js";
+import { KEIYAKU_FILE } from "../../keiyaku.js";
+function throwCarrierDispatchRefusal(contractId, verification) {
+    let status;
+    if (verification.status === "missing") {
+        status = "missing";
+    }
+    else if (verification.status === "invalid-header") {
+        status = "incomplete-replay";
+    }
+    else if (verification.status === "identity-mismatch") {
+        status = verification.actual.contractId !== verification.expected.contractId ? "wrong-contract" : "lagging";
+    }
+    else {
+        status = "modified";
+    }
+    const recoveryCommand = `keiyaku bind --contract ${contractId}`;
+    throw new FlowError("CARRIER_MATERIALIZATION_FAILED", `contract ${contractId} carrier is ${status}; recover with ${recoveryCommand}`, {
+        facts: {
+            kind: "carrier_dispatch_refusal",
+            contractId,
+            status,
+            carrierPath: verification.target,
+            recoveryCommand,
+        },
+    });
+}
 export async function readCallKeiyakuContext(executionCwd, input, ports = {}) {
     executionCwd = normalizeFilesystemCoordinate(executionCwd);
     input.repoCwd = input.repoCwd === undefined ? undefined : normalizeFilesystemCoordinate(input.repoCwd);
@@ -148,49 +176,34 @@ export async function readCallKeiyakuContext(executionCwd, input, ports = {}) {
         if (isTerminalState(address.lifecycle)) {
             throw new FlowError("EMPTY_PARAM", `commission ${contractId} is terminal and cannot launch an Akuma`);
         }
-        const bind = model.history[0]?.entry;
-        if (!bind || bind.kind !== "bind") {
-            throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger is missing bind entry`);
-        }
         const effectiveCwd = model.resources.worktree
             ? await findRegisteredContractWorktreePathFromModel(ledgerCwd, model)
             : await fs.realpath(ledgerCwd);
         if (!effectiveCwd) {
             throw new FlowError("INTERNAL_STATE", `contract ${contractId} has no verified registered engine worktree`);
         }
+        const carrier = await verifyCarrier({
+            target: path.join(effectiveCwd, KEIYAKU_FILE),
+            lifecycle: model,
+        });
+        if (carrier.status !== "current")
+            throwCarrierDispatchRefusal(contractId, carrier);
         const executionAddress = { ...address, workdir: effectiveCwd };
-        const openArc = model.phase === "active" && model.history.some(({ entry }) => entry.kind === "arc")
-            ? model.intent
-            : null;
-        const currentIntent = openArc
-            ? {
-                source: "arc",
-                arc: openArc.arc,
-                title: openArc.title,
-                objective: openArc.objective,
-                brief: openArc.brief ?? "",
-            }
-            : model.history.some(({ entry }) => entry.kind === "arc")
-                ? undefined
-                : {
-                    source: "bind",
-                    arc: 0,
-                    title: bind.data.title,
-                    context: bind.data.context,
-                    objective: bind.data.objective,
-                    design: bind.data.design,
-                    scope: [...model.effectiveScope],
-                    criteria: [...bind.data.criteria],
-                    verification: [...bind.data.verification],
-                    extensions: bind.data.extensions.map((extension) => ({ ...extension })),
-                };
+        const { contractId: verifiedContractId, contractHead: verifiedContractHead, bodyDigest } = carrier.actual;
         return {
             activeKeiyaku: true,
             effectiveCwd,
             historyCwd: ledgerCwd,
             profileCwd: effectiveCwd,
             projectionCwd: ledgerCwd,
-            currentIntent,
+            carrier: {
+                path: ".keiyaku/KEIYAKU.md",
+                identity: {
+                    contractId: verifiedContractId,
+                    contractHead: verifiedContractHead,
+                    bodyDigest,
+                },
+            },
             address: executionAddress,
         };
     });