@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/agents/harness/index.js

@@ -9,37 +9,38 @@ import { startOpencode, opencodeSessionSchema, } from "../providers/opencode-sdk
 import { startPi, piSessionSchema, } from "../providers/pi.js";
 import { SubagentFailure, } from "../types.js";
 import { createEventChannel } from "./event-channel.js";
+import { overflowMarkerFromDropped } from "./execution-handle.js";
 import { buildSyncCheckpointCallback, createReplayRunStartGate, markReplayCompleted, pumpSupervisor, snapshotReplayPrompt } from "./pump.js";
 import { createAbortError, renderCapturedText } from "./runtime.js";
-import { acquireAdmissionLock, createProjectionExecutionId, demoteSubmittedTellsForReplay, generationResultPath, listTellIds, markTellSubmitted, publishGenerationResult, publishVerdict, readAdmissionLock, readGenerationLaunch, releaseAdmissionLockOwned, touchHeartbeat } from "../../core/projection-core.js";
-import { wakeProjection } from "../../core/projection-wake.js";
-export function summon(terms) {
+import { demoteSubmittedTellsForReplay, listTellIds, markTellSubmitted } from "../../core/projection-core.js";
+export { activityEventBodySchema, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, } from "./events.js";
+export function call(terms) {
     return createProjection(terms);
 }
-export function resume(terms) {
+export function revive(terms) {
     return createProjection(terms, terms);
 }
 function mintOutcome(draft) {
     return draft;
 }
-function effectivePolicyFor(shared) {
-    return shared.terms.provider === "codex-sdk" ? shared.terms.effectivePolicy : undefined;
+export function restoreOutcome(record) {
+    return { ...record };
 }
-function createProjection(terms, resumeTerms) {
+function createProjection(terms, reviveTerms) {
     switch (terms.provider) {
         case "pi":
         case "claude-agent-sdk":
         case "codex-app-server":
-            return createSteerableProjection(terms, resumeTerms);
+            return createSteerableProjection(terms, reviveTerms);
         case "codex-sdk":
         case "opencode-sdk":
-            return createReplayProjection(terms, resumeTerms);
+            return createReplayProjection(terms, reviveTerms);
         default:
             return assertNever(terms);
     }
 }
-function createSteerableProjection(terms, resumeTerms) {
-    const shared = createProjectionState(terms, resumeTerms);
+function createSteerableProjection(terms, reviveTerms) {
+    const shared = createProjectionState(terms, reviveTerms);
     const pendingTells = [];
     let flushActive = false;
     const flushPendingTells = async () => {
@@ -69,7 +70,7 @@ function createSteerableProjection(terms, resumeTerms) {
         shared.live = live;
         void flushPendingTells();
     };
-    const outcome = settleProjection(shared).then((value) => finalizeProjectionLedger(shared, value));
+    const outcome = settleProjection(shared);
     return {
         mode: "steerable",
         get id() {
@@ -95,12 +96,12 @@ function createSteerableProjection(terms, resumeTerms) {
         },
     };
 }
-function createReplayProjection(terms, resumeTerms) {
-    const shared = createProjectionState(terms, resumeTerms);
+function createReplayProjection(terms, reviveTerms) {
+    const shared = createProjectionState(terms, reviveTerms);
     shared.onLive = (live) => {
         shared.live = live;
     };
-    const outcome = settleProjection(shared).then((value) => finalizeProjectionLedger(shared, value));
+    const outcome = settleProjection(shared);
     return {
         mode: "replay",
         get id() {
@@ -117,12 +118,14 @@ function createReplayProjection(terms, resumeTerms) {
         },
     };
 }
-function createProjectionState(terms, resumeTerms) {
+function createProjectionState(terms, reviveTerms) {
     const shared = {
         id: randomUUID(),
         terms,
-        resumeTerms,
-        publicEvents: createEventChannel(),
+        reviveTerms,
+        publicEvents: createEventChannel({
+            createOverflowMarker: overflowMarkerFromDropped,
+        }),
         lifecycleAbort: new AbortController(),
         dismissed: false,
         externallyAborted: false,
@@ -143,37 +146,6 @@ function createProjectionState(terms, resumeTerms) {
     }
     return shared;
 }
-function finalizeProjectionLedger(shared, outcome) {
-    const directory = shared.terms.projectionDir;
-    const executionId = shared.terms.projectionExecutionId;
-    if (!directory || !executionId)
-        return outcome;
-    const now = Date.now();
-    publishGenerationResult(directory, {
-        version: 1,
-        executionId,
-        status: outcome.status,
-        createdAt: new Date(now).toISOString(),
-        session: outcome.session,
-        responsePath: generationResultPath(directory, executionId),
-        detail: outcome.status === "failed" ? outcome.error?.message : undefined,
-    });
-    // A stale/duplicate child must never replace a later generation's verdict.
-    if (readAdmissionLock(directory)?.executionId !== executionId)
-        return outcome;
-    const pending = ["inbox", "inflight", "submitted"].some((layer) => listTellIds(directory, layer).length > 0);
-    if (pending && outcome.status === "completed") {
-        // The resume lock is acquired by the one wake orchestrator before it releases
-        // this generation's admission; a crash leaves result-without-done for self-heal.
-        wakeProjection(directory, "sweep-wake", { handoffExecutionId: executionId });
-        return outcome;
-    }
-    publishVerdict(directory, outcome.status === "completed" ? "done" : outcome.status === "dismissed" ? "dismissed" : "failed", now, outcome.status === "failed" ? outcome.error?.message : undefined);
-    releaseAdmissionLockOwned(directory, executionId);
-    if (listTellIds(directory, "inbox").length > 0)
-        wakeProjection(directory, "sweep-wake");
-    return outcome;
-}
 function dismissProjection(shared) {
     if (shared.dismissed || shared.terminal)
         return;
@@ -196,14 +168,8 @@ async function settleProjection(shared) {
         diagnosticsBuffer: new StringTailBuffer(shared.terms.maxCaptureChars),
         warnings: [],
     };
-    let timedOut = false;
     let idleTimedOut = false;
     let abortRequested = false;
-    const timeout = setTimeout(() => {
-        timedOut = true;
-        shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec timed out`));
-    }, shared.terms.timeoutMs);
-    timeout.unref?.();
     let idleTimeout;
     const refreshIdleTimeout = () => {
         if (idleTimeout)
@@ -224,16 +190,12 @@ async function settleProjection(shared) {
     shared.lifecycleAbort.signal.addEventListener("abort", requestLiveAbort, { once: true });
     try {
         if (shared.terms.projectionDir) {
-            const executionId = shared.terms.projectionExecutionId ?? createProjectionExecutionId();
-            const acquired = acquireAdmissionLock(shared.terms.projectionDir, process.pid, Date.now(), executionId);
-            if (acquired === "taken")
-                throw new FlowError("INTERNAL_STATE", "projection already has an active generation");
-            touchHeartbeat(shared.terms.projectionDir, Date.now());
+            const executionId = shared.terms.projectionExecutionId;
+            if (!executionId)
+                throw new FlowError("INTERNAL_STATE", "projection execution id is required in supervisor mode");
             demoteSubmittedTellsForReplay(shared.terms.projectionDir, executionId);
         }
-        const launchTellFence = shared.terms.projectionDir && shared.terms.projectionExecutionId
-            ? readGenerationLaunch(shared.terms.projectionDir, shared.terms.projectionExecutionId).inputs.tellFence
-            : undefined;
+        const launchTellFence = shared.terms.projectionTellFence;
         const tellFence = launchTellFence === undefined
             ? []
             : Array.isArray(launchTellFence) && launchTellFence.every((tellId) => typeof tellId === "string")
@@ -244,35 +206,41 @@ async function settleProjection(shared) {
             : undefined;
         const launchTerms = launchSnapshot
             ? shared.terms.provider === "codex-sdk" && launchSnapshot.effort
-                ? { ...shared.terms, prompt: launchSnapshot.prompt, threadOptions: { ...shared.terms.threadOptions, modelReasoningEffort: launchSnapshot.effort === "max" ? "xhigh" : launchSnapshot.effort } }
+                ? { ...shared.terms, prompt: launchSnapshot.prompt, threadOptions: { ...shared.terms.threadOptions, modelReasoningEffort: launchSnapshot.effort } }
                 : { ...shared.terms, prompt: launchSnapshot.prompt }
             : shared.terms;
-        const live = await startLiveProjection(launchTerms, shared.lifecycleAbort.signal, shared.resumeTerms, launchSnapshot?.tellIds);
         // 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 && shared.terms.provider !== "codex-app-server" && shared.terms.projectionDir && shared.terms.projectionExecutionId
             ? createReplayRunStartGate(shared.terms.projectionDir, shared.terms.projectionExecutionId, launchSnapshot.tellIds)
             : undefined;
+        const live = await startLiveProjection(launchTerms, shared.lifecycleAbort.signal, shared.reviveTerms, launchSnapshot?.tellIds, refreshIdleTimeout);
         shared.onLive(live);
         if (shared.lifecycleAbort.signal.aborted) {
             requestLiveAbort();
         }
         const projectionDir = shared.terms.projectionDir;
         if (projectionDir) {
-            // Supervisor mode: pump with heartbeat, checkpoint, claim inbox, deliver tells.
-            await pumpSupervisor(live, projectionDir, shared.publicEvents, (event) => {
-                replayStartGate?.observeProviderEvent();
-                refreshIdleTimeout();
-                processEvent(state, event);
+            const executionId = shared.terms.projectionExecutionId;
+            if (!executionId) {
+                throw new Error("projection execution id is required in supervisor mode");
+            }
+            // Supervisor mode: persist events, checkpoint, and claim heart-backed tells.
+            await pumpSupervisor(live, projectionDir, executionId, shared.publicEvents, {
+                onEvent: (event) => {
+                    replayStartGate?.observeProviderEvent();
+                    refreshIdleTimeout();
+                    processEvent(state, event);
+                },
             });
         }
         else {
             // Legacy mode: direct event loop without supervisor pump.
             for await (const event of live.events) {
                 replayStartGate?.observeProviderEvent();
-                shared.publicEvents.push(event);
                 refreshIdleTimeout();
+                shared.publicEvents.push(event);
                 processEvent(state, event);
             }
         }
@@ -282,16 +250,16 @@ async function settleProjection(shared) {
             return failFromFailEvent(shared, state, state.failEvent);
         }
         if (!completionResult.ok) {
-            return classifyFailure(shared, state, completionResult.error, timedOut, idleTimedOut);
+            return classifyFailure(shared, state, completionResult.error, idleTimedOut);
         }
         if (shared.lifecycleAbort.signal.aborted) {
-            return classifyFailure(shared, state, shared.lifecycleAbort.signal.reason, timedOut, idleTimedOut);
+            return classifyFailure(shared, state, shared.lifecycleAbort.signal.reason, idleTimedOut);
         }
         if (!state.doneEvent && !completionOutcome) {
             return failWithError(shared, state, {
                 code: "SUBAGENT_EXEC_ERROR",
                 message: `${shared.terms.provider} exec ended before completion`,
-                timeoutMs: shared.terms.timeoutMs,
+                timeoutMs: null,
                 exitCode: null,
             }, state.finalMessageCandidate);
         }
@@ -304,7 +272,7 @@ async function settleProjection(shared) {
             return failWithError(shared, state, {
                 code: "SUBAGENT_EXEC_ERROR",
                 message: `${shared.terms.provider} exec ended without a session handle`,
-                timeoutMs: shared.terms.timeoutMs,
+                timeoutMs: null,
                 exitCode: null,
             }, finalMessage);
         }
@@ -321,17 +289,15 @@ async function settleProjection(shared) {
             diagnostics: renderCapturedText(state.diagnosticsBuffer),
             session,
             warnings: [...state.warnings],
-            ...(effectivePolicyFor(shared) ? { effectivePolicy: effectivePolicyFor(shared) } : {}),
         });
     }
     catch (error) {
         if (error instanceof FlowError) {
             throw error;
         }
-        return classifyFailure(shared, state, error, timedOut, idleTimedOut);
+        return classifyFailure(shared, state, error, idleTimedOut);
     }
     finally {
-        clearTimeout(timeout);
         if (idleTimeout)
             clearTimeout(idleTimeout);
         shared.lifecycleAbort.signal.removeEventListener("abort", requestLiveAbort);
@@ -341,9 +307,6 @@ async function settleProjection(shared) {
 }
 function processEvent(state, event) {
     switch (event.type) {
-        case "output":
-            state.outputBuffer.append(`${JSON.stringify(event.value)}\n`);
-            return;
         case "diagnostic":
             state.diagnosticsBuffer.append(event.text);
             return;
@@ -366,6 +329,14 @@ function processEvent(state, event) {
                 state.diagnosticsBuffer.append(event.diagnostics);
             }
             return;
+        case "activity":
+        case "unknown":
+        case "turn":
+        case "usage":
+        case "thought":
+        case "plan":
+        case "truncation":
+            return;
     }
 }
 function failFromFailEvent(shared, state, failEvent) {
@@ -378,11 +349,11 @@ function failFromFailEvent(shared, state, failEvent) {
     return failWithError(shared, state, {
         code,
         message: failEvent.message,
-        timeoutMs: shared.terms.timeoutMs,
+        timeoutMs: null,
         exitCode: failEvent.exitCode ?? null,
     }, state.finalMessageCandidate, failEvent.diagnostics ?? diagnostics);
 }
-function classifyFailure(shared, state, error, timedOut, idleTimedOut) {
+function classifyFailure(shared, state, error, idleTimedOut) {
     if (shared.dismissed || shared.externallyAborted) {
         return mintOutcome({
             status: "dismissed",
@@ -391,17 +362,8 @@ function classifyFailure(shared, state, error, timedOut, idleTimedOut) {
             diagnostics: renderCapturedText(state.diagnosticsBuffer),
             session: state.session ?? fallbackSession(shared),
             warnings: [...state.warnings],
-            ...(effectivePolicyFor(shared) ? { effectivePolicy: effectivePolicyFor(shared) } : {}),
         });
     }
-    if (timedOut) {
-        return failWithError(shared, state, {
-            code: "SUBAGENT_TIMEOUT",
-            message: `${shared.terms.provider} exec timed out`,
-            timeoutMs: shared.terms.timeoutMs,
-            exitCode: null,
-        }, state.finalMessageCandidate);
-    }
     if (idleTimedOut) {
         return failWithError(shared, state, {
             code: "SUBAGENT_TIMEOUT",
@@ -436,11 +398,10 @@ function failWithError(shared, state, error, finalMessage, diagnostics = renderC
         diagnostics,
         session: state.session ?? fallbackSession(shared),
         warnings: [...state.warnings],
-        ...(effectivePolicyFor(shared) ? { effectivePolicy: effectivePolicyFor(shared) } : {}),
     });
 }
 function fallbackSession(shared) {
-    return shared.resumeTerms?.session ?? {
+    return shared.reviveTerms?.session ?? {
         provider: shared.terms.provider,
         version: SUBAGENT_SESSION_VERSION,
         handle: null,
@@ -472,8 +433,10 @@ function admitResumeShape(provider, schema, session, resumePath) {
     }
     return shapeResult.data;
 }
-async function startLiveProjection(terms, signal, resumeTerms, initialTellIds = []) {
-    const projectionCheckpoint = terms.projectionDir ? buildSyncCheckpointCallback(terms.projectionDir) : undefined;
+async function startLiveProjection(terms, signal, reviveTerms, initialTellIds = [], onIngress) {
+    const projectionCheckpoint = terms.projectionDir && terms.projectionExecutionId
+        ? buildSyncCheckpointCallback(terms.projectionDir, terms.projectionExecutionId)
+        : undefined;
     let appServerInitialFencePending = terms.provider === "codex-app-server" && initialTellIds.length > 0;
     const onSyncCheckpoint = terms.projectionDir
         ? (control, checkpoint) => {
@@ -493,8 +456,8 @@ async function startLiveProjection(terms, signal, resumeTerms, initialTellIds =
             : undefined;
     switch (terms.provider) {
         case "pi": {
-            if (resumeTerms) {
-                const session = admitResumeShape("pi", piSessionSchema, resumeTerms.session, resumeTerms.resumePath);
+            if (reviveTerms) {
+                const session = admitResumeShape("pi", piSessionSchema, reviveTerms.session, reviveTerms.resumePath);
                 return startPi(terms.prompt, terms.workdir, {
                     model: terms.model,
                     thinkingLevel: terms.thinkingLevel,
@@ -503,6 +466,8 @@ async function startLiveProjection(terms, signal, resumeTerms, initialTellIds =
                     appendSystemPromptOverride: terms.appendSystemPromptOverride,
                     onSyncCheckpoint,
                     onEvidence: terms.onEvidence,
+                    onIngress,
+                    initialTurn: terms.initialTurn,
                 });
             }
             return startPi(terms.prompt, terms.workdir, {
@@ -512,44 +477,45 @@ async function startLiveProjection(terms, signal, resumeTerms, initialTellIds =
                 appendSystemPromptOverride: terms.appendSystemPromptOverride,
                 onSyncCheckpoint,
                 onEvidence: terms.onEvidence,
+                onIngress,
+                initialTurn: terms.initialTurn,
             });
         }
         case "claude-agent-sdk": {
-            if (resumeTerms) {
-                const session = admitResumeShape("claude-agent-sdk", claudeSessionSchema, resumeTerms.session, resumeTerms.resumePath);
-                return startClaudeAgentSdk(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    executable: terms.executable,
-                    effort: terms.effort,
-                    signal,
-                    permissionMode: terms.permissionMode,
-                    settingSources: terms.settingSources,
-                    systemPrompt: terms.systemPrompt,
-                    sessionId: session.sessionId,
-                    onSyncCheckpoint,
-                    onEvidence: terms.onEvidence,
-                });
-            }
-            return startClaudeAgentSdk(terms.prompt, terms.workdir, {
+            const claudeOptions = {
                 model: terms.model,
                 executable: terms.executable,
                 effort: terms.effort,
                 signal,
                 permissionMode: terms.permissionMode,
                 settingSources: terms.settingSources,
+                allowDangerouslySkipPermissions: terms.allowDangerouslySkipPermissions,
+                disallowedTools: terms.disallowedTools,
                 systemPrompt: terms.systemPrompt,
                 onSyncCheckpoint,
                 onEvidence: terms.onEvidence,
-            });
+                onIngress,
+                initialTurn: terms.initialTurn,
+            };
+            if (reviveTerms) {
+                const session = admitResumeShape("claude-agent-sdk", claudeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
+                return startClaudeAgentSdk(terms.prompt, terms.workdir, {
+                    ...claudeOptions,
+                    sessionId: session.sessionId,
+                });
+            }
+            return startClaudeAgentSdk(terms.prompt, terms.workdir, claudeOptions);
         }
         case "codex-app-server": {
-            if (resumeTerms) {
-                const session = admitResumeShape("codex-app-server", codexAppServerSessionSchema, resumeTerms.session, resumeTerms.resumePath);
+            if (reviveTerms) {
+                const session = admitResumeShape("codex-app-server", codexAppServerSessionSchema, reviveTerms.session, reviveTerms.resumePath);
                 return startCodexAppServer(terms.prompt, terms.workdir, {
                     model: terms.model,
                     effort: terms.effort,
                     profile: terms.profile,
                     config: terms.config,
+                    sandboxPolicy: terms.sandboxPolicy,
+                    approvalPolicy: terms.approvalPolicy,
                     executable: terms.executable,
                     signal,
                     threadId: session.threadId,
@@ -557,6 +523,8 @@ async function startLiveProjection(terms, signal, resumeTerms, initialTellIds =
                     developerInstructions: terms.developerInstructions,
                     onSyncCheckpoint,
                     onEvidence: terms.onEvidence,
+                    onIngress,
+                    initialTurn: terms.initialTurn,
                 });
             }
             return startCodexAppServer(terms.prompt, terms.workdir, {
@@ -564,16 +532,20 @@ async function startLiveProjection(terms, signal, resumeTerms, initialTellIds =
                 effort: terms.effort,
                 profile: terms.profile,
                 config: terms.config,
+                sandboxPolicy: terms.sandboxPolicy,
+                approvalPolicy: terms.approvalPolicy,
                 executable: terms.executable,
                 signal,
                 developerInstructions: terms.developerInstructions,
                 onSyncCheckpoint,
                 onEvidence: terms.onEvidence,
+                onIngress,
+                initialTurn: terms.initialTurn,
             });
         }
         case "codex-sdk": {
-            if (resumeTerms) {
-                const session = admitResumeShape("codex-sdk", codexThreadSchema, resumeTerms.session, resumeTerms.resumePath);
+            if (reviveTerms) {
+                const session = admitResumeShape("codex-sdk", codexThreadSchema, reviveTerms.session, reviveTerms.resumePath);
                 return startCodexSdk(terms.prompt, terms.workdir, {
                     model: terms.model,
                     profile: terms.profile,
@@ -583,6 +555,8 @@ async function startLiveProjection(terms, signal, resumeTerms, initialTellIds =
                     signal,
                     threadId: session.threadId,
                     onEvidence: terms.onEvidence,
+                    onIngress,
+                    initialTurn: terms.initialTurn,
                 });
             }
             return startCodexSdk(terms.prompt, terms.workdir, {
@@ -593,24 +567,32 @@ async function startLiveProjection(terms, signal, resumeTerms, initialTellIds =
                 executable: terms.executable,
                 signal,
                 onEvidence: terms.onEvidence,
+                onIngress,
+                initialTurn: terms.initialTurn,
             });
         }
         case "opencode-sdk": {
-            if (resumeTerms) {
-                const session = admitResumeShape("opencode-sdk", opencodeSessionSchema, resumeTerms.session, resumeTerms.resumePath);
+            if (reviveTerms) {
+                const session = admitResumeShape("opencode-sdk", opencodeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
                 return startOpencode(terms.prompt, terms.workdir, {
                     model: terms.model,
+                    effort: terms.effort,
                     executable: terms.executable,
                     signal,
                     sessionId: session.sessionId,
                     onEvidence: terms.onEvidence,
+                    onIngress,
+                    initialTurn: terms.initialTurn,
                 });
             }
             return startOpencode(terms.prompt, terms.workdir, {
                 model: terms.model,
+                effort: terms.effort,
                 executable: terms.executable,
                 signal,
                 onEvidence: terms.onEvidence,
+                onIngress,
+                initialTurn: terms.initialTurn,
             });
         }
         default:

package/build/agents/harness/pump.js

@@ -1,6 +1,5 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { claimAllInbox, claimFencedTells, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, readAdmissionLock, isTellCausallyConsumed, touchHeartbeat as touchHeartbeatFile, } from "../../core/projection-core.js";
+import { claimAllInbox, claimFencedTells, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "../../core/projection-core.js";
+import { prepareAgentEventForPersistence, } from "./execution-handle.js";
 /** Tier-2 boundary snapshot. No tells leaves prompt byte-identical. */
 export function snapshotReplayPrompt(projectionDirectory, prompt, tellFence, executionId) {
     const tellIds = claimFencedTells(projectionDirectory, tellFence, executionId);
@@ -43,79 +42,73 @@ export function createReplayRunStartGate(projectionDirectory, executionId, tellI
     };
     return { observeProviderEvent: start, observeSuccessfulCompletion: start };
 }
-/** Heartbeat throttle: no more than one utimes call per 5000ms. */
-export const HEARTBEAT_MIN_INTERVAL_MS = 5_000;
 /**
  * Supervisor pump: iterates handle.events, forwards to publicChannel,
- * touches heartbeat (throttled), checks inbox at checkpoints,
- * and on final sweep publishes verdict.
+ * persists public events and checks the tell ledger at checkpoints.
  */
-export async function pumpSupervisor(handle, projectionDirectory, publicChannel, onEvent) {
-    let lastHeartbeatMs = 0;
-    let heartbeatDegraded = false;
-    const heartbeat = () => {
-        const now = Date.now();
-        if (now - lastHeartbeatMs < HEARTBEAT_MIN_INTERVAL_MS)
-            return;
-        lastHeartbeatMs = now;
-        try {
-            touchHeartbeatFile(projectionDirectory, now);
-            heartbeatDegraded = false;
-        }
-        catch (error) {
-            if (!heartbeatDegraded) {
-                publicChannel.push({
-                    type: "diagnostic",
-                    text: `heartbeat degraded: ${String(error)}`,
-                });
+export async function pumpSupervisor(handle, projectionDirectory, executionId, publicChannel, callbacks = {}, dependencies = {}) {
+    let persistenceEnabled = true;
+    let persistenceDiagnosticQueued = false;
+    const pendingDiagnostics = [];
+    const appendEvent = dependencies.appendGenerationEvent ?? appendGenerationEvent;
+    const dispatch = (event, persist = true) => {
+        if (persist && persistenceEnabled) {
+            try {
+                appendEvent(projectionDirectory, executionId, prepareAgentEventForPersistence(event));
+            }
+            catch (error) {
+                persistenceEnabled = false;
+                if (!persistenceDiagnosticQueued) {
+                    persistenceDiagnosticQueued = true;
+                    pendingDiagnostics.push({
+                        text: `event persistence degraded: ${String(error)}`,
+                        persist: false,
+                    });
+                }
             }
-            heartbeatDegraded = true;
         }
+        publicChannel.push(event);
+        callbacks.onEvent?.(event);
     };
-    const heartbeatTimer = setInterval(heartbeat, HEARTBEAT_MIN_INTERVAL_MS);
-    const stopHeartbeatTimer = () => clearInterval(heartbeatTimer);
     try {
         for await (const event of handle.events) {
-            publicChannel.push(event);
-            onEvent?.(event);
-            heartbeat();
-            if (event.type === "done" || event.type === "fail")
-                stopHeartbeatTimer();
+            dispatch(event);
         }
     }
     catch (error) {
         if (error instanceof Error && error.code === "PROJECTION_STATE_ERROR") {
-            publicChannel.push({
+            const event = handle.mintEvent({
                 type: "fail",
                 code: "PROJECTION_STATE_ERROR",
                 message: error.message,
             });
+            if (event)
+                dispatch(event);
         }
         else {
-            publicChannel.push({
+            const event = handle.mintEvent({
                 type: "diagnostic",
                 text: `pump error: ${String(error)}`,
             });
+            if (event)
+                dispatch(event);
         }
     }
-    finally {
-        stopHeartbeatTimer();
+    for (const pending of pendingDiagnostics) {
+        const event = handle.mintEvent({ type: "diagnostic", text: pending.text });
+        if (event)
+            dispatch(event, pending.persist);
     }
 }
-function readTellOriginalText(projectionDirPath, tellId, layer = "inflight") {
-    const content = JSON.parse(fs.readFileSync(path.join(projectionDirPath, layer, tellId), "utf8"));
-    return content.text;
-}
 /**
  * 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) {
+export function buildSyncCheckpointCallback(projectionDirectory, executionId) {
     const submitting = new Set();
     return (control, checkpoint) => {
         claimAllInbox(projectionDirectory);
-        const executionId = readAdmissionLock(projectionDirectory)?.executionId;
         for (const tellId of listTellIds(projectionDirectory, "inflight")) {
             if (submitting.has(tellId))
                 continue;
@@ -129,8 +122,6 @@ export function buildSyncCheckpointCallback(projectionDirectory) {
             };
             void control.enqueue(tell)
                 .then((ack) => {
-                if (!executionId)
-                    throw new Error("projection checkpoint has no execution admission");
                 if (!ack)
                     throw new Error("provider enqueue resolved without TellSubmitAck");
                 markTellSubmitted(projectionDirectory, tellId, { executionId, fence: ack.fence });
@@ -140,8 +131,6 @@ export function buildSyncCheckpointCallback(projectionDirectory) {
             })
                 .finally(() => submitting.delete(tellId));
         }
-        if (!executionId)
-            return;
         for (const tellId of listTellIds(projectionDirectory, "submitted")) {
             const submitted = readTellSubmitted(projectionDirectory, tellId);
             if (submitted.executionId === executionId && submitted.fence && isTellCausallyConsumed(submitted.fence, checkpoint.fence)) {

package/build/agents/harness/runtime.js

@@ -38,6 +38,9 @@ export function createAbortError(message) {
     error.name = "AbortError";
     return error;
 }
+export function coerceString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
 export function renderTruncationSuffix(truncatedChars) {
     if (truncatedChars <= 0)
         return "";