@pugi/cli 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/core/engine/native-pugi.js

@@ -241,6 +241,9 @@ export class NativePugiEngineAdapter {
         for (const event of buffer)
             yield event;
         // Translate the loop outcome into an EngineResult.
+        // `aborted` (α6.9: operator cancelled mid-tool) maps to `blocked`
+        // because the operator chose the outcome, same shape as
+        // budget_exhausted / tool_refused.
         const status = outcome.status === 'completed'
             ? 'done'
             : outcome.status === 'failed'
@@ -252,7 +255,9 @@ export class NativePugiEngineAdapter {
                 ? '[budget_exhausted] '
                 : outcome.status === 'tool_refused'
                     ? '[plan_mode_refused] '
-                    : '[failed] ';
+                    : outcome.status === 'aborted'
+                        ? '[operator_aborted] '
+                        : '[failed] ';
         const filesChangedList = Array.from(filesChanged).sort();
         appendSessionMirror(sessionEventsPath, {
             type: 'outcome',

package/dist/core/engine/tool-bridge.js

@@ -1,4 +1,4 @@
-import { editTool, globTool, grepTool, readTool, writeTool, } from '../../tools/file-tools.js';
+import { editTool, globTool, grepTool, OperatorAbortedError, readTool, writeTool, } from '../../tools/file-tools.js';
 import { bashToolSync } from '../../tools/bash.js';
 /**
  * Tool-bridge: turns the abstract tool registry into:
@@ -147,6 +147,14 @@ export function buildExecutor(input) {
             // outcome, not a failure, because plan mode is doing its job.
             throw new Error(`PLAN_MODE_REFUSED: ${name} is not allowed in plan mode`);
         }
+        // α6.9: refuse cancelled-token tool dispatch BEFORE PreToolUse
+        // hooks fire so a cancelled brief never reaches user-defined
+        // hook scripts. Sentinel `OPERATOR_ABORTED:<tool>` is recognised
+        // by `runEngineLoop` as a terminal-cancel signal so the loop
+        // returns control to the caller rather than retrying the model.
+        if (ctx.cancellation && ctx.cancellation.isAborted) {
+            throw new Error(`OPERATOR_ABORTED: ${name} refused — operator cancelled the dispatch.`);
+        }
         // Fire PreToolUse hooks. The match grammar takes the tool name and
         // (when extractable) the target path. Each new tool dispatch starts a
         // fresh dedup batch so a hook fires once per dispatch, not once per
@@ -194,6 +202,30 @@ export function buildExecutor(input) {
             return result;
         }
         catch (error) {
+            // α6.9: re-shape OperatorAbortedError throws from the
+            // file-tools layer into the same `OPERATOR_ABORTED:` sentinel
+            // the upstream cancellation gate uses so `runEngineLoop` sees
+            // a consistent terminal-cancel signal regardless of whether
+            // the abort landed pre-dispatch or mid-tool (e.g. inside the
+            // grep file-loop).
+            if (error instanceof OperatorAbortedError) {
+                if (hooks && sessionId) {
+                    const path = extractToolPath(name, argsRaw);
+                    await hooks.fire({
+                        sessionId,
+                        event: 'PostToolUseFailure',
+                        tool: name,
+                        path,
+                        payload: {
+                            tool: name,
+                            arguments: argsRaw,
+                            ok: false,
+                            error: `OPERATOR_ABORTED: ${name}`,
+                        },
+                    });
+                }
+                throw new Error(`OPERATOR_ABORTED: ${name} aborted mid-execution.`);
+            }
             if (hooks && sessionId) {
                 const path = extractToolPath(name, argsRaw);
                 await hooks.fire({

package/dist/core/repl/dispatch-fsm.js

@@ -133,7 +133,7 @@ export class DispatchFSM {
      * listener still fires.
      *
      * Re-entrant calls (a listener calls `transition()` again) are
-     * queued — the inner transition runs after the outer listener drain
+     * queued - the inner transition runs after the outer listener drain
      * completes, in FIFO order. See `firing` field comment.
      */
     transition(next, reason) {
@@ -143,12 +143,28 @@ export class DispatchFSM {
         }
         this.firing = true;
         try {
-            this.commit(next, reason);
-            while (this.pending.length > 0) {
-                const queued = this.pending.shift();
-                if (!queued)
-                    break;
-                this.commit(queued.next, queued.reason);
+            // R2 P2 fix (Codex triple-review 2026-05-25): if `commit` throws -
+            // either the first move or any queued nested move - we MUST flush
+            // the pending queue before propagating the error. Otherwise a
+            // later `transition()` call would drain stale entries left over
+            // from the failed turn, firing onEnter listeners under a wholly
+            // different state context. The queue is "poisoned" the moment any
+            // entry throws; the safest move is to drop the rest and surface
+            // the failure to the caller.
+            try {
+                this.commit(next, reason);
+                while (this.pending.length > 0) {
+                    const queued = this.pending.shift();
+                    if (!queued)
+                        break;
+                    this.commit(queued.next, queued.reason);
+                }
+            }
+            catch (err) {
+                // Drop every still-queued entry so the next external transition
+                // starts on a clean queue. See the inline rationale above.
+                this.pending.length = 0;
+                throw err;
             }
         }
         finally {
@@ -156,7 +172,7 @@ export class DispatchFSM {
         }
     }
     /**
-     * Inner commit step — legality check + state mutation + listener
+     * Inner commit step - legality check + state mutation + listener
      * drain. Called by `transition()` directly for the first move and
      * for every queued nested move thereafter. Errors propagate to the
      * outer `transition()` caller (illegal transitions still throw).

package/dist/core/repl/session.js

@@ -37,6 +37,8 @@ import { getJobRegistry } from '../jobs/registry.js';
 import { extractAskTags, extractPlanReviewTags, signatureForAsk, } from './ask.js';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
+import { CancellationToken } from './cancellation.js';
+import { DispatchFSM } from './dispatch-fsm.js';
 const MAX_TRANSCRIPT_ROWS = 500;
 const MAX_TOOL_CALLS = 200;
 const MAX_RECONNECT_ATTEMPTS = 10;
@@ -220,6 +222,67 @@ export class ReplSession {
      * complete envelope lands OR the turn ends. (α6.3.)
      */
     askBuffer = new Map();
+    /**
+     * α6.9 dispatch FSM. One instance owned by the session; transitions
+     * are mirrored into `state.dispatchState` via an onEnter listener so
+     * subscribers see every change. Resets to `idle` after a terminal
+     * transition (`completed` / `failed` / `aborted`) so the next brief
+     * starts clean. Idle is the start state.
+     */
+    // Not readonly: resetFsmToIdle swaps the instance in place on the
+    // next brief after a terminal transition (the FSM does not allow
+    // direct `completed -> awaiting_response`, so we mint a fresh
+    // machine). External read-only access stays via `getDispatchState()`
+    // accessor - callers cannot reach into this private field.
+    fsm = new DispatchFSM();
+    /**
+     * α6.9 cancellation token for the currently in-flight dispatch.
+     * Minted on `dispatchBrief()` and released on terminal transitions.
+     * When non-null, calling `cancel()` aborts the token, closes the SSE
+     * stream, and transitions the FSM to `aborting` → `aborted`.
+     *
+     * Null when `dispatchState === 'idle'` — no dispatch to cancel.
+     */
+    currentDispatchToken = null;
+    /**
+     * R2 P1 fix (Codex triple-review 2026-05-25): monotonic dispatch
+     * sequence id. Incremented on every `dispatchBrief()`. The
+     * agent.spawned handler stamps the current value into
+     * `taskDispatchSeq[event.taskId]`. Terminal handlers
+     * (agent.completed / blocked / failed) check the stamped value
+     * against `dispatchSeq` and short-circuit if the event belongs to
+     * a SUPERSEDED dispatch. Without this gate a stale terminal event
+     * from a prior dispatch would drive the new FSM to terminal and
+     * null the new dispatch's token, leaving brief #2 uncancellable.
+     */
+    dispatchSeq = 0;
+    /**
+     * Per-task dispatch-sequence stamp. Populated on agent.spawned with
+     * the live `dispatchSeq` value. Consulted by terminal handlers to
+     * decide whether the event belongs to the current dispatch (seq
+     * matches) or a superseded one (seq is stale). Entries are NOT
+     * removed on terminal events because a late event from the same
+     * task should still be classified correctly; the map is small
+     * (one entry per spawned subagent in the session lifetime) and
+     * cleared on close().
+     */
+    taskDispatchSeq = new Map();
+    /**
+     * R3 P1 fix (Codex triple-review 2026-05-25): wall-clock guard used to
+     * drop SSE events whose `event.timestamp` predates the current
+     * dispatch. The R2 seq gate alone fails when a LATE `agent.spawned`
+     * from brief #1 arrives AFTER brief #2 mints a new dispatch token:
+     * the late spawn would stamp the OLD taskId with the NEW dispatchSeq
+     * (because `this.dispatchSeq` already advanced), so any subsequent
+     * terminal event for that task would look like it belongs to the new
+     * dispatch and would null the new token.
+     *
+     * Recorded inside `dispatchBrief()` BEFORE bumping `dispatchSeq`, so
+     * any event with `event.timestamp` strictly before this value is
+     * guaranteed to belong to a superseded dispatch and is dropped silently.
+     * Zero means "no dispatch has started yet" and disables the gate.
+     */
+    currentDispatchStartTime = 0;
     /**
      * Tracks taskIds that had an `<pugi-ask>` or `<pugi-plan-review>`
      * envelope mid-stream the last time the parser ran on the buffer. If
@@ -257,7 +320,20 @@ export class ReplSession {
             pendingAskSource: null,
             pendingPlanReview: null,
             pendingPlanReviewSource: null,
+            dispatchState: 'idle',
+            dispatchToolLabel: null,
         };
+        // α6.9: mirror every FSM transition into the public state so the
+        // status-bar surface can rerender on the next frame. Local listener
+        // is intentionally cheap — just a patch + clear the per-state tool
+        // label when leaving `tool_running`.
+        this.fsm.onEnter('idle', () => this.patch({ dispatchState: 'idle', dispatchToolLabel: null }));
+        this.fsm.onEnter('awaiting_response', () => this.patch({ dispatchState: 'awaiting_response', dispatchToolLabel: null }));
+        this.fsm.onEnter('tool_running', () => this.patch({ dispatchState: 'tool_running' }));
+        this.fsm.onEnter('aborting', () => this.patch({ dispatchState: 'aborting', dispatchToolLabel: null }));
+        this.fsm.onEnter('aborted', () => this.patch({ dispatchState: 'aborted', dispatchToolLabel: null }));
+        this.fsm.onEnter('completed', () => this.patch({ dispatchState: 'completed', dispatchToolLabel: null }));
+        this.fsm.onEnter('failed', () => this.patch({ dispatchState: 'failed', dispatchToolLabel: null }));
     }
     /* ------------- subscribe / state -------------- */
     subscribe(callback) {
@@ -344,6 +420,14 @@ export class ReplSession {
      */
     close() {
         this.closed = true;
+        // α6.9: fire the cancellation token before tearing down the stream
+        // so any in-flight tool sees the abort signal AND any pending
+        // PostBrief promise can short-circuit. Idempotent — token.abort()
+        // is a no-op when already aborted.
+        if (this.currentDispatchToken) {
+            this.currentDispatchToken.abort();
+            this.currentDispatchToken = null;
+        }
         if (this.streamHandle) {
             this.streamHandle.close();
             this.streamHandle = undefined;
@@ -352,6 +436,11 @@ export class ReplSession {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = undefined;
         }
+        // R2 P1: drop the per-task seq stamps on close(). The map is
+        // small but clearing prevents accidental seq-comparison drift if
+        // a resurrected session reuses taskIds (admin-api currently mints
+        // unique ids, but the gate stays robust on either contract).
+        this.taskDispatchSeq.clear();
         // Detach watcher listeners so any chokidar event landing between
         // session.close() and the bootstrap-owned watcher.close() does NOT
         // run a handler on a dead session. The handlers themselves also
@@ -363,6 +452,101 @@ export class ReplSession {
             this.watcher.off('capExceeded', this.filewatchCapHandler);
         }
     }
+    /* ------------- α6.9 cancellation surface -------------- */
+    /**
+     * Operator-driven abort for the in-flight dispatch. Idempotent — a
+     * second call while already in `aborting` / `aborted` is a no-op.
+     *
+     * Steps (in order):
+     *
+     *   1. Snapshot the current state. If terminal or idle, no-op.
+     *   2. Transition the FSM to `aborting` so the bottom-bar shows the
+     *      pending shutdown immediately (the operator gets feedback
+     *      before any IO completes).
+     *   3. Abort the cancellation token. This fans out to every listener
+     *      that was attached during the dispatch — chiefly the SSE
+     *      stream wrapper (which calls `streamHandle.close()`) and any
+     *      mid-flight tool executor that polled `isAborted`.
+     *   4. Append a system line so the conversation reads "Aborted." at
+     *      the operator's last input position.
+     *   5. Transition to `aborted` (terminal). The next operator brief
+     *      mints a fresh token + transitions back to
+     *      `awaiting_response`.
+     *
+     * Returns `true` when an abort was actually issued (state was
+     * non-terminal + non-idle), `false` otherwise.
+     */
+    cancel() {
+        const current = this.fsm.current;
+        if (this.fsm.isTerminal || current === 'idle')
+            return false;
+        // Step 2: transient state (UI sees `aborting` between abort signal
+        // and full shutdown).
+        this.fsm.transition('aborting', 'operator_abort');
+        // Step 3: fire the token so any mid-flight tool executor that
+        // polled `isAborted` shuts down. Token is single-use — clear the
+        // ref AFTER both the abort fan-out AND the stream teardown so any
+        // onAbort listener calling getCurrentDispatchToken() during the
+        // teardown observes the (now-aborted) token rather than null.
+        // Contract: listeners fire first, stream closes second, token
+        // field nulls third. (P2 cancel-ordering fix.)
+        const token = this.currentDispatchToken;
+        if (token) {
+            token.abort();
+        }
+        // Step 3b: tear down the SSE stream so no further `agent.step`
+        // events update the agent tree under the aborted dispatch. The
+        // stream reopens on the NEXT brief via `openStream()` (driven by
+        // dispatchBrief's reset-to-idle path). The session id stays valid
+        // server-side; admin-api keeps the dispatch around for forensic
+        // replay but the client stops listening.
+        if (this.streamHandle) {
+            this.streamHandle.close();
+            this.streamHandle = undefined;
+        }
+        // P2 Codex: clear the SSE cursor on deliberate cancel. The
+        // admin-api Last-Event-ID replay would otherwise re-feed any
+        // buffered events from the cancelled dispatch into the next
+        // brief's stream, polluting the agent tree with ghosts of the
+        // aborted turn. The new brief mints a fresh server-side cursor
+        // anyway, so `undefined` is the correct subscribe arg.
+        this.lastEventId = undefined;
+        // Null the token AFTER stream teardown (see step 3 comment).
+        this.currentDispatchToken = null;
+        // Mark any agents that are still "running" as failed/aborted so
+        // the agent-tree pane reflects reality. We use the existing
+        // `failed` status (the tree pane already knows how to render it)
+        // with a clear detail string so the operator sees WHY.
+        this.patch({
+            agents: this.state.agents.map((a) => a.status === 'queued' || a.status === 'thinking'
+                ? { ...a, status: 'failed', detail: 'aborted by operator' }
+                : a),
+        });
+        // Step 4: visible operator-facing confirmation. Brand voice gate:
+        // single ASCII line, no em-dashes, no emoji.
+        this.appendSystemLine('Aborted.');
+        // Step 5: terminal transition. The FSM will accept a fresh
+        // dispatch on the next brief.
+        this.fsm.transition('aborted', 'operator_abort');
+        // Clear briefStartedAtEpochMs so the status-bar clock resets.
+        this.patch({ briefStartedAtEpochMs: undefined });
+        return true;
+    }
+    /**
+     * Current FSM state. Surfaced for the REPL UI to read on first paint
+     * (subscribe + initial state are decoupled).
+     */
+    getDispatchState() {
+        return this.fsm.current;
+    }
+    /**
+     * Current cancellation token. Returned for the tool execution path
+     * (file-tools.ts) so it can pass the token down into a ToolContext
+     * extension. Null when no dispatch is in flight.
+     */
+    getCurrentDispatchToken() {
+        return this.currentDispatchToken;
+    }
     /* ------------- input handling -------------- */
     /**
      * Run one line of operator input through the slash command parser
@@ -953,6 +1137,92 @@ export class ReplSession {
         }
         this.appendOperatorLine(brief);
         this.patch({ briefStartedAtEpochMs: this.now() });
+        // α6.9 + R3 P1 (Codex triple-review 2026-05-25): supersede the
+        // prior dispatch when one is in flight. Steps in order:
+        //
+        //   1. Abort the old CancellationToken so any in-flight tool
+        //      holding `ctx.cancellation` sees `isAborted = true` and bails
+        //      (the R2 fix; preserves the file-tools cancellation gate).
+        //   2. Drive the OLD FSM through `aborting -> aborted` terminal.
+        //      This is load-bearing for the R3 race: a LATE event arriving
+        //      on the old FSM (`agent.spawned`, `agent.step`, terminal,
+        //      etc.) before the timestamp gate trips would otherwise still
+        //      attempt to transition the new FSM. Driving the old FSM to a
+        //      terminal state means the FSM check in
+        //      `advanceFsmOnDispatchEnd` (`isTerminal`) short-circuits as a
+        //      defense-in-depth layer.
+        //   3. `resetFsmToIdle()` mints a fresh FSM so the new dispatch
+        //      starts clean. The FSM legal-transition matrix forbids
+        //      `aborted -> awaiting_response`, so the reset is required.
+        //   4. Record `currentDispatchStartTime` BEFORE bumping
+        //      `dispatchSeq` + clearing `taskDispatchSeq`. The timestamp
+        //      gate in `handleServerEvent` checks
+        //      `event.timestamp < currentDispatchStartTime` to drop late
+        //      events from any superseded dispatch (including the late
+        //      `agent.spawned` that the R2 seq gate could not catch).
+        //   5. Clear `taskDispatchSeq` so any stamp left over from the old
+        //      dispatch cannot influence seq comparisons for the new turn.
+        //   6. Bump `dispatchSeq` and mint a fresh `CancellationToken`.
+        //
+        // If no prior dispatch is in flight (clean idle / terminal entry),
+        // the supersede block is skipped; we only reset the FSM if it sits
+        // in a terminal state from the prior turn.
+        if (this.currentDispatchToken) {
+            // Step 1: abort the old token. Listeners (including the
+            // file-tools cancellation gate) fan out before we replace the
+            // field below.
+            this.currentDispatchToken.abort();
+            // Step 2: walk the old FSM to terminal. Guard against an FSM
+            // that already sits in `aborting` or a terminal state - the
+            // legal-transition matrix forbids `aborting -> aborting` and
+            // forbids any outgoing transition from terminal states.
+            if (!this.fsm.isTerminal) {
+                if (this.fsm.current !== 'aborting') {
+                    this.fsm.transition('aborting', 'superseded_by_new_brief');
+                }
+                this.fsm.transition('aborted', 'superseded_by_new_brief');
+            }
+            // Step 3: fresh FSM so the new dispatch can walk
+            // `idle -> awaiting_response` cleanly.
+            this.resetFsmToIdle();
+        }
+        else if (this.fsm.isTerminal) {
+            // Prior turn ended naturally (completed / failed / aborted) with
+            // no live token left around. Reset only the FSM.
+            this.resetFsmToIdle();
+        }
+        // Step 4: record the dispatch start time BEFORE bumping the seq.
+        // The timestamp gate in `handleServerEvent` reads this value to
+        // decide whether an inbound event predates the live dispatch and
+        // should be dropped. Recording before the seq bump is critical:
+        // any concurrent SSE event landing between this line and the seq
+        // bump must still see a strictly-monotonic timestamp boundary.
+        this.currentDispatchStartTime = this.now();
+        // Step 5: clear the per-task seq stamps. Any leftover stamp from a
+        // superseded dispatch would otherwise look like it matched the new
+        // dispatchSeq (because the late `agent.spawned` for that taskId
+        // could stamp the OLD taskId with the NEW seq), nulling the new
+        // token via a stale terminal event. The timestamp gate is the
+        // primary defense; the clear is belt-and-braces.
+        this.taskDispatchSeq.clear();
+        // Step 6: bump seq + mint fresh token.
+        this.dispatchSeq += 1;
+        this.currentDispatchToken = new CancellationToken();
+        // The FSM is now `idle` (either fresh-start or post-reset). Walk
+        // to `awaiting_response` so the bottom-bar surface picks up the
+        // new dispatch state immediately.
+        if (this.fsm.current === 'idle') {
+            this.fsm.transition('awaiting_response', 'brief_dispatched');
+        }
+        // α6.9: re-open the SSE stream if a prior `cancel()` tore it
+        // down. Without this, the new brief would dispatch on admin-api
+        // but the client would never observe `agent.spawned` / `step` /
+        // `completed` — the operator would see a stalled status bar
+        // forever. Idempotent: openStream() short-circuits when a handle
+        // already exists or the session is closed.
+        if (!this.streamHandle && !this.closed) {
+            this.openStream();
+        }
         try {
             await this.options.transport.postBrief({
                 apiUrl: this.options.apiUrl,
@@ -963,8 +1233,79 @@ export class ReplSession {
         }
         catch (error) {
             this.appendSystemLine(`Brief dispatch refused: ${this.errorMessage(error)}`);
+            // α6.9: a failed brief POST never produced a turn, so we move
+            // the FSM straight to `failed` so the bottom-bar surfaces the
+            // outcome and the next brief can mint a fresh token.
+            this.markDispatchFailed('post_brief_failed');
         }
     }
+    /**
+     * α6.9: reset the FSM to `idle` after a terminal transition so the
+     * next brief can start. The FSM does not allow direct
+     * `completed -> awaiting_response`, so we mint a fresh FSM by
+     * overwriting the field. Listeners on the old FSM are dropped (they
+     * cannot fire again — terminal states have no outgoing transitions).
+     * The state.dispatchState patch happens via the new FSM's listeners
+     * which we re-attach immediately.
+     */
+    resetFsmToIdle() {
+        // Re-attach the same listeners on a fresh FSM instance. We cannot
+        // mutate `this.fsm` because it is `readonly`; but we mark it as
+        // mutable for this single reset path.
+        const next = new DispatchFSM();
+        next.onEnter('idle', () => this.patch({ dispatchState: 'idle', dispatchToolLabel: null }));
+        next.onEnter('awaiting_response', () => this.patch({ dispatchState: 'awaiting_response', dispatchToolLabel: null }));
+        next.onEnter('tool_running', () => this.patch({ dispatchState: 'tool_running' }));
+        next.onEnter('aborting', () => this.patch({ dispatchState: 'aborting', dispatchToolLabel: null }));
+        next.onEnter('aborted', () => this.patch({ dispatchState: 'aborted', dispatchToolLabel: null }));
+        next.onEnter('completed', () => this.patch({ dispatchState: 'completed', dispatchToolLabel: null }));
+        next.onEnter('failed', () => this.patch({ dispatchState: 'failed', dispatchToolLabel: null }));
+        // Swap the instance - the FSM does not allow direct
+        // `<terminal> -> awaiting_response`, so the next brief needs a
+        // fresh machine to walk from `idle`. Clean assignment (no cast)
+        // because `fsm` is no longer declared readonly.
+        this.fsm = next;
+        // State patch so subscribers see the idle transition immediately.
+        this.patch({ dispatchState: 'idle', dispatchToolLabel: null });
+    }
+    /**
+     * α6.9: short-circuit the FSM to `failed` on a non-recoverable
+     * dispatch error (network refusal, malformed event, etc). Idempotent
+     * — a second call from a terminal state is a no-op.
+     */
+    markDispatchFailed(reason) {
+        if (this.fsm.isTerminal)
+            return;
+        if (this.fsm.current === 'idle')
+            return;
+        // From `awaiting_response` or `tool_running` we can transition to
+        // `failed` directly per the legal-transition matrix. From `aborting`
+        // the only legal move is `aborted`, so skip — the abort path is
+        // already in motion.
+        if (this.fsm.current === 'aborting')
+            return;
+        this.fsm.transition('failed', reason);
+        // α6.9 P1 fix (Claude triple-review): postBrief threw between
+        // openStream() and dispatch registration server-side. The local
+        // SSE handle is open but listening for events under a dispatchId
+        // the admin-api never created. If we leave it open, any inbound
+        // event for a future dispatch on the same session would drive
+        // the FSM from terminal `failed` -> illegal target and throw
+        // IllegalDispatchTransitionError. Tear down so the next brief
+        // re-opens cleanly via dispatchBrief's openStream() gate.
+        //
+        // R2 P2 fix (Claude triple-review 2026-05-25): tear down the
+        // stream BEFORE nulling the token. Same ordering contract as
+        // `cancel()`: any onAbort listener fired during teardown should
+        // observe the (now-aborted) token via getCurrentDispatchToken()
+        // rather than null. Nulling the token first would race the
+        // teardown's listener fan-out against a stale null read.
+        if (this.streamHandle) {
+            this.streamHandle.close();
+            this.streamHandle = undefined;
+        }
+        this.currentDispatchToken = null;
+    }
     async dispatchStop(persona) {
         const sessionId = this.state.sessionId;
         if (!sessionId) {
@@ -1140,6 +1481,31 @@ export class ReplSession {
     }
     /* ------------- event reducer -------------- */
     handleServerEvent(event) {
+        // R3 P1 fix (Codex triple-review 2026-05-25): wall-clock gate that
+        // drops events from a SUPERSEDED dispatch. The R2 seq gate alone
+        // could not catch a LATE `agent.spawned` for an old taskId arriving
+        // AFTER `dispatchBrief` already bumped `dispatchSeq`. The late
+        // spawn would stamp the OLD taskId with the NEW seq, so the
+        // subsequent terminal event for that task looked current and
+        // nulled the freshly minted token. Comparing `event.timestamp`
+        // against `currentDispatchStartTime` (recorded BEFORE the seq
+        // bump) catches the late event before it can corrupt the seq map
+        // or drive the live FSM.
+        //
+        // `Date.parse` returns NaN on malformed input; we treat NaN as
+        // "unknown timestamp, do not drop" so a transport bug never
+        // silently swallows events. Zero `currentDispatchStartTime` means
+        // no dispatch has started yet (start() path) — same fail-open.
+        const eventTs = event.timestamp ? Date.parse(event.timestamp) : 0;
+        if (Number.isFinite(eventTs)
+            && eventTs > 0
+            && this.currentDispatchStartTime > 0
+            && eventTs < this.currentDispatchStartTime) {
+            // Late event from a superseded dispatch. Drop silently — the
+            // operator already saw the new brief land, and the new dispatch
+            // owns the surface now.
+            return;
+        }
         switch (event.type) {
             case 'agent.spawned': {
                 const persona = safePersonaName(event.role);
@@ -1176,6 +1542,12 @@ export class ReplSession {
                 else {
                     this.patch({ agents: [node, ...this.state.agents] });
                 }
+                // R2 P1 fix (Codex triple-review 2026-05-25): stamp the live
+                // dispatch sequence onto this taskId so terminal handlers can
+                // tell apart a "current dispatch" event from a "superseded
+                // dispatch" event. See `dispatchSeq` + `taskDispatchSeq`
+                // field comments.
+                this.taskDispatchSeq.set(event.taskId, this.dispatchSeq);
                 // The conversation pane already prefixes persona rows with the
                 // persona name in the persona's hue colour. Skip embedding the
                 // name in the body text to avoid the `Marcus Marcus dispatched`
@@ -1218,6 +1590,12 @@ export class ReplSession {
                 });
                 if (synthesised) {
                     this.appendToolCall(synthesised);
+                    // α6.9: a fresh tool call moves the FSM to `tool_running`
+                    // when the dispatch is still active. The status-bar surface
+                    // also gets a short label (`tool: read`, `tool: bash`, etc).
+                    // Aborting / terminal states are not allowed to transition
+                    // here — we silently skip rather than throw.
+                    this.advanceFsmOnToolStart(synthesised.tool);
                 }
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
@@ -1254,6 +1632,12 @@ export class ReplSession {
                         ? { ...a, status: 'shipped', detail: 'shipped' }
                         : a),
                 });
+                // α6.9: transition the FSM to `completed` when no other
+                // dispatch is still in flight. The check uses the agents list
+                // POST-patch so any sibling task in `queued` / `thinking` keeps
+                // the dispatch alive; the FSM only goes terminal when the last
+                // agent ships.
+                this.advanceFsmOnDispatchEnd('completed', 'agent_completed', event.taskId);
                 if (target) {
                     // If the persona actually produced a reply via incremental
                     // agent.step events, render that reply in the transcript so
@@ -1314,6 +1698,11 @@ export class ReplSession {
                 if (target) {
                     this.appendPersonaLine(target.personaSlug, `blocked: ${event.detail}`);
                 }
+                // α6.9: `blocked` is a graceful refusal, not a crash — treat it
+                // as a `completed` outcome from the FSM's perspective so the
+                // operator sees the bottom-bar settle back to `idle` after the
+                // last block clears.
+                this.advanceFsmOnDispatchEnd('completed', 'agent_blocked', event.taskId);
                 return;
             }
             case 'agent.failed': {
@@ -1332,9 +1721,86 @@ export class ReplSession {
                 if (target) {
                     this.appendPersonaLine(target.personaSlug, `failed: ${event.error}`);
                 }
+                // α6.9: terminal `failed` transition when no sibling task
+                // remains. Same defer-until-last-agent semantics as
+                // `completed` so the bottom-bar surface tracks the dispatch
+                // collectively.
+                this.advanceFsmOnDispatchEnd('failed', 'agent_failed', event.taskId);
+                return;
+            }
+        }
+    }
+    /**
+     * α6.9 helper: advance the FSM to `tool_running` when a tool call
+     * lands mid-dispatch. Guarded against terminal / aborting states so
+     * a late tool event after `cancel()` does not throw on an illegal
+     * transition. The `tool` label drives the bottom-bar's
+     * `tool: <kind>` granularity.
+     */
+    advanceFsmOnToolStart(tool) {
+        const current = this.fsm.current;
+        if (this.fsm.isTerminal)
+            return;
+        if (current === 'aborting')
+            return;
+        if (current === 'idle')
+            return;
+        // Only `awaiting_response -> tool_running` is a hard move. From
+        // `tool_running` we patch the label without a state transition so
+        // a multi-tool turn shows the latest tool's label without churning
+        // the FSM through transient idle states.
+        if (current === 'awaiting_response') {
+            this.fsm.transition('tool_running', `tool_${tool}`);
+        }
+        this.patch({ dispatchToolLabel: `tool: ${tool}` });
+    }
+    /**
+     * α6.9 helper: advance the FSM toward a terminal outcome when the
+     * LAST in-flight agent's lifecycle ends. The dispatch is "still
+     * running" when any other agent in the tree is in `queued` /
+     * `thinking`; the FSM only goes terminal when the last one settles.
+     *
+     * Idempotent + guarded against illegal transitions: a late event
+     * after a manual `cancel()` finds the FSM already in `aborted` and
+     * is silently dropped.
+     */
+    advanceFsmOnDispatchEnd(outcome, reason, taskId) {
+        // R2 P1 fix (Codex triple-review 2026-05-25): a terminal event
+        // for a SUPERSEDED dispatch must NOT advance the live FSM or null
+        // the live token. If the event carries a taskId and the stamped
+        // dispatchSeq for that task is older than the current dispatchSeq,
+        // the event belongs to a prior dispatch that was replaced by a
+        // newer `dispatchBrief()`. Silently drop the FSM advance.
+        if (taskId !== undefined) {
+            const taskSeq = this.taskDispatchSeq.get(taskId);
+            if (taskSeq !== undefined && taskSeq < this.dispatchSeq) {
+                // Stale dispatch event - the live dispatch is a newer turn.
+                // Skip the FSM advance + token null so brief #N+1 stays
+                // cancellable and the new turn's lifecycle is not corrupted.
                 return;
             }
         }
+        if (this.fsm.isTerminal)
+            return;
+        if (this.fsm.current === 'aborting')
+            return;
+        if (this.fsm.current === 'idle')
+            return;
+        // Defer until every agent has settled so a multi-agent dispatch
+        // collectively transitions once on the LAST settle.
+        const stillActive = this.state.agents.some((a) => a.status === 'queued' || a.status === 'thinking');
+        if (stillActive)
+            return;
+        // From `tool_running` we must walk through `awaiting_response`
+        // first (the legal-transition matrix forbids
+        // tool_running -> completed). The intermediate step is a one-tick
+        // pass through and immediately settles to terminal.
+        if (this.fsm.current === 'tool_running') {
+            this.fsm.transition('awaiting_response', `${reason}_drained`);
+        }
+        this.fsm.transition(outcome, reason);
+        this.currentDispatchToken = null;
+        this.patch({ briefStartedAtEpochMs: undefined });
     }
     /* ------------- transcript helpers -------------- */
     /**

package/dist/runtime/cli.js

@@ -44,7 +44,7 @@ import { dispatchEdit, } from '../core/edits/index.js';
  * packages/pugi-sdk/package.json); the publish workflow validates the
  * three are in lockstep.
  */
-const PUGI_CLI_VERSION = "0.1.0-alpha.19";
+const PUGI_CLI_VERSION = "0.1.0-alpha.20";
 const handlers = {
     accounts,
     agents: dispatchAgents,

package/dist/tools/file-tools.js

@@ -6,6 +6,35 @@ import { decidePermission } from '../core/permission.js';
 import { createReadRecord, hashContent } from '../core/file-cache.js';
 import { resolveWorkspacePath } from '../core/path-security.js';
 import { recordFileMutation, recordToolCall, recordToolResult } from '../core/session.js';
+/**
+ * α6.9 WriteGate marker — thrown by `gateOnCancellation` when the
+ * caller supplied a cancellation token that has already aborted. The
+ * tool dispatch loop in `tool-bridge.ts` recognises the name and folds
+ * the throw into a `status: 'aborted'` tool result rather than a hard
+ * error so the loop terminates cleanly.
+ */
+export class OperatorAbortedError extends Error {
+    constructor(toolName) {
+        super(`operator_aborted: ${toolName} refused — operator cancelled the dispatch.`);
+        this.name = 'OperatorAbortedError';
+    }
+}
+/**
+ * α6.9 WriteGate: refuse the tool dispatch when the active
+ * cancellation token has aborted. Idempotent (the token's `isAborted`
+ * is a getter, no side effects). Returns void on the happy path so the
+ * tool can proceed; throws `OperatorAbortedError` when cancelled.
+ *
+ * The audit trail still gets the call: `recordToolCall` already fired
+ * upstream of this guard so the abort + reason are persisted. The
+ * matching `recordToolResult` is fired by the caller in its catch
+ * block with `status: 'cancelled'` (see existing path for `error`).
+ */
+export function gateOnCancellation(ctx, toolName) {
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        throw new OperatorAbortedError(toolName);
+    }
+}
 /**
  * Re-check the permission decision against the *resolved* real path so
  * a workspace-local symlink (`alias -> .env`) cannot bypass the protected
@@ -42,6 +71,13 @@ function permissionGatedResolve(ctx, inputPath, action, toolName) {
 }
 export function readTool(ctx, path) {
     const toolCallId = recordToolCall(ctx.session, 'read', path);
+    // α6.9 WriteGate: fail fast on operator cancel BEFORE permission
+    // decision so a half-second post-cancel race never lands the read.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: read refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('read');
+    }
     const decision = decidePermission({ tool: 'read', kind: 'read', target: path }, ctx.settings, ctx.root);
     if (decision.decision !== 'allow') {
         const reason = `Permission ${decision.decision} for read ${path}: ${decision.reason}`;
@@ -64,6 +100,14 @@ export function readTool(ctx, path) {
 }
 export function writeTool(ctx, path, content) {
     const toolCallId = recordToolCall(ctx.session, 'write', path);
+    // α6.9 WriteGate: refuse the write when the operator has cancelled
+    // the dispatch. The audit log captures the cancellation reason so a
+    // post-mortem can distinguish operator_aborted from settings-deny.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: write refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('write');
+    }
     const decision = decidePermission({ tool: 'write', kind: 'edit', target: path }, ctx.settings, ctx.root);
     if (decision.decision !== 'allow') {
         const reason = `Permission ${decision.decision} for write ${path}: ${decision.reason}`;
@@ -95,6 +139,15 @@ export function writeTool(ctx, path, content) {
 }
 export function editTool(ctx, path, oldString, newString) {
     const toolCallId = recordToolCall(ctx.session, 'edit', path);
+    // α6.9 WriteGate: refuse the edit when the operator has cancelled
+    // the dispatch. Edits are higher-risk than reads — surface the abort
+    // BEFORE we even consult permissions so a cancel-during-tool-loop
+    // never partially mutates the workspace.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: edit refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('edit');
+    }
     const decision = decidePermission({ tool: 'edit', kind: 'edit', target: path }, ctx.settings, ctx.root);
     if (decision.decision !== 'allow') {
         const reason = `Permission ${decision.decision} for edit ${path}: ${decision.reason}`;
@@ -140,6 +193,14 @@ export function editTool(ctx, path, oldString, newString) {
 }
 export function globTool(ctx, pattern) {
     const toolCallId = recordToolCall(ctx.session, 'glob', pattern);
+    // α6.9 WriteGate: cancel-aware short-circuit. Glob is read-only but
+    // can be expensive on large trees; respecting the abort here keeps
+    // the tool loop responsive when the operator hits Ctrl+C mid-scan.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: glob refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('glob');
+    }
     // Pugi globs are workspace-scoped. Reject any pattern that could enumerate
     // outside the workspace:
     //   1. absolute paths (`/etc/**/*`) — globSync resolves these against `/`
@@ -169,11 +230,28 @@ export function globTool(ctx, pattern) {
 }
 export function grepTool(ctx, query) {
     const toolCallId = recordToolCall(ctx.session, 'grep', query);
+    // α6.9 WriteGate: refuse before scanning. Grep walks the whole
+    // workspace and can take seconds on a large repo; check abort first
+    // so a cancel mid-scan returns immediately rather than after the
+    // full walk completes.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: grep refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('grep');
+    }
     const files = globTool(ctx, '**/*').filter((path) => !path.endsWith('/'));
     const matches = [];
     for (const path of files) {
         if (matches.length >= 200)
             break;
+        // α6.9 WriteGate: poll abort inside the file loop so a cancel
+        // arriving mid-scan terminates early. The per-file branch keeps
+        // the responsiveness bounded by the slowest single-file read.
+        if (ctx.cancellation && ctx.cancellation.isAborted) {
+            const reason = `operator_aborted: grep stopped mid-scan after ${matches.length} matches`;
+            recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+            throw new OperatorAbortedError('grep');
+        }
         // Permission gate every file read individually — grep used to bypass
         // `decidePermission` and could surface lines from protected files
         // (.env, *.sql, *.pem, ~/.ssh/**) when invoked from a directory walk.
@@ -241,6 +319,18 @@ export const BASH_DEFAULT_TIMEOUT_MS = 30_000;
 export const BASH_CHILD_MAXBUFFER = 10 * 1024 * 1024;
 export function bashTool(ctx, command, options = {}) {
     const toolCallId = recordToolCall(ctx.session, 'bash', command);
+    // α6.9 WriteGate: bash is the highest-risk tool surface. Refuse
+    // before the destructive-pattern classifier even runs so a
+    // cancelled dispatch never spawns a child process. Note: this is
+    // pre-spawn cancellation only; once the /bin/sh -c process is
+    // running, the synchronous spawnSync wait blocks until it exits or
+    // the 30s timeout fires. Phase 2 will wire SIGTERM forwarding via
+    // an async wrapper.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: bash refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('bash');
+    }
     const decision = decidePermission({ tool: 'bash', kind: 'bash', target: command }, ctx.settings, ctx.root);
     if (decision.decision !== 'allow') {
         const reason = `Permission ${decision.decision} for bash: ${decision.reason}`;

package/dist/tui/input-box.js

@@ -131,14 +131,57 @@ export function InputBox(props) {
     useInput((input, key) => {
         if (key.ctrl && input === 'c') {
             const t = now();
-            if (typeof lastCtrlCAt === 'number' && t - lastCtrlCAt <= CTRL_C_DOUBLE_TAP_MS) {
+            // α6.9: Claude Code-style double-press semantics. First Ctrl+C
+            // ALWAYS attempts to cancel an in-flight dispatch (when the
+            // session reports non-idle); second Ctrl+C within 1s exits the
+            // process. If onCancel is omitted (legacy callers, tests), the
+            // old behaviour is preserved: first Ctrl+C clears the buffer +
+            // arms the exit timer, second Ctrl+C exits.
+            const withinDoubleTapWindow = typeof lastCtrlCAt === 'number' && t - lastCtrlCAt <= CTRL_C_DOUBLE_TAP_MS;
+            if (withinDoubleTapWindow) {
+                // Second press inside the window — always exit. This matches
+                // Claude Code: even mid-dispatch, the second Ctrl+C wins so
+                // the operator can always escape a stuck REPL.
                 props.onExit();
                 return;
             }
+            // First press in a fresh window. If the host wired a cancel
+            // surface and there is something to cancel, abort the dispatch.
+            // The buffer is left untouched on a cancel (the operator's
+            // current input is NOT trashed by an accidental Ctrl+C while a
+            // tool is running).
+            //
+            // Three-valued onCancel return (see prop docstring):
+            //   - true       → dispatch cancelled, keep buffer, arm exit timer
+            //   - false      → idle, clear buffer (legacy), arm exit timer
+            //   - undefined  → handler bypassed (modal owns input); NO state
+            //                  change at all. Buffer stays, exit timer NOT
+            //                  armed (otherwise the modal would silently
+            //                  promote a Ctrl+C to "press again to exit",
+            //                  which is wrong context for a modal cancel).
+            let cancelResult;
+            if (props.onCancel) {
+                cancelResult = props.onCancel();
+            }
+            if (cancelResult === undefined && props.onCancel) {
+                // Bypass path - modal owns the input. Drop the press silently
+                // so the modal's own cancel surface (Esc / its own Ctrl+C
+                // binding inside the modal component) takes effect on its own
+                // terms. P2 fix: previously this fell through to the
+                // legacy buffer-clear + setLastCtrlCAt path and wiped modal
+                // draft text on first Ctrl+C.
+                return;
+            }
             setLastCtrlCAt(t);
-            setLine('');
-            setCursor(0);
-            setSearch(undefined);
+            // Legacy behaviour: on idle (or no onCancel wired), clear the
+            // buffer + reset search so the operator's screen is calm before
+            // they confirm exit. When we DID cancel a live dispatch, keep
+            // the buffer so a half-typed brief is not lost.
+            if (cancelResult !== true) {
+                setLine('');
+                setCursor(0);
+                setSearch(undefined);
+            }
             return;
         }
         // Search-mode key handling. Ctrl+R / Ctrl+S cycle, Enter accepts,
@@ -456,7 +499,7 @@ export function InputBox(props) {
         : Math.min(paletteIndex, paletteView.rows.length - 1);
     const divider = '─'.repeat(innerWidth);
     const focusedMatch = search ? search.matches[search.focusedIndex] : undefined;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next  ·  Ctrl+S prev  ·  Enter accept  ·  Esc cancel  ·  ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "cyan", dimColor: true, children: divider }), line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history  ·  Ctrl+R search  ·  / commands  ·  Enter brief  ·  Esc cancel  ·  Ctrl+C ×2 exit' }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next  ·  Ctrl+S prev  ·  Enter accept  ·  Esc cancel  ·  ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "cyan", dimColor: true, children: divider }), line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history  ·  Ctrl+R search  ·  / commands  ·  Enter brief  ·  Esc cancel  ·  Ctrl+C abort / ×2 exit' }) })] }));
 }
 /**
  * Render the line with the cursor glyph inserted at `cursor`. The cursor

package/dist/tui/repl.js

@@ -156,11 +156,33 @@ export function Repl(props) {
     const handlePlanReviewResolve = useCallback((result) => {
         void props.session.resolvePlanReview(result);
     }, [props.session]);
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [props.updateBanner ? _jsx(UpdateBanner, { result: props.updateBanner }) : null, splashVisible ? (_jsx(ReplSplash, { cliVersion: state.cliVersion, workspaceLabel: state.workspaceLabel, plan: props.splashPlan, model: props.splashModel, tenant: props.splashTenant, onDismiss: dismissSplash, mascotPrePrinted: props.mascotPrePrinted === true })) : null, _jsx(Header, { state: state }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: overlay === 'help' ? (_jsx(HelpOverlay, {})) : overlay === 'roster' ? (_jsx(RosterOverlay, {})) : overlay === 'farewell' ? (_jsx(FarewellOverlay, {})) : (_jsx(MainArea, { state: state, personaNames: personaNames, nowEpochMs: tickNow, hideToolStream: props.hideToolStream === true, toolStreamCollapsed: toolStreamCollapsed })) }), state.pendingAsk ? (_jsx(Box, { marginTop: 1, children: _jsx(AskModal, { tag: state.pendingAsk, onResolve: handleAskResolve }) })) : null, state.pendingPlanReview ? (_jsx(Box, { marginTop: 1, children: _jsx(PlanReviewModal, { tag: state.pendingPlanReview, onResolve: handlePlanReviewResolve }) })) : null, _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [overlay === 'farewell' || modalActive ? null : (_jsx(InputBox, { onSubmit: handleSubmit, onExit: handleExit, now: props.now, 
+    // α6.9: Ctrl+C abort handler. Forwards to ReplSession.cancel() which
+    // aborts the in-flight dispatch, closes the SSE stream, and surfaces
+    // "Aborted." in the transcript.
+    //
+    // Return contract (consumed by InputBox):
+    //   - true        - dispatch was cancelled (keep the buffer + DO arm
+    //                   the press-again-to-exit timer; second Ctrl+C in
+    //                   the window exits).
+    //   - false       - idle / nothing to cancel (legacy: clear buffer +
+    //                   arm the exit timer so the operator sees the hint
+    //                   and can confirm exit on the next press).
+    //   - undefined   - bypassed entirely (e.g. a modal owns the input).
+    //                   InputBox MUST NOT arm the exit timer and MUST
+    //                   NOT clear the buffer. P2 fix: previously this
+    //                   returned `false` and the buffer-clear path wiped
+    //                   the operator's mid-typed modal text on the first
+    //                   Ctrl+C, costing a press of work.
+    const handleCancel = useCallback(() => {
+        if (modalActive)
+            return undefined;
+        return props.session.cancel();
+    }, [props.session, modalActive]);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [props.updateBanner ? _jsx(UpdateBanner, { result: props.updateBanner }) : null, splashVisible ? (_jsx(ReplSplash, { cliVersion: state.cliVersion, workspaceLabel: state.workspaceLabel, plan: props.splashPlan, model: props.splashModel, tenant: props.splashTenant, onDismiss: dismissSplash, mascotPrePrinted: props.mascotPrePrinted === true })) : null, _jsx(Header, { state: state }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: overlay === 'help' ? (_jsx(HelpOverlay, {})) : overlay === 'roster' ? (_jsx(RosterOverlay, {})) : overlay === 'farewell' ? (_jsx(FarewellOverlay, {})) : (_jsx(MainArea, { state: state, personaNames: personaNames, nowEpochMs: tickNow, hideToolStream: props.hideToolStream === true, toolStreamCollapsed: toolStreamCollapsed })) }), state.pendingAsk ? (_jsx(Box, { marginTop: 1, children: _jsx(AskModal, { tag: state.pendingAsk, onResolve: handleAskResolve }) })) : null, state.pendingPlanReview ? (_jsx(Box, { marginTop: 1, children: _jsx(PlanReviewModal, { tag: state.pendingPlanReview, onResolve: handlePlanReviewResolve }) })) : null, _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [overlay === 'farewell' || modalActive ? null : (_jsx(InputBox, { onSubmit: handleSubmit, onExit: handleExit, onCancel: handleCancel, now: props.now, 
                         // Slug from process.cwd() (full path) so two workspaces with
                         // the same basename do not share history. state.workspaceLabel
                         // is the basename only. Codex review P2.
-                        workspaceSlug: slugForCwd(process.cwd()) })), _jsx(StatusBar, { connection: state.connection, activeAgentCount: countActive(state), tokensDownstreamTotal: state.tokensDownstreamTotal, briefStartedAtEpochMs: state.briefStartedAtEpochMs, nowEpochMs: tickNow, pulsePhase: pulsePhase, pugiMdCount: workspaceContext.pugiMdCount, mcpServerCount: workspaceContext.mcpServerCount, skillCount: workspaceContext.skillCount, quotaPct: props.quotaPct })] })] }));
+                        workspaceSlug: slugForCwd(process.cwd()) })), _jsx(StatusBar, { connection: state.connection, activeAgentCount: countActive(state), tokensDownstreamTotal: state.tokensDownstreamTotal, briefStartedAtEpochMs: state.briefStartedAtEpochMs, nowEpochMs: tickNow, pulsePhase: pulsePhase, pugiMdCount: workspaceContext.pugiMdCount, mcpServerCount: workspaceContext.mcpServerCount, skillCount: workspaceContext.skillCount, quotaPct: props.quotaPct, dispatchState: state.dispatchState, dispatchToolLabel: state.dispatchToolLabel })] })] }));
 }
 function Header({ state }) {
     return (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Pugi" }), _jsx(Text, { bold: true, color: "cyan", children: ".io" }), _jsx(Text, { dimColor: true, children: `  ·  workspace: ${state.workspaceLabel}  ·  v${state.cliVersion}  ·  ` }), _jsx(Text, { color: "cyan", children: state.connection === 'on_watch' ? 'on watch' : state.connection.replace('_', ' ') })] }));

package/dist/tui/status-bar.js

@@ -12,7 +12,12 @@ export function StatusBar(props) {
     const tokenLabel = formatTokens(props.tokensDownstreamTotal);
     const phase = clampPhase(props.pulsePhase);
     const glyph = PULSE_DOTS[Math.min(phase, PULSE_DOTS.length - 1)] ?? PULSE_DOTS[0];
-    const status = connectionLabel(props.connection);
+    // α6.9: composite status label — connection problems trump dispatch
+    // state because the operator needs to know about a dropped admin-api
+    // first. When the connection is healthy (`on_watch` / `connecting`),
+    // the FSM dispatch state takes over to show the dispatch lifecycle
+    // (`dispatching` / `tool: read` / `aborting` / etc.).
+    const status = composeStatusLabel(props.connection, props.dispatchState, props.dispatchToolLabel);
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: status.color, children: `${glyph ?? '●'} ${status.label}` }), _jsx(Text, { dimColor: true, children: `  ·  ${props.activeAgentCount} agents  ·  ` }), _jsx(Text, { children: `↓ ${tokenLabel} tokens` }), _jsx(Text, { dimColor: true, children: `  ·  ${elapsedLabel}` })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `${formatCount(props.pugiMdCount)} PUGI.md  ·  ${formatCount(props.mcpServerCount)} MCP  ·  ${formatCount(props.skillCount)} skills  ·  ${formatQuota(props.quotaPct)} quota` }) })] }));
 }
 /**
@@ -28,10 +33,17 @@ function formatQuota(pct) {
         return '—';
     return `${Math.round(pct)}%`;
 }
-function connectionLabel(connection) {
+// Exported for test introspection (status-bar-fsm.spec.tsx asserts
+// connecting vs on_watch render in distinct colors; ink-testing-library
+// strips ANSI from lastFrame() so we read the resolved color directly).
+export function connectionLabel(connection) {
     switch (connection) {
         case 'connecting':
-            return { label: 'connecting', color: 'cyan' };
+            // P2 fix: was 'cyan', same as 'on_watch' - operator could not
+            // tell boot from stable. Magenta is distinct from every other
+            // state in this palette (cyan steady, yellow reconnect, gray
+            // offline) so a brief flicker through this state stands out.
+            return { label: 'connecting', color: 'magenta' };
         case 'on_watch':
             return { label: 'on watch', color: 'cyan' };
         case 'reconnecting':
@@ -40,6 +52,54 @@ function connectionLabel(connection) {
             return { label: 'offline', color: 'gray' };
     }
 }
+/**
+ * α6.9: compose the visible status label from connection + FSM state.
+ *
+ * Priority order:
+ *
+ *   1. `offline` / `reconnecting` — transport health wins; the
+ *      operator needs to know about a dropped stream before anything
+ *      about the dispatch.
+ *   2. `aborting` / `aborted` / `failed` — operator-visible terminal
+ *      states the FSM reached; the colour shifts to amber/red so the
+ *      anomaly stands out vs the calm cyan baseline.
+ *   3. `tool_running` — surfaces the tool label when available
+ *      (`tool: read`), falls back to `tool` when not.
+ *   4. `awaiting_response` — `dispatching` (matches Codex CLI's verb
+ *      for the same state).
+ *   5. `completed` — `shipped` (matches the agent tree status glyph
+ *      so the operator's eye links the two surfaces).
+ *   6. `idle` / unknown — connection label (`on watch` / `connecting`).
+ *
+ * The dispatch label `dispatchToolLabel` is already shaped as
+ * `tool: <kind>` upstream so we just concatenate; null falls through
+ * to the bare `tool` placeholder.
+ */
+function composeStatusLabel(connection, dispatchState, toolLabel) {
+    // Transport health wins.
+    if (connection === 'offline' || connection === 'reconnecting') {
+        return connectionLabel(connection);
+    }
+    // FSM dispatch state overlay (only when the FSM was wired).
+    switch (dispatchState) {
+        case 'aborting':
+            return { label: 'aborting', color: 'yellow' };
+        case 'aborted':
+            return { label: 'aborted', color: 'gray' };
+        case 'failed':
+            return { label: 'failed', color: 'red' };
+        case 'tool_running':
+            return { label: toolLabel ?? 'tool', color: 'cyan' };
+        case 'awaiting_response':
+            return { label: 'dispatching', color: 'cyan' };
+        case 'completed':
+            return { label: 'shipped', color: 'green' };
+        case 'idle':
+        case undefined:
+        default:
+            return connectionLabel(connection);
+    }
+}
 function formatElapsed(startedAt, now) {
     if (typeof startedAt !== 'number')
         return 'idle';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-alpha.19",
+  "version": "0.1.0-alpha.20",
   "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -52,7 +52,7 @@
     "undici": "^8.3.0",
     "zod": "^3.23.0",
     "@pugi/personas": "0.1.1",
-    "@pugi/sdk": "0.1.0-alpha.19"
+    "@pugi/sdk": "0.1.0-alpha.20"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",