@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/core/projection-activity.js

@@ -9,6 +9,15 @@ function duration(first, last) {
     return Math.max(0, last - first);
 }
 function warningIdentity(warning) {
+    if (warning.reason === "retry") {
+        return JSON.stringify({
+            reason: warning.reason,
+            attempt: warning.attempt,
+            maxRetries: warning.maxRetries,
+            retryDelayMs: warning.retryDelayMs,
+            errorStatus: warning.errorStatus,
+        });
+    }
     return JSON.stringify({
         reason: warning.reason,
         originalModel: warning.originalModel,
@@ -37,6 +46,7 @@ export function foldAgentActivity(events) {
     const latestThought = new Map();
     const firstThoughtAt = new Map();
     const thoughtEventCount = new Map();
+    const latestMessage = new Map();
     const warnings = new Map();
     const usageByTurn = new Map();
     const turns = [];
@@ -46,6 +56,9 @@ export function foldAgentActivity(events) {
     for (const indexed of sorted) {
         const event = indexed.event;
         switch (event.type) {
+            case "message":
+                latestMessage.set(JSON.stringify([event.turn, event.id]), indexed);
+                break;
             case "activity": {
                 latestActivity.set(event.id, indexed);
                 if (event.phase !== "updated" && !firstActivityCall.has(event.id))
@@ -96,8 +109,16 @@ export function foldAgentActivity(events) {
     const ledgerActivities = [];
     for (const indexed of sorted) {
         const event = indexed.event;
-        if (event.type === "message") {
-            settled.push({ kind: "said", order: indexed.order, at: event.at, turn: event.turn, text: event.text, settled: true });
+        if (event.type === "message" && latestMessage.get(JSON.stringify([event.turn, event.id])) === indexed) {
+            settled.push({
+                kind: "said",
+                order: indexed.order,
+                at: event.at,
+                turn: event.turn,
+                id: event.id,
+                text: event.text,
+                settled: true,
+            });
             continue;
         }
         if (event.type === "activity" && latestActivity.get(event.id) === indexed) {

package/build/core/projection-core.js

@@ -4,7 +4,8 @@ import { isErrnoException } from "../errno.js";
 import { projectionCoordinateRoot } from "./projection-coordinate.js";
 import { ProjectionStateError, } from "./atomic-publish.js";
 export { atomicPublishFile, ProjectionStateError, randomHex8 } from "./atomic-publish.js";
-export { claimAllInbox, claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, isTellCausallyConsumed, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./projection-tells.js";
+export { isTellCausallyConsumed, } from "./projection/tell/model.js";
+export { claimAllInbox, claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./projection/tell/store.js";
 /** Relative segments for `.keiyaku/projection`. */
 export const PROJECTION_ROOT_SEGMENTS = [".keiyaku", "projection"];
 export const PROJECTION_ID_PATTERN = /^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*\/[0-9a-f]{8}$/;

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

@@ -0,0 +1,259 @@
+import { claimAllInbox, claimFencedTells, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
+import { openProjectionTellObserver, } from "./projection/tell/database.js";
+function frameTellBodies(projectionDirectory, tellIds) {
+    const originals = tellIds.map((tellId) => readTellOriginal(projectionDirectory, "inflight", tellId));
+    const frames = originals
+        .map((original, index) => `--- tell ${tellIds[index]} ---\n${original.text}`)
+        .join("\n\n");
+    const effort = originals.reduce((value, original) => original.effort ?? value, undefined);
+    return { frames, ...(effort ? { effort } : {}) };
+}
+function operatorBodyForContinuation(prompt, tellFrames, sessionContinuationPromptPrefix) {
+    return sessionContinuationPromptPrefix === undefined
+        ? `${prompt}\n\n${tellFrames}`
+        : `${sessionContinuationPromptPrefix}${tellFrames}`;
+}
+/** Tier-2 boundary snapshot. No tells leaves prompt byte-identical. */
+export function snapshotReplayPrompt(projectionDirectory, prompt, tellFence, executionId, options = {}) {
+    const tellIds = claimFencedTells(projectionDirectory, tellFence, executionId);
+    if (tellIds.length === 0)
+        return { prompt, tellIds };
+    const { frames, effort } = frameTellBodies(projectionDirectory, tellIds);
+    const nextPrompt = operatorBodyForContinuation(prompt, frames, options.sessionContinuationPromptPrefix);
+    return { prompt: nextPrompt, tellIds, ...(effort ? { effort } : {}) };
+}
+/** Tier-2 has no steer acknowledgement: actual driver start is its ordinal-zero submission point. */
+export function markReplayStarted(projectionDirectory, executionId, tellIds) {
+    for (const tellId of tellIds) {
+        if (listTellIds(projectionDirectory, "inflight").includes(tellId)) {
+            markTellSubmitted(projectionDirectory, tellId, { executionId, fence: { kind: "ordinal", ordinal: 0 } });
+        }
+    }
+}
+/** A successful replay terminal is checkpoint ordinal one; failures intentionally do not consume. */
+export function markReplayCompleted(projectionDirectory, executionId) {
+    for (const tellId of listTellIds(projectionDirectory, "submitted")) {
+        const submitted = readTellSubmitted(projectionDirectory, tellId);
+        if (submitted.executionId === executionId && submitted.fence && isTellCausallyConsumed(submitted.fence, { kind: "ordinal", ordinal: 1 })) {
+            markTellConsumed(projectionDirectory, tellId);
+        }
+    }
+}
+/**
+ * Tier-2's only submission acknowledgement. A created driver is deliberately
+ * insufficient: observe the first provider event, or a successful completion
+ * from a provider that emitted no events.
+ */
+export function createReplayRunStartGate(projectionDirectory, executionId, tellIds) {
+    let started = false;
+    const start = () => {
+        if (started)
+            return;
+        markReplayStarted(projectionDirectory, executionId, tellIds);
+        started = true;
+    };
+    return { observeProviderEvent: start, observeSuccessfulCompletion: start };
+}
+const LIVE_TELL_DELIVERY_THROTTLE_MS = 200;
+function submitEligible(projectionDirectory, executionId, control, requireInbox, submitting, observer, pendingCompletionEvidence) {
+    if (requireInbox && !observer?.hasInbox())
+        return;
+    claimAllInbox(projectionDirectory);
+    for (const tellId of listTellIds(projectionDirectory, "inflight")) {
+        if (submitting.has(tellId))
+            continue;
+        // Construct before pin: a sync read/build failure must not leave submitting stuck.
+        const original = readTellOriginal(projectionDirectory, "inflight", tellId);
+        const tell = {
+            id: tellId,
+            text: `--- tell ${tellId} ---\n${original.text}`,
+            ...(original.effort ? { effort: original.effort } : {}),
+        };
+        submitting.add(tellId);
+        void Promise.resolve()
+            .then(() => control.enqueue(tell))
+            .then((ack) => {
+            if (!ack)
+                throw new Error("provider enqueue resolved without TellSubmitAck");
+            markTellSubmitted(projectionDirectory, tellId, { executionId, fence: ack.fence });
+            const pending = pendingCompletionEvidence.get(tellId);
+            if (!pending)
+                return;
+            for (const evidence of pending) {
+                if (isTellCausallyConsumed(ack.fence, evidence)) {
+                    markTellConsumed(projectionDirectory, tellId);
+                    break;
+                }
+            }
+            pendingCompletionEvidence.delete(tellId);
+        })
+            .catch(() => {
+            // Leave in inflight for the next checkpoint or ingress opportunity.
+            // Reject means this crossing never accepted the tell; drop stale evidence.
+            pendingCompletionEvidence.delete(tellId);
+        })
+            .finally(() => submitting.delete(tellId));
+    }
+}
+export function createLiveTellDeliveryController(projectionDirectory, executionId, dependencies = {}) {
+    const now = dependencies.now ?? Date.now;
+    const setTimer = dependencies.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+    const clearTimer = dependencies.clearTimer ?? ((timer) => clearTimeout(timer));
+    const openObserver = dependencies.openObserver ?? openProjectionTellObserver;
+    const submitting = new Set();
+    // In-memory only: bridges completion-before-ack when a tell is still submitting.
+    const pendingCompletionEvidence = new Map();
+    let observer;
+    let timer;
+    let nextOpportunityAt = 0;
+    let checking = false;
+    let dirty = false;
+    let closed = false;
+    let latestControl;
+    let opportunityEpoch = 0;
+    const scheduleTrailing = () => {
+        if (closed || timer !== undefined || !dirty)
+            return;
+        const delayMs = Math.max(0, nextOpportunityAt - now());
+        timer = setTimer(() => {
+            timer = undefined;
+            if (closed || !dirty)
+                return;
+            if (now() < nextOpportunityAt) {
+                scheduleTrailing();
+                return;
+            }
+            const control = latestControl;
+            if (control)
+                runOpportunity(control);
+        }, delayMs);
+    };
+    const discardObserver = () => {
+        try {
+            observer?.close();
+        }
+        catch {
+            // Observer close failures cannot change delivery policy.
+        }
+        observer = undefined;
+    };
+    const runOpportunity = (control) => {
+        if (closed)
+            return;
+        const epoch = opportunityEpoch;
+        dirty = false;
+        checking = true;
+        nextOpportunityAt = now() + LIVE_TELL_DELIVERY_THROTTLE_MS;
+        try {
+            observer ??= openObserver(projectionDirectory);
+            if (observer.hasDataVersionChanged()) {
+                submitEligible(projectionDirectory, executionId, control, true, submitting, observer, pendingCompletionEvidence);
+            }
+        }
+        catch {
+            // Observation and event delivery failures never terminate provider execution.
+            discardObserver();
+        }
+        finally {
+            checking = false;
+            if (epoch === opportunityEpoch && dirty)
+                scheduleTrailing();
+        }
+    };
+    const cancelOpportunity = () => {
+        opportunityEpoch += 1;
+        dirty = false;
+        if (timer !== undefined) {
+            clearTimer(timer);
+            timer = undefined;
+        }
+    };
+    return {
+        requestDelivery(control) {
+            if (closed)
+                return;
+            latestControl = control;
+            dirty = true;
+            if (checking || now() < nextOpportunityAt) {
+                scheduleTrailing();
+                return;
+            }
+            runOpportunity(control);
+        },
+        checkpoint(control, checkpoint) {
+            if (closed)
+                return;
+            latestControl = control;
+            cancelOpportunity();
+            submitEligible(projectionDirectory, executionId, control, false, submitting, observer, pendingCompletionEvidence);
+            if (!checkpoint.consumptionEvidence)
+                return;
+            for (const tellId of listTellIds(projectionDirectory, "submitted")) {
+                const submitted = readTellSubmitted(projectionDirectory, tellId);
+                if (submitted.executionId === executionId && submitted.fence && isTellCausallyConsumed(submitted.fence, checkpoint.fence)) {
+                    markTellConsumed(projectionDirectory, tellId);
+                }
+            }
+            // Capture still-in-flight enqueues so a late ack can still see this evidence.
+            for (const tellId of submitting) {
+                const pending = pendingCompletionEvidence.get(tellId);
+                if (pending)
+                    pending.push(checkpoint.fence);
+                else
+                    pendingCompletionEvidence.set(tellId, [checkpoint.fence]);
+            }
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            cancelOpportunity();
+            discardObserver();
+            // Do not drop pendingCompletionEvidence: in-flight acks may still submit/consume.
+        },
+    };
+}
+/**
+ * Build an onSyncCheckpoint callback that claims all inbox tells
+ * and delivers them via the given SteerControl.
+ * Intended for use inside adapter start() calls as the onSyncCheckpoint callback.
+ */
+export function buildSyncCheckpointCallback(projectionDirectory, executionId) {
+    const controller = createLiveTellDeliveryController(projectionDirectory, executionId);
+    return (control, checkpoint) => controller.checkpoint(control, checkpoint);
+}
+/**
+ * Durable execution observer: appends prepared events, delivers live tells at
+ * checkpoints, and exposes the public ExecutionObserver surface for harness call/revive.
+ */
+export function createProjectionExecutionObserver(input, dependencies = {}) {
+    const appendEvent = dependencies.appendGenerationEvent ?? appendGenerationEvent;
+    const tellController = createLiveTellDeliveryController(input.projectionDirectory, input.executionId);
+    let closed = false;
+    const observer = {
+        onEvent(event) {
+            input.replayStartGate?.observeProviderEvent();
+            appendEvent(input.projectionDirectory, input.executionId, event);
+        },
+        onCheckpoint(control, checkpoint) {
+            tellController.checkpoint(control, checkpoint);
+        },
+        onDeliveryOpportunity(control) {
+            tellController.requestDelivery(control);
+        },
+    };
+    return {
+        observer,
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            try {
+                tellController.close();
+            }
+            catch {
+                // Controller cleanup cannot change provider completion.
+            }
+        },
+    };
+}

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

@@ -1,5 +1,5 @@
 import { ProjectionStateError } from "./atomic-publish.js";
-import { applySnapshotEffort, parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot_v2.js";
+import { applySnapshotEffort, parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot/model.js";
 import { listTellIds, readTellOriginal, readTellSubmitted, } from "./projection-core.js";
 export function snapshotPendingTells(projectionDirectory) {
     const pending = ["inbox", "inflight", "submitted"]

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

@@ -1,8 +1,9 @@
 import { initializeConfig } from "../config/env.js";
-import { buildCallTermsV2 } from "../agents/call-terms_v2.js";
-import { parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot_v2.js";
-import { revive, call } from "../agents/harness/index.js";
-import { readProjectionEvents } from "./projection-core.js";
+import { buildCallTerms } from "../agents/call-terms.js";
+import { parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot/model.js";
+import { revive, call, } from "../agents/harness/index.js";
+import { demoteSubmittedTellsForReplay, readProjectionEvents, } from "./projection-core.js";
+import { createProjectionExecutionObserver, createReplayRunStartGate, markReplayCompleted, snapshotReplayPrompt, } from "./projection-execution-observer.js";
 import { readProjectionIdentity } from "./projection-identity.js";
 import { selectValidStoredAgentEvents } from "./stored-agent-event.js";
 import { persistResponseHistory } from "./transcripts.js";
@@ -45,6 +46,7 @@ function parseLaunchInputs(launch) {
     const title = optionalString(raw.title, "title");
     const context = optionalString(raw.context, "context");
     const resumePath = optionalString(raw.resumePath, "resumePath");
+    const sourceArtifactId = optionalString(raw.sourceArtifactId, "sourceArtifactId");
     return {
         prompt: requireString(raw.prompt, "prompt"),
         cwd: requireString(raw.cwd, "cwd"),
@@ -58,6 +60,7 @@ function parseLaunchInputs(launch) {
         persistProjectionResponse: raw.persistProjectionResponse,
         ...(raw.session ? { session: raw.session } : {}),
         ...(resumePath ? { resumePath } : {}),
+        ...(sourceArtifactId ? { sourceArtifactId } : {}),
     };
 }
 function persistenceError(error) {
@@ -81,8 +84,9 @@ function maximumValidEnvelopeTurn(projectionDirectory) {
     return maximum;
 }
 async function completionFacts(projectionDirectory, executionId, inputs, outcome) {
+    const providerUnavailable = outcome.error?.code === "SUBAGENT_PROVIDER_UNAVAILABLE";
     let persistence = {};
-    if (inputs.persistProjectionResponse) {
+    if (inputs.persistProjectionResponse && !providerUnavailable) {
         try {
             if (!inputs.evidenceCwd) {
                 throw new Error("projection response persistence is missing evidenceCwd");
@@ -120,29 +124,95 @@ async function completionFacts(projectionDirectory, executionId, inputs, outcome
         launchSnapshot: inputs.launchSnapshot,
         effectivePolicy: inputs.launchSnapshot.akuma.policy,
         ...(outcome.error ? { error: outcome.error } : {}),
+        ...(providerUnavailable && inputs.sourceArtifactId
+            ? { sourceArtifactId: inputs.sourceArtifactId }
+            : {}),
         ...persistence,
     });
 }
-export async function executeProjectionGeneration(projectionDirectory, launch) {
+/**
+ * Construct the public Projection once and expose a provider-neutral execution
+ * handle. Provider adapters and harness public types are unchanged.
+ */
+export function executeProjectionGeneration(projectionDirectory, launch) {
     const inputs = parseLaunchInputs(launch);
     initializeConfig(process.env, inputs.cwd);
-    const terms = buildCallTermsV2(inputs.launchSnapshot, inputs.prompt, inputs.cwd, {
+    const executionId = launch.executionId;
+    const tellFence = launch.facts.tellFence ?? [];
+    demoteSubmittedTellsForReplay(projectionDirectory, executionId);
+    const baseTerms = buildCallTerms(inputs.launchSnapshot, inputs.prompt, inputs.cwd, {
         idleTimeoutMs: inputs.idleTimeoutMs,
-        projectionDir: projectionDirectory,
-        projectionExecutionId: launch.executionId,
-        projectionTellFence: launch.facts.tellFence ?? [],
         initialTurn: maximumValidEnvelopeTurn(projectionDirectory),
     });
-    const projection = inputs.session && inputs.resumePath
-        ? revive({ ...terms, session: inputs.session, resumePath: inputs.resumePath })
-        : call(terms);
-    const outcome = await projection.outcome;
+    const launchSnapshot = baseTerms.provider === "codex-sdk"
+        ? snapshotReplayPrompt(projectionDirectory, baseTerms.prompt, tellFence, executionId, {
+            sessionContinuationPromptPrefix: inputs.session && inputs.resumePath
+                ? baseTerms.sessionContinuationPromptPrefix
+                : undefined,
+        })
+        : undefined;
+    const terms = launchSnapshot
+        ? baseTerms.provider === "codex-sdk" && launchSnapshot.effort
+            ? {
+                ...baseTerms,
+                prompt: launchSnapshot.prompt,
+                threadOptions: {
+                    ...baseTerms.threadOptions,
+                    modelReasoningEffort: launchSnapshot.effort,
+                },
+            }
+            : { ...baseTerms, prompt: launchSnapshot.prompt }
+        : baseTerms;
+    // A constructed driver is not an SDK run acknowledgement. Tier-2 has no
+    // live steer surface, so the first provider event is the earliest harness
+    // observable start; a successful no-event completion is the only fallback.
+    const replayStartGate = launchSnapshot
+        ? createReplayRunStartGate(projectionDirectory, executionId, launchSnapshot.tellIds)
+        : undefined;
+    const observerController = createProjectionExecutionObserver({
+        projectionDirectory,
+        executionId,
+        ...(replayStartGate ? { replayStartGate } : {}),
+    });
+    let projection;
+    try {
+        projection = inputs.session && inputs.resumePath
+            ? revive({ ...terms, session: inputs.session, resumePath: inputs.resumePath }, { observer: observerController.observer })
+            : call(terms, { observer: observerController.observer });
+    }
+    catch (error) {
+        observerController.close();
+        throw error;
+    }
+    const outcome = projection.outcome.then(async (result) => {
+        try {
+            if (result.status === "completed") {
+                // A provider may complete successfully without emitting any observable
+                // events. Its successful completion is still a real run start.
+                replayStartGate?.observeSuccessfulCompletion();
+                if (launchSnapshot) {
+                    markReplayCompleted(projectionDirectory, executionId);
+                }
+            }
+            return {
+                verdict: result.status === "completed"
+                    ? "completed"
+                    : result.status === "dismissed"
+                        ? "dismissed"
+                        : "failed",
+                facts: await completionFacts(projectionDirectory, executionId, inputs, result),
+            };
+        }
+        finally {
+            observerController.close();
+        }
+    }, (error) => {
+        observerController.close();
+        throw error;
+    });
     return {
-        verdict: outcome.status === "completed"
-            ? "completed"
-            : outcome.status === "dismissed"
-                ? "dismissed"
-                : "failed",
-        facts: await completionFacts(projectionDirectory, launch.executionId, inputs, outcome),
+        events: projection.events,
+        outcome,
+        abort: (mode) => projection.abort(mode),
     };
 }

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

@@ -1,5 +1,5 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { openProjectionGenerationStore } from "./projection-generation-store.js";
+import { openProjectionGenerationStore } from "./projection/generation/store.js";
 import { spawnProjectionGenerationRunner, } from "./projection-generation-process.js";
 export const PROJECTION_ADOPTION_TIMEOUT_MS = 4_000;
 export const PROJECTION_ADOPTION_POLL_MS = 20;