commandmate 0.49.1 → 0.49.2

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

@@ -1 +1 @@
-{"version":3,"file":"ask.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/ask.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8cpC,wBAAgB,gBAAgB,IAAI,OAAO,CA4L1C"}
+{"version":3,"file":"ask.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/ask.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuepC,wBAAgB,gBAAgB,IAAI,OAAO,CA6N1C"}

package/dist/cli/commands/ask.js

@@ -62,6 +62,11 @@ const PANE_FALLBACK_TAIL = 80;
  * marked yet — a session that already answered returns on the first read. When
  * it does elapse the existing pane fallback takes over, so the cost of guessing
  * this too low is a screen scrape, never a lost turn.
+ *
+ * Issue #3983: also the bound of each read after the turn ended (the ledger,
+ * the overlap pages, the pane). Those are outside `--timeout` — the turn has
+ * already completed in time — so a read that does not answer within the grace
+ * moves on to the next fallback rather than ending the ask with 124.
  */
 const REPLY_TURN_ROW_GRACE_MS = 15_000;
 /** How often the grace above re-reads the ledger. */
@@ -130,8 +135,19 @@ function parseTimeout(raw) {
 async function readLatestReply(client, worktreeId, instanceId, since, cliToolId) {
     const requireTurnRow = cliToolId !== undefined && reply_ledger_1.TRANSCRIPT_READER_TOOLS.has(cliToolId);
     const deadline = Date.now() + (requireTurnRow ? REPLY_TURN_ROW_GRACE_MS : 0);
+    // Issue #3983: every read is bounded by the grace, with or without a turn row
+    // to wait for; one that runs out falls back to the pane like an empty ledger.
+    const graceClient = client.withDeadline(Date.now() + REPLY_TURN_ROW_GRACE_MS);
     for (;;) {
-        const messages = await (0, reply_ledger_1.fetchRecentMessages)(client, worktreeId, instanceId);
+        let messages;
+        try {
+            messages = await (0, reply_ledger_1.fetchRecentMessages)(graceClient, worktreeId, instanceId);
+        }
+        catch (error) {
+            if (!(0, api_client_1.isDeadlineExceeded)(error))
+                throw error;
+            return { content: null, messages: null };
+        }
         // The rules are `reply`'s too (Issue #3039). A tool with no transcript
         // takes the newest row after the send, marker or not, with no wait.
         const reply = (0, reply_ledger_1.pickLatestReply)((0, reply_ledger_1.replyCandidates)(messages ?? [], since), requireTurnRow);
@@ -158,7 +174,10 @@ async function readLatestReply(client, worktreeId, instanceId, since, cliToolId)
  * @param instanceId - Resolved instance ID
  */
 async function readPaneTail(client, worktreeId, cliToolId, instanceId) {
-    return (0, capture_1.readSqueezedPaneTail)(client, worktreeId, cliToolId, instanceId, PANE_FALLBACK_TAIL);
+    // Issue #3983: bounded like the ledger reads; a pane that does not answer is
+    // "no readable pane" (readSqueezedPaneTail never throws).
+    const graceClient = client.withDeadline(Date.now() + REPLY_TURN_ROW_GRACE_MS);
+    return (0, capture_1.readSqueezedPaneTail)(graceClient, worktreeId, cliToolId, instanceId, PANE_FALLBACK_TAIL);
 }
 /** Argument checks. A mocked `process.exit` returns, so nothing here stops early. */
 function validateAskArgs(worktreeId, message, options) {
@@ -329,7 +348,14 @@ function overlapWindowEnd(askedAt, turnEndedAt, closedAt) {
 async function readOverlapLedger(client, worktreeId, instanceId, message, askedAt, until, messages) {
     let rows = messages;
     if (rows && (0, reply_ledger_1.mayHaveDroppedRowsSince)(rows, askedAt)) {
-        const since = await (0, reply_ledger_1.fetchPromptRowsSince)(client, worktreeId, instanceId, askedAt);
+        // Issue #3983: bounded by the reply grace; a page that does not answer in
+        // it is read like one that failed — the rows already read stand.
+        const graceClient = client.withDeadline(Date.now() + REPLY_TURN_ROW_GRACE_MS);
+        const since = await (0, reply_ledger_1.fetchPromptRowsSince)(graceClient, worktreeId, instanceId, askedAt).catch((error) => {
+            if ((0, api_client_1.isDeadlineExceeded)(error))
+                return null;
+            throw error;
+        });
         if (since)
             rows = [...rows, ...since];
     }
@@ -401,7 +427,9 @@ Exit codes (wait's, unchanged; --async always exits 0 once the relay exists):
        name it (id=...). id=context-limit: the conversation is over the model's
        limit; \`instances <id> kill <instance>\` and ask again in a fresh session
   21   nothing was running to ask
-  124  timed out. Look with \`capture <id> --instance <id> --pane --tail 60\`
+  124  timed out. Look with \`capture <id> --instance <id> --pane --tail 60\`.
+       When the send itself returned past the deadline, the message WAS sent
+       (stderr says so); do not send it again
 
 Send one ask at a time to an instance (Issue #3955). A message sent while the
 instance is mid-turn can be folded into that turn (codex does), and the two
@@ -416,10 +444,14 @@ There is deliberately no --auto-yes: turning another session's Auto-Yes on is
 a decision about that session's guard rails, not part of asking it a question.
 `)
         .action(async (worktreeId, message, options) => {
+        // Issue #3983: `--timeout` counts from here, the resolution and the send
+        // included.
+        const commandStartedAt = Date.now();
         try {
             validateAskArgs(worktreeId, message, options);
             const timeout = parseTimeout(options.timeout);
             const client = new api_client_1.ApiClient({ token: options.token });
+            const deadlineAt = commandStartedAt + timeout * 1000;
             // Resolved once, before the send, and reused for the wait and both
             // reads: the alias-to-id mapping and the roster's tool are the same
             // facts for all four requests, and asking twice is how two of them end
@@ -433,7 +465,10 @@ a decision about that session's guard rails, not part of asking it a question.
             // worktree default: exit 21 while the default was not running, and the
             // default's turn instead of <tool>'s while it was.
             const selector = options.instance ?? options.agent;
-            const { agent, instanceId } = await (0, command_target_1.resolveCommandTarget)(client, worktreeId, selector, options.agent);
+            //
+            // Issue #3983: bounded by `--timeout`; running out is exit 124, nothing sent.
+            const commandTarget = await (0, command_target_1.resolveCommandTarget)(client.withDeadline(deadlineAt), worktreeId, selector, options.agent);
+            const { agent, instanceId } = commandTarget;
             // Taken BEFORE the send so a reply written by the previous turn cannot
             // be read as this one's. Milliseconds, compared against the row's own
             // timestamp rather than against a re-derived clock.
@@ -441,6 +476,9 @@ a decision about that session's guard rails, not part of asking it a question.
             // Issue #2377: registered BEFORE the send, so a session that answers
             // immediately cannot finish its turn in the window between the message
             // and the ledger row. A refusal exits 2 having sent nothing.
+            //
+            // Issue #3983: the endpoint resolution is bounded by `--timeout` (exit
+            // 124, nothing registered or sent); the relay POST is not cut, like `/send`.
             let relay;
             if (options.async) {
                 relay = await (0, message_dispatch_1.registerRelayForMessage)(client, {
@@ -449,6 +487,7 @@ a decision about that session's guard rails, not part of asking it a question.
                     instance: options.instance,
                     agent: options.agent,
                     allowRelayChain: options.allowRelayChain,
+                    resolveClient: client.withDeadline(deadlineAt),
                 });
             }
             const sendBody = { content: message };
@@ -465,6 +504,7 @@ a decision about that session's guard rails, not part of asking it a question.
             const sent = await (0, message_dispatch_1.postMessage)(client, worktreeId, sendBody, {
                 relay,
                 promptWaitingFallback: `${worktreeId} is waiting on a prompt; the message was not sent.`,
+                target: commandTarget,
             });
             // Issue #2377: the whole point of `--async`. Nothing is waited on, so
             // the caller's own turn ends here and the answer arrives later, in their
@@ -473,6 +513,16 @@ a decision about that session's guard rails, not part of asking it a question.
                 printAsyncAck(worktreeId, instanceId, agent, relay.id, options);
                 return;
             }
+            // Issue #3983: the send itself is not cut by `--timeout` — aborting it
+            // would leave "was it sent?" unanswered — but its time counts. Past the
+            // deadline once it returns, the ask ends here, saying the message went in.
+            if (Date.now() >= deadlineAt) {
+                console.error(`Timeout: ${worktreeId} exceeded ${timeout}s while the message was being sent. `
+                    + 'The message was sent; not waiting for the reply. '
+                    + `Look with \`capture ${worktreeId}${instanceId ? ` --instance ${instanceId}` : ''} --pane --tail 60\`.`);
+                process.exit(types_1.WaitExitCode.TIMEOUT);
+                return;
+            }
             console.error('Message sent. Waiting for the reply...');
             // `wait`'s own poller, with `wait`'s own defaults: --on-prompt is left
             // at `agent`, so a prompt ends this ask with exit 10 and the payload
@@ -484,6 +534,7 @@ a decision about that session's guard rails, not part of asking it a question.
             const record = { openAtSend: false, closedAt: null };
             const result = await (0, wait_1.pollWorktree)(client, worktreeId, {
                 timeout,
+                timeoutStartedAt: commandStartedAt,
                 instance: instanceId,
                 token: options.token,
                 // Always on (Issue #3011): a turn that never ran must not read as a reply.

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

@@ -32,6 +32,7 @@
 import { Command } from 'commander';
 import { ApiClient } from '../utils/api-client';
 import type { ApiErrorPayload } from '../utils/api-client';
+import { type CommandTarget } from './command-target';
 /** The name `attach` will connect to, and whether the server published it. */
 export interface AttachSessionTarget {
     sessionName: string;
@@ -136,11 +137,13 @@ export declare function planGuardedAttach(ownership: Extract<AttachOwnership, {
  * @param cliToolId - Resolved CLI tool
  * @param worktreeId - Worktree id, so the hint's commands are copy-pasteable
  * @param sessionName - Resolved tmux session name
- * @param options - The flags as given
+ * @param options - The flags as given; `target` is the resolved target the
+ *   `capture` hints name (Issue #3982), none when absent
  */
 export declare function buildAttachHints(cliToolId: string, worktreeId: string, sessionName: string, options: {
     readOnly?: boolean;
     live?: boolean;
+    target?: CommandTarget;
 }): string[];
 export declare function createAttachCommand(): Command;
 //# sourceMappingURL=attach.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"attach.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/attach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EACL,SAAS,EAMV,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAsD3D,8EAA8E;AAC9E,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAqCD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,GAChD;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,GAAG,EAAE,YAAY,GAAG,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE5F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,eAAe,CAAC,CAqB1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,OAAO,EAAE,SAAS,GAAG,aAAa,CAAA;CAAE,CAAC,EAC3E,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAC/C;IAAE,eAAe,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CA0C/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9C,MAAM,EAAE,CAmCV;AAiDD,wBAAgB,mBAAmB,IAAI,OAAO,CAoF7C"}
+{"version":3,"file":"attach.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/attach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EACL,SAAS,EAMV,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAO3D,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAsDvE,8EAA8E;AAC9E,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAqCD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACpB;IAAE,OAAO,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,GAChD;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,GAAG,EAAE,YAAY,GAAG,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE5F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,eAAe,CAAC,CAqB1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,OAAO,EAAE,SAAS,GAAG,aAAa,CAAA;CAAE,CAAC,EAC3E,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,GAC/C;IAAE,eAAe,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CA0C/C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,aAAa,CAAA;CAAE,GACtE,MAAM,EAAE,CAuCV;AAiDD,wBAAgB,mBAAmB,IAAI,OAAO,CAqF7C"}

package/dist/cli/commands/attach.js

@@ -44,6 +44,8 @@ const cli_tool_ids_1 = require("../config/cli-tool-ids");
 const agent_target_options_1 = require("../config/agent-target-options");
 const session_target_1 = require("../utils/session-target");
 const agent_instances_1 = require("../utils/agent-instances");
+const follow_up_command_1 = require("../utils/follow-up-command");
+const command_target_1 = require("./command-target");
 const session_name_1 = require("../../lib/cli-tools/session-name");
 const validation_1 = require("../../lib/cli-tools/validation");
 const tmux_session_surface_1 = require("../../lib/session/tmux-session-surface");
@@ -71,9 +73,14 @@ async function resolveTarget(client, worktreeId, options) {
         console.error(`Error: ${(0, session_target_1.describeSessionTargetConflict)(target.conflict)}`);
         process.exit(types_1.ExitCode.CONFIG_ERROR);
     }
+    const cliToolId = target.cliToolId ?? options.agent ?? cli_tool_ids_1.DEFAULT_CLI_TOOL_ID;
+    const instanceId = target.instanceId ?? options.instance;
     return {
-        cliToolId: target.cliToolId ?? options.agent ?? cli_tool_ids_1.DEFAULT_CLI_TOOL_ID,
-        instanceId: target.instanceId ?? options.instance,
+        cliToolId,
+        instanceId,
+        // Issue #3982: what the hints name — the instance only when one was asked
+        // for (the server echoes the default instance otherwise), as `resolveCommandTarget`.
+        commandTarget: (0, command_target_1.commandTargetOf)(options.instance ? { cliToolId, instanceId } : null, options.agent),
     };
 }
 /**
@@ -233,18 +240,22 @@ function planGuardedAttach(ownership, sessionName, options) {
  * @param cliToolId - Resolved CLI tool
  * @param worktreeId - Worktree id, so the hint's commands are copy-pasteable
  * @param sessionName - Resolved tmux session name
- * @param options - The flags as given
+ * @param options - The flags as given; `target` is the resolved target the
+ *   `capture` hints name (Issue #3982), none when absent
  */
 function buildAttachHints(cliToolId, worktreeId, sessionName, options) {
+    const capture = (flags) => options.target
+        ? (0, follow_up_command_1.followUpCommand)('capture', worktreeId, options.target, undefined, flags)
+        : `commandmate capture ${worktreeId} ${flags}`;
     const hints = [`Attaching to ${sessionName} (${cliToolId}). Detach with Ctrl+b then d.`];
     if ((0, tmux_session_surface_1.usesAltScreen)(cliToolId) && !options.live) {
-        hints.push(`${cliToolId} draws its transcript at the top of a 200x1000 canvas and its composer at the`, 'bottom, and tmux follows the cursor — so this attach shows the composer and blank rows,', 'not the conversation. To read it:', `  prefix + g                                     popup, in this terminal`, `  commandmate capture ${worktreeId} --pane --tail 60   without attaching`, `  commandmate capture ${worktreeId} --pane --follow    live, without attaching`);
+        hints.push(`${cliToolId} draws its transcript at the top of a 200x1000 canvas and its composer at the`, 'bottom, and tmux follows the cursor — so this attach shows the composer and blank rows,', 'not the conversation. To read it:', `  prefix + g                                     popup, in this terminal`, `  ${capture('--pane --tail 60')}   without attaching`, `  ${capture('--pane --follow')}    live, without attaching`);
         if ((0, tmux_session_surface_1.isLiveAttachSupported)(cliToolId)) {
             hints.push(`  commandmate attach ${worktreeId} --live               re-lay-out to this terminal`);
         }
     }
     if (options.readOnly) {
-        hints.push('Read-only attach: tmux delivers no keys but the detach one, so prefix + g does NOT open', 'the popup here. Read with `commandmate capture <id> --pane --follow` in another terminal.');
+        hints.push('Read-only attach: tmux delivers no keys but the detach one, so prefix + g does NOT open', `the popup here. Read with \`${capture('--pane --follow')}\` in another terminal.`);
     }
     if (options.live) {
         hints.push('Live attach: this session follows THIS terminal until you detach, then goes back to', '200x1000. The web terminal shows the smaller frame while you are attached.');
@@ -322,11 +333,11 @@ function createAttachCommand() {
                 process.exit(types_1.ExitCode.CONFIG_ERROR);
             }
             const client = new api_client_1.ApiClient({ token: options.token });
-            const { cliToolId, instanceId } = await resolveTarget(client, worktreeId, options);
+            const { cliToolId, instanceId, commandTarget } = await resolveTarget(client, worktreeId, options);
             if (options.live && !(0, tmux_session_surface_1.isLiveAttachSupported)(cliToolId)) {
                 console.error(`Error: --live is not supported for ${cliToolId}. It is claude-only until each other `
                     + "agent's detection rules are re-measured at a terminal-sized pane (Issue #2317). "
-                    + `Attach without it, or read with: commandmate capture ${worktreeId} --pane --follow`);
+                    + `Attach without it, or read with: ${(0, follow_up_command_1.followUpCommand)('capture', worktreeId, commandTarget, undefined, '--pane --follow')}`);
                 process.exit(types_1.ExitCode.CONFIG_ERROR);
             }
             const target = await resolveAttachSessionName(client, worktreeId, cliToolId, instanceId);
@@ -357,6 +368,7 @@ function createAttachCommand() {
             for (const line of buildAttachHints(cliToolId, worktreeId, sessionName, {
                 readOnly,
                 live: options.live,
+                target: commandTarget,
             })) {
                 console.error(line);
             }

package/dist/cli/commands/command-target.d.ts

@@ -20,4 +20,11 @@ export interface CommandTarget {
  * @param mode - Passed on only when given, so the call shape stays as it was
  */
 export declare function resolveCommandTarget(client: ApiClient, worktreeId: string, selector: string | undefined, requestedAgent: string | undefined, mode?: InstanceConflictMode): Promise<CommandTarget>;
+/**
+ * The {@link CommandTarget} for a target resolved some other way (Issue #3982:
+ * `attach` and `wait` resolve their own), by the same rule as above.
+ *
+ * @param target - The resolved instance, or null when no selector was given
+ */
+export declare function commandTargetOf(target: ResolvedInstanceTarget | null, requestedAgent: string | undefined): CommandTarget;
 //# sourceMappingURL=command-target.d.ts.map

package/dist/cli/commands/command-target.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-target.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/command-target.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAEhF,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACtC,0EAA0E;IAC1E,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,gEAAgE;IAChE,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,CAAC,EAAE,oBAAoB,GAC1B,OAAO,CAAC,aAAa,CAAC,CASxB"}
+{"version":3,"file":"command-target.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/command-target.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAEhF,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACtC,0EAA0E;IAC1E,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,gEAAgE;IAChE,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,CAAC,EAAE,oBAAoB,GAC1B,OAAO,CAAC,aAAa,CAAC,CAOxB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,sBAAsB,GAAG,IAAI,EACrC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,aAAa,CAIf"}

package/dist/cli/commands/command-target.js

@@ -8,6 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCommandTarget = resolveCommandTarget;
+exports.commandTargetOf = commandTargetOf;
 const instances_1 = require("./instances");
 /**
  * @param selector - Falsy means "no instance": nothing is requested of the server
@@ -19,6 +20,15 @@ async function resolveCommandTarget(client, worktreeId, selector, requestedAgent
             ? await (0, instances_1.resolveInstanceTarget)(client, worktreeId, selector, requestedAgent)
             : await (0, instances_1.resolveInstanceTarget)(client, worktreeId, selector, requestedAgent, mode)
         : null;
+    return commandTargetOf(target, requestedAgent);
+}
+/**
+ * The {@link CommandTarget} for a target resolved some other way (Issue #3982:
+ * `attach` and `wait` resolve their own), by the same rule as above.
+ *
+ * @param target - The resolved instance, or null when no selector was given
+ */
+function commandTargetOf(target, requestedAgent) {
     const agent = target ? target.cliToolId : requestedAgent;
     const instanceId = target?.instanceId;
     return { target, agent, instanceId };

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

@@ -1 +1 @@
-{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/instances.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,EAAE,SAAS,EAAkD,MAAM,qBAAqB,CAAC;AAsKhG;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,GAAE,oBAA+B,GACpC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAG7B;AAiBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAKzD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,QAE6D,CAAC;AAErG,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,QAE0B,CAAC;AAE/D,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB;IACrC,wEAAwE;IACxE,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,GAAE,oBAA+B,GACpC,OAAO,CAAC,sBAAsB,CAAC,CAmCjC;AAqUD,wBAAgB,sBAAsB,IAAI,OAAO,CAgFhD"}
+{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/instances.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,EAAE,SAAS,EAAkD,MAAM,qBAAqB,CAAC;AA4KhG;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,GAAE,oBAA+B,GACpC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAG7B;AAiBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAKzD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,QAE6D,CAAC;AAErG,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,QAE0B,CAAC;AAE/D,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB;IACrC,wEAAwE;IACxE,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,GAAE,oBAA+B,GACpC,OAAO,CAAC,sBAAsB,CAAC,CAmCjC;AAsWD,wBAAgB,sBAAsB,IAAI,OAAO,CAgFhD"}

package/dist/cli/commands/instances.js

@@ -26,6 +26,9 @@ const session_target_1 = require("../utils/session-target");
 // "the worktree id is wrong", and only the session's own identity can tell them
 // apart.
 const whoami_1 = require("./whoami");
+// Issue #3993: each kill is recorded so the env-clean gate can tell a sibling
+// session the orchestrator stopped from one a worker killed.
+const session_kill_ledger_1 = require("../../lib/verification/session-kill-ledger");
 // Issue #2317: the tmux session name each instance runs in, so `commandmate
 // attach` / `tmux attach` need no hand-assembly of `mcbd-<tool>-<wt>[-<suffix>]`.
 const session_name_1 = require("../../lib/cli-tools/session-name");
@@ -388,6 +391,37 @@ async function addInstance(client, worktreeId, options) {
         console.log(JSON.stringify(next, null, 2));
     }
 }
+/**
+ * Record a successful kill in the session-kill ledger (Issue #3993): which
+ * worktree and instance, the tmux sessions the server says it stopped
+ * (`killedSessions` of the kill-session response), and who asked — this
+ * process's cwd and tmux session. A response without `killedSessions` (an
+ * older server) records no session, which excuses nothing.
+ * Best effort: the ledger never fails the command, the kill already happened.
+ */
+function recordSessionKill(worktreeId, instanceId, response) {
+    let callerCwd;
+    try {
+        callerCwd = process.cwd();
+    }
+    catch {
+        callerCwd = null;
+    }
+    const killed = response?.killedSessions;
+    (0, session_kill_ledger_1.appendSessionKillRecord)({
+        version: session_kill_ledger_1.SESSION_KILL_LEDGER_VERSION,
+        at: Date.now(),
+        api: 'kill-session',
+        origin: 'cli',
+        worktreeId,
+        instanceId,
+        sessionNames: Array.isArray(killed)
+            ? killed.filter((name) => typeof name === 'string')
+            : [],
+        callerCwd,
+        callerSession: (0, whoami_1.readTmuxSessionName)(),
+    });
+}
 /**
  * Remove action: drop an instance from the roster. Kills the session first
  * (when --kill) so the server can still resolve its CLI tool from the roster.
@@ -408,7 +442,8 @@ async function removeInstance(client, worktreeId, instanceId, options) {
     }
     if (options.kill) {
         try {
-            await client.post(`/api/worktrees/${worktreeId}/kill-session?instance=${encodeURIComponent(instanceId)}`);
+            const killResponse = await client.post(`/api/worktrees/${worktreeId}/kill-session?instance=${encodeURIComponent(instanceId)}`);
+            recordSessionKill(worktreeId, instanceId, killResponse);
             console.error(`Session killed: ${instanceId}`);
         }
         catch (killError) {
@@ -451,7 +486,8 @@ async function killInstance(client, worktreeId, instanceId) {
         console.error('Error: Invalid instance id. Must be an alphanumeric/underscore/hyphen identifier (max 64 chars).');
         process.exit(types_1.ExitCode.CONFIG_ERROR);
     }
-    await client.post(`/api/worktrees/${worktreeId}/kill-session?instance=${encodeURIComponent(instanceId)}`);
+    const killResponse = await client.post(`/api/worktrees/${worktreeId}/kill-session?instance=${encodeURIComponent(instanceId)}`);
+    recordSessionKill(worktreeId, instanceId, killResponse);
     console.error(`Session killed: ${instanceId}`);
 }
 /**

package/dist/cli/commands/message-dispatch.d.ts

@@ -8,6 +8,7 @@
  */
 import type { ChatMessage } from '../types/api-responses';
 import { ApiClient } from '../utils/api-client';
+import type { CommandTarget } from './command-target';
 import { type RegisteredRelay } from './relays';
 /**
  * Code the send API returns when the session is blocked on a prompt (Issue
@@ -23,6 +24,13 @@ export interface RegisterRelayForMessageInput {
     instance?: string;
     agent?: string;
     allowRelayChain?: boolean;
+    /**
+     * Issue #3983: the client the two endpoints are resolved with (`ask` passes
+     * its `--timeout`-bounded one). Defaults to `client`. The relay POST itself
+     * always goes through `client`: it creates state, and cutting it would leave
+     * "was the relay opened?" unanswered — the same reason `/send` is not cut.
+     */
+    resolveClient?: ApiClient;
 }
 /** Resolve both endpoints and open the relay; returns its id and whether it is bound. */
 export declare function registerRelayForMessage(client: ApiClient, input: RegisterRelayForMessageInput): Promise<RegisteredRelay>;
@@ -36,13 +44,19 @@ export interface PostMessageOptions {
     onFailure?: () => Promise<void>;
     /** Printed (after `Error: `) when PROMPT_WAITING carried no message body. */
     promptWaitingFallback: string;
+    /** The resolved target the send addressed; the hints name it (Issue #3982). */
+    target: CommandTarget;
 }
 /**
  * What to tell the sender about resending a failed send, from the server's
- * `sendOutcome` on the error (Issue #3992). Null when the error carries none
- * (a send that named no bound relay, an older server) or says `sent`.
+ * `sendOutcome` on the error (Issue #3992). Issue #4011: the route puts it on
+ * every failure recorded as the send's attempt, bound relay or not. Null when
+ * the error carries none (a 400, an older server) or says `sent`.
+ *
+ * @param target - The resolved target, so the `capture` reads the pane the
+ *   message went to (Issue #3982); omitted, the hint names no target
  */
-export declare function describeFailedSendOutcome(error: unknown, worktreeId: string): string | null;
+export declare function describeFailedSendOutcome(error: unknown, worktreeId: string, target?: CommandTarget): string | null;
 /**
  * Post the message; on failure cancel the relay and report PROMPT_WAITING.
  *

package/dist/cli/commands/message-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message-dispatch.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/message-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAY,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAML,KAAK,eAAe,EACrB,MAAM,UAAU,CAAC;AAElB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,MAAM,WAAW,4BAA4B;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,yFAAyF;AACzF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,eAAe,CAAC,CAa1B;AAED,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,6EAA6E;IAC7E,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAwCD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAc3F;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,WAAW,CAAC,CA+CtB"}
+{"version":3,"file":"message-dispatch.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/message-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAY,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAML,KAAK,eAAe,EACrB,MAAM,UAAU,CAAC;AAElB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,MAAM,WAAW,4BAA4B;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,SAAS,CAAC;CAC3B;AAED,yFAAyF;AACzF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,eAAe,CAAC,CAc1B;AAED,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,6EAA6E;IAC7E,qBAAqB,EAAE,MAAM,CAAC;IAC9B,+EAA+E;IAC/E,MAAM,EAAE,aAAa,CAAC;CACvB;AAwCD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAcnH;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,WAAW,CAAC,CA+CtB"}

package/dist/cli/commands/message-dispatch.js

@@ -14,6 +14,7 @@ exports.describeFailedSendOutcome = describeFailedSendOutcome;
 exports.postMessage = postMessage;
 const types_1 = require("../types");
 const api_client_1 = require("../utils/api-client");
+const follow_up_command_1 = require("../utils/follow-up-command");
 const relays_1 = require("./relays");
 /**
  * Code the send API returns when the session is blocked on a prompt (Issue
@@ -24,8 +25,9 @@ const relays_1 = require("./relays");
 exports.PROMPT_WAITING_CODE = 'PROMPT_WAITING';
 /** Resolve both endpoints and open the relay; returns its id and whether it is bound. */
 async function registerRelayForMessage(client, input) {
-    const replyEndpoint = await (0, relays_1.resolveRelayEndpoint)(client, input.replyTo);
-    const workerEndpoint = await (0, relays_1.resolveEndpointForWorktree)(client, input.worktreeId, input.instance, input.agent);
+    const resolveClient = input.resolveClient ?? client;
+    const replyEndpoint = await (0, relays_1.resolveRelayEndpoint)(resolveClient, input.replyTo);
+    const workerEndpoint = await (0, relays_1.resolveEndpointForWorktree)(resolveClient, input.worktreeId, input.instance, input.agent);
     return (0, relays_1.registerRelay)(client, {
         from: replyEndpoint,
         to: workerEndpoint,
@@ -69,10 +71,14 @@ async function resolveBoundSendOutcome(client, relayId, error) {
 }
 /**
  * What to tell the sender about resending a failed send, from the server's
- * `sendOutcome` on the error (Issue #3992). Null when the error carries none
- * (a send that named no bound relay, an older server) or says `sent`.
+ * `sendOutcome` on the error (Issue #3992). Issue #4011: the route puts it on
+ * every failure recorded as the send's attempt, bound relay or not. Null when
+ * the error carries none (a 400, an older server) or says `sent`.
+ *
+ * @param target - The resolved target, so the `capture` reads the pane the
+ *   message went to (Issue #3982); omitted, the hint names no target
  */
-function describeFailedSendOutcome(error, worktreeId) {
+function describeFailedSendOutcome(error, worktreeId, target) {
     if (!(error instanceof api_client_1.ApiError))
         return null;
     const outcome = error.payload?.sendOutcome;
@@ -81,7 +87,7 @@ function describeFailedSendOutcome(error, worktreeId) {
     }
     if (outcome === 'unknown') {
         return ('Note: whether the message was sent is not known (sendOutcome=unknown); '
-            + `check the pane first (\`commandmate capture ${worktreeId} --pane\`) and do not resend before that, `
+            + `check the pane first (\`${(0, follow_up_command_1.paneCaptureCommand)(worktreeId, target)}\`) and do not resend before that, `
             + 'or it may arrive twice.');
     }
     return null;
@@ -122,14 +128,14 @@ async function postMessage(client, worktreeId, sendBody, options) {
         }
         else if (relayId && outcome === 'unknown') {
             // Issue #3992: the relay notice carries the "look before resending" hint.
-            (0, relays_1.printRelayUnconfirmedNotice)(relayId, worktreeId);
+            (0, relays_1.printRelayUnconfirmedNotice)(relayId, worktreeId, options.target);
         }
         const promptWaiting = error instanceof api_client_1.ApiError && error.apiCode === exports.PROMPT_WAITING_CODE;
         // Issue #3992: whether it may be sent again, as the server said — not on
         // PROMPT_WAITING, whose own line says to answer the prompt first, and not
         // when the relay notice above already said it.
         if (!promptWaiting && !(relayId && outcome === 'unknown')) {
-            const resendNote = describeFailedSendOutcome(error, worktreeId);
+            const resendNote = describeFailedSendOutcome(error, worktreeId, options.target);
             if (resendNote !== null)
                 console.error(resendNote);
         }

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

@@ -27,6 +27,7 @@
  */
 import { Command } from 'commander';
 import { ApiClient } from '../utils/api-client';
+import type { CommandTarget } from './command-target';
 /**
  * The codes `POST /api/relays` refuses with.
  *
@@ -110,6 +111,6 @@ export declare function cancelRelayQuietly(client: ApiClient, relayId: string):
  * The relay is left open — withdrawing it would drop a reply that may well be
  * on its way — and the message is not resent, which could make it arrive twice.
  */
-export declare function printRelayUnconfirmedNotice(relayId: string, worktreeId?: string): void;
+export declare function printRelayUnconfirmedNotice(relayId: string, worktreeId?: string, target?: CommandTarget): void;
 export declare function createRelaysCommand(): Command;
 //# sourceMappingURL=relays.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"relays.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/relays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,OAAO,EAAE,SAAS,EAA+B,MAAM,qBAAqB,CAAC;AAgB7E;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,aAM9B,CAAC;AAEH,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B,QAEiD,CAAC;AAE1F,yDAAyD;AACzD,eAAO,MAAM,6BAA6B,QAER,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CAyB3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,gBAAgB,CAAC,CA0B3B;AAED,wCAAwC;AACxC,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,IAAI,EAAE,gBAAgB,CAAC;IACvB,+BAA+B;IAC/B,EAAE,EAAE,gBAAgB,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,0DAA0D;AAC1D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,QAEkD,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,eAAe,CAAC,CAkB1B;AAED,+EAA+E;AAC/E,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAY1F;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAWtF;AAwCD,wBAAgB,mBAAmB,IAAI,OAAO,CAuJ7C"}
+{"version":3,"file":"relays.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/relays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,OAAO,EAAE,SAAS,EAA+B,MAAM,qBAAqB,CAAC;AAI7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AActD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,aAM9B,CAAC;AAEH,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B,QAEiD,CAAC;AAE1F,yDAAyD;AACzD,eAAO,MAAM,6BAA6B,QAER,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CAyB3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,gBAAgB,CAAC,CA0B3B;AAED,wCAAwC;AACxC,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,IAAI,EAAE,gBAAgB,CAAC;IACvB,+BAA+B;IAC/B,EAAE,EAAE,gBAAgB,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,0DAA0D;AAC1D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,QAEkD,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,eAAe,CAAC,CAkB1B;AAED,+EAA+E;AAC/E,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAY1F;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,IAAI,CAW9G;AAwCD,wBAAgB,mBAAmB,IAAI,OAAO,CAuJ7C"}

package/dist/cli/commands/relays.js

@@ -39,6 +39,7 @@ const types_1 = require("../types");
 const api_client_1 = require("../utils/api-client");
 const command_helpers_1 = require("../utils/command-helpers");
 const session_target_1 = require("../utils/session-target");
+const follow_up_command_1 = require("../utils/follow-up-command");
 const instances_1 = require("./instances");
 const whoami_1 = require("./whoami");
 /** crypto.randomUUID() output; mirrors RELAY_ID_PATTERN in the API route. */
@@ -193,12 +194,12 @@ async function cancelRelayQuietly(client, relayId) {
  * The relay is left open — withdrawing it would drop a reply that may well be
  * on its way — and the message is not resent, which could make it arrive twice.
  */
-function printRelayUnconfirmedNotice(relayId, worktreeId) {
+function printRelayUnconfirmedNotice(relayId, worktreeId, target) {
     // Issue #3992: a failed send names the pane to look at before any resend, in
-    // the same line rather than a second notice.
+    // the same line rather than a second notice. Issue #3982: the target's pane.
     const resend = worktreeId === undefined
         ? ''
-        : ` Do not resend before checking the pane (\`commandmate capture ${worktreeId} --pane\`), or it may arrive twice.`;
+        : ` Do not resend before checking the pane (\`${(0, follow_up_command_1.paneCaptureCommand)(worktreeId, target)}\`), or it may arrive twice.`;
     console.error(`Warning: whether the message reached the session is not known; relay ${relayId} was left open `
         + 'and the message was not resent. '
         + `Check it with \`commandmate relays --id ${relayId}\`.${resend}`);

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

@@ -1 +1 @@
-{"version":3,"file":"respond-strict.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/respond-strict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAe/C,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAOhE;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CA2B7G;AAED,8FAA8F;AAC9F,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GAAG,MAAM,CAMhG;AA0CD,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,cAAc,EAAE,OAAO,GAAG,OAAO,CAS/D;AAuED,kDAAkD;AAClD,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC,CAyCf"}
+{"version":3,"file":"respond-strict.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/respond-strict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAgB/C,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAOhE;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CA2B7G;AAED,8FAA8F;AAC9F,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GAAG,MAAM,CAMhG;AA0CD,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,cAAc,EAAE,OAAO,GAAG,OAAO,CAS/D;AA+FD,kDAAkD;AAClD,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC,CA0Cf"}

package/dist/cli/commands/respond-strict.js

@@ -25,6 +25,7 @@ const types_1 = require("../types");
 const api_client_1 = require("../utils/api-client");
 const kinds_1 = require("../../lib/prompt-observation/kinds");
 const command_target_1 = require("./command-target");
+const follow_up_command_1 = require("../utils/follow-up-command");
 /** Mirrors the server's check. */
 const OPERATION_ID_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;
 const ANSWERED_BY_PATTERN = /^[A-Za-z0-9_:/.@-]{1,160}$/;
@@ -143,7 +144,22 @@ function verdictOfApiError(error, options, operationId) {
     return localResult(options, operationId, 41, 'response_unknown', `The server's answer was lost (${error.message}); keys may have been sent. Do not answer again blindly: ` +
         `re-run with --operation-id ${operationId} to read the result of this one.`);
 }
-function printResult(result, options) {
+/**
+ * The commands the strict respond's failure hints name (Issue #4031), aimed at
+ * the target the request resolved to (#3982's `followUpCommand`). A request
+ * that named no target keeps the hints as they were.
+ */
+function strictRespondHints(worktreeId, target) {
+    if ((0, follow_up_command_1.targetFlags)(target) === '') {
+        return { prompt: '`commandmate prompt`', look: '`commandmate prompt` / `capture --pane`' };
+    }
+    // `prompt` takes `--instance` only; `capture` takes either flag.
+    const prompt = target.instanceId
+        ? `\`commandmate prompt ${worktreeId} --instance ${target.instanceId}\``
+        : `\`commandmate prompt ${worktreeId}\``;
+    return { prompt, look: `${prompt} / \`${(0, follow_up_command_1.paneCaptureCommand)(worktreeId, target)}\`` };
+}
+function printResult(result, options, worktreeId, commandTarget) {
     if (options.json) {
         console.log(JSON.stringify(result));
         return;
@@ -157,12 +173,12 @@ function printResult(result, options) {
     const target = result.observedTarget === null ? '' : ` Observed target: ${result.observedTarget}.`;
     if (result.code === types_1.StrictRespondExitCode.NOT_SENT) {
         console.error(`Error: Answer was not sent. Reason: ${result.reason} — ${result.message}${observed}${target}`);
-        console.error('Observe the screen again with `commandmate prompt` before answering.');
+        console.error(`Observe the screen again with ${strictRespondHints(worktreeId, commandTarget).prompt} before answering.`);
     }
     else {
         console.error(`Error: Keys were sent (${result.keysSent}, delivery ${result.delivery}) and the answer is not confirmed. ` +
             `Reason: ${result.reason} — ${result.message}${observed}`);
-        console.error('Do not send it again: look at the pane (`commandmate prompt` / `capture --pane`) first.');
+        console.error(`Do not send it again: look at the pane (${strictRespondHints(worktreeId, commandTarget).look}) first.`);
     }
 }
 /** Run the strict respond; sets the exit code. */
@@ -175,7 +191,8 @@ async function runStrictRespond(worktreeId, answer, options) {
     }
     const operationId = options.operationId ?? (0, crypto_1.randomUUID)();
     const client = new api_client_1.ApiClient({ token: options.token });
-    const { agent, instanceId } = await (0, command_target_1.resolveCommandTarget)(client, worktreeId, options.instance, options.agent);
+    const commandTarget = await (0, command_target_1.resolveCommandTarget)(client, worktreeId, options.instance, options.agent);
+    const { agent, instanceId } = commandTarget;
     const body = {
         expectScreen: options.expectScreen,
         observation: options.observation,
@@ -208,7 +225,7 @@ async function runStrictRespond(worktreeId, answer, options) {
         // Not this endpoint's answer: whatever served it, nothing says what happened.
         result = localResult(options, operationId, 41, 'response_unknown', 'The server answered with something that is not a strict respond result.');
     }
-    printResult(result, options);
+    printResult(result, options, worktreeId, commandTarget);
     if (result.code !== types_1.StrictRespondExitCode.SUCCESS)
         process.exit(result.code);
 }