commandmate 0.44.2 → 0.44.3

package/dist/server/src/lib/session/current-output-history-writers.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * The history rows `buildCurrentOutput` writes on its own account: the
+ * "detection failed on this frame" row and the "a dialog is open and we could
+ * not read it" row, and the push that delivers either to the worktree room
+ * (Issue #3215).
+ *
+ * Moved verbatim out of `current-output-builder`. The comments came along
+ * unedited: where one says "this module", it was written about
+ * `current-output-builder`.
+ *
+ * `recordUnclassifiedFrame` and `recordStructuredPrompt` are exported for
+ * `buildPayload` and for nothing else; `current-output-builder` does not
+ * re-export them.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordUnclassifiedFrame = recordUnclassifiedFrame;
+exports.recordStructuredPrompt = recordStructuredPrompt;
+const db_1 = require("../../lib/db");
+const opencode_pane_obstruction_1 = require("../../lib/detection/opencode-pane-obstruction");
+const models_1 = require("../../types/models");
+const logger_1 = require("../../lib/logger");
+const structured_prompt_1 = require("../../lib/session/structured-prompt");
+// Issue #3215: the name is the one these lines have always been logged under.
+// It is what an operator greps for, so it did not move with the code.
+const logger = (0, logger_1.createLogger)('current-output-builder');
+/**
+ * Write the "detection failed on this frame" row (Issue #1708).
+ *
+ * Stored as a `prompt` message so `capture --prompts` — the audit trail that
+ * exists precisely to answer "why did this stall?" — lists it alongside the
+ * prompts that WERE detected. It must never read as one of them, so the
+ * promptData carries `type: 'unclassified'` and `status: 'unclassified'`; the
+ * latter is also what keeps it out of `markPendingPromptsAsAnswered()`, whose
+ * SQL selects `status = 'pending'`. A frame nobody could read must not end up
+ * stamped "(answered via terminal)" the moment the flag clears.
+ *
+ * Not broadcast: this is a record for after the fact, and the prompt-answering
+ * UI has nothing to render for a frame with no parsed options.
+ *
+ * REACH, stated plainly because it is a real limit: this is driven by
+ * observation, not by the server's own loops. `buildCurrentOutput` has exactly
+ * two callers — the current-output route and `broadcastTerminalSnapshot`, which
+ * returns immediately when the room has no subscribers. So a row is written
+ * while `commandmate wait` is polling (every POLL_INTERVAL_MS), while a browser
+ * has the terminal open, or on a `capture --json`. A stall that nobody is
+ * watching at all writes nothing, and `capture --prompts` afterwards will not
+ * show it. That is tolerable because the stalls this exists to explain are the
+ * ones something WAS waiting on — but it means the Auto-Yes poller running
+ * alone is not enough. Feeding the tracker from that loop would need a second
+ * producer of `isUnclassifiedActive`, i.e. either duplicating its definition or
+ * adding a detectSessionStatus pass to a hot path; deliberately not done here.
+ *
+ * Best effort — a failed insert must never break the payload the caller is
+ * waiting on. The tracker has already marked the run as recorded, so a failure
+ * costs this one row, not a retry storm.
+ */
+/**
+ * The sentence that turns "nothing could read this frame" into "here is what is
+ * on it, and here is the key that removes it" (Issue #2095).
+ *
+ * Empty string when there is no obstruction, so every caller can concatenate it
+ * unconditionally and the #1708 wording is byte-identical on a frame that has
+ * none.
+ *
+ * English, like the rest of {@link recordUnclassifiedFrame}'s row and unlike the
+ * UI banner this pairs with. The row is read in `capture --prompts` as often as
+ * in the history pane, and `commandmate` has no locale to read it in.
+ */
+function describePaneObstruction(obstruction) {
+    if (!obstruction)
+        return '';
+    return (` Cause: opencode's sidebar is sharing rows with the transcript ` +
+        `(paneObstruction=${obstruction.id}, second column reads ` +
+        `${JSON.stringify(obstruction.matchedText)}), which covers the marker that ends a ` +
+        `turn. Press \`${opencode_pane_obstruction_1.OPENCODE_SIDEBAR_RECOVERY_CHORD}\` in the pane to close it.`);
+}
+/**
+ * Push a history row this module just wrote to the worktree room (Issue #2214).
+ *
+ * Always `'message'`: both callers INSERT a brand-new row, so nothing has been
+ * delivered for it before and the client appends rather than replaces.
+ *
+ * Detached on purpose, and for two reasons that both matter here:
+ *
+ *  - the `ws-server` import stays dynamic, which is the same bargain
+ *    {@link emitChatTurnProgress} strikes — this module's *other* callers (the
+ *    `/current-output` route and the terminal push) must not pull the WebSocket
+ *    server into their graph just by building a payload;
+ *  - the row is already committed when this runs, so a socket write can never
+ *    turn a written row into a failed one. The two record functions below are
+ *    best-effort by contract and their callers are waiting on a payload.
+ *
+ * #2214 recorded a limitation here — a route bundle holding its own empty copy
+ * of `ws-server`'s `rooms` under `next dev` — and added that "production runs
+ * one custom-server bundle and is unaffected". **That last clause was wrong.**
+ * `npm run dev` and `npm start` run the *same* custom server (`tsx server.ts`
+ * vs `node dist/server/server.js`); what differs is only whether Next evaluates
+ * a route handler from a dev compilation or from `.next/server`. Either way the
+ * route handler's copy of this module and of `ws-server` is not the custom
+ * server's, so this push was silent in production too. #2220 bridged it: the
+ * `broadcastMessage` below now reaches the socket owner through
+ * `lib/realtime/publisher-registry` regardless of which graph called it.
+ */
+function broadcastRecordedRow(worktreeId, message) {
+    void Promise.resolve().then(() => __importStar(require('../../lib/ws-server'))).then(({ broadcastMessage }) => {
+        broadcastMessage('message', { worktreeId, message });
+    })
+        .catch((error) => {
+        logger.warn('history-row-broadcast-failed', {
+            worktreeId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+function recordUnclassifiedFrame(db, params) {
+    const dwellSeconds = Math.round(params.dwellMs / 1000);
+    const statusReason = `${params.sessionStatus}/${params.sessionStatusReason}`;
+    const question = `Unclassified interactive frame (${statusReason}) held for ${dwellSeconds}s. ` +
+        `The detection layer could not parse it, so no prompt was published and ` +
+        `nothing could answer it. Inspect the raw pane with ` +
+        `\`commandmate capture ${params.worktreeId} --pane\`.` +
+        // Issue #2095: appended rather than substituted. Everything above is still
+        // true — the frame really was unreadable — and a caller matching on the
+        // #1708 wording keeps matching. What follows turns "we could not read it"
+        // into "here is why, and here is the key that fixes it".
+        describePaneObstruction(params.obstruction);
+    const record = {
+        type: models_1.UNCLASSIFIED_PROMPT_TYPE,
+        status: 'unclassified',
+        question,
+        options: [],
+        dwellSeconds,
+        sessionStatusReason: statusReason,
+    };
+    try {
+        const message = (0, db_1.createMessage)(db, {
+            worktreeId: params.worktreeId,
+            role: 'assistant',
+            content: question,
+            messageType: 'prompt',
+            // Not a PromptData: nothing may answer this row, which is why the record
+            // type is kept out of that union (see UnclassifiedFrameRecord). The column
+            // is shared, so the cast is confined to this one write.
+            promptData: record,
+            timestamp: new Date(),
+            cliToolId: params.cliToolId,
+            instanceId: params.instanceId,
+        });
+        logger.info('unclassified-frame-recorded', {
+            worktreeId: params.worktreeId,
+            cliToolId: params.cliToolId,
+            dwellSeconds,
+            statusReason,
+        });
+        // `cliToolId` / `instanceId` are already the explicit values passed above —
+        // `createMessage` hands back the caller's own object — so the published row
+        // addresses the same instance the column does.
+        broadcastRecordedRow(params.worktreeId, message);
+    }
+    catch (error) {
+        logger.warn('unclassified-frame-record-failed', {
+            worktreeId: params.worktreeId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/**
+ * Write the "the agent said a dialog is open and we could not read it" row
+ * (Issue #1725, continuing #1708's proposal 2).
+ *
+ * Written once per waiting episode, and ONLY while the scraper is publishing no
+ * prompt of its own. Both halves matter:
+ *
+ *  - once, because `buildCurrentOutput` runs on every poll and a row per poll
+ *    would turn one blocked dialog into a wall of identical history;
+ *  - only when the scraper is blind, because when it is not, the existing
+ *    prompt writers already record that prompt with its options and its answer.
+ *    A second row would double-count the audit trail `capture --prompts` prints
+ *    and put a "nobody could read this" line next to the parsed prompt that
+ *    proves somebody could.
+ *
+ * So a row here means exactly one thing, which is the thing #1708 asked to be
+ * recorded: a prompt existed and the detection layer did not see it.
+ *
+ * Best effort, for the same reason as {@link recordUnclassifiedFrame}: the
+ * caller is waiting on a payload, and a failed insert must cost this row and
+ * nothing else.
+ */
+function recordStructuredPrompt(db, params) {
+    const record = (0, structured_prompt_1.buildStructuredPromptHistoryRecord)(params.worktreeId, params.facts);
+    try {
+        const message = (0, db_1.createMessage)(db, {
+            worktreeId: params.worktreeId,
+            role: 'assistant',
+            content: record.question,
+            summary: `structured prompt · source=${params.state.source}${params.state.toolName ? ` · tool=${params.state.toolName}` : ''}`,
+            messageType: 'prompt',
+            // Not a PromptData: it has no options and nothing may answer it by
+            // number. The column is shared, so the cast is confined to this write —
+            // the same arrangement UnclassifiedFrameRecord uses.
+            promptData: record,
+            timestamp: new Date(),
+            cliToolId: params.cliToolId,
+            instanceId: params.instanceId,
+        });
+        logger.info('structured-prompt-recorded', {
+            worktreeId: params.worktreeId,
+            cliToolId: params.cliToolId,
+            instanceId: params.instanceId,
+            source: params.state.source,
+            toolName: params.state.toolName,
+        });
+        broadcastRecordedRow(params.worktreeId, message);
+    }
+    catch (error) {
+        logger.warn('structured-prompt-record-failed', {
+            worktreeId: params.worktreeId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/dist/server/src/lib/session/current-output-types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * The shapes `buildCurrentOutput` publishes (Issue #3215).
+ *
+ * Types only: no function, no constant, nothing that exists at runtime. Moved
+ * verbatim out of `current-output-builder`, which re-exports every name here,
+ * so an import from either module reads the same declaration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/lib/session/detection-divergence.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * How long the screen and the agent kept disagreeing (Issue #3311).
+ *
+ * `detection-divergence` (Issue #1723 §3) is written on every poll where the
+ * scraper's status and the agent's own differ, and on no other. Joining those
+ * lines cannot say how long one disagreement lasted: nothing marks the polls in
+ * between where the two agreed again. So the server keeps, per target, when the
+ * current disagreement began, and says once — `detection-divergence-resolved`,
+ * written by the caller — when a poll finds the two agreeing again. One line
+ * per disagreement, at its end; the per-poll line is left as it was.
+ *
+ * A disagreement whose target is never polled again (the session was killed,
+ * nobody watches it) is never resolved and has no length. It stays in the map,
+ * one small entry per target, until the next poll of that target.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackDetectionDivergence = trackDetectionDivergence;
+exports.resetDetectionDivergenceTracking = resetDetectionDivergenceTracking;
+const global_state_1 = require("../global-state");
+/**
+ * On `globalThis` because the HTTP pull and the WebSocket push both build the
+ * payload, and under `next dev` they are separate bundles: two maps would each
+ * see half the polls.
+ */
+const episodes = (0, global_state_1.getOrInitGlobal)('__detectionDivergenceEpisodes', () => new Map());
+function targetKey(worktreeId, cliToolId, instanceId) {
+    return `${worktreeId}\u0000${cliToolId}\u0000${instanceId}`;
+}
+/**
+ * Record one poll's verdict. Returns the disagreement that this poll ended, or
+ * null — for a diverging poll, and for an agreeing one with nothing to end.
+ *
+ * @param diverging - Whether this poll wrote `detection-divergence`
+ * @param now - Epoch ms; defaults to now
+ */
+function trackDetectionDivergence(worktreeId, cliToolId, instanceId, diverging, now = Date.now()) {
+    const key = targetKey(worktreeId, cliToolId, instanceId);
+    const episode = episodes.get(key);
+    if (diverging) {
+        if (episode)
+            episode.polls++;
+        else
+            episodes.set(key, { startedAt: now, polls: 1 });
+        return null;
+    }
+    if (!episode)
+        return null;
+    episodes.delete(key);
+    return { durationMs: Math.max(0, now - episode.startedAt), polls: episode.polls };
+}
+/** Forget every open disagreement. Test seam. */
+function resetDetectionDivergenceTracking() {
+    episodes.clear();
+}

package/dist/server/src/lib/session/global-session-constants.js

@@ -3,11 +3,10 @@
  * Global session constants for assistant chat feature
  * Issue #649: Assistant chat with global (non-worktree) sessions
  *
- * These constants define the special worktree ID used for global assistant sessions
- * and polling configuration for the assistant chat panel.
+ * Defines the special worktree ID used for global assistant sessions.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GLOBAL_POLL_MAX_RETRIES = exports.GLOBAL_POLL_INTERVAL_MS = exports.GLOBAL_SESSION_WORKTREE_ID = void 0;
+exports.GLOBAL_SESSION_WORKTREE_ID = void 0;
 /**
  * Special worktree ID for global assistant sessions.
  * Used as the worktreeId parameter when creating tmux sessions
@@ -16,13 +15,3 @@ exports.GLOBAL_POLL_MAX_RETRIES = exports.GLOBAL_POLL_INTERVAL_MS = exports.GLOB
  * This value must NOT appear as a real worktree ID in the database.
  */
 exports.GLOBAL_SESSION_WORKTREE_ID = '__global__';
-/**
- * Polling interval for global session output capture (ms).
- * Matches the existing POLLING_INTERVAL in response-poller-core.ts (2 seconds).
- */
-exports.GLOBAL_POLL_INTERVAL_MS = 2000;
-/**
- * Maximum number of polling retries before giving up.
- * 900 retries * 2s interval = 30 minutes (matches MAX_POLLING_DURATION).
- */
-exports.GLOBAL_POLL_MAX_RETRIES = 900;

package/dist/server/src/lib/session/hook-turn-hold.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Whether the agent's own hooks hold a pane at `running` over what the screen
+ * reads (Issue #3337).
+ *
+ * The one statement of the rule, read by both places that ask "is this pane
+ * mid-turn": `buildCurrentOutput` (`capture --json`, the terminal stream) and
+ * the relay's readiness check, which types a reply into the pane only when it
+ * is not. Two copies of it is how a relay was free to type into a running codex
+ * turn whose `capture --json` already said `running`.
+ *
+ * The rule: when the agent's hooks speak for the pane (source kind `hooks`)
+ * and the tool is one whose hook turns the screen may not end
+ * ({@link screenMayCloseHookTurn} — codex, where a frame of a live 0.160.0 turn
+ * read `ready`, `tests/fixtures/codex-mid-turn-3337/`), a turn the hooks opened
+ * ends at the agent's own `Stop`. Only two things end it without the `Stop`,
+ * because they say the `Stop` is not coming:
+ *
+ *  - `stale` — nothing heard for `TURN_STALE_AFTER_MS`, applied by the turn
+ *    record itself;
+ *  - a frame that shows the turn was abandoned (codex's `■ Conversation
+ *    interrupted`).
+ *
+ * Every other case is not held, as before #3337: a source with no hooks
+ * (`scraper`), a pull source (`sse`), and a hooks tool with no policy (Claude
+ * and the rest), whose turns the screen still closes.
+ *
+ * @module lib/session/hook-turn-hold
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.screenMayEndTurn = screenMayEndTurn;
+exports.agentEventSourceKind = agentEventSourceKind;
+exports.hookTurnHoldsPane = hookTurnHoldsPane;
+exports.structuredStateForFrame = structuredStateForFrame;
+const turn_abandoned_1 = require("../../lib/detection/turn-abandoned");
+const define_source_1 = require("../../lib/hooks/sources/define-source");
+const registry_1 = require("../../lib/hooks/sources/registry");
+const agent_event_state_1 = require("../../lib/session/agent-event-state");
+/**
+ * Whether the screen may end a turn the agent has not ended.
+ *
+ * `buildCurrentOutput` passes this to `observeScraperCompletionEvidence` as its
+ * `mayClose`.
+ *
+ * @param sourceKind - `structuredEvents.source.kind` for the pane
+ * @param output - The pane as captured
+ */
+function screenMayEndTurn(sourceKind, cliToolId, output) {
+    return sourceKind !== 'hooks' || (0, turn_abandoned_1.screenMayCloseHookTurn)(cliToolId, output);
+}
+/** The source kind speaking for this pane now — the same fold `capture --json` publishes. */
+function agentEventSourceKind(worktreeId, cliToolId, instanceId, now = Date.now()) {
+    const source = (0, registry_1.getAgentEventSource)(cliToolId);
+    return (0, define_source_1.describeAgentEventSource)(source, source.liveness({ worktreeId, cliToolId, instanceId: instanceId ?? cliToolId }), now).kind;
+}
+/**
+ * Whether the hooks hold this pane at `running`, whatever the frame reads.
+ *
+ * True when the source is `hooks`, the tool's policy keeps the screen from
+ * ending the turn on this frame ({@link screenMayEndTurn}), and its turn record
+ * publishes `running` (open, current generation, not stale, no dialog — a dialog
+ * is `waiting`, which is the send path's to judge).
+ *
+ * @param output - The pane as captured
+ */
+function hookTurnHoldsPane(worktreeId, cliToolId, instanceId, output, now = Date.now()) {
+    const kind = agentEventSourceKind(worktreeId, cliToolId, instanceId, now);
+    if (screenMayEndTurn(kind, cliToolId, output))
+        return false;
+    return (0, agent_event_state_1.getStructuredSessionState)(worktreeId, cliToolId, instanceId, now)?.status === 'running';
+}
+/**
+ * The turn record's verdict as this frame lets it be published (Issue #3377).
+ *
+ * `getStructuredSessionState`, except that a `running` is dropped (null — the
+ * frame decides) when the hooks speak for the pane and the frame shows the
+ * turn was abandoned (codex's `■ Conversation interrupted`). That is the frame
+ * this module already lets the screen end the turn on, and the one the list
+ * already reads as not processing (`hookTurnHoldsPane` does not hold it).
+ * Without this, `capture --json` kept publishing `running` until
+ * `SCRAPER_COMPLETION_POLLS` such frames had closed the record — ~3 s on
+ * 2026-10-06 while the list said not processing.
+ *
+ * Only what is PUBLISHED changes: the record still closes on the third frame,
+ * as before. Every other frame — a misread mid-turn frame included — keeps the
+ * hooks' `running` (#3337), and a tool with no policy (Claude and the rest) is
+ * untouched.
+ *
+ * Read by `buildCurrentOutput` and the list's `foldHookTurn`.
+ *
+ * @param sourceKind - `structuredEvents.source.kind` for the pane
+ * @param output - The pane as captured
+ */
+function structuredStateForFrame(worktreeId, cliToolId, instanceId, sourceKind, output, now = Date.now()) {
+    const state = (0, agent_event_state_1.getStructuredSessionState)(worktreeId, cliToolId, instanceId, now);
+    if (state?.status === 'running' &&
+        sourceKind === 'hooks' &&
+        (0, turn_abandoned_1.screenShowsAbandonedHookTurn)(cliToolId, output)) {
+        return null;
+    }
+    return state;
+}

package/dist/server/src/lib/session/layer-disagreement.js

@@ -47,6 +47,7 @@ const status_detector_1 = require("../../lib/detection/status-detector");
 const cli_patterns_1 = require("../../lib/detection/cli-patterns");
 const agent_event_types_1 = require("../../lib/hooks/agent-event-types");
 const logger_1 = require("../../lib/logger");
+const global_state_1 = require("../global-state");
 const logger = (0, logger_1.createLogger)('layer-disagreement');
 /**
  * Classify one poll. Pure.
@@ -74,8 +75,7 @@ function classifyLayerDisagreement(input) {
 }
 /** How many rows of the frame's tail go into the log line. */
 exports.DISAGREEMENT_FRAME_TAIL_ROWS = 40;
-const reported = globalThis.__layerDisagreementReported ??
-    (globalThis.__layerDisagreementReported = new Set());
+const reported = (0, global_state_1.getOrInitGlobal)('__layerDisagreementReported', () => new Set());
 /** Bound on {@link reported}; at the cap the set is cleared (worst case: one repeat line). */
 const REPORTED_CAP = 512;
 /**

package/dist/server/src/lib/session/opencode-session-store.js

@@ -74,6 +74,7 @@ const path_1 = require("path");
 const safe_directory_1 = require("../../config/safe-directory");
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const logger_1 = require("../../lib/logger");
+const global_state_1 = require("../global-state");
 const logger = (0, logger_1.createLogger)('lib/session/opencode-session-store');
 /**
  * What an opencode session id looks like.
@@ -94,7 +95,7 @@ function isOpencodeSessionId(value) {
 }
 /** Longest title kept. Display only; opencode's own titles are one line. */
 exports.MAX_OPENCODE_SESSION_TITLE_LENGTH = 200;
-const memories = (globalThis.__opencodeSessionMemories ??= new Map());
+const memories = (0, global_state_1.getOrInitGlobal)('__opencodeSessionMemories', () => new Map());
 function keyOf(target) {
     return (0, auto_yes_state_1.buildCompositeKey)(target.worktreeId, target.cliToolId, target.instanceId);
 }

package/dist/server/src/lib/session/prompt-view.js

@@ -65,9 +65,32 @@ function promptHeadingMessage(heading) {
 // Field readers (moved from components/worktree/prompt-decision-id, #1932/#2039/#3181)
 // =============================================================================
 /**
- * The option labels measured to be a text field on screen (Issue #2573).
- * Restated from `TYPED_TEXT_FIELD_LABEL_PATTERNS` in
- * `lib/detection/prompt-detect-multiple-choice`, whose graph reaches `fs`.
+ * Labels of the rows measured to BE a text field on screen (Issue #2573).
+ *
+ * `requiresTextInput` (from {@link TEXT_INPUT_PATTERNS}) reads the WORDS of a
+ * label — "tell … what to do differently", "custom", "enter …" — and says the
+ * option is about the user's own text. It does not say where typed characters
+ * land, and for two rows it flags alike the measured answer is opposite:
+ *
+ * | row | on screen | free text + Enter |
+ * |-----|-----------|-------------------|
+ * | Command Code `AskUserQuestion` `Type something...` (#2522) | a `TextInput` | lands in the field — the answer |
+ * | Command Code permission `No, tell Command Code what to do differently` | a menu row | ignored; the Enter confirms the highlighted `1. Yes` |
+ *
+ * The second is how a "No + reason" was delivered as an approval. The same
+ * words sit on codex's and copilot's approval rows (codex's also name letter
+ * hotkeys, `(y)` / `(p)`), and the generic patterns match inside the command an
+ * approval row quotes (`… commands that start with 'npm run custom'`).
+ *
+ * So this is an allowlist of what was measured, not a denylist of what went
+ * wrong: a flagged row is a field only when its label is one of these. Anchored
+ * at the start so Command Code's folded description (`Type something... Give me
+ * a branch name …`) still matches. Command Code's reader
+ * (`tools/command-code/dialog.ts`) marks the same rows with the same expression.
+ *
+ * The one definition since Issue #3218: `isTypedTextFieldOption` in
+ * `lib/detection/prompt-detect-multiple-choice`, whose graph reaches `fs`,
+ * reads it through `optionTakesTypedText` below.
  */
 exports.TYPED_TEXT_FIELD_LABEL_PATTERNS = [
     /^[^\S\n]*type\s+something\b/i,

package/dist/server/src/lib/session/prompt-waiting-composition.js

@@ -45,8 +45,9 @@ const structured_prompt_1 = require("../../lib/session/structured-prompt");
  * Whether a structured wait is one the app answers over the agent's own API
  * (Issue #3184, design §6-2).
  *
- * The same three conjuncts `current-output-builder` requires before it
- * publishes a `decisionId` on the live payload (its `addressableDecisionId`):
+ * The three conjuncts `composePromptData` in `current-output-builder` requires
+ * — by calling this function (Issue #3215) — before it publishes a
+ * `decisionId` on the live payload (its `addressableDecisionId`):
  * the record came from `Notification(permission_prompt)` rather than being a
  * `permission-request` forecast, the tool's event source names each decision
  * by id (`eventIdentity: 'permission-id'`), and the record carries such an id.

package/dist/server/src/lib/session/provisional-turn.js

@@ -88,7 +88,9 @@ exports.TURN_ACTIVITY_EVENTS = new Set([
  *    bound that stops a lost `Stop` from asserting `running` forever.
  *  - `scraper_evidence` — the terminal frame said "done" on
  *    {@link SCRAPER_COMPLETION_POLLS} consecutive polls with positive evidence.
- *    The screen, not the agent.
+ *    The screen, not the agent. For a codex hooks source only when the frame
+ *    shows a turn whose `Stop` is not coming — an interrupt (Issue #3337, see
+ *    `lib/detection/turn-abandoned`).
  *  - `resync_idle` — a source that can be re-read (`capabilities.resync`) was
  *    asked after a dropped transport and answered "not busy".
  *  - `generation` — the process that owned the turn was replaced.

package/dist/server/src/lib/session/send-user-message.js

@@ -401,7 +401,7 @@ async function sendUserMessage(db, params) {
     (0, db_1.updateLastUserMessage)(db, worktreeId, content, userMessageTimestamp);
     // 8. Clear in-progress message ID (session state managed by savePendingAssistantResponse).
     (0, db_1.clearInProgressMessageId)(db, worktreeId, cliToolId, instanceId);
-    logger.info('cleared-in-progress-message-for');
+    logger.info('cleared-in-progress-message');
     // 9. Start polling for the CLI tool's response.
     (0, response_poller_1.startPolling)(worktreeId, cliToolId, instanceId);
     return { ok: true, message };

package/dist/server/src/lib/session/session-starting-state.js

@@ -73,13 +73,11 @@ const node_async_hooks_1 = require("node:async_hooks");
 const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const status_reason_1 = require("../../lib/detection/status-reason");
 const session_starting_config_1 = require("../../config/session-starting-config");
-const records = globalThis.__sessionStartingRecords ??
-    (globalThis.__sessionStartingRecords = new Map());
+const global_state_1 = require("../global-state");
+const records = (0, global_state_1.getOrInitGlobal)('__sessionStartingRecords', () => new Map());
 /** On `globalThis` like the map, so tokens keep growing across route bundles. */
-const tokenSeq = globalThis.__sessionStartingTokenSeq ??
-    (globalThis.__sessionStartingTokenSeq = { last: 0 });
-const tokenScope = globalThis.__sessionStartingTokenScope ??
-    (globalThis.__sessionStartingTokenScope = new node_async_hooks_1.AsyncLocalStorage());
+const tokenSeq = (0, global_state_1.getOrInitGlobal)('__sessionStartingTokenSeq', () => ({ last: 0 }));
+const tokenScope = (0, global_state_1.getOrInitGlobal)('__sessionStartingTokenScope', () => new node_async_hooks_1.AsyncLocalStorage());
 /**
  * A token for a launch about to begin (Issue #3195). Strictly greater than
  * every token issued before it.

package/dist/server/src/lib/session/status-evidence-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/lib/session/status-evidence.js

@@ -55,6 +55,7 @@ exports.clearLastKnownStatuses = clearLastKnownStatuses;
 // at exactly that moment (`worktree-status-helper.test.ts` does).
 const status_reason_1 = require("../../lib/detection/status-reason");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
+const global_state_1 = require("../global-state");
 /**
  * The reasons that mean "no rule could read this frame" (Issue #2011).
  *
@@ -110,8 +111,7 @@ function isUnclassifiedFrame(status, reason) {
  * whole job is to be honest about age.
  */
 exports.LAST_KNOWN_STATUS_TTL_MS = agent_event_state_1.STRUCTURED_STATE_MAX_AGE_MS;
-const latches = globalThis.__lastKnownStatusByKey ??
-    (globalThis.__lastKnownStatusByKey = new Map());
+const latches = (0, global_state_1.getOrInitGlobal)('__lastKnownStatusByKey', () => new Map());
 /**
  * Cap on retained latches, so a long-lived server cannot grow one per worktree
  * per tool per instance forever.