commandmate 0.49.1 → 0.49.2

package/dist/server/src/lib/cli-tools/vibe-local.js

@@ -92,7 +92,8 @@ class VibeLocalTool extends base_1.BaseCLITool {
             }
             // Start vibe-local in interactive mode with auto-approve (-y)
             // -y flag skips the permission confirmation prompt
-            await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(vibeLocalCommand), true);
+            // Issue #3981: in one writer's turn of the input lock.
+            await this.typeLaunchLines(sessionName, [(0, launch_screen_1.withLaunchScreenCleared)(vibeLocalCommand)]);
             // Wait for vibe-local to initialize (banner + model loading)
             await new Promise((resolve) => setTimeout(resolve, VIBE_LOCAL_INIT_WAIT_MS));
             logger.info('started-vibe-local-session');
@@ -137,7 +138,8 @@ class VibeLocalTool extends base_1.BaseCLITool {
         }
         catch (error) {
             const errorMessage = (0, errors_1.getErrorMessage)(error);
-            throw new Error(`Failed to send message to Vibe Local: ${errorMessage}`);
+            // Issue #4031: the cause keeps a failed `load-buffer`'s code (`classifySendFailure`).
+            throw new Error(`Failed to send message to Vibe Local: ${errorMessage}`, { cause: error });
         }
     }
     /**

package/dist/server/src/lib/db/db-migration-path.js

@@ -15,6 +15,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAndValidatePath = resolveAndValidatePath;
 exports.getLegacyDbPaths = getLegacyDbPaths;
 exports.migrateDbIfNeeded = migrateDbIfNeeded;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = require("os");
@@ -83,6 +85,61 @@ function getLegacyDbPaths() {
     }
     return paths;
 }
+/**
+ * Whether committed updates of `dbPath` may still live only in its `-wal` file.
+ *
+ * An empty or absent `-wal` means the main file is the whole database.
+ */
+function hasPendingWal(dbPath) {
+    try {
+        return fs_1.default.statSync(`${dbPath}-wal`).size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Write a self-contained copy of the database at `sourcePath` to `destPath`
+ * (Issue #3993).
+ *
+ * Same tool as the pre-migration backup (`migrations/pre-migration-backup.ts`,
+ * Issue #3985): `VACUUM INTO` reads inside one read transaction, so updates
+ * still in `-wal` are included, and the result is a rollback-journal file that
+ * needs no sidecar. Copying the main file alone dropped them. The source is
+ * opened read-only; the copy is written to a temporary name and renamed into
+ * place, because `VACUUM INTO` refuses a non-empty destination.
+ */
+function snapshotDatabase(sourcePath, destPath) {
+    const tempPath = `${destPath}.${crypto_1.default.randomBytes(4).toString('hex')}.partial`;
+    try {
+        // VACUUM INTO accepts an empty existing file; creating it first fixes the mode.
+        fs_1.default.closeSync(fs_1.default.openSync(tempPath, 'wx', 0o600));
+        const source = new better_sqlite3_1.default(sourcePath, { readonly: true, fileMustExist: true });
+        try {
+            source.prepare('VACUUM INTO ?').run(tempPath);
+        }
+        finally {
+            source.close();
+        }
+        fs_1.default.renameSync(tempPath, destPath);
+    }
+    catch (error) {
+        fs_1.default.rmSync(tempPath, { force: true });
+        throw error;
+    }
+}
+/**
+ * Copy a legacy database: a consistent snapshot when it has a non-empty `-wal`,
+ * the file itself otherwise (unchanged from before Issue #3993).
+ */
+function copyLegacyDatabase(sourcePath, destPath) {
+    if (hasPendingWal(sourcePath)) {
+        snapshotDatabase(sourcePath, destPath);
+    }
+    else {
+        fs_1.default.copyFileSync(sourcePath, destPath);
+    }
+}
 /**
  * Migrate database to new path if legacy DB exists
  *
@@ -92,6 +149,10 @@ function getLegacyDbPaths() {
  * 3. Creates a backup of the legacy database
  * 4. Copies the database to the new location
  *
+ * A legacy database with a non-empty `-wal` is copied as a `VACUUM INTO`
+ * snapshot (both the backup and the new location), so updates not yet written
+ * back to the main file are kept (Issue #3993).
+ *
  * Security features:
  * - SEC-002: Symlink resolution via realpathSync
  * - SEC-003: Directory creation with mode 0o700
@@ -125,7 +186,7 @@ function migrateDbIfNeeded(targetPath) {
         }
         // Create backup (SEC-006)
         const backupPath = `${resolvedLegacyPath}.bak`;
-        fs_1.default.copyFileSync(resolvedLegacyPath, backupPath);
+        copyLegacyDatabase(resolvedLegacyPath, backupPath);
         fs_1.default.chmodSync(backupPath, 0o600);
         // Create target directory if needed (SEC-003)
         const targetDir = path_1.default.dirname(resolvedTargetPath);
@@ -133,7 +194,7 @@ function migrateDbIfNeeded(targetPath) {
             fs_1.default.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
         }
         // Copy database to new location
-        fs_1.default.copyFileSync(resolvedLegacyPath, resolvedTargetPath);
+        copyLegacyDatabase(resolvedLegacyPath, resolvedTargetPath);
         logger.info(`[Migration] Database migrated from ${resolvedLegacyPath} to ${resolvedTargetPath}`);
         logger.info(`[Migration] Backup created at ${backupPath}`);
         return {

package/dist/server/src/lib/detection/prompt-detect-multiple-choice.js

@@ -753,7 +753,7 @@ function detectMultipleChoicePrompt(output, options, truncateRawContentFn) {
     // Issue #1699: the same block, cut at the previous turn's boundary. Display
     // keeps the wide window; deny patterns are judged against this one.
     const approvalBlock = extractApprovalTarget(lines, questionEndIndex, effectiveEnd, pickerTop);
-    // Issue #616: Determine submitMode from confirmation footer (detected in single-pass above)
+    // Issue #616: Determine submitMode from confirmation footer (detected in single-pass by findConfirmationFooter())
     const submitMode = hasConfirmationFooter
         ? (hasNumberFooter ? 'answer_only' : 'answer_then_enter')
         : undefined;
@@ -808,7 +808,7 @@ function hasModelOverlayFooter(scanWindow) {
     // [Issue #1495] Claude `/model` local-settings overlay guard.
     // The `/model` overlay renders a ❯-marked numbered model list ("1. Default …
     // 5. Haiku") under a "Select model" header, which the option-collection logic
-    // below would otherwise return as a genuine multiple_choice prompt. Auto-Yes
+    // (collectOptions()) would otherwise return as a genuine multiple_choice prompt. Auto-Yes
     // (detectAndRespondToPrompt) calls detectPrompt() directly and would resolve +
     // Enter-confirm the default option — silently changing the user's default model.
     // The overlay-unique "Enter to set as default …" footer never appears in real
@@ -948,10 +948,11 @@ function isMetadataRow(state, rawLine, line, paneCut) {
     // would then poison isValidPrecedingOption() and cause every real option
     // above (1./2./3.) to be rejected — resulting in collectedOptions.length<2
     // and a spurious no_prompt verdict. Treat the summary line as metadata
-    // (same continuation handling as COLLAPSED_OUTPUT_PATTERN above) so the
+    // (same continuation handling as the COLLAPSED_OUTPUT_PATTERN check earlier
+    // in isMetadataRow()) so the
     // reverse scan continues into the actual option block.
     //
-    // Defense-in-depth: works alongside the S2 effectiveEnd trim above. Either
+    // Defense-in-depth: works alongside the S2 effectiveEnd trim in findScanWindow(). Either
     // S1 or S2 alone is sufficient to fix Issue #704; keeping both protects
     // against future Claude renderings where the footer line text changes
     // (S1 still catches) or the summary line wording changes (S2 still

package/dist/server/src/lib/hooks/sources/copilot/hook-settings.js

@@ -868,9 +868,8 @@ function writeCopilotHookSettings(options = {}) {
  *
  * Applied to the launched process rather than through `tmux set-environment`:
  * the pane is created before the agent starts and the assignment then travels
- * with the one process that matters, out of reach of
- * `sanitizeSessionEnvironment` and of anything else that edits the session's
- * environment later.
+ * with the one process that matters, out of reach of anything that edits
+ * the session's environment later (claude's `unset CLAUDECODE` among them).
  *
  * Returned as a map since Issue #1846. It used to be a pre-quoted
  * `NAME=value NAME=value` string that the caller concatenated in front of the

package/dist/server/src/lib/prompt-answer-errors.js

@@ -2,12 +2,17 @@
 /**
  * The refusals and failures `prompt-answer-sender` throws, with the reason
  * codes they carry (Issue #3965: moved out of `prompt-answer-sender`, which
- * re-exports every name here, so callers keep importing from it).
+ * re-exports every error and reason code here, so callers keep importing from it).
+ *
+ * Issue #3982: also how each of them is answered over HTTP
+ * ({@link promptAnswerErrorResponse}), in one table both answering routes read.
+ * That mapping is imported from this module directly.
  *
  * Type-only imports: this module must not import the sender back.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptAnswerAbortedError = exports.PromptAnswerInputLostError = exports.ANSWER_INPUT_LOST_REASON = exports.PromptAnswerNotDeliveredError = exports.ANSWER_NOT_DELIVERED_REASON = exports.MultiSelectAnswerRejectedError = exports.MULTI_SELECT_NOT_COMMITTED_REASON = exports.FreeTextAtChoiceOnlyPromptError = exports.FreeTextAnswerRejectedError = exports.FREE_TEXT_AT_MENU_ROW_REASON = exports.PromptAnswerRejectedError = exports.ANSWER_MODE_KEYS_REASON = void 0;
+exports.PROMPT_ANSWER_ERROR_RESPONSES = exports.PromptAnswerAbortedError = exports.ANSWER_ABORTED_REASON = exports.PromptAnswerInputLostError = exports.ANSWER_INPUT_LOST_REASON = exports.PromptAnswerNotDeliveredError = exports.ANSWER_NOT_DELIVERED_REASON = exports.MultiSelectAnswerRejectedError = exports.MULTI_SELECT_NOT_COMMITTED_REASON = exports.FreeTextAtChoiceOnlyPromptError = exports.FreeTextAnswerRejectedError = exports.FREE_TEXT_AT_MENU_ROW_REASON = exports.PromptAnswerRejectedError = exports.ANSWER_MODE_KEYS_REASON = void 0;
+exports.promptAnswerErrorResponse = promptAnswerErrorResponse;
 /**
  * The reason code a caller gets back when a digit meets a `keys`-mode dialog
  * (Issue #2033).
@@ -269,6 +274,12 @@ class PromptAnswerInputLostError extends Error {
     }
 }
 exports.PromptAnswerInputLostError = PromptAnswerInputLostError;
+/**
+ * The reason code of {@link PromptAnswerAbortedError} on the wire (Issue #3982).
+ * Neither answering route passes a `stillCurrent`, so neither is expected to
+ * see one; it has a code so that the mapping below has no hole.
+ */
+exports.ANSWER_ABORTED_REASON = 'answer_aborted';
 /**
  * The caller's `stillCurrent` said no after one of the send's waits
  * (Issue #3706): the keys not yet sent were not sent. Keys already typed cannot
@@ -286,3 +297,66 @@ class PromptAnswerAbortedError extends Error {
     }
 }
 exports.PromptAnswerAbortedError = PromptAnswerAbortedError;
+function row(errorClass, facts, status) {
+    return [errorClass, { facts: facts, status }];
+}
+/**
+ * Every error class this module exports, and how each route answers it
+ * (Issue #3982).
+ *
+ * Before this table each route had its own `instanceof` chain, and an error
+ * added to one was missing from the other: `/prompt-response` answered
+ * {@link PromptAnswerInputLostError} as a bare 500 with neither `reason` nor
+ * `keysSent`, so a caller could only find the reason by reading the message —
+ * which is also where a quoted answer lands. A unit test enumerates this
+ * module's exported classes and fails when one has no row here.
+ *
+ * `keysSent` is stated here for the refusals that never touch the pane rather
+ * than put on those errors: Auto-Yes reads `keysSent` off a thrown error to
+ * count its attempt, and that count is not this table's to change.
+ */
+exports.PROMPT_ANSWER_ERROR_RESPONSES = new Map([
+    row(PromptAnswerRejectedError, (e) => ({ reason: e.reason, keysSent: false }), { 'prompt-response': 200, respond: 500 }),
+    row(FreeTextAnswerRejectedError, (e) => ({ reason: e.reason, keysSent: false }), { 'prompt-response': 200, respond: 500 }),
+    row(FreeTextAtChoiceOnlyPromptError, (e) => ({ reason: e.reason, keysSent: false }), { 'prompt-response': 200, respond: 500 }),
+    row(MultiSelectAnswerRejectedError, (e) => ({ reason: e.reason, keysSent: e.keysSent }), { 'prompt-response': 200, respond: 500 }),
+    row(PromptAnswerNotDeliveredError, (e) => ({ reason: e.reason, keysSent: e.keysSent }), { 'prompt-response': 200, respond: 409 }),
+    // Keys reached the pane: a failure, not a refusal, on both routes (#3952 review P2).
+    row(PromptAnswerInputLostError, (e) => ({ reason: e.reason, keysSent: e.keysSent }), { 'prompt-response': 500, respond: 500 }),
+    row(PromptAnswerAbortedError, (e) => ({ reason: exports.ANSWER_ABORTED_REASON, keysSent: e.keysSent }), { 'prompt-response': 500, respond: 500 }),
+]);
+/** The mapping row for an error, or null when it is not one of this module's. */
+function mappingOf(error) {
+    if (!(error instanceof Error))
+        return null;
+    for (const [errorClass, mapping] of exports.PROMPT_ANSWER_ERROR_RESPONSES) {
+        if (error instanceof errorClass)
+            return mapping;
+    }
+    return null;
+}
+/**
+ * How `route` answers an error `sendPromptAnswer` threw (Issue #3982), or null
+ * for an error this module does not define (the route keeps its own 500).
+ *
+ * The body always carries `reason` and `keysSent`. Its other keys are the ones
+ * each status already had: `success: false` + `message` for a 200 refusal (the
+ * route adds `answer`), `error` for a 409, and `error` prefixed
+ * `Failed to send answer to tmux:` for a 500. That 500's `error` still quotes
+ * the message, so a CLI older than this table reads it as before.
+ */
+function promptAnswerErrorResponse(error, route) {
+    const mapping = mappingOf(error);
+    if (mapping === null)
+        return null;
+    const err = error;
+    const { reason, keysSent } = mapping.facts(err);
+    const status = mapping.status[route];
+    if (status === 200) {
+        return { status, body: { success: false, reason, message: err.message, keysSent } };
+    }
+    if (status >= 500) {
+        return { status, body: { error: `Failed to send answer to tmux: ${err.message}`, reason, keysSent } };
+    }
+    return { status, body: { error: err.message, reason, keysSent } };
+}

package/dist/server/src/lib/session/agent-event-state.js

@@ -69,6 +69,7 @@ const agent_event_structured_state_1 = require("../../lib/session/agent-event-st
 const agent_event_awaiting_instruction_1 = require("../../lib/session/agent-event-awaiting-instruction");
 const agent_event_ask_user_question_1 = require("../../lib/session/agent-event-ask-user-question");
 const global_state_1 = require("../global-state");
+const prompt_submit_receipt_1 = require("../../lib/session/prompt-submit-receipt");
 var agent_event_dedup_2 = require("../../lib/session/agent-event-dedup");
 Object.defineProperty(exports, "AGENT_EVENT_DEDUP_WINDOW_MS", { enumerable: true, get: function () { return agent_event_dedup_2.AGENT_EVENT_DEDUP_WINDOW_MS; } });
 Object.defineProperty(exports, "agentEventKeyClaimedAt", { enumerable: true, get: function () { return agent_event_dedup_2.agentEventKeyClaimedAt; } });
@@ -224,6 +225,9 @@ function recordAgentEvent(worktreeId, cliToolId, instanceId, record, options = {
         return { recorded: false, skipped: 'late-session-start' };
     }
     lastAgentEvent.set(key, record);
+    // Issue #4035: what the sender asks before trusting an empty-looking composer
+    // on a session's first prompt.
+    (0, prompt_submit_receipt_1.notePromptSubmitHook)({ worktreeId, cliToolId, instanceId }, record.event, record.at);
     const outcomes = [];
     if (record.event === 'session_start') {
         // Issue #2357: a new agent process, whatever model it names first is its

package/dist/server/src/lib/session/agent-session-lifecycle.js

@@ -46,6 +46,7 @@ const session_generation_archive_1 = require("../../lib/session/session-generati
 const session_starting_state_1 = require("../../lib/session/session-starting-state");
 const auto_yes_enter_fallback_state_1 = require("../../lib/polling/auto-yes-enter-fallback-state");
 const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
+const prompt_submit_receipt_1 = require("../../lib/session/prompt-submit-receipt");
 const session_name_1 = require("../../lib/cli-tools/session-name");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('lib/session/agent-session-lifecycle');
@@ -93,7 +94,11 @@ function beginAgentSession(target, at = Date.now()) {
     // `invalidateInstanceInput`). In memory only; a name that does not resolve
     // has no lock to expire.
     try {
-        (0, instance_input_lock_1.invalidateInstanceInput)((0, session_name_1.resolveSessionName)(target.cliToolId, target.worktreeId, target.instanceId));
+        const sessionName = (0, session_name_1.resolveSessionName)(target.cliToolId, target.worktreeId, target.instanceId);
+        (0, instance_input_lock_1.invalidateInstanceInput)(sessionName);
+        // Issue #4035: the new process's first prompt is confirmed by its own
+        // `UserPromptSubmit`, which is looked up by this session name.
+        (0, prompt_submit_receipt_1.notePromptSubmitSession)(sessionName, target, at);
     }
     catch (error) {
         logger.warn('instance-input-invalidate-failed', {

package/dist/server/src/lib/session/claude-session.js

@@ -35,6 +35,8 @@ const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const session_start_error_1 = require("../../lib/session/session-start-error");
 const launch_screen_1 = require("../../lib/session/launch-screen");
 const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
+const session_launch_flight_1 = require("../../lib/session/session-launch-flight");
+const launch_keys_1 = require("../../lib/cli-tools/launch-keys");
 const logger = (0, logger_1.createLogger)('claude-session');
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 // ----- Helper Functions -----
@@ -686,12 +688,22 @@ async function startClaudeSession(options) {
             sessionName,
             workingDirectory: worktreePath,
         });
-        // SF-S2-003: Sanitize environment after createSession, before launching Claude CLI
-        await (0, session_key_sender_1.sanitizeSessionEnvironment)(sessionName);
-        // Start Claude CLI in interactive mode using dynamically resolved path.
-        // Issue #3975: one writer's turn, as gemini's launch line; the init polls
-        // below stay outside the lock.
-        await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, () => (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true));
+        // SF-S2-003: Sanitize environment after createSession, before launching
+        // Claude CLI (what session-key-sender's `sanitizeSessionEnvironment` did
+        // until #4032 removed it): drop CLAUDECODE from
+        // tmux's global environment (MF-S3-002), then `unset` it in the pane's
+        // shell, then start Claude in interactive mode using the dynamically
+        // resolved path.
+        //
+        // Issue #3981: the two lines are typed in ONE writer's turn of the input
+        // lock (#3975 locked only the launch line; the `unset` went out before it
+        // with no lock), so neither lands inside a send's body. The sanitize's
+        // 100 ms pause between them is gone: both lines queue in the same shell's
+        // input in order, so the `unset` runs first without it, and a pause inside
+        // the turn would only hold sends off longer. The init polls below stay
+        // outside the lock.
+        await execAsync('tmux set-environment -g -u CLAUDECODE 2>/dev/null || true');
+        await (0, launch_keys_1.typeLaunchLines)(sessionName, ['unset CLAUDECODE', (0, launch_screen_1.withLaunchScreenCleared)(launchCommand)]);
         // Wait for Claude to initialize with dynamic detection (OCP-001)
         // Use constants instead of hardcoded values
         const maxWaitTime = exports.CLAUDE_INIT_TIMEOUT;
@@ -799,6 +811,10 @@ async function startClaudeSession(options) {
  */
 async function sendMessageToClaude(worktreeId, message, instanceId) {
     const sessionName = getSessionName(worktreeId, instanceId);
+    // Issue #3981: a session another request is still launching shows a shell
+    // (`❯ ` can pass for Claude's prompt) — wait for that launch, or, holding the
+    // input lock as the send service does, refuse with nothing typed (R1).
+    await (0, session_launch_flight_1.settleSessionLaunch)(sessionName, 'Claude Code');
     await (0, session_key_sender_1.sendMessageToSession)(sessionName, message, exports.CLAUDE_POST_PROMPT_DELAY, exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT);
 }
 /**

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

@@ -237,7 +237,7 @@ function readAgentEvents(worktreeId, cliToolId, instanceId, resolvedInstanceId)
  * every value below is derived from the arguments, and nothing is assigned
  * outside this function.
  */
-function composePromptData({ worktreeId, cliToolId, output, captureWindowLines, statusResult, startingSince, promptWaiting, askUserQuestion, eventSource, }) {
+function composePromptData({ worktreeId, cliToolId, instanceId, output, captureWindowLines, statusResult, startingSince, promptWaiting, askUserQuestion, eventSource, }) {
     const scraperPromptWaiting = statusResult.hasActivePrompt;
     // Issue #1726: the agent's own account of what it asked. It contributes only
     // where some other layer has already established that a dialog is on screen —
@@ -338,9 +338,9 @@ function composePromptData({ worktreeId, cliToolId, output, captureWindowLines,
         : scraperPromptWaiting
             ? correctedPromptData ??
                 scraperPromptData ??
-                (structuredFacts ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts) : null)
+                (structuredFacts ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts, instanceId) : null)
             : structuredFacts
-                ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts)
+                ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts, instanceId)
                 : null;
     // Issue #2870: whether `/prompt-response` would answer the prompt published
     // above, read by the SAME function it re-verifies with. In #2868 `promptData`
@@ -813,6 +813,7 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     const { structuredFacts, promptData, promptAnswerable } = composePromptData({
         worktreeId,
         cliToolId,
+        instanceId,
         output,
         captureWindowLines,
         statusResult,
@@ -920,6 +921,7 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
             worktreeId,
             cliToolId,
             instanceId: resolvedInstanceId,
+            respondInstanceId: instanceId,
             state: promptWaiting,
             facts: structuredFacts,
         });

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

@@ -221,7 +221,7 @@ function recordUnclassifiedFrame(db, params) {
  * nothing else.
  */
 function recordStructuredPrompt(db, params) {
-    const record = (0, structured_prompt_1.buildStructuredPromptHistoryRecord)(params.worktreeId, params.facts);
+    const record = (0, structured_prompt_1.buildStructuredPromptHistoryRecord)(params.worktreeId, params.facts, params.respondInstanceId);
     try {
         const message = (0, db_1.createMessage)(db, {
             worktreeId: params.worktreeId,

package/dist/server/src/lib/session/prompt-submit-receipt.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * Whether the agent itself reported a sent prompt (Issue #4035).
+ *
+ * The submit-verified sender decides "the message left the composer" from the
+ * screen. Two of its rules say only that the body is NOT in the composer — B
+ * (no composer, or an empty one) and F (other text, such as claude's dim
+ * `Try "…"` placeholder) — and right after a claude session starts that is not
+ * the same thing: measured on Claude Code 2.1.314 (`tests/fixtures/claude-first-send-4035/`),
+ * keys typed in the first second after the prompt appeared were drawn into the
+ * composer ~1.7 s later, the Enter typed after them was lost, and the frame
+ * read after the Enter still showed the idle placeholder, so F answered
+ * `submitted` for a body that sat unsent until the next send threw it away.
+ *
+ * Claude reports every submitted prompt with its `UserPromptSubmit` hook. This
+ * module keeps, per tmux session this server started, when that hook last
+ * arrived, so the sender can ask for it before trusting B or F on the
+ * session's first prompt ({@link readPromptSubmitReceipt}). It also keeps a
+ * fingerprint (digests, never the text) of the last body the sender reported
+ * submitted, so a later send that has to clear that very body out of the
+ * composer can say so ({@link matchesSubmittedBody}).
+ *
+ * In memory on `globalThis`, like the other per-session state; a session this
+ * server did not start (one adopted after a restart) has no entry, and every
+ * question about it is answered "not required", i.e. exactly as before.
+ *
+ * @module lib/session/prompt-submit-receipt
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notePromptSubmitSession = notePromptSubmitSession;
+exports.notePromptSubmitHook = notePromptSubmitHook;
+exports.getPromptSubmitTarget = getPromptSubmitTarget;
+exports.readPromptSubmitReceipt = readPromptSubmitReceipt;
+exports.noteSubmittedBody = noteSubmittedBody;
+exports.matchesSubmittedBody = matchesSubmittedBody;
+exports.clearPromptSubmitReceipts = clearPromptSubmitReceipts;
+const crypto_1 = require("crypto");
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const global_state_1 = require("../../lib/global-state");
+/** How many sessions are tracked at once; the least recently started is forgotten first. */
+const MAX_TRACKED_SESSIONS = 1024;
+/**
+ * Compacted characters a body's prefix fingerprint covers. A composer read is
+ * cut by the reader, so a long body is recognised by its beginning.
+ */
+const BODY_PREFIX_CHARS = 64;
+const sessions = (0, global_state_1.getOrInitGlobal)('__promptSubmitSessions', () => new Map());
+const sessionByInstance = (0, global_state_1.getOrInitGlobal)('__promptSubmitSessionByInstance', () => new Map());
+function instanceKey(target) {
+    return (0, auto_yes_state_1.buildCompositeKey)(target.worktreeId, target.cliToolId, target.instanceId);
+}
+/** The tools whose prompt hook is trusted as proof of a submit. */
+function reportsPrompts(cliToolId) {
+    // Claude only. codex's hooks run in a machine-wide daemon that can file a
+    // turn under the wrong instance (#2874), and copilot's arrive out of order
+    // (#1903); neither is evidence about one pane's composer.
+    return cliToolId === 'claude';
+}
+/**
+ * A session's generation began here (`beginAgentSession`). Forgets what was
+ * known about the previous process in the same pane name.
+ */
+function notePromptSubmitSession(sessionName, target, at = Date.now()) {
+    sessions.delete(sessionName);
+    sessions.set(sessionName, { target, startedAt: at, lastEventAt: null, lastPromptAt: null, submittedBody: null });
+    sessionByInstance.set(instanceKey(target), sessionName);
+    while (sessions.size > MAX_TRACKED_SESSIONS) {
+        const oldest = sessions.keys().next().value;
+        if (oldest === undefined)
+            break;
+        const entry = sessions.get(oldest);
+        sessions.delete(oldest);
+        if (entry !== undefined && sessionByInstance.get(instanceKey(entry.target)) === oldest) {
+            sessionByInstance.delete(instanceKey(entry.target));
+        }
+    }
+}
+/** A hook was applied for this instance (`recordAgentEvent`). */
+function notePromptSubmitHook(target, event, at) {
+    let sessionName;
+    try {
+        sessionName = sessionByInstance.get(instanceKey(target));
+    }
+    catch {
+        return;
+    }
+    const entry = sessionName === undefined ? undefined : sessions.get(sessionName);
+    if (entry === undefined)
+        return;
+    entry.lastEventAt = at;
+    if (event === 'user_prompt_submit')
+        entry.lastPromptAt = at;
+}
+/** The instance a session this server started runs, or null. */
+function getPromptSubmitTarget(sessionName) {
+    return sessions.get(sessionName)?.target ?? null;
+}
+/**
+ * Whether the screen's B/F verdict for a send whose first Enter went in at
+ * `enteredAt` needs the agent's own report (Issue #4035).
+ */
+function readPromptSubmitReceipt(sessionName, cliToolId, enteredAt) {
+    if (!reportsPrompts(cliToolId))
+        return 'not-required';
+    const entry = sessions.get(sessionName);
+    if (entry === undefined || entry.target.cliToolId !== cliToolId)
+        return 'not-required';
+    if (entry.lastPromptAt !== null && entry.lastPromptAt >= enteredAt)
+        return 'received';
+    if (entry.lastEventAt === null || entry.lastEventAt < entry.startedAt)
+        return 'not-required';
+    if (entry.lastPromptAt !== null && entry.lastPromptAt >= entry.startedAt)
+        return 'not-required';
+    return 'awaited';
+}
+function compact(text) {
+    return text.replace(/\s+/g, '');
+}
+function digest(text) {
+    return (0, crypto_1.createHash)('sha256').update(text, 'utf8').digest('hex').slice(0, 16);
+}
+/**
+ * The sender reported this body submitted on this session from the screen
+ * alone — not for one the agent's hook reported, which did leave.
+ */
+function noteSubmittedBody(sessionName, message) {
+    const entry = sessions.get(sessionName);
+    if (entry === undefined)
+        return;
+    const body = compact(message);
+    entry.submittedBody = {
+        full: digest(body),
+        prefix: body.length >= BODY_PREFIX_CHARS ? digest(body.slice(0, BODY_PREFIX_CHARS)) : null,
+    };
+}
+/**
+ * Whether a composer read is the body last reported submitted on this session:
+ * the whole of it, or — for a read long enough — its beginning.
+ */
+function matchesSubmittedBody(sessionName, composerText) {
+    const body = sessions.get(sessionName)?.submittedBody;
+    if (body === null || body === undefined)
+        return false;
+    const read = compact(composerText);
+    if (read === '')
+        return false;
+    if (digest(read) === body.full)
+        return true;
+    return body.prefix !== null && read.length >= BODY_PREFIX_CHARS && digest(read.slice(0, BODY_PREFIX_CHARS)) === body.prefix;
+}
+/** Forget every session (tests). */
+function clearPromptSubmitReceipts() {
+    sessions.clear();
+    sessionByInstance.clear();
+}

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

@@ -128,13 +128,20 @@ async function isPromptWaiting(worktreeId, cliToolId, instanceId, options) {
  * That is precisely the state where a guard turns into an outage, so the message
  * has to name the way past it and how long it lasts if they do nothing.
  *
+ * Issue #4031: the commands it names carry ` --instance <id>` when the refused
+ * request named an instance, so the answer goes to the instance that is
+ * waiting. A request for the primary instance (no `instanceId`) gets the
+ * sentence as before.
+ *
  * @param blockedBy - Which layer refused; omitted callers get the plain message
+ * @param instanceId - The instance the refused request named, if any
  */
-function promptWaitingMessage(worktreeId, blockedBy) {
+function promptWaitingMessage(worktreeId, blockedBy, instanceId) {
+    const target = instanceId ? ` --instance ${instanceId}` : '';
     const base = `${worktreeId} is waiting on a prompt. Sending now would type into the ` +
         `prompt's input line instead of reaching the agent, and would leave that ` +
         `text in place for the next answer. Answer the prompt first: ` +
-        `\`commandmate respond ${worktreeId} <answer>\`.`;
+        `\`commandmate respond ${worktreeId} <answer>${target}\`.`;
     if (blockedBy !== 'structured')
         return base;
     const ttlMinutes = Math.round(prompt_waiting_composition_1.STRUCTURED_SEND_BLOCK_MAX_AGE_MS / 60_000);
@@ -142,6 +149,6 @@ function promptWaitingMessage(worktreeId, blockedBy) {
         `visible to the terminal scraper, so if the pane looks idle the record has ` +
         `outlived its dialog: it stops blocking sends ${ttlMinutes} minutes after ` +
         `it was reported, or immediately with ` +
-        `\`commandmate send ${worktreeId} <message> --ignore-structured-prompt\` ` +
+        `\`commandmate send ${worktreeId} <message>${target} --ignore-structured-prompt\` ` +
         `(server-wide: ${prompt_waiting_composition_1.STRUCTURED_SEND_GUARD_ENV}=off).`);
 }