@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/core/projection-generation-runner.js

@@ -1,7 +1,10 @@
-import { openProjectionGenerationStore, } from "./projection-generation-store.js";
+import { openProjectionGenerationStore, } from "./projection/generation/store.js";
 import { acquireProjectionRunnerLock, observeProjectionRunnerLock, } from "./projection-runner-lock.js";
 import { createProjectionExecutionId } from "./projection-generation-identity.js";
 import { applyContinuationEffort, } from "./projection-generation-continuation.js";
+import { openProjectionTellObserver } from "./projection/tell/database.js";
+/** Private runner-side kill grace. Not a setting, env, parameter, or export. */
+const KILL_GRACE_MS = 5000;
 function successorLaunchFacts(launch, completionFacts, effort, now) {
     const { tellFence: _tellFence, ...inherited } = launch.facts;
     const rawInputs = launch.facts.inputs;
@@ -10,13 +13,15 @@ function successorLaunchFacts(launch, completionFacts, effort, now) {
         && !Array.isArray(rawInputs)
         ? rawInputs
         : {};
+    // Revive source identity is launch-local; never inherit it onto a tell handoff successor.
+    const { sourceArtifactId: _sourceArtifactId, ...inheritedInputs } = inputs;
     return {
         ...inherited,
         createdAt: new Date(now()).toISOString(),
         launchedBy: "sweep-wake",
         parentExecutionId: launch.executionId,
         inputs: applyContinuationEffort({
-            ...inputs,
+            ...inheritedInputs,
             ...(completionFacts.session ? { session: completionFacts.session } : {}),
             ...(typeof completionFacts.responsePath === "string"
                 ? { resumePath: completionFacts.responsePath }
@@ -30,6 +35,19 @@ function normalizeTellFence(tellIds) {
 function errorDetail(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function nonReservedRunnerKillFacts(facts) {
+    const { state: _state, killIntentSeq: _killIntentSeq, killedAt: _killedAt, ...rest } = facts;
+    return rest;
+}
+function readOutcomeState(state) {
+    if (state.status === "fulfilled") {
+        return { status: "fulfilled", execution: state.execution };
+    }
+    if (state.status === "rejected") {
+        return { status: "rejected", error: state.error };
+    }
+    return { status: "pending" };
+}
 function acquireRunnerLockOrObserveDuplicate(projectionDirectory) {
     try {
         return acquireProjectionRunnerLock(projectionDirectory);
@@ -41,6 +59,9 @@ function acquireRunnerLockOrObserveDuplicate(projectionDirectory) {
         throw error;
     }
 }
+function observeAbandoned(promise) {
+    void promise.then(() => { }, () => { });
+}
 /**
  * Own one exact generation from kernel-lock acquisition through its terminal
  * transaction. Provider execution is injected so this actor never depends on
@@ -52,6 +73,14 @@ export async function runProjectionGeneration(input) {
     let runnerLock;
     let adopted = false;
     let settled = false;
+    let tellObserver;
+    let graceTimer;
+    const clearGraceTimer = () => {
+        if (graceTimer === undefined)
+            return;
+        clearTimeout(graceTimer);
+        graceTimer = undefined;
+    };
     try {
         const initial = store.readCurrentGeneration();
         if (initial?.launch.executionId !== input.executionId
@@ -73,7 +102,151 @@ export async function runProjectionGeneration(input) {
         if (current?.launch.executionId !== input.executionId) {
             throw new Error("adopted generation stopped being current");
         }
-        const execution = await input.execute(current.launch);
+        // Pre-admission kill: skip provider work and commit killed directly.
+        if (current.killIntent) {
+            const killed = store.runnerKilledIfRequested({ executionId: input.executionId });
+            if (killed.status !== "committed")
+                return { status: "rejected" };
+            settled = true;
+            return { status: "completed" };
+        }
+        const handle = input.execute(current.launch);
+        tellObserver = openProjectionTellObserver(input.projectionDirectory);
+        let gracefulAbortInvoked = false;
+        let forceAbortInvoked = false;
+        let sawKillIntent = false;
+        const observeKillBoundary = () => {
+            try {
+                if (!tellObserver.hasDataVersionChanged())
+                    return;
+                const live = store.readCurrentGeneration();
+                if (live?.launch.executionId !== input.executionId)
+                    return;
+                if (live.verdict)
+                    return;
+                if (!live.killIntent)
+                    return;
+                sawKillIntent = true;
+                if (gracefulAbortInvoked)
+                    return;
+                gracefulAbortInvoked = true;
+                void handle.abort("graceful").catch(() => {
+                    // Abort observation failures fail closed for this boundary.
+                });
+            }
+            catch {
+                // Observation failures fail closed and must not change provider outcome.
+            }
+        };
+        // Mutable box so async settlement is readable without control-flow narrowing traps.
+        const outcomeBox = { status: "pending" };
+        let resolveActivity;
+        const activityChanged = () => new Promise((resolve) => {
+            resolveActivity = resolve;
+        });
+        const bumpActivity = () => {
+            const resolve = resolveActivity;
+            resolveActivity = undefined;
+            resolve?.();
+        };
+        const outcomeWatch = handle.outcome.then((execution) => {
+            outcomeBox.status = "fulfilled";
+            outcomeBox.execution = execution;
+            observeKillBoundary();
+            bumpActivity();
+        }, (error) => {
+            outcomeBox.status = "rejected";
+            outcomeBox.error = error;
+            observeKillBoundary();
+            bumpActivity();
+        });
+        // Always rejection-observe so abandon paths never surface unhandled rejections.
+        observeAbandoned(outcomeWatch);
+        const eventDrain = (async () => {
+            try {
+                for await (const _event of handle.events) {
+                    if (forceAbortInvoked)
+                        return;
+                    observeKillBoundary();
+                    bumpActivity();
+                }
+            }
+            catch {
+                // Event-stream failures fail closed for observation; abandon quietly.
+            }
+            bumpActivity();
+        })();
+        observeAbandoned(eventDrain);
+        while (outcomeBox.status === "pending" && !sawKillIntent) {
+            await activityChanged();
+        }
+        if (sawKillIntent) {
+            // Grace race: outcome settlement inside the window is stop proof.
+            if (outcomeBox.status === "pending") {
+                const graceExpired = new Promise((resolve) => {
+                    graceTimer = setTimeout(() => {
+                        graceTimer = undefined;
+                        resolve("timeout");
+                    }, KILL_GRACE_MS);
+                });
+                await Promise.race([
+                    outcomeWatch.then(() => "outcome"),
+                    graceExpired,
+                ]);
+                clearGraceTimer();
+            }
+            const killOutcome = readOutcomeState(outcomeBox);
+            if (killOutcome.status !== "pending") {
+                const facts = killOutcome.status === "fulfilled"
+                    ? nonReservedRunnerKillFacts(killOutcome.execution.facts)
+                    : undefined;
+                const killed = store.runnerKilledIfRequested({
+                    executionId: input.executionId,
+                    ...(facts && Object.keys(facts).length > 0 ? { facts } : {}),
+                });
+                if (killed.status !== "committed")
+                    return { status: "rejected" };
+                settled = true;
+                return { status: "completed" };
+            }
+            // Force escalation: resolution is stop proof; rejection is kill failure.
+            forceAbortInvoked = true;
+            try {
+                await handle.abort("force");
+                const killed = store.runnerKilledIfRequested({ executionId: input.executionId });
+                if (killed.status !== "committed")
+                    return { status: "rejected" };
+                settled = true;
+                return { status: "completed" };
+            }
+            catch (error) {
+                const failed = store.verdictIfOpen({
+                    executionId: input.executionId,
+                    verdict: "failed",
+                    facts: {
+                        operatorAction: "kill",
+                        diagnostic: "escalation-failed",
+                        detail: errorDetail(error),
+                        failedAt: new Date(now()).toISOString(),
+                    },
+                });
+                // Durably completed after the failed verdict; outer catch must not overwrite.
+                settled = true;
+                if (failed.status !== "committed")
+                    return { status: "rejected" };
+                return { status: "completed" };
+            }
+        }
+        // No kill intent: ordinary outcome, then pending-tell handoff or verdict.
+        await outcomeWatch;
+        const ordinaryOutcome = readOutcomeState(outcomeBox);
+        if (ordinaryOutcome.status === "rejected") {
+            throw ordinaryOutcome.error;
+        }
+        if (ordinaryOutcome.status !== "fulfilled") {
+            throw new Error("projection generation outcome did not settle");
+        }
+        const execution = ordinaryOutcome.execution;
         const pending = execution.verdict === "completed"
             ? input.snapshotPendingTells()
             : { tellIds: [] };
@@ -115,8 +288,22 @@ export async function runProjectionGeneration(input) {
             verdict: execution.verdict,
             facts: execution.facts,
         });
-        if (verdict.status !== "committed")
+        if (verdict.status !== "committed") {
+            // Kill intent may commit after the last outcome-boundary observation and
+            // before this transaction. The settled outcome is already stop proof.
+            if (verdict.reason === "kill-requested") {
+                const facts = nonReservedRunnerKillFacts(execution.facts);
+                const killed = store.runnerKilledIfRequested({
+                    executionId: input.executionId,
+                    ...(Object.keys(facts).length > 0 ? { facts } : {}),
+                });
+                if (killed.status !== "committed")
+                    return { status: "rejected" };
+                settled = true;
+                return { status: "completed" };
+            }
             return { status: "rejected" };
+        }
         settled = true;
         return { status: "completed" };
     }
@@ -134,6 +321,13 @@ export async function runProjectionGeneration(input) {
         throw error;
     }
     finally {
+        clearGraceTimer();
+        try {
+            tellObserver?.close();
+        }
+        catch {
+            // Observer cleanup cannot reopen life or product authority.
+        }
         try {
             runnerLock?.close();
         }

package/build/core/projection-identity.js

@@ -1,4 +1,4 @@
-import { openProjectionGenerationStoreReadOnly, } from "./projection-generation-store.js";
+import { openProjectionGenerationStoreReadOnly, } from "./projection/generation/store.js";
 /** Read the immutable projection identity from the heart database. */
 export function readProjectionIdentity(projectionDirectory) {
     const heart = openProjectionGenerationStoreReadOnly(projectionDirectory);

package/build/core/projection-kill.js

@@ -1,24 +1,57 @@
-import { openProjectionGenerationStore } from "./projection-generation-store.js";
+import { openProjectionGenerationStore } from "./projection/generation/store.js";
+import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
+function settleReleasedLeash(store, projectionDirectory, executionId) {
+    const observation = observeProjectionRunnerLock(projectionDirectory);
+    if (observation.state === "held" || observation.state === "unknown") {
+        return { status: "accepted", executionId };
+    }
+    // Positive released-leash evidence only; settlement race still reports accepted.
+    store.settleKillIfRunnerDead({
+        executionId,
+        releasedLockEvidence: {
+            state: "released",
+            executionId,
+        },
+    });
+    return { status: "accepted", executionId };
+}
+/**
+ * Durably request stop for the current open generation. Intent durability is
+ * never published as killed; terminal settlement is runner-owned or dead-leash
+ * settle-kill-if-runner-dead only.
+ */
 export function killProjectionGeneration(projectionDirectory, nowMs = Date.now()) {
     const store = openProjectionGenerationStore(projectionDirectory);
     try {
-        const current = store.readCurrentGeneration();
-        if (!current)
-            return { status: "already-resting" };
-        if (current.verdict) {
-            return { status: "already-resting", executionId: current.launch.executionId };
+        const killedAt = new Date(nowMs).toISOString();
+        // Retry only on not-current races so an open successor is never labeled closed.
+        for (;;) {
+            const current = store.readCurrentGeneration();
+            if (!current)
+                return { status: "already-closed" };
+            if (current.verdict) {
+                return { status: "already-closed", executionId: current.launch.executionId };
+            }
+            const executionId = current.launch.executionId;
+            const request = store.requestKillIfOpen({ executionId, killedAt });
+            if (request.status === "committed") {
+                return settleReleasedLeash(store, projectionDirectory, executionId);
+            }
+            if (request.reason === "kill-requested") {
+                // Idempotent first intent: still accepted, then one leash observation.
+                return settleReleasedLeash(store, projectionDirectory, executionId);
+            }
+            if (request.reason === "already-terminal") {
+                return { status: "already-closed", executionId };
+            }
+            if (request.reason === "no-current-launch") {
+                return { status: "already-closed" };
+            }
+            if (request.reason === "not-current") {
+                continue;
+            }
+            return { status: "already-closed", executionId };
         }
-        const transition = store.verdictIfOpen({
-            executionId: current.launch.executionId,
-            verdict: "completed",
-            facts: {
-                operatorAction: "kill",
-                killedAt: new Date(nowMs).toISOString(),
-            },
-        });
-        return transition.status === "committed"
-            ? { status: "killed", executionId: current.launch.executionId }
-            : { status: "already-resting", executionId: current.launch.executionId };
     }
     finally {
         store.close();

package/build/core/projection-life-observer.js

@@ -1,4 +1,4 @@
-import { openProjectionGenerationStoreReadOnly, } from "./projection-generation-store.js";
+import { openProjectionGenerationStoreReadOnly, } from "./projection/generation/store.js";
 import { deriveProjectionLife, selectCurrentGeneration, } from "./projection-life-protocol.js";
 import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
 function errorDetail(error) {

package/build/core/projection-life-protocol.js

@@ -4,6 +4,7 @@ export const GENERATION_VERDICT_STATES = [
     "launch-failed",
     "lost-runner",
     "dismissed",
+    "killed",
 ];
 function asLaunch(record) {
     return record.kind === "launch"
@@ -15,6 +16,11 @@ function asAdoption(record) {
         ? record
         : undefined;
 }
+function asKillIntent(record) {
+    return record.kind === "kill-intent"
+        ? record
+        : undefined;
+}
 function asVerdict(record) {
     return record.kind === "verdict"
         ? record
@@ -34,16 +40,19 @@ export function selectCurrentGeneration(records) {
     if (!launch)
         return null;
     let adoption;
+    let killIntent;
     let verdict;
     for (const record of records) {
         if (record.seq <= launch.seq || record.executionId !== launch.executionId)
             continue;
         adoption ??= asAdoption(record);
+        killIntent ??= asKillIntent(record);
         verdict ??= asVerdict(record);
     }
     return {
         launch,
         ...(adoption ? { adoption } : {}),
+        ...(killIntent ? { killIntent } : {}),
         ...(verdict ? { verdict } : {}),
     };
 }
@@ -58,6 +67,7 @@ function phaseForVerdict(state) {
     switch (state) {
         case "completed": return "done";
         case "dismissed": return "dismissed";
+        case "killed": return "killed";
         case "lost-runner": return "lost";
         case "failed":
         case "launch-failed":

package/build/core/projection-mint.js

@@ -4,7 +4,7 @@ import { isErrnoException } from "../errno.js";
 import { ProjectionStateError, randomHex8 } from "./atomic-publish.js";
 import { isoFromNowMs, PROJECTION_ROOT_SEGMENTS, projectionDir, projectionRoot, } from "./projection-core.js";
 import { parseExecutionAuthoritySelection, parseExecutionPact, parseExecutionPactFields, } from "./execution-pact.js";
-import { openProjectionGenerationStore } from "./projection-generation-store.js";
+import { openProjectionGenerationStore } from "./projection/generation/store.js";
 import { initializeProjectionRunnerLockDatabase } from "./projection-runner-lock.js";
 export class ProjectionMintCollisionError extends Error {
     code = "PROJECTION_MINT_COLLISION";

package/build/core/projection-status.js

@@ -6,8 +6,8 @@ import { readProjectionAlias } from "./projection-alias.js";
 import { ProjectionStateError } from "./atomic-publish.js";
 import { foldAgentActivity, } from "./projection-activity.js";
 import { readProjectionIdentity } from "./projection-identity.js";
-import { readProjectionTellCounts, } from "./projection-tells.js";
-import { ProjectionGenerationStoreError } from "./projection-generation-store.js";
+import { readProjectionTellCounts } from "./projection/tell/store.js";
+import { isProjectionGenerationSchemaV1Residue, ProjectionGenerationStoreError, } from "./projection/generation/store.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
 import { selectCurrentGeneration } from "./projection-life-protocol.js";
@@ -23,10 +23,15 @@ const STATUS_GROUP = {
     failed: 2,
     dead: 2,
     done: 3,
+    killed: 4,
     dismissed: 4,
 };
 function isOmissibleProjectionStatusState(state) {
-    return state === "failed" || state === "dead" || state === "done" || state === "dismissed";
+    return state === "failed"
+        || state === "dead"
+        || state === "done"
+        || state === "killed"
+        || state === "dismissed";
 }
 function rowSortTime(row) {
     if (row.activityAtMs !== undefined && Number.isFinite(row.activityAtMs)) {
@@ -65,6 +70,7 @@ export function prioritizeProjectionStatusRows(rows, showAll) {
         failed: 0,
         dead: 0,
         done: 0,
+        killed: 0,
         dismissed: 0,
     };
     for (const row of ordered) {
@@ -84,27 +90,29 @@ class ProjectionStatusFileError extends Error {
     diagnostic;
     constructor(kind, filePath) {
         const label = path.basename(filePath);
-        const detail = kind === "non-regular-projection-file"
-            ? `${label} is not a regular file`
-            : `${label} exceeds status read limit`;
+        const detail = `${label} is not a regular file`;
         super(detail);
         this.name = "ProjectionStatusFileError";
         this.diagnostic = { kind, detail };
     }
 }
+function oversizedProjectionFileDiagnostic(filePath) {
+    const label = path.basename(filePath);
+    return {
+        kind: "oversized-projection-file",
+        detail: `${label} exceeds status read limit · newest complete events retained`,
+    };
+}
 function recordProjectionStatusFileError(error, diagnostics) {
     if (!(error instanceof ProjectionStatusFileError))
         return false;
     diagnostics.push(error.diagnostic);
     return true;
 }
-function readBoundedRegularFile(filePath) {
+function readBoundedRegularFileTail(filePath) {
     const before = fs.lstatSync(filePath);
     if (!before.isFile())
         throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
-    if (before.size > MAX_STATUS_FILE_BYTES) {
-        throw new ProjectionStatusFileError("oversized-projection-file", filePath);
-    }
     let fd;
     try {
         fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK | fs.constants.O_NOFOLLOW);
@@ -119,23 +127,27 @@ function readBoundedRegularFile(filePath) {
         const opened = fs.fstatSync(fd);
         if (!opened.isFile())
             throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
-        if (opened.size > MAX_STATUS_FILE_BYTES) {
-            throw new ProjectionStatusFileError("oversized-projection-file", filePath);
-        }
-        const chunks = [];
+        const snapshotSize = opened.size;
+        const truncated = snapshotSize > MAX_STATUS_FILE_BYTES;
+        const readLength = Math.min(snapshotSize, MAX_STATUS_FILE_BYTES);
+        const readOffset = Math.max(0, snapshotSize - MAX_STATUS_FILE_BYTES);
+        const buffer = Buffer.allocUnsafe(readLength);
         let total = 0;
-        while (total <= MAX_STATUS_FILE_BYTES) {
-            const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, MAX_STATUS_FILE_BYTES + 1 - total));
-            const bytesRead = fs.readSync(fd, chunk, 0, chunk.length, null);
+        while (total < readLength) {
+            const bytesRead = fs.readSync(fd, buffer, total, readLength - total, readOffset + total);
             if (bytesRead === 0)
                 break;
-            chunks.push(chunk.subarray(0, bytesRead));
             total += bytesRead;
         }
-        if (total > MAX_STATUS_FILE_BYTES) {
-            throw new ProjectionStatusFileError("oversized-projection-file", filePath);
+        let tail = buffer.subarray(0, total);
+        if (truncated) {
+            const firstLf = tail.indexOf(0x0a);
+            if (firstLf < 0) {
+                return { content: "", truncated: true };
+            }
+            tail = tail.subarray(firstLf + 1);
         }
-        return Buffer.concat(chunks, total).toString("utf8");
+        return { content: tail.toString("utf8"), truncated };
     }
     finally {
         fs.closeSync(fd);
@@ -196,8 +208,12 @@ function readHeartTellCounts(projectionDir, diagnostics) {
 }
 function readStoredEvents(projectionDir, executionId, diagnostics) {
     let content;
+    let truncated = false;
+    const eventsPath = executionEventsPath(projectionDir, executionId);
     try {
-        content = readBoundedRegularFile(executionEventsPath(projectionDir, executionId));
+        const read = readBoundedRegularFileTail(eventsPath);
+        content = read.content;
+        truncated = read.truncated;
     }
     catch (error) {
         if (isErrnoException(error) && error.code === "ENOENT")
@@ -207,8 +223,12 @@ function readStoredEvents(projectionDir, executionId, diagnostics) {
         diagnostics.push({ kind: "unreadable-activity", detail: `activity ledger unreadable: ${String(error)}` });
         return [];
     }
+    if (truncated) {
+        diagnostics.push(oversizedProjectionFileDiagnostic(eventsPath));
+    }
+    // Parse only LF-terminated records. An unterminated final line is ignored even
+    // when it happens to parse: it may be a concurrent append fragment.
     const lines = content.split("\n");
-    const terminated = content.endsWith("\n");
     const values = [];
     let malformed = 0;
     for (const line of lines.slice(0, -1)) {
@@ -219,15 +239,6 @@ function readStoredEvents(projectionDir, executionId, diagnostics) {
             malformed += 1;
         }
     }
-    const finalLine = lines.at(-1);
-    if (!terminated && finalLine) {
-        try {
-            values.push(JSON.parse(finalLine));
-        }
-        catch {
-            // A concurrent append can leave only this final record incomplete.
-        }
-    }
     if (malformed > 0) {
         diagnostics.push({
             kind: "invalid-activity-event",
@@ -371,6 +382,8 @@ export function readProjectionStatusBoard(cwd, nowMs, options = {}) {
             catch {
                 continue;
             }
+            if (isProjectionGenerationSchemaV1Residue(dir))
+                continue;
             rows.push(readProjectionRow(dir, id, aliases.get(id), nowMs));
         }
     }

package/build/core/projection-wait.js

@@ -4,7 +4,7 @@ import { readProjectionIdentity } from "./projection-identity.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
 import { selectCurrentGeneration } from "./projection-life-protocol.js";
-import { readProjectionTellCounts } from "./projection-tells.js";
+import { readProjectionTellCounts } from "./projection/tell/store.js";
 import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents, } from "./stored-agent-event.js";
 const WAIT_POLL_MS = 100;
 function sleep(ms) {
@@ -39,7 +39,7 @@ function relativeEventLedgerFile(executionId) {
 }
 function timestampFact(current, nowMs) {
     const facts = current.verdict?.facts;
-    for (const key of ["completedAt", "failedAt", "dismissedAt"]) {
+    for (const key of ["completedAt", "failedAt", "dismissedAt", "killedAt"]) {
         const value = facts?.[key];
         if (typeof value === "string" && Number.isFinite(Date.parse(value)))
             return value;
@@ -76,6 +76,14 @@ function buildSnapshot(input) {
     const invalidActivity = invalidActivityEventDiagnostic(malformedEvents);
     const responsePath = current?.verdict?.facts.responsePath;
     const artifactId = current?.verdict?.facts.artifactId;
+    const sourceArtifactId = current?.verdict?.facts.sourceArtifactId;
+    const errorFact = current?.verdict?.facts.error;
+    const failureCode = errorFact
+        && typeof errorFact === "object"
+        && !Array.isArray(errorFact)
+        && typeof errorFact.code === "string"
+        ? errorFact.code
+        : undefined;
     return {
         phase,
         observedAtMs: Number.isFinite(anchorMs) ? anchorMs : nowMs,
@@ -93,6 +101,8 @@ function buildSnapshot(input) {
         } : {}),
         ...(typeof responsePath === "string" && responsePath.trim() ? { responsePath } : {}),
         ...(typeof artifactId === "string" && artifactId.trim() ? { artifactId } : {}),
+        ...(typeof sourceArtifactId === "string" && sourceArtifactId.trim() ? { sourceArtifactId } : {}),
+        ...(failureCode ? { failureCode } : {}),
     };
 }
 export async function waitForProjection(input) {

package/build/core/projection-wake.js

@@ -1,10 +1,10 @@
 import { FlowError } from "../flow-error.js";
-import { parseResolvedAkumaLaunchSnapshot } from "../agents/launch-snapshot_v2.js";
+import { parseResolvedAkumaLaunchSnapshot } from "../agents/launch-snapshot/model.js";
 import { ProjectionStateError } from "./atomic-publish.js";
 import { applyContinuationEffort, snapshotPendingTells, } from "./projection-generation-continuation.js";
 import { createProjectionExecutionId } from "./projection-generation-identity.js";
 import { startProjectionGeneration } from "./projection-generation-launcher.js";
-import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./projection-generation-store.js";
+import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./projection/generation/store.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./projection-generation-launcher.js";
 import { observeProjectionLife } from "./projection-life-observer.js";
 import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
@@ -59,6 +59,9 @@ export function assertTellEffortSupported(projectionDirectory, effort) {
     catch (error) {
         throw new ProjectionStateError("generation launch has an invalid immutable launchSnapshot", { cause: error });
     }
+    if (launchSnapshot.akuma.model === undefined) {
+        throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' requires an explicit model.`);
+    }
     const effortOptions = launchSnapshot.akuma.effortOptions;
     if (effortOptions === undefined)
         return;

package/build/core/{queue_v2.js → queue.js}

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 import { FlowError } from "../flow-error.js";
 import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
 import { listContractIds, readLedger } from "./ledger.js";
-import { commissionTarget, deriveContractState } from "./status.js";
+import { deriveContractState } from "./status/lifecycle.js";
+import { commissionTarget } from "./status/drift.js";
 const EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 const MISSING_REF_SENTINEL = "0".repeat(40);
 const ISO_UTC_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;

package/build/core/registry.js

@@ -2,7 +2,7 @@ import { FlowError } from "../flow-error.js";
 import { readLedger } from "./ledger.js";
 import { appendRefLogWithRetry } from "./ref-log.js";
 import { isNegativeScopePattern, patternsOverlap } from "./scope.js";
-import { deriveContractState, isTerminalState } from "./status.js";
+import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 export const REGISTRY_REF = "refs/keiyaku/registry";
 function parseRegistryEntry(message) {
     const body = message.slice(message.indexOf("\n\n") + 2).trim();