@aragon-agent/cli 0.6.4 → 0.6.7

package/dist/config/store.js

@@ -14,7 +14,7 @@ import { dirname } from 'node:path';
 import process from 'node:process';
 import { getConfigPath, getSessionsDir } from './app-paths.js';
 import { registerSecretsFrom } from '../logging/secret-registry.js';
-import { clampBashConfig, CONFIG_VERSION, DEFAULT_CONFIG, clampCompactionConfig, clampFastConfig, clampLogConfig, clampMaxTokens, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampUpdateConfig, isAutoToken, stripLegacyStateKeys, } from './schema.js';
+import { clampBashConfig, CONFIG_VERSION, DEFAULT_CONFIG, clampCompactionConfig, clampFastConfig, clampLogConfig, clampMaxTokens, clampRetryConfig, clampSkillsConfig, clampTeamConfig, clampTodoConfig, clampContextWindow, clampUpdateConfig, isAutoToken, stripLegacyStateKeys, } from './schema.js';
 /**
  * Normalize `maxTokens` for both directions of the config file.
  *
@@ -31,6 +31,22 @@ function normalizeMaxTokens(v) {
         return null;
     return clampMaxTokens(v) ?? null;
 }
+/**
+ * Normalize `contextWindow` for both directions of the config file.
+ *
+ * THE SAME TRI-STATE DISCIPLINE AS `maxTokens` ABOVE, and for the same reason:
+ * hardening only the read path leaves a bad value on disk that reverts on every
+ * launch and presents as "my setting won't stick". `null` is AUTO and survives
+ * untouched; `auto` / `0` / an empty string mean AUTO too; a number is clamped;
+ * anything else on a hand-edited file becomes AUTO rather than a silent default.
+ */
+function normalizeContextWindow(v) {
+    if (v === undefined)
+        return DEFAULT_CONFIG.contextWindow;
+    if (v === null || isAutoToken(v))
+        return null;
+    return clampContextWindow(v, null);
+}
 // Re-exported so the many existing importers of `store.js` keep working; the
 // definitions live in `app-paths.ts` because they are pure path arithmetic.
 export { getConfigPath, getSessionsDir };
@@ -114,6 +130,11 @@ export function loadPersistedConfig() {
         maxTokens: Object.prototype.hasOwnProperty.call(partial, 'maxTokens')
             ? normalizeMaxTokens(partial.maxTokens)
             : DEFAULT_CONFIG.maxTokens,
+        // Own-property aware for the reason its neighbour records: `null` is AUTO
+        // and a spread cannot tell it from an absent key.
+        contextWindow: Object.prototype.hasOwnProperty.call(partial, 'contextWindow')
+            ? normalizeContextWindow(partial.contextWindow)
+            : DEFAULT_CONFIG.contextWindow,
         apiKeys: { ...DEFAULT_CONFIG.apiKeys, ...(partial.apiKeys ?? {}) },
         // `skills` is the second nested object in this file and needs the same
         // treatment `apiKeys` gets — see the note on updatePersistedConfig below.
@@ -198,6 +219,11 @@ export function updatePersistedConfig(patch) {
         maxTokens: Object.prototype.hasOwnProperty.call(patch, 'maxTokens')
             ? normalizeMaxTokens(patch.maxTokens)
             : current.maxTokens,
+        // The write half of the same gate: without it `config set contextWindow
+        // 99999999` puts a number on disk that the read path silently rewrites.
+        contextWindow: Object.prototype.hasOwnProperty.call(patch, 'contextWindow')
+            ? normalizeContextWindow(patch.contextWindow)
+            : current.contextWindow,
         apiKeys: { ...current.apiKeys, ...(patch.apiKeys ?? {}) },
         skills: clampSkillsConfig({ ...current.skills, ...(patch.skills ?? {}) }),
         // Without this line, changing the log level from the settings screen would

package/dist/exec/events.d.ts

@@ -71,6 +71,43 @@ export interface ExecSystemInitEvent {
     permissionMode: ExecPermissionMode;
     tools: string[];
     resumed: boolean;
+    /**
+     * Capabilities of THIS build that a caller has to know about before using
+     * them. Optional so older consumers are unaffected, and additive so
+     * `EXEC_SCHEMA_VERSION` does not move (see the file header).
+     *
+     * `'interrupt'` means the stdin `{"type":"interrupt"}` frame really does run
+     * the full settle -> persist -> `result` sequence ON EVERY PLATFORM. Builds
+     * before that fix routed it through a self-directed SIGINT, which on Windows
+     * terminates the process outright with exit code 1 - no persistence, no
+     * `result`. A wrapper cannot tell the two apart by observation, and guessing
+     * wrong costs the user their conversation, so this build states it.
+     */
+    capabilities?: string[];
+    /**
+     * Absolute path of the session file THIS run reads and writes; `null` under
+     * `--no-save-session` (web-use-durable-control-and-tier-accountability W2).
+     *
+     * Optional and additive, so `EXEC_SCHEMA_VERSION` does not move (file header).
+     * Stamped by `buildInitEvent`, never set by a caller - the same discipline
+     * `capabilities` follows.
+     *
+     * ## Why a wrapper cannot work this out for itself
+     *
+     * Deriving it host-side means re-implementing `getSessionsDir()`
+     * (`envPaths('aragon-agent')` plus its environment override) in a second
+     * codebase that has no way to notice when this one changes. The failure mode
+     * of a drifted copy is a path that does not exist, which a wrapper reads as
+     * "that conversation is gone" - identical, on screen, to the session really
+     * being gone. The run that is writing the file is the only party that can say
+     * where it is without guessing.
+     *
+     * It is the id THIS RUN writes back under, not the string the caller typed:
+     * `--resume` accepts `<id|path>`, and `resumedSessionId()` decides what the
+     * file is actually called. A wrapper asking "can I reattach later" needs the
+     * latter.
+     */
+    sessionFile?: string | null;
 }
 export interface ExecUserEvent {
     type: 'user';
@@ -84,6 +121,22 @@ export interface ExecUserEvent {
      */
     source: 'caller' | 'todo_continue';
 }
+/** One caller input and its complete automatic follow-through chain. */
+export interface ExecTurnStateEvent {
+    type: 'turn_state';
+    sessionId: string;
+    requestSeq: number;
+    phase: 'started' | 'completed' | 'failed' | 'cancelled';
+}
+/** Semantic source progress; never includes model or tool content. */
+export interface ExecProgressEvent {
+    type: 'execution_progress';
+    sessionId: string;
+    requestSeq: number;
+    progressSeq: number;
+    phase: 'model' | 'thinking' | 'tool_arguments' | 'tool' | 'compaction' | 'retry';
+    retryDelayMs?: number;
+}
 export interface ExecTextDeltaEvent {
     type: 'text_delta';
     sessionId: string;
@@ -157,6 +210,57 @@ export interface ExecFastReviewEvent {
     model: string;
     text: string;
 }
+/**
+ * What the fast tier is ACTUALLY doing, as opposed to what it was configured to
+ * do (web-use-tier-cooperation-and-control-closure W2).
+ *
+ * ONE ADDITIVE EVENT TYPE, AND `EXEC_SCHEMA_VERSION` DOES NOT MOVE — the same
+ * rule `ExecCompactionEvent` states. A consumer that ignores event types it does
+ * not know is unaffected.
+ *
+ * THE PROBLEM IT SOLVES. `fast_review` only fires when a review produced TEXT,
+ * so every other outcome — a review that failed, a tier that switched itself off
+ * after three failures, a budget that ran out, a delegation that did or did not
+ * happen — was invisible to a wrapper. The single most likely and least
+ * self-diagnosable failure ("it runs but not one review card ever arrives") had
+ * no signal at all on this stream.
+ *
+ * IT IS A STATE EVENT, NOT A LOG LINE. It fires on `tier_changed` and on every
+ * `review_end`, which in a session with reviews is a handful per hundred turns.
+ */
+export interface ExecFastTierEvent {
+    type: 'fast_tier';
+    sessionId: string;
+    /** Taken from the runner's own turn counter — `tier_changed` carries none. */
+    turn: number;
+    /** The tier resolved AND the live switch is on. */
+    live: boolean;
+    /**
+     * The CLI switched the fast REVIEWS off by itself after three consecutive
+     * non-transient failures.
+     *
+     * ORTHOGONAL TO `live` AND NOT DERIVABLE FROM IT: the self-disable leaves
+     * `live` at `true`. A consumer reporting "the reviews stopped" MUST read this
+     * field; `live === false && reviews > 0` is a predicate that can never be true.
+     */
+    selfDisabled: boolean;
+    model: string;
+    sameAsMain: boolean;
+    reviews: number;
+    reviewBudget: number;
+    budgetReached: boolean;
+    /** Fast-tier children dispatched — the only evidence delegation is working. */
+    delegated: number;
+    inFlight: boolean;
+    /** Present only on the `review_end` branch. */
+    review?: {
+        index: number;
+        kind: 'ok' | 'advice' | 'empty' | 'failed' | 'dropped';
+        detail?: string;
+        durationMs: number;
+        injected: boolean;
+    };
+}
 /**
  * Context compaction (context-auto-compaction §4.6).
  *
@@ -251,7 +355,7 @@ export interface ExecResultEvent {
     todos: ExecTodoCounts | null;
     error: ExecErrorInfo | null;
 }
-export type ExecEvent = ExecSystemInitEvent | ExecUserEvent | ExecTextDeltaEvent | ExecThinkingEvent | ExecAssistantEvent | ExecToolCallEvent | ExecToolResultEvent | ExecTodoEvent | ExecTeamEvent | ExecFastReviewEvent | ExecCompactionEvent | ExecRetryEvent | ExecErrorEvent | ExecResultEvent;
+export type ExecEvent = ExecSystemInitEvent | ExecUserEvent | ExecTurnStateEvent | ExecProgressEvent | ExecTextDeltaEvent | ExecThinkingEvent | ExecAssistantEvent | ExecToolCallEvent | ExecToolResultEvent | ExecTodoEvent | ExecTeamEvent | ExecFastReviewEvent | ExecFastTierEvent | ExecCompactionEvent | ExecRetryEvent | ExecErrorEvent | ExecResultEvent;
 /** Everything `system/init` needs that the runner cannot derive for itself. */
 export interface ExecInitParams {
     sessionId: string;
@@ -266,7 +370,40 @@ export interface ExecInitParams {
     permissionMode: ExecPermissionMode;
     tools: string[];
     resumed: boolean;
+    /**
+     * Absolute path of the session file this run reads and writes; `null` under
+     * `--no-save-session`. See `ExecSystemInitEvent.sessionFile`.
+     */
+    sessionFile?: string | null;
 }
+/**
+ * What this build announces in `system/init`.
+ *
+ * Stamped by `buildInitEvent`, never by a caller - the same discipline as
+ * `schemaVersion`. A caller that could set it could claim a capability the
+ * binary does not have, which is precisely the mistake the field exists to
+ * prevent.
+ */
+/**
+ * APPEND ONLY, NEVER REORDER. Consumers use `includes()`, but the next one may
+ * not; inserting ahead of `'interrupt'` costs nothing and makes a diff look
+ * bigger than it is.
+ *
+ *  · `'interrupt'`         — `{"type":"interrupt"}` on stdin settles the turn
+ *                            without killing the process.
+ *  · `'fast-policy'`       — this build understands `--fast-delegate` and
+ *                            `--fast-review`. FOR AFTER-THE-FACT DISPLAY ONLY:
+ *                            argv is fixed before `system/init` arrives, so it
+ *                            cannot gate whether the flags are passed.
+ *  · `'fast-tier-events'`  — this build emits `fast_tier`. Its ABSENCE is what
+ *                            lets a wrapper say "this CLI does not report" and
+ *                            not "the fast tier did nothing" — two very
+ *                            different sentences to a user.
+ *  · `'session-file'`      — `system/init` carries `sessionFile`, so a wrapper
+ *                            can check on disk whether a stopped conversation
+ *                            is still resumable instead of guessing the path.
+ */
+export declare const EXEC_CAPABILITIES: readonly string[];
 export declare function buildInitEvent(params: ExecInitParams): ExecSystemInitEvent;
 /** Everything `result` needs. `schemaVersion` is stamped here, never by a caller. */
 export type ExecResultParams = Omit<ExecResultEvent, 'type' | 'schemaVersion'>;

package/dist/exec/events.js

@@ -19,6 +19,41 @@
  * additive change and every wrapper would pin an exact number forever.
  */
 export const EXEC_SCHEMA_VERSION = 1;
+/**
+ * What this build announces in `system/init`.
+ *
+ * Stamped by `buildInitEvent`, never by a caller - the same discipline as
+ * `schemaVersion`. A caller that could set it could claim a capability the
+ * binary does not have, which is precisely the mistake the field exists to
+ * prevent.
+ */
+/**
+ * APPEND ONLY, NEVER REORDER. Consumers use `includes()`, but the next one may
+ * not; inserting ahead of `'interrupt'` costs nothing and makes a diff look
+ * bigger than it is.
+ *
+ *  · `'interrupt'`         — `{"type":"interrupt"}` on stdin settles the turn
+ *                            without killing the process.
+ *  · `'fast-policy'`       — this build understands `--fast-delegate` and
+ *                            `--fast-review`. FOR AFTER-THE-FACT DISPLAY ONLY:
+ *                            argv is fixed before `system/init` arrives, so it
+ *                            cannot gate whether the flags are passed.
+ *  · `'fast-tier-events'`  — this build emits `fast_tier`. Its ABSENCE is what
+ *                            lets a wrapper say "this CLI does not report" and
+ *                            not "the fast tier did nothing" — two very
+ *                            different sentences to a user.
+ *  · `'session-file'`      — `system/init` carries `sessionFile`, so a wrapper
+ *                            can check on disk whether a stopped conversation
+ *                            is still resumable instead of guessing the path.
+ */
+export const EXEC_CAPABILITIES = [
+    'interrupt',
+    'fast-policy',
+    'fast-tier-events',
+    'session-file',
+    'turn-lifecycle',
+    'execution-progress',
+];
 export function buildInitEvent(params) {
     return {
         type: 'system',
@@ -32,6 +67,13 @@ export function buildInitEvent(params) {
         permissionMode: params.permissionMode,
         tools: params.tools,
         resumed: params.resumed,
+        capabilities: [...EXEC_CAPABILITIES],
+        // `?? null` rather than a conditional spread: the field's contract is
+        // three-valued for a CONSUMER (`undefined` = an old build that cannot say,
+        // `null` = this run saves nothing, a string = here it is), and omitting it
+        // when a caller passed nothing would make this build indistinguishable from
+        // one that predates the field.
+        sessionFile: params.sessionFile ?? null,
     };
 }
 export function buildResultEvent(params) {

package/dist/exec/index.js

@@ -58,7 +58,18 @@ export async function runExec(flags, raw, promptArg, ctx) {
     const plan = planSession(options, cwd, err);
     if (!plan)
         return 2;
-    const prompts = resolvePromptSource(options, promptArg, ctx, err);
+    /**
+     * Late-bound interrupt hook (see `resolvePromptSource` and `execute`).
+     *
+     * The stdin stream is built - and already reading - about eighty lines before
+     * the runner exists, so the frame handler cannot close over the runner
+     * directly. The box starts as a no-op and is filled in AFTER
+     * `runner.attach(controller)`; during that gap an interrupt does nothing at
+     * all, which is the honest outcome (the user simply presses it again). See
+     * `execute` for why "does nothing" beats "does half of it".
+     */
+    const interrupt = { fire: () => { } };
+    const prompts = resolvePromptSource(options, promptArg, ctx, err, interrupt);
     if (!prompts)
         return 2;
     const lock = plan.saving ? tryAcquireSessionLock(plan.id) : null;
@@ -68,14 +79,14 @@ export async function runExec(flags, raw, promptArg, ctx) {
         return 2;
     }
     try {
-        return await execute({ flags, options, plan, prompts, ctx, out, err, now, appended });
+        return await execute({ flags, options, plan, prompts, ctx, out, err, now, appended, interrupt });
     }
     finally {
         lock?.release();
     }
 }
 async function execute(input) {
-    const { options, plan, ctx, out, err, now } = input;
+    const { options, plan, ctx, out, err, now, interrupt } = input;
     const startedAt = now();
     const permission = resolvePermission({
         mode: options.permissionMode,
@@ -117,8 +128,29 @@ async function execute(input) {
         permissionMode: options.permissionMode,
         tools: controller.listTools().map((t) => t.name),
         resumed: plan.saved !== null,
+        // W2 - where this run's conversation lives, so a wrapper can check on disk
+        // whether it is still resumable rather than re-deriving the sessions dir.
+        //
+        // `plan.id`, NEVER `options.resume`. The flag accepts `<id|path>`, and
+        // `planSession` runs the caller's string through `resumedSessionId()` to
+        // decide what the file is actually named - so "the file the caller pointed
+        // at" and "the file this run writes" are routinely two different paths. The
+        // question a wrapper is asking ("what can I reattach to next time") is
+        // answered by the second one.
+        //
+        // `!plan.saving` is `--no-save-session`: nothing is written, so there will
+        // be nothing to reattach to, and `null` says that outright.
+        sessionFile: plan.saving ? sessionPathFor(plan.id) : null,
     });
     runner.attach(controller);
+    // AFTER `attach`, never before. The terminator closure ends on
+    // `this.controller?.abort()`, so before `attach` the controller is still
+    // `undefined` and that last statement is a silent no-op - while the SAME
+    // closure has already written `lastSignalAt` and `stopReason = 'interrupted'`.
+    // A real interrupt arriving within the next two seconds would then be judged a
+    // SECOND signal and take `signals.exit(128 + signo)`: a hard exit, no persist,
+    // no `result` - exactly the outcome the caller was trying to avoid.
+    interrupt.fire = () => runner.requestInterrupt();
     const pre = controller.preflight();
     if (!pre.ok) {
         runner.detach();
@@ -261,7 +293,7 @@ function failedResult(sessionId, config, message, code, durationMs) {
  * Returns `null` after writing the reason to stderr, so the caller can exit 2
  * without a second error vocabulary.
  */
-function resolvePromptSource(options, promptArg, ctx, err) {
+function resolvePromptSource(options, promptArg, ctx, err, interrupt) {
     const stdin = ctx.stdin ?? process.stdin;
     const opening = [];
     const positional = promptArg?.trim();
@@ -282,8 +314,13 @@ function resolvePromptSource(options, promptArg, ctx, err) {
             // line is skipped either way, which is the property AC-20 pins.
             onBadLine: (message) => err.write(`${message}\n`),
             // The runner installs the signal terminator; a caller-requested
-            // interrupt is the same intent arriving through a different channel.
-            onInterrupt: () => process.kill(process.pid, 'SIGINT'),
+            // interrupt is the same intent arriving through a different channel -
+            // so it now calls the runner DIRECTLY rather than raising a signal at
+            // ourselves. `process.kill(process.pid, 'SIGINT')` does not reach this
+            // process's own handlers on Windows: it terminates with exit code 1,
+            // skipping the settle path, `persist()` and the `result` event. See
+            // `ExecRunner.requestInterrupt`.
+            onInterrupt: () => interrupt.fire(),
         }));
     }
     if (opening.length === 0 && !stdinIsTty(stdin)) {

package/dist/exec/progress-reporter.d.ts

@@ -0,0 +1,23 @@
+import type { ExecProgressEvent } from './events.js';
+/** Request-scoped, one-shot aggregation of real semantic events. */
+export declare class ExecProgressReporter {
+    private readonly sessionId;
+    private readonly emit;
+    private readonly now;
+    private requestSeq;
+    private progressSeq;
+    private sentSeq;
+    private phase;
+    private retryDelayMs;
+    private lastSentAt;
+    private timer;
+    private enabled;
+    constructor(sessionId: string, emit: (event: ExecProgressEvent) => void, now?: () => number);
+    begin(requestSeq: number): void;
+    /** Called only after the started event has reached the emitter. */
+    started(requestSeq: number): void;
+    record(phase: ExecProgressEvent['phase'], retryDelayMs?: number): void;
+    flush(): void;
+    finish(requestSeq: number): void;
+    dispose(): void;
+}

package/dist/exec/progress-reporter.js

@@ -0,0 +1,88 @@
+const PROGRESS_INTERVAL_MS = 1_000;
+/** Request-scoped, one-shot aggregation of real semantic events. */
+export class ExecProgressReporter {
+    sessionId;
+    emit;
+    now;
+    requestSeq = null;
+    progressSeq = 0;
+    sentSeq = 0;
+    phase = 'model';
+    retryDelayMs;
+    lastSentAt = -Infinity;
+    timer = null;
+    enabled = false;
+    constructor(sessionId, emit, now = () => performance.now()) {
+        this.sessionId = sessionId;
+        this.emit = emit;
+        this.now = now;
+    }
+    begin(requestSeq) {
+        this.dispose();
+        this.requestSeq = requestSeq;
+        this.progressSeq = 0;
+        this.sentSeq = 0;
+        this.phase = 'model';
+        this.retryDelayMs = undefined;
+        this.lastSentAt = -Infinity;
+    }
+    /** Called only after the started event has reached the emitter. */
+    started(requestSeq) {
+        if (this.requestSeq === requestSeq)
+            this.enabled = true;
+    }
+    record(phase, retryDelayMs) {
+        if (!this.enabled || this.requestSeq === null)
+            return;
+        const changed = phase !== this.phase;
+        if (changed)
+            this.flush();
+        this.phase = phase;
+        this.retryDelayMs = phase === 'retry' && Number.isFinite(retryDelayMs)
+            ? Math.min(120_000, Math.max(0, retryDelayMs)) : undefined;
+        this.progressSeq += 1;
+        if (changed || this.now() - this.lastSentAt >= PROGRESS_INTERVAL_MS) {
+            this.flush();
+        }
+        else if (!this.timer) {
+            const requestSeq = this.requestSeq;
+            this.timer = setTimeout(() => {
+                this.timer = null;
+                if (this.requestSeq === requestSeq && this.enabled)
+                    this.flush();
+            }, Math.max(0, PROGRESS_INTERVAL_MS - (this.now() - this.lastSentAt)));
+            this.timer.unref?.();
+        }
+    }
+    flush() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        if (!this.enabled || this.requestSeq === null || this.sentSeq === this.progressSeq)
+            return;
+        this.sentSeq = this.progressSeq;
+        this.lastSentAt = this.now();
+        this.emit({
+            type: 'execution_progress', sessionId: this.sessionId,
+            requestSeq: this.requestSeq, progressSeq: this.progressSeq, phase: this.phase,
+            ...(this.retryDelayMs !== undefined ? { retryDelayMs: this.retryDelayMs } : {}),
+        });
+    }
+    finish(requestSeq) {
+        if (this.requestSeq !== requestSeq)
+            return;
+        try {
+            this.flush();
+        }
+        finally {
+            this.dispose();
+        }
+    }
+    dispose() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.requestSeq = null;
+        this.enabled = false;
+    }
+}

package/dist/exec/runner.d.ts

@@ -18,6 +18,7 @@ import type { TokenUsage } from '@aragon-agent/core';
 import type { HeadlessController } from '../agent/headless.js';
 import { type FollowThroughMode } from '../todo/follow-through.js';
 import type { ExecEmitter } from './emitter.js';
+import type { FastSnapshot } from '../fast/types.js';
 import type { ExecStopReason } from './events.js';
 /**
  * The controller surface the runner needs.
@@ -34,6 +35,16 @@ export interface ExecRunnerController extends HeadlessController {
         providerId: string;
         modelId: string;
     }): boolean;
+    /**
+     * The fast tier's current snapshot, or `null` when this session has no tier
+     * (web-use-tier-cooperation-and-control-closure §4.2.1).
+     *
+     * OPTIONAL, for the identical reason `subscribeFast` is: this interface is
+     * minimal so a test can satisfy it with an object literal, and a controller
+     * with no tier has nothing to report. Called with `?.()`, so a stub that omits
+     * it simply emits no `fast_tier` events.
+     */
+    fastSnapshot?(): FastSnapshot | null;
 }
 /** Where the caller's messages come from. One turn, or an NDJSON stdin stream. */
 export interface ExecPromptSource {
@@ -77,6 +88,7 @@ export declare class ExecRunner {
     private readonly opts;
     private readonly signals;
     private readonly now;
+    private readonly progress;
     private controller;
     private unsubscribers;
     private turns;
@@ -131,6 +143,9 @@ export declare class ExecRunner {
      * the two faces cannot drift about what "unfinished" means.
      */
     run(source: ExecPromptSource): Promise<void>;
+    private requestSeq;
+    private requestHadError;
+    private isRequestCancelled;
     /** One caller message plus every auto-continuation it produces. */
     private runFollowThroughChain;
     /**
@@ -192,6 +207,25 @@ export declare class ExecRunner {
      * this and add the getter.
      */
     private installTerminator;
+    /**
+     * Exactly synonymous with a SIGINT, only it does not travel through a signal.
+     *
+     * The stdin `{"type":"interrupt"}` frame routes here. It used to route through
+     * `process.kill(process.pid, 'SIGINT')`, which is fine on POSIX and WRONG on
+     * Windows: Node does not deliver a self-directed SIGINT to its own handlers
+     * there, so the process terminates with exit code 1 having run neither the
+     * terminator below, nor the settle path, nor `persist()`, nor the `result`
+     * event. A wrapper that interrupts a turn and respawns on the same
+     * `--session-id` would silently get a conversation missing everything since the
+     * last save - and `exec/index.ts` was already designed for exactly that caller
+     * ("PERSIST FIRST, ANNOUNCE SECOND").
+     *
+     * POSIX behaviour is byte-for-byte unchanged: the same closure runs, with
+     * `signalNumber = 2`, `exitCode() = 130`, and the two-second second-signal
+     * escape hatch intact.
+     */
+    requestInterrupt(): void;
+    private onSignal;
     private emit;
     /** Caller-facing prose. STDERR ALWAYS - stdout carries nothing but the schema. */
     private note;