commandmate 0.40.1 → 0.41.0

package/dist/server/src/lib/polling/antigravity-permission-receipts.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Short-lived record of the `PreToolUse` questions agy asked CommandMate
+ * (Issue #2849).
+ *
+ * ## Why this exists
+ *
+ * agy registers its permission hook on every tool call and waits for the reply
+ * before it either draws an approval dialog or runs the tool (#2848). A dialog
+ * that is really open on the pane therefore always follows a request that
+ * reached `POST /api/hooks/permission-request` a moment earlier. A dialog that
+ * agy only QUOTED in a reply — `Do you want to proceed?` and its four options
+ * in the model's prose — follows nothing. That asymmetry is the whole signal:
+ * "did agy ask us about a tool call just now" is a fact the screen cannot fake.
+ *
+ * ## Why no existing record can be used instead
+ *
+ * - `reportPermissionRequestPending` is not called for antigravity when
+ *   `permissionHookPredictsDialog` is false, which is the ordinary case;
+ * - `pendingByInstance` is emptied by `closeDecisionSlot` the moment CommandMate
+ *   answers, and the answer and the dialog belong to one causal chain — by the
+ *   time the dialog is on the pane the slot is already gone.
+ *
+ * ## What is kept
+ *
+ * ONE entry per instance: the tool name and the arrival time of the most recent
+ * question. A second question replaces the first, because the only thing asked
+ * of this record is "was there one lately".
+ *
+ * The screen carries no tool name (only the option labels), so the caller that
+ * reads a frame asks {@link hasRecentAntigravityPermissionReceipt} without one
+ * and gets a time-only answer. The name is still stored and comparable, for a
+ * caller that does know it.
+ *
+ * In-memory and per-process, like the Auto-Yes state it is read beside: a server
+ * restart empties it, and the cost is that a dialog opened within
+ * {@link ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS} of the restart is left to a
+ * human — never that a quotation is answered.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS = void 0;
+exports.recordAntigravityPermissionReceipt = recordAntigravityPermissionReceipt;
+exports.hasRecentAntigravityPermissionReceipt = hasRecentAntigravityPermissionReceipt;
+exports.resetAntigravityPermissionReceiptsForTests = resetAntigravityPermissionReceiptsForTests;
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+/**
+ * How long after a `PreToolUse` question a dialog still counts as its dialog.
+ *
+ * The hook's own timeout is 5 seconds, and the frame the poller reads can lag the
+ * pane by a capture interval on top, so 8 seconds is the hook timeout plus the
+ * margin for that lag. A `PreToolUse` that timed out never produced a dialog at
+ * all (agy proceeds without one), so the window does not need to be longer to
+ * cover it.
+ */
+exports.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS = 8_000;
+const receipts = globalThis.__antigravityPermissionReceipts ??
+    (globalThis.__antigravityPermissionReceipts = new Map());
+/**
+ * How long an entry is kept before it is dropped on the next write.
+ *
+ * Far beyond the window on purpose: an entry older than the window is already
+ * useless to the reader, so this only bounds the Map for sessions nobody asks
+ * about again (a removed worktree, a killed instance).
+ */
+const RECEIPT_IDLE_TTL_MS = 60 * 60 * 1000;
+function pruneExpiredReceipts(now) {
+    for (const [key, receipt] of receipts) {
+        if (now - receipt.at > RECEIPT_IDLE_TTL_MS)
+            receipts.delete(key);
+    }
+}
+/**
+ * Record that agy asked CommandMate about a tool call.
+ *
+ * A null `toolName` is not recorded: the payload could not be read, so there is
+ * nothing to say the request was a `PreToolUse` at all.
+ *
+ * @param worktreeId - Worktree the request resolved to
+ * @param cliToolId - CLI tool the request came from
+ * @param instanceId - Agent instance id (the tool id itself for the primary)
+ * @param toolName - Tool the request named, or null when the payload had none
+ * @param at - Epoch ms the request arrived
+ */
+function recordAntigravityPermissionReceipt(worktreeId, cliToolId, instanceId, toolName, at = Date.now()) {
+    if (toolName === null)
+        return;
+    pruneExpiredReceipts(at);
+    receipts.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), { toolName, at });
+}
+/**
+ * Did agy ask CommandMate about a tool call, for this instance, within
+ * {@link ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS}?
+ *
+ * @param worktreeId - Worktree the frame belongs to
+ * @param cliToolId - CLI tool the frame belongs to
+ * @param instanceId - Agent instance id; the tool id itself or `undefined` for
+ *   the primary (the spelling the Auto-Yes poller carries)
+ * @param toolName - When given, the question must have named this tool. Omit it
+ *   to ask only "was there one lately" — a frame carries no tool name.
+ * @param now - Epoch ms to measure against
+ */
+function hasRecentAntigravityPermissionReceipt(worktreeId, cliToolId, instanceId, toolName, now = Date.now()) {
+    const receipt = receipts.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
+    if (!receipt)
+        return false;
+    if (toolName !== undefined && receipt.toolName !== toolName)
+        return false;
+    return now - receipt.at <= exports.ANTIGRAVITY_PERMISSION_RECEIPT_WINDOW_MS;
+}
+/** Empty the record. Tests only: production entries age out on their own. */
+function resetAntigravityPermissionReceiptsForTests() {
+    receipts.clear();
+}

package/dist/server/src/lib/polling/response-checker.js

@@ -18,6 +18,8 @@ const db_1 = require("../../lib/db");
 const ws_server_1 = require("../../lib/ws-server");
 const prompt_detector_1 = require("../../lib/detection/prompt-detector");
 const dialog_1 = require("../../lib/detection/tools/antigravity/dialog");
+const detect_1 = require("../../lib/detection/tools/antigravity/detect");
+const frame_1 = require("../../lib/detection/tools/frame");
 const dialog_2 = require("../../lib/detection/tools/command-code/dialog");
 const conversation_logger_1 = require("../../lib/conversation-logger");
 const types_1 = require("../../lib/cli-tools/types");
@@ -33,6 +35,7 @@ const response_cleaner_1 = require("../response-cleaner");
 const copilot_constants_1 = require("../../config/copilot-constants");
 const tui_accumulator_1 = require("../tui-accumulator");
 const prompt_dedup_1 = require("./prompt-dedup");
+const antigravity_permission_receipts_1 = require("./antigravity-permission-receipts");
 // Issue #2457: the same rollout table, `hasDialogRules` cross-check and
 // `detectDialog` seam Auto-Yes reads, reached through the presence helper rather
 // than through `evaluateAutoYesDialogGate` — see `isNumberedDialogVouched`.
@@ -226,9 +229,14 @@ function buildPromptExtractionResult(lines, lastCapturedLine, totalLines, buffer
  *   (Issue #499 Item 4); must be the split of THIS string, not of the raw capture
  * @param rawFrame - the SAME tick's capture with its box drawing intact (ANSI
  *   optional), for the tool readers anchored on it (Issue #2522)
+ * @param receiptScope - whose frame this is, when the caller answers it
+ *   automatically (Issue #2849). For agy only: a frame that reads as a prompt is
+ *   then handed back as no prompt unless agy asked CommandMate about a tool call
+ *   for that instance a moment ago. Omitted, the reading is not gated — which is
+ *   what every caller that only DISPLAYS the frame wants.
  * @returns PromptDetectionResult with isPrompt, promptData, and cleanContent
  */
-function detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawFrame) {
+function detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawFrame, receiptScope) {
     // Issue #2364: agy's `↑/↓ Navigate` dialogs are read by agy's own reader
     // before the generic pass, on the same spelling `tools/antigravity/detect.ts`
     // reads them on. The generic multiple-choice parser takes one row per option
@@ -246,8 +254,11 @@ function detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawF
     // API published the very same screen as an answerable four-option prompt.
     if (cliToolId === 'antigravity') {
         const dialog = (0, dialog_1.detectAntigravityNumberedDialogPrompt)(cleanOutput);
-        if (dialog !== null)
-            return dialog;
+        if (dialog !== null) {
+            return isWithheldForWantOfReceipt(receiptScope)
+                ? { isPrompt: false, cleanContent: cleanOutput.trim() }
+                : dialog;
+        }
     }
     // Issue #2522: Command Code's footer-less `AskUserQuestion`, read by the same
     // module `tools/command-code/detect.ts` publishes its status from — so the
@@ -275,7 +286,65 @@ function detectPromptOnCleanFrame(cleanOutput, cliToolId, precomputedLines, rawF
         }
     }
     const promptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId);
-    return (0, prompt_detector_1.detectPrompt)(cleanOutput, precomputedLines ? { ...promptOptions, precomputedLines } : promptOptions);
+    const result = (0, prompt_detector_1.detectPrompt)(cleanOutput, precomputedLines ? { ...promptOptions, precomputedLines } : promptOptions);
+    // Issue #2851: agy's reader above declines a dialog quoted in a reply (#2845),
+    // and this generic pass then read the quotation itself — `Do you want to
+    // proceed?` and its four options, above a live `>` composer — as an answerable
+    // `multiple_choice`. agy's Auto-Yes gate row is `legacy`, so nothing after this
+    // point judges the frame again and the poller answered a dialog nobody had
+    // opened. The status side declines the same candidate with the same predicate
+    // (`isStalePrompt`, #2845): agy draws its numbered screens in place of the
+    // composer or below it, never above it, so a composer under the list's last
+    // row makes the list a quotation.
+    //
+    // `rawFrame` when the caller has it, and `cleanOutput` otherwise. The status
+    // side normalises the capture as captured and the predicate then strips box
+    // drawing exactly once; handing it `cleanOutput` — already stripped once, and
+    // `stripBoxDrawing` is not idempotent — would strip a second time and could
+    // read different rows.
+    if (cliToolId === 'antigravity' &&
+        result.isPrompt &&
+        (0, detect_1.isAntigravityQuotedNumberedList)((0, frame_1.normalizeFrame)(rawFrame ?? cleanOutput), result)) {
+        return { isPrompt: false, cleanContent: cleanOutput.trim() };
+    }
+    // Issue #2849: the same withholding on this exit. agy's reader answering `null`
+    // does not mean the frame is no dialog — the generic pass above reads shapes
+    // agy's reader declines, and #2851 showed it can read a quotation — so a gate
+    // that covered only the reader's exit would leave this one open.
+    if (cliToolId === 'antigravity' && result.isPrompt && isWithheldForWantOfReceipt(receiptScope)) {
+        return { isPrompt: false, cleanContent: cleanOutput.trim() };
+    }
+    return result;
+}
+/**
+ * Should an agy frame that reads as a prompt be treated as no prompt because
+ * agy asked CommandMate about no tool call lately? (Issue #2849)
+ *
+ * agy asks (`PreToolUse`) before it draws ANY approval dialog and waits for the
+ * reply, so a dialog that is really open follows a question a moment before it,
+ * and one that is only quoted in a reply follows nothing. The frame carries no
+ * tool name, so the check is time-only.
+ *
+ * Not gated (false) when there is no scope: a caller that only shows the frame —
+ * the status API, the response poller's stored `prompt` row, the notification —
+ * must keep showing a real dialog on a machine whose hook is not installed or
+ * did not reach us. Only the caller that ANSWERS the frame opts in, because for
+ * it a missed answer costs a human a keystroke and a wrong one is sent as an
+ * utterance nobody asked for.
+ *
+ * `debug`, not `info`: the poller re-reads a static pane every 2s, so a
+ * quotation left on screen would print this on every tick.
+ */
+function isWithheldForWantOfReceipt(scope) {
+    if (scope === undefined)
+        return false;
+    if ((0, antigravity_permission_receipts_1.hasRecentAntigravityPermissionReceipt)(scope.worktreeId, 'antigravity', scope.instanceId))
+        return false;
+    logger.debug('antigravity-dialog-no-recent-receipt', {
+        worktreeId: scope.worktreeId,
+        instanceId: scope.instanceId ?? 'antigravity',
+    });
+    return true;
 }
 /**
  * Is the generic parser's numbered-list candidate a dialog the tool vouches for?

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

@@ -85,6 +85,7 @@ const prompt_waiting_composition_1 = require("../../lib/session/prompt-waiting-c
 const provisional_turn_1 = require("../../lib/session/provisional-turn");
 const status_evidence_1 = require("../../lib/session/status-evidence");
 const ask_user_question_prompt_1 = require("../../lib/session/ask-user-question-prompt");
+const layer_disagreement_1 = require("../../lib/session/layer-disagreement");
 const structured_prompt_1 = require("../../lib/session/structured-prompt");
 const logger = (0, logger_1.createLogger)('current-output-builder');
 /**
@@ -1093,6 +1094,30 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
             obstruction: paneObstruction,
         });
     }
+    // Issue #2843: the opposite gap — the scraper reads a dialog on a turn the
+    // agent's own `Stop` closed. Logged only (see `layer-disagreement.ts`); fed the
+    // SCRAPER's verdict, because the merge lets a scraper `waiting` win and would
+    // hide the very disagreement this records.
+    const disagreement = (0, layer_disagreement_1.classifyLayerDisagreement)({
+        supportedEvents: eventSource.capabilities.supportedEvents,
+        scraperStatus: statusResult.status,
+        scraperReason: statusResult.reason,
+        hasActivePrompt: scraperPromptWaiting,
+        lastEventType: structuredEvents.lastEventType,
+        lastEventDetail: structuredEvents.lastEventDetail,
+    });
+    if (disagreement !== null) {
+        (0, layer_disagreement_1.reportLayerDisagreement)({
+            compositeKey,
+            worktreeId,
+            cliToolId,
+            instanceId: resolvedInstanceId,
+            turnId: structuredEvents.turnId,
+            kind: disagreement,
+            scraperReason: statusResult.reason,
+            frame: output,
+        });
+    }
     // Issue #1725: the structured layer saw a dialog the scraper did not. That
     // gap is the fact worth keeping — see recordStructuredPrompt.
     if (promptWaiting !== null && structuredFacts !== null && !scraperPromptWaiting && !promptWaiting.recorded) {

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

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * The screen says "a dialog is open", the agent's own hooks say "the turn is
+ * over" — record it (Issue #2843).
+ *
+ * A tool's dialogs are read off the pane (`lib/detection/tools/*`), and the pane
+ * is free text: every few weeks a new wording, a new screen or a quoted
+ * paragraph was misread as a dialog, and each time the report came from a user
+ * who saw a card that should not have been there. The hook layer is an
+ * independent witness that already runs on every poll: the agent fires `Stop`
+ * when a turn ends, and a dialog that belongs to a turn (an approval, a
+ * question) only ever appears inside one. So a screen `waiting` whose newest
+ * hook event is `stop` is either a dialog the user opened themselves (`/model`,
+ * `/experimental` …) or a misreading.
+ *
+ * This module does NOT change any verdict. `mergeStructuredStatus` deliberately
+ * lets the screen's `waiting` win (Claude emits nothing while its picker is up,
+ * #1708), and overturning that is a separate decision that needs the numbers
+ * this module produces. What it does is leave one log line per turn, with the
+ * frame's tail, so the next misreading arrives as a fixture candidate instead
+ * of as a bug report.
+ *
+ * Which tools qualify is decided by what their hooks deliver, not by name: the
+ * rule needs BOTH ends of a turn. A tool whose hooks never announce the start of
+ * a turn (`user_prompt_submit` — antigravity, Command Code) keeps the previous
+ * turn's `stop` as its newest event while the next turn runs, so a genuine
+ * dialog in the middle of that turn would be logged as a disagreement.
+ * Likewise a `stop` whose detail is `self_resume_pending` says "the turn is
+ * closed but the agent wakes itself", not "the agent is done".
+ *
+ * The two kinds are logged separately because they mean different things:
+ *
+ *  - `approval-after-stop` — the screen reads an ANSWERABLE prompt
+ *    (`hasActivePrompt`). The agent asks for permission before it draws a
+ *    dialog, inside a turn, so after `Stop` every line of this kind is a
+ *    detector defect to fixture.
+ *  - `menu-after-stop` — the screen reads a selection list / pager. A user who
+ *    opened `/model` after the turn produces this legitimately, so these lines
+ *    are triaged, not fixed on sight.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DISAGREEMENT_FRAME_TAIL_ROWS = void 0;
+exports.classifyLayerDisagreement = classifyLayerDisagreement;
+exports.reportLayerDisagreement = reportLayerDisagreement;
+exports.resetLayerDisagreementForTests = resetLayerDisagreementForTests;
+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 logger = (0, logger_1.createLogger)('layer-disagreement');
+/**
+ * Classify one poll. Pure.
+ *
+ * Only tools whose hooks deliver both `user_prompt_submit` and `stop` qualify
+ * (claude, codex, copilot, gemini, opencode): without the turn's start, "the
+ * newest event is `stop`" cannot tell a closed turn from a running one.
+ */
+function classifyLayerDisagreement(input) {
+    if (!input.supportedEvents.includes('user_prompt_submit') ||
+        !input.supportedEvents.includes('stop')) {
+        return null;
+    }
+    if (input.scraperStatus !== 'waiting')
+        return null;
+    if (input.lastEventType !== 'stop')
+        return null;
+    if (input.lastEventDetail === agent_event_types_1.SELF_RESUME_PENDING_DETAIL)
+        return null;
+    if (input.hasActivePrompt)
+        return 'approval-after-stop';
+    if (status_detector_1.SELECTION_LIST_REASONS.has(input.scraperReason))
+        return 'menu-after-stop';
+    return null;
+}
+/** 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());
+/** Bound on {@link reported}; at the cap the set is cleared (worst case: one repeat line). */
+const REPORTED_CAP = 512;
+/**
+ * Log one disagreement, once per (session, turn, kind).
+ *
+ * @returns true when a line was written (for tests)
+ */
+function reportLayerDisagreement(report) {
+    const key = `${report.compositeKey}|${report.turnId ?? '-'}|${report.kind}`;
+    if (reported.has(key))
+        return false;
+    if (reported.size >= REPORTED_CAP)
+        reported.clear();
+    reported.add(key);
+    const rows = (0, cli_patterns_1.stripAnsi)(report.frame).split('\n').filter((row) => row.trim() !== '');
+    logger.warn('layerDisagreement', {
+        kind: report.kind,
+        worktreeId: report.worktreeId,
+        cliToolId: report.cliToolId,
+        instanceId: report.instanceId,
+        turnId: report.turnId,
+        scraperReason: report.scraperReason,
+        frameTail: rows.slice(-exports.DISAGREEMENT_FRAME_TAIL_ROWS).join('\n'),
+    });
+    return true;
+}
+/** Test-only: forget what has been reported. */
+function resetLayerDisagreementForTests() {
+    reported.clear();
+}

package/dist/server/src/types/sidebar.js

@@ -330,6 +330,7 @@ function toBranchItem(worktree) {
         status,
         hasUnread,
         lastActivity: worktree.updatedAt,
+        lastActivityByInstance: worktree.lastActivityByInstance,
         description: worktree.description,
         cliStatus,
         cliStatusLabels,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commandmate",
-  "version": "0.40.1",
+  "version": "0.41.0",
   "description": "A local control plane for agent CLIs — orchestration and visibility for Claude Code, Codex, Gemini CLI, and more across Git worktrees",
   "keywords": [
     "claude-code",

package/release-notes/0.41.0.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.41.0",
+  "date": "2026-09-25",
+  "highlight": {
+    "ja": "エージェントが返答の中でダイアログの文面を引用しただけなのに、ダイアログが開いていると表示される問題を直しました。",
+    "en": "Fixed a dialog being shown as open when the agent had only quoted a dialog's text in its reply."
+  },
+  "added": [],
+  "improved": [
+    {
+      "ja": "Antigravity の Auto-Yes は、本当に確認を求められたときだけ承認に答えるようになりました。",
+      "en": "Antigravity's Auto-Yes now answers an approval only when the agent actually asked for one."
+    }
+  ],
+  "fixed": [
+    {
+      "ja": "Codex・Antigravity・Command Code・Claude で、入力待ちなのに選択リストやダイアログが開いていると表示される問題を直しました。",
+      "en": "Fixed Codex, Antigravity, Command Code and Claude showing an open selection list or dialog while waiting for input."
+    },
+    {
+      "ja": "Antigravity の Auto-Yes が、返答に引用されたダイアログの文面に自動で答えてしまう問題を直しました。",
+      "en": "Fixed Antigravity's Auto-Yes answering dialog text that was only quoted in a reply."
+    },
+    {
+      "ja": "サイドバーのセッション表示で、選んだ並び順どおりに並ぶようになりました。",
+      "en": "The session view in the sidebar now follows the sort order you choose."
+    }
+  ]
+}