commandmate 0.42.2 → 0.44.0

package/dist/cli/commands/reply.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * reply Command - read an agent session's latest reply (Issue #3039)
+ *
+ *   commandmate reply <worktree-id> [--instance <id|alias>] [--agent <tool>]
+ *                     [--since <iso8601>] [--json]
+ *
+ * ## Why this exists next to ask / capture
+ *
+ * `ask` reads the reply to the turn IT sent. A supervisor that nudged a worker
+ * with a plain `send` ("stop and report") had no way to read the answer short
+ * of opening the tool's transcript file itself — which works for Claude, whose
+ * path is computable from the cwd, and not for Command Code, whose project slug
+ * is not. `capture` is no substitute: the pane also holds the nudge's own echo,
+ * and a pane line cannot be attributed to a turn.
+ *
+ * The server already has the reply: the transcript readers write each turn into
+ * the chat ledger keyed `<tool>-turn:<id>`, and `ask` reads it from there. This
+ * command is that read on its own, through the same shared rules
+ * (`utils/reply-ledger`), so the two can never disagree about what a reply is.
+ *
+ * ## What it deliberately does not do
+ *
+ * - No pane fallback. A row off the screen is exactly what cannot be attributed
+ *   to a turn; returning it would re-introduce the problem this command solves.
+ *   Only transcript-reader rows count, for every tool.
+ * - No wait. It is one read; "no reply yet" is an answer (exit 0, empty stdout,
+ *   `reply: null`), not an error, so a caller can poll or give up on its terms.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReplyCommand = createReplyCommand;
+const commander_1 = require("commander");
+const types_1 = require("../types");
+const api_client_1 = require("../utils/api-client");
+const command_helpers_1 = require("../utils/command-helpers");
+const cli_tool_ids_1 = require("../config/cli-tool-ids");
+const agent_target_options_1 = require("../config/agent-target-options");
+const instances_1 = require("./instances");
+const reply_ledger_1 = require("../utils/reply-ledger");
+/**
+ * A date-time that starts with a calendar date. Date.parse alone would also
+ * take "1" or "Sep 30", which is a typo more often than an intent.
+ */
+const ISO_DATE_PREFIX = /^\d{4}-\d{2}-\d{2}/;
+/**
+ * Parse `--since <iso8601>` into epoch ms. No value means "any time".
+ *
+ * @param raw - Raw option value, if the user passed one
+ */
+function parseSince(raw) {
+    if (raw === undefined)
+        return Number.NEGATIVE_INFINITY;
+    const value = Date.parse(raw);
+    if (!ISO_DATE_PREFIX.test(raw) || !Number.isFinite(value)) {
+        console.error('Error: --since must be an ISO 8601 date-time (e.g. 2026-09-30T12:00:00Z).');
+        process.exit(types_1.ExitCode.CONFIG_ERROR);
+    }
+    return value;
+}
+function createReplyCommand() {
+    const cmd = new commander_1.Command('reply');
+    cmd
+        .description('Print the latest reply an agent session wrote (from its transcript; '
+        + 'exit 0 with empty stdout when there is none yet)')
+        .argument('<worktree-id>', 'Worktree ID')
+        .option('--instance <id>', `${agent_target_options_1.INSTANCE_OPTION_DESCRIPTION} ${instances_1.INSTANCE_ALIAS_HELP_SUFFIX}`)
+        .option('--agent <agent>', agent_target_options_1.AGENT_OPTION_DESCRIPTION)
+        .option('--since <iso8601>', 'Only a reply written at or after this time')
+        .option('--json', 'Print { worktreeId, instanceId, cliToolId, reply, requestId, at }')
+        .option('--token <token>', command_helpers_1.TOKEN_WARNING)
+        .addHelpText('after', `
+Only rows a transcript reader wrote (<tool>-turn:<id>) count as a reply, the
+same rule \`ask\` uses; the pane is never read. Tools with a transcript reader:
+claude, codex, antigravity, command-code, opencode.
+
+No reply yet (or none after --since) is not an error: stdout is empty, stderr
+says so in one line, and the exit code is 0. --json prints "reply": null.
+`)
+        .action(async (worktreeId, options) => {
+        try {
+            if (!(0, api_client_1.isValidWorktreeId)(worktreeId)) {
+                console.error('Error: Invalid worktree ID format.');
+                process.exit(types_1.ExitCode.CONFIG_ERROR);
+            }
+            if (options.agent && !(0, cli_tool_ids_1.isCliToolId)(options.agent)) {
+                console.error(`Error: Invalid agent. Must be one of: ${cli_tool_ids_1.CLI_TOOL_IDS.join(', ')}`);
+                process.exit(types_1.ExitCode.CONFIG_ERROR);
+            }
+            if (options.instance && !(0, instances_1.isInstanceSelector)(options.instance)) {
+                console.error(instances_1.INSTANCE_SELECTOR_ERROR);
+                process.exit(types_1.ExitCode.CONFIG_ERROR);
+            }
+            const since = parseSince(options.since);
+            const client = new api_client_1.ApiClient({ token: options.token });
+            // Resolved exactly as `ask` resolves it: `--agent` alone names that
+            // tool's primary instance (Issue #2479).
+            const selector = options.instance ?? options.agent;
+            const target = selector
+                ? await (0, instances_1.resolveInstanceTarget)(client, worktreeId, selector, options.agent)
+                : null;
+            const cliToolId = target ? target.cliToolId : options.agent;
+            const instanceId = target?.instanceId;
+            // Unlike `ask`, a failed read is not swallowed: there is no turn this
+            // command completed that a fallback would be protecting.
+            const messages = await (0, reply_ledger_1.requestRecentMessages)(client, worktreeId, instanceId);
+            const latest = (0, reply_ledger_1.pickLatestReply)((0, reply_ledger_1.replyCandidates)(messages, since), true);
+            if (options.json) {
+                const payload = {
+                    worktreeId,
+                    instanceId: instanceId ?? null,
+                    cliToolId: cliToolId ?? null,
+                    reply: latest?.content ?? null,
+                    requestId: latest?.requestId ?? null,
+                    at: latest?.at ?? null,
+                };
+                console.log(JSON.stringify(payload, null, 2));
+            }
+            else if (latest) {
+                console.log(latest.content);
+            }
+            if (!latest) {
+                console.error(options.since
+                    ? `No reply since ${options.since} (no transcript row yet).`
+                    : 'No reply yet (no transcript row yet).');
+            }
+            process.exit(types_1.ExitCode.SUCCESS);
+        }
+        catch (error) {
+            (0, command_helpers_1.handleCommandError)(error);
+        }
+    });
+    return cmd;
+}

package/dist/cli/commands/respond.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"respond.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/respond.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2JpC,wBAAgB,oBAAoB,IAAI,OAAO,CA4L9C"}
+{"version":3,"file":"respond.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/respond.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8apC,wBAAgB,oBAAoB,IAAI,OAAO,CA6F9C"}

package/dist/cli/commands/respond.js

@@ -120,6 +120,240 @@ async function answerSolePendingDecision(client, worktreeId, body) {
         throw error;
     }
 }
+/** Reason `/prompt-response` gives when no dialog is on screen any more. */
+const PROMPT_NO_LONGER_ACTIVE = 'prompt_no_longer_active';
+/**
+ * Issue #3125: what `--plan-review` takes. Restated rather than imported from
+ * `src/lib` (the CLI build does not reach it); the server validates the same set.
+ */
+const PLAN_REVIEW_ACTIONS = ['comment', 'submit', 'approve', 'cancel'];
+/** Reasons the server gives for a plan review answer it refused before any key. */
+function isPlanReviewRefusal(reason) {
+    return reason.startsWith('plan_review_');
+}
+/** ` --instance <id>` as the caller spelled it, or nothing. */
+function instanceFlag(instance) {
+    return instance ? ` --instance ${instance}` : '';
+}
+/**
+ * `textFollowUp` from a `/prompt-response` success (Issue #3093), read
+ * defensively: an older server omits it, and the route's mirror type is not
+ * this command's to widen.
+ */
+function readTextFollowUp(result) {
+    const value = result?.textFollowUp;
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const { optionNumber, optionLabel } = value;
+    if (typeof optionNumber !== 'number' || typeof optionLabel !== 'string')
+        return null;
+    return { optionNumber, optionLabel };
+}
+/** Argument checks; returns whether --default was chosen. A mocked `process.exit` returns, so nothing here stops early. */
+function validateRespondArgs(worktreeId, answer, options) {
+    // [SEC4-04] Validate worktree ID
+    if (!(0, api_client_1.isValidWorktreeId)(worktreeId)) {
+        console.error('Error: Invalid worktree ID format.');
+        process.exit(types_1.ExitCode.CONFIG_ERROR);
+    }
+    // Validate agent if provided
+    if (options.agent && !(0, cli_tool_ids_1.isCliToolId)(options.agent)) {
+        console.error('Error: Invalid agent.');
+        process.exit(types_1.ExitCode.CONFIG_ERROR);
+    }
+    // Issue #868 / #2376: an instance id or a roster alias.
+    if (options.instance && !(0, instances_1.isInstanceSelector)(options.instance)) {
+        console.error(instances_1.INSTANCE_SELECTOR_ERROR);
+        process.exit(types_1.ExitCode.CONFIG_ERROR);
+    }
+    // Issue #1681: exactly one of <answer> / --default
+    const useDefault = options.default === true;
+    // Issue #3125: Command Code's plan review. `approve` / `cancel` take no text,
+    // `comment` needs it, and `submit` takes an optional comment to send first.
+    const planReview = options.planReview;
+    if (planReview !== undefined) {
+        if (!PLAN_REVIEW_ACTIONS.includes(planReview)) {
+            console.error(`Error: --plan-review must be one of: ${PLAN_REVIEW_ACTIONS.join(', ')}.`);
+            process.exit(types_1.ExitCode.CONFIG_ERROR);
+        }
+        if (useDefault) {
+            console.error('Error: --plan-review and --default are mutually exclusive.');
+            process.exit(types_1.ExitCode.CONFIG_ERROR);
+        }
+        if ((planReview === 'approve' || planReview === 'cancel') && answer !== undefined) {
+            console.error(`Error: --plan-review ${planReview} takes no <answer>.`);
+            process.exit(types_1.ExitCode.CONFIG_ERROR);
+        }
+        if (planReview === 'comment' && (answer === undefined || !answer.trim())) {
+            console.error('Error: --plan-review comment needs the comment text as <answer>.');
+            process.exit(types_1.ExitCode.CONFIG_ERROR);
+        }
+        return false;
+    }
+    if (useDefault && answer !== undefined) {
+        console.error('Error: <answer> and --default are mutually exclusive.');
+        process.exit(types_1.ExitCode.CONFIG_ERROR);
+    }
+    if (!useDefault && (answer === undefined || !answer.trim())) {
+        console.error('Error: Answer cannot be empty. Provide an answer or --default.');
+        process.exit(types_1.ExitCode.CONFIG_ERROR);
+    }
+    return useDefault;
+}
+/** The `/prompt-response` request body. */
+function buildPromptResponseBody(useDefault, answer, agent, instanceId, planReview) {
+    // [DR2-06] Use prompt-response API with cliTool (not cliToolId)
+    const body = useDefault ? { useDefault: true } : { answer };
+    // Issue #3125: Command Code's plan review action.
+    if (planReview !== undefined) {
+        body.planReviewAction = planReview;
+    }
+    if (agent) {
+        body.cliTool = agent;
+    }
+    // Issue #868: target a specific agent instance
+    if (instanceId) {
+        body.instanceId = instanceId;
+    }
+    return body;
+}
+/** Reports a `success: false` result and sets the exit code. */
+function reportFailedResponse(result, worktreeId, answer, useDefault, options) {
+    // [DR2-06] Check reason for failure
+    const reason = result.reason || 'unknown';
+    // Issue #1681 / #1726: these mean the server refused BEFORE sending,
+    // so the terminal is untouched — worth saying plainly, because the
+    // other reasons leave the answer's fate unknown. Issue #2486 adds
+    // `unsupported_dialog_layout`: a picker IS on screen but its layout
+    // could not be verified, and the server's message says what to do.
+    // Issue #3125 adds the `plan_review_*` refusals: the plan review overlay was
+    // read and the request did not fit its current focus, so nothing was typed.
+    const refusedBeforeSending = reason === 'unresolvable_answer' ||
+        reason === 'answer_out_of_range' ||
+        reason === 'unsupported_dialog_layout' ||
+        isPlanReviewRefusal(reason);
+    // Issue #1898: the verdict was addressed to the agent's own API and
+    // the POST did not land. Distinct from the two above — the answer was
+    // resolved and an attempt was made — and distinct from a keystroke,
+    // whose fate is never knowable.
+    if (reason === 'decision_not_delivered') {
+        console.error(`Error: The approval could not be delivered to the agent (reason: ${reason}). ` +
+            'The dialog is still open; answer it in the terminal.');
+        process.exit(types_1.ExitCode.UNEXPECTED_ERROR);
+    }
+    if (refusedBeforeSending) {
+        console.error(`Error: Answer was not sent. Reason: ${reason}${result.message ? ` (${result.message})` : ''}`);
+        // Issue #2583: the operator who lands here typed WORDS at a dialog
+        // that only takes a choice — a claude / agy Bash approval refused as
+        // free text, or #2573's "No, tell … what to do differently" row. The
+        // server's sentence ends with "answer with the option number", and
+        // this is that command with the ids already filled in, so the next
+        // step is a paste rather than a trip to the docs while a dialog sits
+        // open. Printed only for the reason that means "this answer could not
+        // be mapped onto a choice", and only when the answer was not already
+        // a number (where the number itself is what was wrong).
+        if (reason === 'unresolvable_answer' && answer !== undefined && !/^\d+$/.test(answer.trim())) {
+            const target = options.instance ? ` --instance ${options.instance}` : '';
+            console.error(`Hint: answer with the option number — \`commandmate respond ${worktreeId} <number>${target}\` ` +
+                `(\`commandmate capture ${worktreeId}${target}\` prints the dialog and its numbers).`);
+        }
+    }
+    else {
+        console.error(`Warning: Response may not have been applied. Reason: ${reason}`);
+        // Issue #3093: the usual way here is the second half of a "No, tell
+        // … what to do differently" answer — the row closed the dialog and
+        // the agent is waiting for the reason in its input box, which
+        // `respond` (dialogs only) cannot reach and `send` can.
+        if (reason === PROMPT_NO_LONGER_ACTIVE && !useDefault && answer !== undefined && !/^\d+$/.test(answer.trim())) {
+            console.error('Hint: no dialog is open, so this text was not delivered. If you just chose an option that asks ' +
+                'for text (e.g. "No, tell … what to do differently"), the agent is waiting for it in its input box — ' +
+                `send it with \`commandmate send ${worktreeId} "<text>"${instanceFlag(options.instance)}\`.`);
+        }
+    }
+    // Issue #1726: an option number the agent's own payload does not offer
+    // is a bad argument, so it exits with the input-error code the rest of
+    // this command already uses for a malformed worktree id or agent.
+    process.exit(reason === 'answer_out_of_range' ? types_1.ExitCode.CONFIG_ERROR : types_1.ExitCode.UNEXPECTED_ERROR);
+}
+/**
+ * What was done on Command Code's plan review (Issue #3125), and the next step:
+ * a pinned comment is not delivered to the agent until the review is submitted.
+ */
+function printPlanReviewOutcome(result, worktreeId, options) {
+    const planReview = result.planReview;
+    if (!planReview)
+        return;
+    const target = instanceFlag(options.instance);
+    switch (planReview.action) {
+        case 'comment':
+            console.log(`Plan review: pinned comment "${planReview.comment ?? ''}".`);
+            console.error(`Next: send the review with \`commandmate respond ${worktreeId} --plan-review submit${target}\` ` +
+                `(ctrl+r), or approve with \`--plan-review approve\` (comments go along as notes).`);
+            break;
+        case 'submit':
+            console.log(planReview.comment
+                ? `Plan review: pinned comment "${planReview.comment}" and submitted the review (ctrl+r).`
+                : 'Plan review: submitted the review (ctrl+r).');
+            break;
+        case 'approve':
+            if (planReview.phase === 'approve-choice') {
+                console.log(`Plan review: confirmed the approval (${planReview.approveChoice === 'discard-comments' ? 'discarding' : 'with'} the pending comments).`);
+            }
+            else {
+                console.log('Plan review: approved the plan (ctrl+a).');
+                if (planReview.pendingCommentsBefore > 0) {
+                    console.error('Note: with pending comments Command Code may ask how to approve — confirm with ' +
+                        `\`commandmate respond ${worktreeId} --plan-review approve${target}\` again, or go back with \`--plan-review cancel\`.`);
+                }
+            }
+            break;
+        case 'cancel':
+            console.log(planReview.phase === 'approve-choice'
+                ? 'Plan review: went back from the approval choice (esc).'
+                : 'Plan review: cancelled the plan (esc).');
+            if (planReview.phase !== 'approve-choice' && planReview.pendingCommentsBefore > 0) {
+                console.error(`Note: ${planReview.pendingCommentsBefore} pending comment(s) were discarded with it.`);
+            }
+            break;
+    }
+}
+/** Audit trail of which option was actually selected. */
+function printResolvedAudit(result, answer) {
+    // Issue #1681: audit trail — print which option was actually selected.
+    const resolved = result?.resolved;
+    if (resolved) {
+        if (resolved.via === 'structured-decision') {
+            // Issue #1898: no key was sent. The verdict went to the agent's own
+            // API by decision id, which is the only way an opencode approval can
+            // be answered at all — worth saying, because "Response sent." on
+            // this path would read as "a 1 was typed into the pane".
+            console.log(`Answered approval ${resolved.decisionId ?? '(unknown id)'} with ` +
+                `option ${resolved.optionNumber}: ${resolved.optionLabel}`);
+        }
+        else if (resolved.via === 'structured-question') {
+            // Issue #2040: a question, answered over `POST /question/:id/reply`.
+            // What is printed is what reached the AGENT — the labels — rather
+            // than the number that was typed: `respond <id> 2` at a question is
+            // a position in the agent's own list, and an operator reconciling
+            // what they meant against what was sent needs the other end of that
+            // mapping. `freeText` prints the text for the same reason.
+            const chosen = resolved.optionLabels ?? [];
+            console.log(`Answered question ${resolved.decisionId ?? '(unknown id)'} with ` +
+                (chosen.length > 0
+                    ? chosen.map((label, index) => `${resolved.optionNumbers?.[index] ?? '?'}: ${label}`).join(', ')
+                    : `free text: ${(resolved.answers?.[0] ?? []).join(', ')}`));
+        }
+        else if (resolved.via === 'semantic') {
+            console.log(`Resolved "${answer}" to option ${resolved.optionNumber}: ${resolved.optionLabel}`);
+        }
+        else if (resolved.optionNumber !== undefined) {
+            console.log(`Selected default option ${resolved.optionNumber}: ${resolved.optionLabel}`);
+        }
+        else {
+            console.log(`Selected default answer: ${resolved.optionLabel}`);
+        }
+    }
+}
 function createRespondCommand() {
     const cmd = new commander_1.Command('respond');
     cmd
@@ -127,36 +361,14 @@ function createRespondCommand() {
         .argument('<worktree-id>', 'Worktree ID')
         .argument('[answer]', 'Response answer (yes, no, number, or free text)')
         .option('--default', "Select the prompt's default option (mutually exclusive with <answer>)")
+        .option('--plan-review <action>', 'Command Code plan review: comment | submit | approve | cancel ' +
+        '(text alone is a comment; submit takes an optional comment; approve/cancel take no <answer>)')
         .option('--instance <id>', `${agent_target_options_1.INSTANCE_OPTION_DESCRIPTION} ${instances_1.INSTANCE_ALIAS_HELP_SUFFIX}`)
         .option('--agent <agent>', agent_target_options_1.AGENT_OPTION_DESCRIPTION)
         .option('--token <token>', command_helpers_1.TOKEN_WARNING)
         .action(async (worktreeId, answer, options) => {
         try {
-            // [SEC4-04] Validate worktree ID
-            if (!(0, api_client_1.isValidWorktreeId)(worktreeId)) {
-                console.error('Error: Invalid worktree ID format.');
-                process.exit(types_1.ExitCode.CONFIG_ERROR);
-            }
-            // Validate agent if provided
-            if (options.agent && !(0, cli_tool_ids_1.isCliToolId)(options.agent)) {
-                console.error('Error: Invalid agent.');
-                process.exit(types_1.ExitCode.CONFIG_ERROR);
-            }
-            // Issue #868 / #2376: an instance id or a roster alias.
-            if (options.instance && !(0, instances_1.isInstanceSelector)(options.instance)) {
-                console.error(instances_1.INSTANCE_SELECTOR_ERROR);
-                process.exit(types_1.ExitCode.CONFIG_ERROR);
-            }
-            // Issue #1681: exactly one of <answer> / --default
-            const useDefault = options.default === true;
-            if (useDefault && answer !== undefined) {
-                console.error('Error: <answer> and --default are mutually exclusive.');
-                process.exit(types_1.ExitCode.CONFIG_ERROR);
-            }
-            if (!useDefault && (answer === undefined || !answer.trim())) {
-                console.error('Error: Answer cannot be empty. Provide an answer or --default.');
-                process.exit(types_1.ExitCode.CONFIG_ERROR);
-            }
+            const useDefault = validateRespondArgs(worktreeId, answer, options);
             const client = new api_client_1.ApiClient({ token: options.token });
             // Issue #1629: /prompt-response derives the session name from cliTool
             // and falls back to the worktree default, so `--instance codex` alone
@@ -168,15 +380,7 @@ function createRespondCommand() {
             const agent = target ? target.cliToolId : options.agent;
             // Issue #2376: the resolved id. /prompt-response reads instance ids.
             const instanceId = target?.instanceId;
-            // [DR2-06] Use prompt-response API with cliTool (not cliToolId)
-            const body = useDefault ? { useDefault: true } : { answer };
-            if (agent) {
-                body.cliTool = agent;
-            }
-            // Issue #868: target a specific agent instance
-            if (instanceId) {
-                body.instanceId = instanceId;
-            }
+            const body = buildPromptResponseBody(useDefault, answer, agent, instanceId, options.planReview);
             // Issue #2040: for an agent that publishes per-decision ids (opencode
             // today, and only opencode), a bare `respond <worktree> 3` names the ONE
             // decision that agent is holding, and the number is resolved against
@@ -189,7 +393,11 @@ function createRespondCommand() {
             // the structured path refuses it (`answerStructuredDecision` says so in
             // as many words) — while Enter at a `keys` dialog is a real answer that
             // this command has always been able to give.
-            const structured = !useDefault && (await addressesDecisionsById(client, worktreeId, agent, instanceId));
+            //
+            // Issue #3125: a plan review action names no decision, so it skips this.
+            const structured = !useDefault &&
+                options.planReview === undefined &&
+                (await addressesDecisionsById(client, worktreeId, agent, instanceId));
             let result = null;
             if (structured) {
                 const outcome = await answerSolePendingDecision(client, worktreeId, body);
@@ -205,85 +413,20 @@ function createRespondCommand() {
                 result = await client.post(`/api/worktrees/${worktreeId}/prompt-response`, body);
             }
             if (result && !result.success) {
-                // [DR2-06] Check reason for failure
-                const reason = result.reason || 'unknown';
-                // Issue #1681 / #1726: these mean the server refused BEFORE sending,
-                // so the terminal is untouched — worth saying plainly, because the
-                // other reasons leave the answer's fate unknown. Issue #2486 adds
-                // `unsupported_dialog_layout`: a picker IS on screen but its layout
-                // could not be verified, and the server's message says what to do.
-                const refusedBeforeSending = reason === 'unresolvable_answer' ||
-                    reason === 'answer_out_of_range' ||
-                    reason === 'unsupported_dialog_layout';
-                // Issue #1898: the verdict was addressed to the agent's own API and
-                // the POST did not land. Distinct from the two above — the answer was
-                // resolved and an attempt was made — and distinct from a keystroke,
-                // whose fate is never knowable.
-                if (reason === 'decision_not_delivered') {
-                    console.error(`Error: The approval could not be delivered to the agent (reason: ${reason}). ` +
-                        'The dialog is still open; answer it in the terminal.');
-                    process.exit(types_1.ExitCode.UNEXPECTED_ERROR);
-                }
-                if (refusedBeforeSending) {
-                    console.error(`Error: Answer was not sent. Reason: ${reason}${result.message ? ` (${result.message})` : ''}`);
-                    // Issue #2583: the operator who lands here typed WORDS at a dialog
-                    // that only takes a choice — a claude / agy Bash approval refused as
-                    // free text, or #2573's "No, tell … what to do differently" row. The
-                    // server's sentence ends with "answer with the option number", and
-                    // this is that command with the ids already filled in, so the next
-                    // step is a paste rather than a trip to the docs while a dialog sits
-                    // open. Printed only for the reason that means "this answer could not
-                    // be mapped onto a choice", and only when the answer was not already
-                    // a number (where the number itself is what was wrong).
-                    if (reason === 'unresolvable_answer' && answer !== undefined && !/^\d+$/.test(answer.trim())) {
-                        const target = options.instance ? ` --instance ${options.instance}` : '';
-                        console.error(`Hint: answer with the option number — \`commandmate respond ${worktreeId} <number>${target}\` ` +
-                            `(\`commandmate capture ${worktreeId}${target}\` prints the dialog and its numbers).`);
-                    }
-                }
-                else {
-                    console.error(`Warning: Response may not have been applied. Reason: ${reason}`);
-                }
-                // Issue #1726: an option number the agent's own payload does not offer
-                // is a bad argument, so it exits with the input-error code the rest of
-                // this command already uses for a malformed worktree id or agent.
-                process.exit(reason === 'answer_out_of_range' ? types_1.ExitCode.CONFIG_ERROR : types_1.ExitCode.UNEXPECTED_ERROR);
-            }
-            // Issue #1681: audit trail — print which option was actually selected.
-            const resolved = result?.resolved;
-            if (resolved) {
-                if (resolved.via === 'structured-decision') {
-                    // Issue #1898: no key was sent. The verdict went to the agent's own
-                    // API by decision id, which is the only way an opencode approval can
-                    // be answered at all — worth saying, because "Response sent." on
-                    // this path would read as "a 1 was typed into the pane".
-                    console.log(`Answered approval ${resolved.decisionId ?? '(unknown id)'} with ` +
-                        `option ${resolved.optionNumber}: ${resolved.optionLabel}`);
-                }
-                else if (resolved.via === 'structured-question') {
-                    // Issue #2040: a question, answered over `POST /question/:id/reply`.
-                    // What is printed is what reached the AGENT — the labels — rather
-                    // than the number that was typed: `respond <id> 2` at a question is
-                    // a position in the agent's own list, and an operator reconciling
-                    // what they meant against what was sent needs the other end of that
-                    // mapping. `freeText` prints the text for the same reason.
-                    const chosen = resolved.optionLabels ?? [];
-                    console.log(`Answered question ${resolved.decisionId ?? '(unknown id)'} with ` +
-                        (chosen.length > 0
-                            ? chosen.map((label, index) => `${resolved.optionNumbers?.[index] ?? '?'}: ${label}`).join(', ')
-                            : `free text: ${(resolved.answers?.[0] ?? []).join(', ')}`));
-                }
-                else if (resolved.via === 'semantic') {
-                    console.log(`Resolved "${answer}" to option ${resolved.optionNumber}: ${resolved.optionLabel}`);
-                }
-                else if (resolved.optionNumber !== undefined) {
-                    console.log(`Selected default option ${resolved.optionNumber}: ${resolved.optionLabel}`);
-                }
-                else {
-                    console.log(`Selected default answer: ${resolved.optionLabel}`);
-                }
+                reportFailedResponse(result, worktreeId, answer, useDefault, options);
             }
+            printResolvedAudit(result, answer);
+            if (result && 'planReview' in result)
+                printPlanReviewOutcome(result, worktreeId, options);
             console.error('Response sent.');
+            // Issue #3093: the option just chosen continues as typed text, which the
+            // dialog no longer takes — name the command that does deliver it.
+            const followUp = readTextFollowUp(result);
+            if (followUp) {
+                console.error(`Next: option ${followUp.optionNumber} ("${followUp.optionLabel}") asks for your text, and the dialog ` +
+                    'is closed now, so `respond` cannot deliver it — send it with ' +
+                    `\`commandmate send ${worktreeId} "<text>"${instanceFlag(options.instance)}\`.`);
+            }
         }
         catch (error) {
             (0, command_helpers_1.handleCommandError)(error);

package/dist/cli/commands/stop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/stop.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAA6B,MAAM,UAAU,CAAC;AASlE;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAyFrE"}
+{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/stop.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAA6B,MAAM,UAAU,CAAC;AA8ClE;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA6GrE"}

package/dist/cli/commands/stop.js

@@ -14,7 +14,39 @@ const daemon_1 = require("../utils/daemon");
 const security_logger_1 = require("../utils/security-logger");
 const env_setup_1 = require("../utils/env-setup");
 const input_validators_1 = require("../utils/input-validators");
+const server_ready_1 = require("../utils/server-ready");
+const server_url_1 = require("../utils/server-url");
+const process_inspect_1 = require("../utils/process-inspect");
 const logger = new logger_1.CLILogger();
+/**
+ * Issue #3087: with nothing recorded to stop, make sure nothing answers on the configured port
+ * either. A server whose PID file is gone (an orphan from an earlier start, or a file removed by
+ * a failed run) still serves there, and "Status: Stopped" would be false. Such a process cannot
+ * be proven to be ours, so it is reported, never killed.
+ *
+ * Only the main server's .env port is known here; a worktree server's port is not re-derived.
+ *
+ * @returns true when the configured port is free
+ */
+async function ensureConfiguredPortFree(daemonManager, serverLabel) {
+    const endpoint = (0, server_url_1.resolveServerEndpoint)(daemonManager.getEffectiveEnv());
+    const host = endpoint.bind === '0.0.0.0' ? '127.0.0.1' : endpoint.bind;
+    if (!(await (0, server_ready_1.isPortInUse)(host, endpoint.port))) {
+        return true;
+    }
+    const listeners = (0, process_inspect_1.describeListeners)(endpoint.port);
+    logger.error(`${serverLabel} has no running process on record, but something is answering on ${host}:${endpoint.port}` +
+        `${listeners ? `: ${listeners}` : ''}.`);
+    logger.info('It was not started through this PID file, so it was not stopped. ' +
+        'If it is an earlier CommandMate server, stop it yourself (e.g. kill <PID>).');
+    (0, security_logger_1.logSecurityEvent)({
+        timestamp: new Date().toISOString(),
+        command: 'stop',
+        action: 'failure',
+        details: `Unrecorded listener on port ${endpoint.port}${listeners ? ` (${listeners})` : ''}`,
+    });
+    return false;
+}
 /**
  * Execute stop command
  * Issue #125: Use getPidFilePath for correct path resolution
@@ -44,10 +76,30 @@ async function stopCommand(options) {
             const status = await daemonManager.getStatus();
             if (status === null) {
                 logger.info(`${serverLabel} is not running (no PID file found)`);
-                logger.info('Status: Stopped');
             }
             else {
                 logger.info(`${serverLabel} is not running (stale PID file)`);
+                // Issue #3087: the recorded npm process can be gone while the server it launched still
+                // listens as an orphan. stop() finds that process group and stops it, and only reports
+                // failure when something is left behind.
+                if (!(await daemonManager.stop(options.force))) {
+                    logger.error(`Failed to stop ${serverLabel}: its processes or port are still in use`);
+                    (0, security_logger_1.logSecurityEvent)({
+                        timestamp: new Date().toISOString(),
+                        command: 'stop',
+                        action: 'failure',
+                        details: `Failed to stop orphaned server of PID ${status.pid ?? 'unknown'}${options.issue !== undefined ? ` (Issue #${options.issue})` : ''}`,
+                    });
+                    process.exit(types_1.ExitCode.STOP_FAILED);
+                    return;
+                }
+            }
+            if (options.issue === undefined && !(await ensureConfiguredPortFree(daemonManager, serverLabel))) {
+                process.exit(types_1.ExitCode.STOP_FAILED);
+                return;
+            }
+            if (status === null) {
+                logger.info('Status: Stopped');
             }
             process.exit(types_1.ExitCode.SUCCESS);
             return;

package/dist/cli/commands/sync.js

@@ -39,9 +39,9 @@ function createSyncCommand() {
             }
         }
         catch (error) {
-            // The route's only 400 is "No repositories configured..." — the server's
-            // wording names the fix (WORKTREE_REPOS / CM_ROOT_DIR), so pass it
-            // through instead of the generic "Bad request" mapping.
+            // The route's only 400 is "No repositories are registered yet..." — the
+            // server's wording names the fix (Web UI Add Repository / WORKTREE_REPOS),
+            // so pass it through instead of the generic "Bad request" mapping.
             if (error instanceof api_client_1.ApiError && error.statusCode === 400 && error.payload?.error) {
                 console.error(`Error: ${error.payload.error}`);
                 process.exit(types_1.ExitCode.CONFIG_ERROR);

package/dist/cli/commands/wait.d.ts

@@ -124,6 +124,11 @@ export interface PollWorktreeOptions extends WaitOptions {
 export declare function pollWorktree(client: ApiClient, worktreeId: string, options: PollWorktreeOptions): Promise<{
     exitCode: number;
     output?: WaitPromptOutput;
+    /** Set with exit 11: which upstream fault was on the frame (Issue #3011). */
+    upstreamFault?: {
+        id: string;
+        matchedText: string;
+    };
 }>;
 export declare function createWaitCommand(): Command;
 //# sourceMappingURL=wait.d.ts.map