@bridge4dev/runner 0.48.0 → 0.49.0

package/dist/adapters/claude.js

@@ -2012,12 +2012,18 @@ class ClaudeSession {
         this.aborting = true;
         try {
             await this.q.interrupt();
+            return 'accepted';
         }
         catch (error) {
             // The abort never reached the SDK, so any failure that arrives now is the
             // agent's own and must be reported as one.
             this.aborting = false;
             log.warn('claude: interrupt failed', { error: String(error) });
+            // #373: answered rather than swallowed. `stopped` is the honest reading of
+            // «we closed this query ourselves» — the SDK rejects every outstanding
+            // control request with «Query closed before response received» on close,
+            // and calling that a refusal would turn our own park into a failure.
+            return this.stopped ? 'idle' : 'refused';
         }
     }
     conversationAnchor() {
@@ -2281,6 +2287,19 @@ class ClaudeSession {
                         const aborted = this.aborting;
                         this.aborting = false;
                         const failure = msg.subtype === 'success' ? '' : classifyError(msg.subtype, msg.errors);
+                        // #373, plan stage D. What the incident could not answer: the second
+                        // result's origin was never recorded, so «is this the same turn
+                        // twice or a turn the CLI started by itself» had no evidence either
+                        // way. An allowlist of shapes the SDK marks optional, read through
+                        // type guards so a build that has none of them logs none of them —
+                        // no message text, no tool input, no environment, nothing to mask.
+                        log.info('claude: turn result', {
+                            sessionId: this.spec.sessionId,
+                            subtype: msg.subtype,
+                            aborted,
+                            produced: this.turnProduced,
+                            ...optionalDiagnostics(msg),
+                        });
                         if (failure && isRewindError(failure)) {
                             // Not a failed turn — a refused resume. The CLI answers a bad
                             // `resumeSessionAt` with exactly this and nothing else (no
@@ -2351,6 +2370,12 @@ class ClaudeSession {
                 type: 'error',
                 message: classifyRunError(message),
                 ...(code ? { code } : {}),
+                // #373: this catch is the CLI process falling over under the read loop —
+                // the only place in this adapter where that is what happened. Our own
+                // `q.close()` does NOT come through here (the SDK ends the input stream
+                // and the iteration finishes cleanly), so the flag stays an honest
+                // answer to «did the process die on its own».
+                processGone: true,
             });
         }
         finally {
@@ -2367,6 +2392,41 @@ class ClaudeSession {
         }
     }
 }
+/**
+ * The optional shapes a `result` may carry, and nothing else (#373).
+ *
+ * An allowlist rather than «log the message»: an SDK message holds the whole
+ * turn, and a runner log is not a place for a person's words, a tool's input or
+ * an environment. Each field is read through a type guard and simply absent when
+ * the build does not have it — no private SDK methods, and no minimum CLI
+ * version required to read an optional field.
+ *
+ *  - `uuid`            names the RESULT, not the turn. Two results of one stop
+ *                      have two of these, which is why it is evidence and not an
+ *                      identifier to key anything on.
+ *  - `origin.kind`     `task-notification` is a turn a background subagent woke
+ *                      from inside the CLI — the one thing that tells a genuinely
+ *                      new internal turn from a duplicate ending.
+ *  - `terminal_reason` the CLI's own word for why it stopped.
+ */
+function optionalDiagnostics(msg) {
+    if (!msg || typeof msg !== 'object')
+        return {};
+    const record = msg;
+    const out = {};
+    if (typeof record['uuid'] === 'string')
+        out['resultUuid'] = record['uuid'];
+    if (typeof record['terminal_reason'] === 'string') {
+        out['terminalReason'] = record['terminal_reason'];
+    }
+    const origin = record['origin'];
+    if (origin && typeof origin === 'object') {
+        const kind = origin['kind'];
+        if (typeof kind === 'string')
+            out['originKind'] = kind;
+    }
+    return out;
+}
 // Recursive: MultiEdit-style inputs nest long strings inside arrays — a
 // shallow pass let them blow past the API's 128KB event cap (QA-96 F2).
 function truncateDeep(value, limit) {

package/dist/adapters/codex-protocol.d.ts

@@ -7,6 +7,19 @@ export declare class RpcError extends Error {
     readonly method: string;
     constructor(code: number, message: string, method: string);
 }
+/**
+ * The far end never answered in time (#370).
+ *
+ * A class of its own rather than a number the caller has to recognise: opening
+ * a conversation has to tell «Codex refused» from «Codex was too slow», and the
+ * only other way to ask was the sentence in `message`. That sentence is prose,
+ * and prose is exactly what turned a slow `thread/resume` into a dead session —
+ * `isMissingRollout` matched «no rollout found», not «timed out after 60000ms»,
+ * so none of the recovery already written for a refusal ever ran.
+ */
+export declare class RpcTimeoutError extends RpcError {
+    constructor(method: string, timeoutMs: number);
+}
 export interface ServerRequest {
     id: number | string;
     method: string;

package/dist/adapters/codex-protocol.js

@@ -10,6 +10,22 @@ export class RpcError extends Error {
         this.name = 'RpcError';
     }
 }
+/**
+ * The far end never answered in time (#370).
+ *
+ * A class of its own rather than a number the caller has to recognise: opening
+ * a conversation has to tell «Codex refused» from «Codex was too slow», and the
+ * only other way to ask was the sentence in `message`. That sentence is prose,
+ * and prose is exactly what turned a slow `thread/resume` into a dead session —
+ * `isMissingRollout` matched «no rollout found», not «timed out after 60000ms»,
+ * so none of the recovery already written for a refusal ever ran.
+ */
+export class RpcTimeoutError extends RpcError {
+    constructor(method, timeoutMs) {
+        super(-32000, `${method} timed out after ${timeoutMs}ms`, method);
+        this.name = 'RpcTimeoutError';
+    }
+}
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 /** A line longer than this means the far end is misbehaving — drop the buffer. */
 const MAX_LINE_BYTES = 8 * 1024 * 1024;
@@ -134,7 +150,7 @@ export class AppServerClient {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pending.delete(id);
-                reject(new RpcError(-32000, `${method} timed out after ${timeoutMs}ms`, method));
+                reject(new RpcTimeoutError(method, timeoutMs));
             }, timeoutMs);
             timer.unref();
             this.pending.set(id, {

package/dist/adapters/codex.js

@@ -3,7 +3,7 @@ import { log } from '../log.js';
 import { evaluateToolUse, maskSecrets, maskString, } from '../policy.js';
 import { RUNNER_VERSION } from '../version.js';
 import { repairCodexAuth } from './codex-home.js';
-import { AppServerClient, asRecord, num, str } from './codex-protocol.js';
+import { AppServerClient, asRecord, num, RpcError, RpcTimeoutError, str, } from './codex-protocol.js';
 import { truncate } from './claude.js';
 import { availableModes, MODE_REFUSED_TEXT, MODE_WITHDRAWN_TEXT, DEVBRIDGE_MCP_SERVER_NAME, } from './types.js';
 import { clampPercent, rateWindowKeyFromMinutes } from './rate-limits.js';
@@ -326,13 +326,69 @@ class CodexSession {
      * second; losing the conversation costs the whole context.
      */
     static RESUME_RETRY_DELAY_MS = 1_500;
+    /**
+     * How long opening an existing conversation may take (#370).
+     *
+     * Its own budget rather than the protocol's 60 s default, because it is not a
+     * command — it is the app-server reading a conversation off disk, and the
+     * work grows with the conversation. Session #61 on Athanor died on exactly
+     * that: ~6 900 events, `thread/resume timed out after 60000ms`, twice, and
+     * the session was gone for good.
+     *
+     * Measured here on 06.09.2026, codex-cli 0.153.4, against a real 14 MB
+     * rollout (1 460 lines):
+     *
+     *   without `excludeTurns` — 5 744 ms, a 4.41 MB response line
+     *   with    `excludeTurns` —   673 ms, a 27 KB response line
+     *
+     * So 120 s is ~20× the slowest answer this transport can even carry: the
+     * stdout reader drops any line over 8 MB (`MAX_LINE_BYTES`), which at the
+     * measured 0.77 MB/s is about ten seconds of hydration. The margin is not for
+     * a bigger conversation — it is for a loaded or slow machine, which is what
+     * #370 is actually about.
+     */
+    static RESUME_REQUEST_TIMEOUT_MS = 120_000;
+    /**
+     * Does this build take `excludeTurns`? (#364)
+     *
+     * Remembered per session rather than probed: the answer belongs to the
+     * installed binary, and one refusal is enough to stop asking for the life of
+     * this process. Same shape as the `experimentalApi` fallback below it.
+     */
+    excludeTurnsRefused = false;
+    /**
+     * Open a thread without asking for its whole history (#364).
+     *
+     * The history was always thrown away — `readThread` reads the id and the
+     * model and nothing else — so asking for it bought a deprecation warning in
+     * the user's feed, several megabytes through a pipe that drops anything over
+     * eight, and the seconds that killed #370. Old builds that do not know the
+     * field are answered by retrying once without it.
+     */
+    async openThreadRequest(method, params) {
+        if (!this.excludeTurnsRefused) {
+            try {
+                return asRecord(await this.client.request(method, { ...params, excludeTurns: true }, CodexSession.RESUME_REQUEST_TIMEOUT_MS));
+            }
+            catch (error) {
+                if (!isUnknownParam(error))
+                    throw error;
+                this.excludeTurnsRefused = true;
+                log.warn('codex: this build does not take excludeTurns — asking for the full history', {
+                    sessionId: this.spec.sessionId,
+                    method,
+                });
+            }
+        }
+        return asRecord(await this.client.request(method, params, CodexSession.RESUME_REQUEST_TIMEOUT_MS));
+    }
     /** Branch the thread at `lastTurnId`, dropping every later turn. */
     async forkThread(threadId, lastTurnId) {
-        const result = asRecord(await this.client.request('thread/fork', {
+        const result = await this.openThreadRequest('thread/fork', {
             threadId,
             lastTurnId,
             ...this.threadParams(),
-        }));
+        });
         const thread = asRecord(result['thread']);
         const id = str(thread['id']);
         if (!id)
@@ -344,10 +400,10 @@ class CodexSession {
         // overlay lives only in memory, so resuming with just a thread id brings the
         // conversation back without DevBridge access — the agent then hunts for
         // tickets it can no longer reach (found in the live check).
-        const result = asRecord(await this.client.request('thread/resume', {
+        const result = await this.openThreadRequest('thread/resume', {
             threadId: resumeId,
             ...this.threadParams(),
-        }));
+        });
         const thread = asRecord(result['thread']);
         const id = str(thread['id']);
         if (!id)
@@ -392,9 +448,10 @@ class CodexSession {
                 let error = firstError;
                 // Matched on the message rather than the error class: the same failure
                 // can arrive as an RPC error or as a transport error, and a missed match
-                // would fail the session instead of retrying it.
-                if (isMissingRollout(error)) {
-                    log.warn('codex: thread/resume rejected — retrying once', {
+                // would fail the session instead of retrying it. The one exception is a
+                // timeout, which IS an error class (#370) — see `isResumeRecoverable`.
+                if (isResumeRecoverable(error)) {
+                    log.warn('codex: thread/resume did not open the conversation — retrying once', {
                         sessionId: this.spec.sessionId,
                         threadId: resumeId,
                         error: maskString(describe(error)).slice(0, 300),
@@ -411,14 +468,14 @@ class CodexSession {
                         error = retryError;
                     }
                 }
-                if (isMissingRollout(error)) {
+                if (isResumeRecoverable(error)) {
                     // Losing the conversation is expensive, so record WHY. Verified live
                     // (2026-07-25): resuming this exact thread with these exact params
                     // succeeds in isolation, so a failure here is transient — most likely
                     // the previous agent process still holding the thread during a rapid
                     // stop→continue cycle. Without this line the only trace is a feed
                     // notice that says the context is gone and nothing about the cause.
-                    log.warn('codex: thread/resume rejected — falling back to a fresh thread', {
+                    log.warn('codex: thread/resume gave up — falling back to a fresh thread', {
                         sessionId: this.spec.sessionId,
                         threadId: resumeId,
                         error: maskString(describe(error)).slice(0, 300),
@@ -767,18 +824,23 @@ class CodexSession {
         }
     }
     async interrupt() {
+        // No turn of our own to stop — and that is not a failure (#373): a pause
+        // that lands between turns has nothing to interrupt and must not be read as
+        // a control channel that said no.
         if (!this.threadId || !this.activeTurnId)
-            return;
+            return 'idle';
         try {
             await this.client.request('turn/interrupt', {
                 threadId: this.threadId,
                 turnId: this.activeTurnId,
             });
+            return 'accepted';
         }
         catch (error) {
             if (/no active turn/i.test(describe(error)))
-                return;
+                return 'idle';
             log.warn('codex: interrupt failed', { error: describe(error) });
+            return this.stopped ? 'idle' : 'refused';
         }
     }
     conversationAnchor() {
@@ -1805,6 +1867,9 @@ class CodexSession {
             this.emit({
                 type: 'error',
                 message: `codex app-server exited before the session was ready (code ${info.code ?? 'null'})`,
+                // #373: the process is what ended, not a turn. `stopped` is already
+                // excluded above, so this is always an exit nobody here asked for.
+                processGone: true,
             });
         }
         this.finish();
@@ -2099,6 +2164,51 @@ function describe(error) {
 function isMissingRollout(error) {
     return /no rollout found|not found/i.test(describe(error));
 }
+/**
+ * The conversation did not open, and a fresh one is the way out (#370).
+ *
+ * Two ways for that to happen, and until this ticket only the first counted:
+ *
+ *  - the app-server REFUSED — there is no such rollout. Survivable: the retry
+ *    below, then a fresh thread, and the branch and files are untouched.
+ *  - the app-server never ANSWERED. Read as «something we do not recognise»,
+ *    which fails the session outright — so a conversation that had merely grown
+ *    slow was more fatal than one that had been thrown away.
+ *
+ * The timeout is recognised by its class and not by its sentence: `RpcTimeoutError`
+ * is minted in exactly one place, whereas «timed out» is a phrase any layer
+ * between here and the provider may use about something else entirely.
+ */
+function isResumeRecoverable(error) {
+    return error instanceof RpcTimeoutError || isMissingRollout(error);
+}
+/**
+ * Did the app-server refuse a parameter it does not know? (#364)
+ *
+ * JSON-RPC says «invalid params» is -32602, and that code alone is taken at its
+ * word. App-server also answers -32600 for a field gated behind a capability,
+ * but -32600 is what a stale rollout arrives as too (see the QA-101 tests), so
+ * there the message has to name the field as well — reading a lost conversation
+ * as «this build is old» would double every attempt on the one path that is
+ * already losing it.
+ *
+ * Anything else — a timeout, a missing rollout, a transport failure — must NOT
+ * be re-sent, or one slow resume would become two.
+ */
+function isUnknownParam(error) {
+    if (error instanceof RpcTimeoutError)
+        return false;
+    if (!(error instanceof RpcError))
+        return false;
+    // A stale rollout also arrives as -32600 (see the QA-101 tests), and reading
+    // that as «this build is old» would double every resume attempt on the very
+    // path that is already losing a conversation.
+    if (isMissingRollout(error))
+        return false;
+    if (error.code === -32602)
+        return true;
+    return /unknown field|unknown parameter|unexpected field|excludeTurns/i.test(error.message);
+}
 function delay(ms) {
     return new Promise((resolve) => {
         const timer = setTimeout(resolve, ms);

package/dist/adapters/types.d.ts

@@ -543,7 +543,45 @@ export type AgentEvent = {
      * all. Both still have to withdraw the feed cut and say what happened.
      */
     recovered?: boolean;
+    /**
+     * The agent PROCESS ended with this — it is not an error the running
+     * agent reported (#373).
+     *
+     * Set only where the adapter's own read loop broke, i.e. where the CLI
+     * exited under it. The supervisor needs the difference to tell the tail of
+     * a stop it asked for from a process that died on its own: closing a
+     * process during a pause produces an ending, and an ending must not read
+     * as a failure — while a process that fell over BEFORE we closed it has
+     * genuinely failed and must still say so.
+     *
+     * A flag rather than a sentence on purpose. The wording of these errors
+     * comes from the CLI and changes with it; «who ended this process» is a
+     * fact only the adapter knows.
+     */
+    processGone?: boolean;
 };
+/**
+ * What became of an interrupt request (#373).
+ *
+ * `interrupt()` used to answer `void`, so «the CLI took the stop» and «the
+ * control channel refused it» were the same event from the supervisor's side —
+ * and a refusal that arrived one line before a pause was filed as a clean
+ * cancellation. The three outcomes are what a stop coordinator has to tell
+ * apart to decide whether the process may be closed quietly.
+ */
+export type InterruptOutcome = 
+/** The CLI acknowledged the request. A result for the turn should follow. */
+'accepted'
+/**
+ * There is nothing to stop.
+ *
+ * Either no turn was running, or this session has already been closed — by us
+ * — and the control request went with it. Both mean the same thing to the
+ * caller: no result is coming, and nobody refused anything.
+ */
+ | 'idle'
+/** The control channel said no, or died answering. The turn may still run. */
+ | 'refused';
 export interface AgentSession {
     /** Ends when the underlying agent process is gone. */
     events: AsyncIterable<AgentEvent>;
@@ -615,8 +653,14 @@ export interface AgentSession {
          */
         gitPolicy?: AgentGitPolicy;
     }): void;
-    /** Interrupt the current turn (session stays resumable). */
-    interrupt(): Promise<void>;
+    /**
+     * Interrupt the current turn (session stays resumable).
+     *
+     * Answers what became of the request (#373). The supervisor closes the
+     * process itself after a pause, and «may I close it quietly» has a different
+     * answer for a stop the CLI took and one it refused.
+     */
+    interrupt(): Promise<InterruptOutcome>;
     /**
      * An opaque id naming the conversation as it stands RIGHT NOW (ticket #126).
      *

package/dist/stop-cycle.d.ts

@@ -0,0 +1,148 @@
+import type { AgentEvent, AgentSession, InterruptOutcome } from './adapters/types.js';
+/**
+ * One managed stop of one agent process (#373).
+ *
+ * The defect this exists for: stopping a turn used to be a boolean and a hope.
+ * The Claude adapter armed a single `aborting` flag, EVERY result read and
+ * cleared it, and the second result of the same stop therefore arrived looking
+ * like a failure — `turn_end{ok:false}` → `settleTurnStatus` → FAILED, which is
+ * terminal. A session that had merely run out of plan limit was buried with a
+ * live clock still ticking on it, and nothing would ever wake it again.
+ *
+ * A cycle is bound to ONE process instance and to one reason. Everything that
+ * arrives from that instance while the cycle runs — a late result, the tail of
+ * a tool the CLI had already started, the ending our own `close()` produces —
+ * belongs to the stop and is not news about the session's health. Everything
+ * from any OTHER instance (the process we start after the pause is lifted) is
+ * outside it, which is what keeps a real failure after a resume visible.
+ *
+ * Deliberately a small module of plain rules: the decisions below are the ones
+ * a mistake is expensive in, and they are worth being able to test without a
+ * supervisor, a fake CLI and a socket.
+ */
+/**
+ * How far the stop has got.
+ *
+ *  - `interrupting` — the request is out; the process is still ours to lose.
+ *  - `parking`      — the turn has ended (or will not end), and we are closing
+ *                     the process ourselves. From here on its noises are ours.
+ *  - `parked`       — the event stream ended. Nothing else can arrive.
+ */
+export type StopPhase = 'interrupting' | 'parking' | 'parked';
+/**
+ * Who asked.
+ *
+ * `user` keeps the old contract exactly: one Stop, one ending, and the NEXT
+ * genuine failure still reaches the person. `pause` is the one that closes the
+ * process and therefore has to own what closing it produces.
+ */
+export type StopReason = 'user' | 'pause';
+export interface StopCycle {
+    /** The adapter session this cycle stops. Identity only — never called. */
+    readonly session: AgentSession;
+    /**
+     * Who asked — and it can be RAISED while the stop is in flight.
+     *
+     * A clock landing on a Stop the person pressed a second earlier is the same
+     * stop, not a second one: the CLI has one outstanding interrupt and will
+     * answer it once. But it is now a PAUSE, and a pause closes the process and
+     * owns what closing it produces. Left as `user` the cycle would step aside at
+     * the first ending and the second result would file the session FAILED —
+     * the incident, reached through a door the fix did not cover.
+     */
+    reason: StopReason;
+    /**
+     * Which clock this stop belongs to, for the log.
+     *
+     * Deliberately NOT a guard: what decides whether two stops are the same one
+     * is the process instance, and «a clock lifted and set again» is already
+     * answered by the release dropping a cycle that closed nothing. The number is
+     * here so a line in journald can be tied to the pause that caused it —
+     * reading two stops in one session and not knowing whether they answered one
+     * clock or two is how the incident took a day to reconstruct.
+     */
+    readonly epoch: number;
+    phase: StopPhase;
+    /** The single interrupt round-trip. Every later request joins this one. */
+    inFlight: Promise<void> | null;
+    /** What the CLI said about the request, once it said anything. */
+    outcome: InterruptOutcome | null;
+    /** The control channel refused while the process was still running. */
+    refused: boolean;
+    /**
+     * We closed this process ourselves.
+     *
+     * The line invariant 7 is drawn on. Everything a process says after we have
+     * closed it is the closing; everything it says before is still news about the
+     * session. `phase` alone cannot answer this — a stop that is refused parking
+     * (an open permission card) reaches `parking` with the process untouched.
+     */
+    closed: boolean;
+    /** The one `turn_end` this cycle publishes has gone out. */
+    turnEndSent: boolean;
+    /**
+     * The stop has run its course.
+     *
+     * It still OWNS this process's endings — a late result after a refused park
+     * is exactly the incident's second result — but it no longer stands in the way
+     * of a new stop: a turn that starts minutes later, from inside a CLI nobody
+     * closed, has to be stoppable in its own right.
+     */
+    settled: boolean;
+    /** There was a turn to stop — so an ending is owed to the feed. */
+    readonly hadTurn: boolean;
+    /**
+     * Tool calls already in flight when the stop began.
+     *
+     * The reason the incident fired a SECOND interrupt: the result of the
+     * question this runner had just withdrawn came back as an ordinary tool
+     * event, and «the agent is producing output» could not tell it from a turn
+     * starting up. Ownership answers it — a result for one of these ids is the
+     * tail of the work being stopped, not new work.
+     */
+    readonly toolsAtStop: ReadonlySet<string>;
+    /** Waiting for the result that should follow an accepted interrupt. */
+    settleTimer?: ReturnType<typeof setTimeout>;
+}
+/** Is this cycle the one that owns `session`, and is it still live? */
+export declare function ownsProcess(cycle: StopCycle | undefined, session: AgentSession | null): boolean;
+/**
+ * What to do with a `turn_end` that arrived inside a stop cycle.
+ *
+ *  - `ordinary` — nothing special: a manual Stop keeps the contract it has had
+ *    since QA-120, including the rule that the next real failure is not hidden.
+ *  - `stopped`  — the one ending this cycle publishes: `ok`, `aborted`, and the
+ *    facts the turn actually carried.
+ *  - `tail`     — a second (or third) ending of a turn that has already been
+ *    closed out. The incident's `error_during_execution`, 1.2 s late.
+ */
+export declare function turnEndVerdict(cycle: StopCycle): 'ordinary' | 'stopped' | 'tail';
+/**
+ * What to do with an `error` that arrived inside a stop cycle.
+ *
+ * The one place the difference between «the process fell over» and «the process
+ * was closed» has to be paid attention to, and the only honest source for it is
+ * the adapter's own `processGone` — never the sentence in the message, which is
+ * written by the CLI and changes with it.
+ */
+export declare function errorVerdict(cycle: StopCycle, processGone: boolean): 'failure' | 'tail';
+/**
+ * Is this event work STARTING, rather than the tail of what is being stopped?
+ *
+ * Only a genuinely new turn deserves a second stop. A tool result belonging to
+ * a call that was already running when the stop began is the first stop still
+ * finishing — firing another interrupt at it is what gave the incident two
+ * interrupts, two `aborting` arms and one result too few to spend them.
+ */
+export declare function isNewWork(event: AgentEvent, cycle: StopCycle | undefined): boolean;
+/**
+ * Is this the result of a tool call that was already running when we stopped?
+ *
+ * The incident's `tool_result` at seq 832 was exactly this: the withdrawn
+ * question's own refusal, arriving three seconds after the stop. Kept apart
+ * from «a result we never saw start» rather than lumping every result together
+ * — the two say different things about the process, and the diagnostic log has
+ * to be able to say which one happened.
+ */
+export declare function isStoppedToolTail(cycle: StopCycle, event: AgentEvent): boolean;
+//# sourceMappingURL=stop-cycle.d.ts.map

package/dist/stop-cycle.js

@@ -0,0 +1,86 @@
+/** Is this cycle the one that owns `session`, and is it still live? */
+export function ownsProcess(cycle, session) {
+    return cycle !== undefined && session !== null && cycle.session === session;
+}
+/**
+ * What to do with a `turn_end` that arrived inside a stop cycle.
+ *
+ *  - `ordinary` — nothing special: a manual Stop keeps the contract it has had
+ *    since QA-120, including the rule that the next real failure is not hidden.
+ *  - `stopped`  — the one ending this cycle publishes: `ok`, `aborted`, and the
+ *    facts the turn actually carried.
+ *  - `tail`     — a second (or third) ending of a turn that has already been
+ *    closed out. The incident's `error_during_execution`, 1.2 s late.
+ */
+export function turnEndVerdict(cycle) {
+    if (cycle.reason === 'user')
+        return 'ordinary';
+    if (cycle.turnEndSent)
+        return 'tail';
+    return 'stopped';
+}
+/**
+ * What to do with an `error` that arrived inside a stop cycle.
+ *
+ * The one place the difference between «the process fell over» and «the process
+ * was closed» has to be paid attention to, and the only honest source for it is
+ * the adapter's own `processGone` — never the sentence in the message, which is
+ * written by the CLI and changes with it.
+ */
+export function errorVerdict(cycle, processGone) {
+    // A manual Stop does not close anything, so nothing here is ours.
+    if (cycle.reason === 'user')
+        return 'failure';
+    // We have not closed it: a process dying on its own is a real failure, and
+    // burying it under the pause would be the original defect wearing the fix's
+    // clothes. Everything else from a process we asked to stop is the stopping.
+    if (!cycle.closed)
+        return processGone ? 'failure' : 'tail';
+    // We closed it. Whatever it says on the way out is the closing.
+    return 'tail';
+}
+/**
+ * Is this event work STARTING, rather than the tail of what is being stopped?
+ *
+ * Only a genuinely new turn deserves a second stop. A tool result belonging to
+ * a call that was already running when the stop began is the first stop still
+ * finishing — firing another interrupt at it is what gave the incident two
+ * interrupts, two `aborting` arms and one result too few to spend them.
+ */
+export function isNewWork(event, cycle) {
+    if (event.type !== 'tool')
+        return true;
+    if (event.phase === 'use')
+        return true;
+    // A result is always the tail of something, and the only question is whose.
+    // The tail of a call that was ALREADY RUNNING when we stopped is the stop
+    // finishing — the incident's seq 832, which fired a second interrupt. A
+    // result for a call we did not see start, on a process we asked to stop, is
+    // the opposite: something began after the stop and has now finished.
+    //
+    // Without a cycle there is no ownership to read, and a result on its own is
+    // no evidence of a turn beginning — a turn begins with a call, a thought or a
+    // sentence. Excluding every result regardless of whose it is is what the plan
+    // forbids, and this is the distinction it asks for.
+    if (!cycle)
+        return false;
+    if (event.toolUseId === undefined)
+        return false;
+    return !cycle.toolsAtStop.has(event.toolUseId);
+}
+/**
+ * Is this the result of a tool call that was already running when we stopped?
+ *
+ * The incident's `tool_result` at seq 832 was exactly this: the withdrawn
+ * question's own refusal, arriving three seconds after the stop. Kept apart
+ * from «a result we never saw start» rather than lumping every result together
+ * — the two say different things about the process, and the diagnostic log has
+ * to be able to say which one happened.
+ */
+export function isStoppedToolTail(cycle, event) {
+    return (event.type === 'tool' &&
+        event.phase === 'result' &&
+        event.toolUseId !== undefined &&
+        cycle.toolsAtStop.has(event.toolUseId));
+}
+//# sourceMappingURL=stop-cycle.js.map