@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/agents/harness/outcome.js

@@ -1,6 +1,7 @@
 import { StringTailBuffer } from "../string-tail-buffer.js";
 import { SUBAGENT_SESSION_VERSION, } from "../session.js";
-import { SubagentFailure, } from "../types.js";
+import { OUTCOME_ERROR_VERSION, SubagentFailure, } from "../types.js";
+import { isProviderTerminalError, } from "./provider-adapter.js";
 import { renderCapturedText } from "./runtime.js";
 export function createOutcomeState(maxCaptureChars) {
     return {
@@ -63,7 +64,15 @@ export function failFromFailEvent(shared, state, failEvent) {
         exitCode: failEvent.exitCode ?? null,
     }, state.finalMessageCandidate, failEvent.diagnostics ?? diagnostics);
 }
-export function classifyFailure(shared, state, error, idleTimedOut) {
+export function classifyFailure(shared, state, error, idleTimedOut, transportFailure, policyBudgetExceeded = false) {
+    if (policyBudgetExceeded) {
+        return failWithError(shared, state, {
+            code: "SUBAGENT_POLICY_BUDGET",
+            message: `${shared.terms.provider} execution policy budget expired`,
+            timeoutMs: shared.terms.executionTimeoutMs,
+            exitCode: null,
+        }, state.finalMessageCandidate);
+    }
     if (shared.dismissed || shared.externallyAborted) {
         return mintOutcome({
             status: "dismissed",
@@ -74,6 +83,18 @@ export function classifyFailure(shared, state, error, idleTimedOut) {
             warnings: [...state.warnings],
         });
     }
+    if (transportFailure) {
+        const message = transportFailure instanceof Error ? transportFailure.message : `${shared.terms.provider} session transport probe failed`;
+        const timeoutMs = isProviderTerminalError(transportFailure) && transportFailure.fact.kind === "failed"
+            ? transportFailure.fact.timeoutMs
+            : shared.terms.idleTimeoutMs;
+        return failWithError(shared, state, {
+            code: "SUBAGENT_TRANSPORT_ERROR",
+            message,
+            timeoutMs,
+            exitCode: null,
+        }, state.finalMessageCandidate);
+    }
     if (idleTimedOut) {
         return failWithError(shared, state, {
             code: "SUBAGENT_TIMEOUT",
@@ -82,13 +103,55 @@ export function classifyFailure(shared, state, error, idleTimedOut) {
             exitCode: null,
         }, state.finalMessageCandidate);
     }
+    return classifyExecutionFailure(shared, state, error);
+}
+/**
+ * A rejected graceful settlement is terminal evidence, not an outcome intent.
+ * In particular, dismiss/external-cancel intent must not downgrade it to a
+ * clean dismissed result.
+ */
+export function classifySettlementFailure(shared, state, error) {
+    return classifyExecutionFailure(shared, state, error);
+}
+function classifyFromFailureFact(shared, state, fact) {
+    return failWithError(shared, state, {
+        code: fact.code,
+        message: fact.message,
+        timeoutMs: fact.timeoutMs,
+        exitCode: fact.exitCode,
+        ...(fact.publicCause ? { publicCause: fact.publicCause } : {}),
+    }, state.finalMessageCandidate ?? fact.message, fact.diagnostics || renderCapturedText(state.diagnosticsBuffer), fact.output || renderCapturedText(state.outputBuffer));
+}
+function classifyFromAbortFact(shared, state, fact) {
+    // Abort without dismiss/external-cancel remains failed truth (historical bytes).
+    appendThrownMessage(state.diagnosticsBuffer, fact.message);
+    return failWithError(shared, state, {
+        code: "SUBAGENT_EXEC_ERROR",
+        message: fact.message,
+        timeoutMs: null,
+        exitCode: null,
+    }, state.finalMessageCandidate ?? fact.message);
+}
+function classifyExecutionFailure(shared, state, error) {
+    if (isProviderTerminalError(error)) {
+        if (error.fact.kind === "aborted") {
+            return classifyFromAbortFact(shared, state, error.fact);
+        }
+        return classifyFromFailureFact(shared, state, error.fact);
+    }
     if (error instanceof SubagentFailure) {
-        return failWithError(shared, state, {
+        return classifyFromFailureFact(shared, state, {
+            kind: "failed",
             code: error.code,
             message: error.message,
             timeoutMs: error.timeoutMs,
             exitCode: error.exitCode,
-        }, state.finalMessageCandidate ?? error.message, error.diagnostics || renderCapturedText(state.diagnosticsBuffer), error.output || renderCapturedText(state.outputBuffer));
+            diagnostics: error.diagnostics,
+            output: error.output,
+        });
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+        return classifyFromAbortFact(shared, state, { kind: "aborted", message: error.message });
     }
     const message = error instanceof Error ? error.message : `Unknown ${shared.terms.provider} exec error`;
     appendThrownMessage(state.diagnosticsBuffer, message);
@@ -102,7 +165,7 @@ export function classifyFailure(shared, state, error, idleTimedOut) {
 export function failWithError(shared, state, error, finalMessage, diagnostics = renderCapturedText(state.diagnosticsBuffer), output = renderCapturedText(state.outputBuffer)) {
     return mintOutcome({
         status: "failed",
-        error,
+        error: { version: OUTCOME_ERROR_VERSION, ...error },
         finalMessage: finalMessage ?? error.message,
         output,
         diagnostics,

package/build/agents/harness/projection.js

@@ -2,9 +2,10 @@ import { randomUUID } from "node:crypto";
 import { FlowError } from "../../flow-error.js";
 import { createEventChannel } from "./event-channel.js";
 import { overflowMarkerFromDropped, prepareAgentEventForPersistence, } from "./execution-handle.js";
-import { classifyFailure, completeOutcome, createOutcomeState, failFromFailEvent, failWithError, processEvent, renderOutcomeCapturedText, } from "./outcome.js";
+import { classifyFailure, classifySettlementFailure, completeOutcome, createOutcomeState, failFromFailEvent, failWithError, processEvent, renderOutcomeCapturedText, } from "./outcome.js";
 import { startLiveProjection } from "./router.js";
 import { createAbortError } from "./runtime.js";
+const POLICY_BUDGET_CLEANUP_GRACE_MS = 5_000;
 export function call(terms, options) {
     return createProjection(terms, undefined, options);
 }
@@ -12,17 +13,7 @@ export function revive(terms, options) {
     return createProjection(terms, terms, options);
 }
 function createProjection(terms, reviveTerms, options) {
-    switch (terms.provider) {
-        case "pi":
-        case "claude-agent-sdk":
-        case "codex-app-server":
-        case "opencode-sdk":
-            return createSteerableProjection(terms, reviveTerms, options);
-        case "codex-sdk":
-            return createReplayProjection(terms, reviveTerms, options);
-        default:
-            return assertNever(terms);
-    }
+    return createSteerableProjection(terms, reviveTerms, options);
 }
 function createSteerableProjection(terms, reviveTerms, options) {
     const shared = createProjectionState(terms, reviveTerms, options);
@@ -84,31 +75,6 @@ function createSteerableProjection(terms, reviveTerms, options) {
         },
     };
 }
-function createReplayProjection(terms, reviveTerms, options) {
-    const shared = createProjectionState(terms, reviveTerms, options);
-    shared.onLive = (live) => {
-        shared.live = live;
-    };
-    const outcome = settleProjection(shared);
-    return {
-        mode: "replay",
-        get id() {
-            return shared.id;
-        },
-        get events() {
-            return shared.publicEvents.iterable;
-        },
-        get outcome() {
-            return outcome;
-        },
-        abort(mode) {
-            return abortProjection(shared, mode);
-        },
-        dismiss() {
-            dismissProjection(shared);
-        },
-    };
-}
 function createProjectionState(terms, reviveTerms, options) {
     const shared = {
         id: randomUUID(),
@@ -129,9 +95,7 @@ function createProjectionState(terms, reviveTerms, options) {
     if (terms.signal) {
         const listener = () => {
             shared.externallyAborted = true;
-            if (!shared.lifecycleAbort.signal.aborted) {
-                shared.lifecycleAbort.abort(terms.signal?.reason);
-            }
+            requestControlledGracefulAbort(shared, terms.signal?.reason);
         };
         terms.signal.addEventListener("abort", listener, { once: true });
         if (terms.signal.aborted) {
@@ -144,20 +108,17 @@ function dismissProjection(shared) {
     if (shared.dismissed || shared.terminal)
         return;
     shared.dismissed = true;
-    if (!shared.lifecycleAbort.signal.aborted) {
-        shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec dismissed`));
-    }
-    requestDismissAbort(shared.live);
+    requestControlledGracefulAbort(shared, createAbortError(`${shared.terms.provider} exec dismissed`));
 }
 async function abortProjection(shared, mode = "graceful") {
     shared.explicitlyAborted = true;
-    if (!shared.lifecycleAbort.signal.aborted) {
-        shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec cancelled by client`));
-    }
     if (mode !== "force") {
-        await shared.live?.abort("graceful");
+        await requestControlledGracefulAbort(shared, createAbortError(`${shared.terms.provider} exec cancelled by client`));
         return;
     }
+    if (!shared.lifecycleAbort.signal.aborted) {
+        shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec cancelled by client`));
+    }
     shared.forceAbort ??= (async () => {
         const live = shared.live ?? (shared.terminal ? undefined : await new Promise((resolve) => {
             shared.forceWaiters.add(resolve);
@@ -171,14 +132,44 @@ function resolveForceWaiters(shared, live) {
         resolve(live);
     shared.forceWaiters.clear();
 }
-function requestDismissAbort(live) {
-    if (!live)
-        return;
-    void Promise.resolve()
-        .then(() => live.abort("graceful"))
-        .catch(() => undefined);
+function requestControlledGracefulAbort(shared, reason) {
+    if (shared.gracefulAbort)
+        return shared.gracefulAbort;
+    const live = shared.live;
+    if (!live) {
+        if (!shared.lifecycleAbort.signal.aborted)
+            shared.lifecycleAbort.abort(reason);
+        return Promise.resolve();
+    }
+    shared.gracefulAbort = (async () => {
+        try {
+            await live.abort("graceful");
+        }
+        finally {
+            if (!shared.lifecycleAbort.signal.aborted)
+                shared.lifecycleAbort.abort(reason);
+        }
+    })();
+    // Dismiss, timeout, and external cancellation are outcome-driven controls;
+    // keep their rejection observed while explicit abort still receives it.
+    shared.gracefulAbort.catch(() => undefined);
+    return shared.gracefulAbort;
 }
-function deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, observerEnabled) {
+function requestPolicyBudgetCleanup(shared, reason) {
+    const graceful = requestControlledGracefulAbort(shared, reason);
+    const force = () => {
+        void shared.live?.abort("force").catch(() => undefined);
+    };
+    const cleanupTimeout = setTimeout(force, POLICY_BUDGET_CLEANUP_GRACE_MS);
+    cleanupTimeout.unref?.();
+    void graceful.then(() => clearTimeout(cleanupTimeout), () => {
+        clearTimeout(cleanupTimeout);
+        force();
+    });
+}
+function deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled) {
+    if (shared.terminal)
+        return;
     const prepared = prepareAgentEventForPersistence(event);
     if (observerEnabled.value && shared.observer) {
         try {
@@ -197,24 +188,63 @@ function deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, obse
         }
     }
     shared.publicEvents.push(event);
+    if (event.type === "activity") {
+        if (event.phase === "started")
+            knownActiveTools.add(event.id);
+        if (event.phase === "completed")
+            knownActiveTools.delete(event.id);
+    }
     refreshIdleTimeout();
     processEvent(state, event);
 }
 async function settleProjection(shared) {
     const state = createOutcomeState(shared.terms.maxCaptureChars);
     let idleTimedOut = false;
+    let transportFailure;
+    let policyBudgetExceeded = false;
+    const knownActiveTools = new Set();
     let abortRequested = false;
     const observerEnabled = { value: shared.observer !== undefined };
     let idleTimeout;
+    let executionTimeout;
+    let liveDriver;
+    let probeInFlight;
+    let resolvePolicyBudget;
+    const policyBudget = new Promise((resolve) => {
+        resolvePolicyBudget = resolve;
+    });
     const refreshIdleTimeout = () => {
+        if (shared.terminal)
+            return;
         if (idleTimeout)
             clearTimeout(idleTimeout);
         idleTimeout = setTimeout(() => {
+            if (knownActiveTools.size > 0) {
+                if (!liveDriver?.probe || probeInFlight)
+                    return;
+                probeInFlight = liveDriver.probe()
+                    .then(() => refreshIdleTimeout())
+                    .catch((error) => {
+                    transportFailure = error;
+                    return requestControlledGracefulAbort(shared, error);
+                })
+                    .finally(() => {
+                    probeInFlight = undefined;
+                });
+                probeInFlight.catch(() => undefined);
+                return;
+            }
             idleTimedOut = true;
-            shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec idle timed out`));
+            requestControlledGracefulAbort(shared, createAbortError(`${shared.terms.provider} exec idle timed out`));
         }, shared.terms.idleTimeoutMs);
         idleTimeout.unref?.();
     };
+    executionTimeout = setTimeout(() => {
+        policyBudgetExceeded = true;
+        requestPolicyBudgetCleanup(shared, createAbortError(`${shared.terms.provider} execution policy budget expired`));
+        resolvePolicyBudget();
+    }, shared.terms.executionTimeoutMs);
+    executionTimeout.unref?.();
     refreshIdleTimeout();
     const requestLiveAbort = () => {
         if (shared.explicitlyAborted)
@@ -222,89 +252,114 @@ async function settleProjection(shared) {
         if (abortRequested)
             return;
         abortRequested = true;
-        requestDismissAbort(shared.live);
+        requestControlledGracefulAbort(shared, shared.lifecycleAbort.signal.reason);
     };
     shared.lifecycleAbort.signal.addEventListener("abort", requestLiveAbort, { once: true });
-    try {
-        const live = await startLiveProjection(shared.terms, shared.lifecycleAbort.signal, shared.reviveTerms, refreshIdleTimeout, shared.observer);
-        shared.onLive(live);
-        resolveForceWaiters(shared, live);
-        if (shared.lifecycleAbort.signal.aborted) {
-            requestLiveAbort();
-        }
+    const providerSettlement = (async () => {
         try {
-            for await (const event of live.events) {
-                deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, observerEnabled);
+            const live = await startLiveProjection(shared.terms, shared.lifecycleAbort.signal, shared.reviveTerms, refreshIdleTimeout, shared.observer);
+            liveDriver = live;
+            shared.onLive(live);
+            resolveForceWaiters(shared, live);
+            if (shared.lifecycleAbort.signal.aborted) {
+                requestLiveAbort();
             }
-        }
-        catch (error) {
-            if (error instanceof Error && error.code === "PROJECTION_STATE_ERROR") {
-                const event = live.mintEvent({
-                    type: "fail",
-                    code: "PROJECTION_STATE_ERROR",
-                    message: error.message,
-                });
-                if (event)
-                    deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, observerEnabled);
+            try {
+                for await (const event of live.events) {
+                    deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
+                }
             }
-            else {
-                const event = live.mintEvent({
-                    type: "diagnostic",
-                    text: `pump error: ${String(error)}`,
-                });
-                if (event)
-                    deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, observerEnabled);
+            catch (error) {
+                if (error instanceof Error && error.code === "PROJECTION_STATE_ERROR") {
+                    const event = live.mintEvent({
+                        type: "fail",
+                        code: "PROJECTION_STATE_ERROR",
+                        message: error.message,
+                    });
+                    if (event)
+                        deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
+                }
+                else {
+                    const event = live.mintEvent({
+                        type: "diagnostic",
+                        text: `pump error: ${String(error)}`,
+                    });
+                    if (event)
+                        deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
+                }
             }
+            const completionResult = await live.completion.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+            const completionOutcome = completionResult.ok ? completionResult.value : undefined;
+            // Outcome classification is the terminal publication boundary. A
+            // controlled abort may let the provider run settle before its graceful
+            // cleanup promise does, so prove that shared settlement before publishing
+            // dismissed, failed-for-another-reason, or completed truth.
+            const gracefulResult = shared.gracefulAbort
+                ? await shared.gracefulAbort.then(() => ({ ok: true }), (error) => ({ ok: false, error }))
+                : undefined;
+            if (gracefulResult && !gracefulResult.ok && !transportFailure) {
+                return classifySettlementFailure(shared, state, gracefulResult.error);
+            }
+            if (policyBudgetExceeded || transportFailure) {
+                return classifyFailure(shared, state, completionResult.ok ? undefined : completionResult.error, idleTimedOut, transportFailure, policyBudgetExceeded);
+            }
+            if (state.failEvent) {
+                return failFromFailEvent(shared, state, state.failEvent);
+            }
+            if (!completionResult.ok) {
+                return classifyFailure(shared, state, completionResult.error, idleTimedOut, transportFailure, policyBudgetExceeded);
+            }
+            if (shared.lifecycleAbort.signal.aborted) {
+                return classifyFailure(shared, state, shared.lifecycleAbort.signal.reason, idleTimedOut, transportFailure, policyBudgetExceeded);
+            }
+            if (!state.doneEvent && !completionOutcome) {
+                return failWithError(shared, state, {
+                    code: "SUBAGENT_EXEC_ERROR",
+                    message: `${shared.terms.provider} exec ended before completion`,
+                    timeoutMs: null,
+                    exitCode: null,
+                }, state.finalMessageCandidate);
+            }
+            const finalMessage = state.doneEvent?.finalMessage ??
+                completionOutcome?.finalMessage ??
+                state.finalMessageCandidate ??
+                renderOutcomeCapturedText(state.outputBuffer).trim();
+            const session = state.doneEvent?.session ?? completionOutcome?.session;
+            if (!session) {
+                return failWithError(shared, state, {
+                    code: "SUBAGENT_EXEC_ERROR",
+                    message: `${shared.terms.provider} exec ended without a session handle`,
+                    timeoutMs: null,
+                    exitCode: null,
+                }, finalMessage);
+            }
+            return completeOutcome(shared, state, finalMessage, session);
         }
-        const completionResult = await live.completion.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
-        const completionOutcome = completionResult.ok ? completionResult.value : undefined;
-        if (state.failEvent) {
-            return failFromFailEvent(shared, state, state.failEvent);
-        }
-        if (!completionResult.ok) {
-            return classifyFailure(shared, state, completionResult.error, idleTimedOut);
-        }
-        if (shared.lifecycleAbort.signal.aborted) {
-            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: null,
-                exitCode: null,
-            }, state.finalMessageCandidate);
-        }
-        const finalMessage = state.doneEvent?.finalMessage ??
-            completionOutcome?.finalMessage ??
-            state.finalMessageCandidate ??
-            renderOutcomeCapturedText(state.outputBuffer).trim();
-        const session = state.doneEvent?.session ?? completionOutcome?.session;
-        if (!session) {
-            return failWithError(shared, state, {
-                code: "SUBAGENT_EXEC_ERROR",
-                message: `${shared.terms.provider} exec ended without a session handle`,
-                timeoutMs: null,
-                exitCode: null,
-            }, finalMessage);
-        }
-        return completeOutcome(shared, state, finalMessage, session);
-    }
-    catch (error) {
-        if (error instanceof FlowError) {
-            throw error;
+        catch (error) {
+            if (error instanceof FlowError) {
+                throw error;
+            }
+            return classifyFailure(shared, state, error, idleTimedOut, transportFailure, policyBudgetExceeded);
         }
-        return classifyFailure(shared, state, error, idleTimedOut);
+    })();
+    providerSettlement.catch(() => undefined);
+    try {
+        const settled = await Promise.race([
+            providerSettlement.then((outcome) => ({ kind: "provider", outcome })),
+            policyBudget.then(() => ({ kind: "policy-budget" })),
+        ]);
+        return settled.kind === "provider"
+            ? settled.outcome
+            : classifyFailure(shared, state, undefined, idleTimedOut, transportFailure, true);
     }
     finally {
         if (idleTimeout)
             clearTimeout(idleTimeout);
+        if (executionTimeout)
+            clearTimeout(executionTimeout);
         shared.lifecycleAbort.signal.removeEventListener("abort", requestLiveAbort);
         shared.terminal = true;
         resolveForceWaiters(shared, undefined);
         shared.publicEvents.close();
     }
 }
-function assertNever(_value) {
-    throw new Error("Unhandled provider");
-}

package/build/agents/harness/provider-adapter.js

@@ -0,0 +1,58 @@
+import { SubagentFailure, } from "../types.js";
+/**
+ * Typed rejection carrier for failed/aborted adapter settlement.
+ * Abort keeps name "AbortError" so existing name checks and CLI exit codes hold.
+ */
+export class ProviderTerminalError extends Error {
+    fact;
+    constructor(fact, options) {
+        super(fact.message, options?.cause === undefined ? undefined : { cause: options.cause });
+        this.name = fact.kind === "aborted" ? "AbortError" : "ProviderTerminalError";
+        this.fact = fact;
+    }
+}
+export function isProviderTerminalError(error) {
+    return error instanceof ProviderTerminalError;
+}
+export function createProviderFailure(message, options = {}) {
+    return new ProviderTerminalError({
+        kind: "failed",
+        code: options.code ?? "SUBAGENT_EXEC_ERROR",
+        message,
+        timeoutMs: options.timeoutMs ?? null,
+        exitCode: options.exitCode ?? null,
+        ...(options.diagnostics !== undefined ? { diagnostics: options.diagnostics } : {}),
+        ...(options.output !== undefined ? { output: options.output } : {}),
+        ...(options.publicCause !== undefined ? { publicCause: options.publicCause } : {}),
+    }, options.cause === undefined ? undefined : { cause: options.cause });
+}
+/**
+ * Abort-fact constructor. Abort semantics for every live adapter:
+ * - abort("graceful") requests provider-native interrupt and keeps local signals
+ *   open until native settlement proof (or bounded abort-settlement timeout);
+ * - abort("force") must establish zero later provider side effects or reject;
+ * - run settlement for a requested abort exits as kind "aborted" (name AbortError).
+ */
+export function createAbortError(message, cause) {
+    return new ProviderTerminalError({ kind: "aborted", message }, cause === undefined ? undefined : { cause });
+}
+/** Normalize any thrown value into the typed failure/abort egress fact. */
+export function toProviderTerminalError(error) {
+    if (error instanceof ProviderTerminalError)
+        return error;
+    if (error instanceof SubagentFailure) {
+        return new ProviderTerminalError({
+            kind: "failed",
+            code: error.code,
+            message: error.message,
+            timeoutMs: error.timeoutMs,
+            exitCode: error.exitCode,
+            diagnostics: error.diagnostics,
+            output: error.output,
+        }, { cause: error });
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+        return new ProviderTerminalError({ kind: "aborted", message: error.message }, { cause: error });
+    }
+    return createProviderFailure(error instanceof Error ? error.message : String(error), { cause: error instanceof Error ? error : undefined });
+}