commandmate 0.46.1 → 0.47.2

package/dist/cli/commands/ls.js

@@ -173,12 +173,25 @@ function formatAutoYesRemaining(remainingMs) {
 function remainingAutoYesMs(entry, now) {
     if (!entry || entry.enabled !== true)
         return 0;
+    // Issue #3723: armed, but the contract answers nothing — no Auto-Yes in effect.
+    if (entry.blockedByContract === true)
+        return 0;
     if (entry.expiresAt === null)
         return Number.POSITIVE_INFINITY;
     if (typeof entry.expiresAt !== 'number')
         return 0;
     return entry.expiresAt > now ? entry.expiresAt - now : 0;
 }
+/** Armed, but the contract on the instance says `autoYes.mode: off` (Issue #3723). */
+function isBlockedByContract(entry) {
+    return entry?.enabled === true && entry.blockedByContract === true;
+}
+/**
+ * The AUTO_YES cell for an instance the last server restart released
+ * (Issue #3730). One token, like every other value of the cell, so the
+ * instance parenthesis after it still splits off on whitespace.
+ */
+const OFF_RELEASED_BY_RESTART = 'off(restart)';
 /**
  * The AUTO_YES cell: how long before this row loses Auto-Yes (Issue #2575).
  *
@@ -214,14 +227,22 @@ function deriveAutoYesCell(wt, status, now) {
     const armedByInstance = wt.autoYesByInstance;
     if (!armedByInstance)
         return '-';
+    const releasedByRestart = (id) => wt.autoYesStopReasonByInstance?.[id] === 'server-restart';
     const byInstance = wt.sessionStatusByInstance ?? {};
     let targets = Object.keys(byInstance).filter(id => explainsStatus(byInstance[id], status));
     if (targets.length === 0) {
         if (status !== 'idle')
             return '-';
         targets = Object.keys(armedByInstance);
-        if (targets.length === 0)
-            return 'off';
+        if (targets.length === 0) {
+            // Issue #3730: nothing armed — but if the last restart is why, say so,
+            // about the default's primary when it is one of them.
+            const released = Object.keys(wt.autoYesStopReasonByInstance ?? {}).filter(releasedByRestart).sort();
+            if (released.length === 0)
+                return 'off';
+            const named = released.includes(wt.cliToolId ?? '') ? wt.cliToolId : released[0];
+            return named === wt.cliToolId ? OFF_RELEASED_BY_RESTART : `${OFF_RELEASED_BY_RESTART} (${named})`;
+        }
     }
     // Deterministic order first, so the cell never depends on the key order the
     // server happened to serialise: the worktree default's primary, then
@@ -244,8 +265,14 @@ function deriveAutoYesCell(wt, status, now) {
             remaining = candidate;
         }
     }
+    // Issue #3723: an armed instance its contract keeps silent (`autoYes.mode:
+    // off`) has no Auto-Yes in effect, whatever its countdown says. It counts as
+    // 0 above (see remainingAutoYesMs) and is named `blocked` here, so the cell
+    // stops printing a time beside a prompt only a human will answer.
     const value = remaining === 0
-        ? 'off'
+        ? (isBlockedByContract(armedByInstance[pick])
+            ? 'blocked'
+            : (releasedByRestart(pick) ? OFF_RELEASED_BY_RESTART : 'off'))
         : remaining === Number.POSITIVE_INFINITY
             ? 'on'
             : formatAutoYesRemaining(remaining);
@@ -403,6 +430,15 @@ AUTO_YES column (Issue #2575):
     on         armed, with no expiry the server named
     off        at least one of those instances is NOT armed, so a prompt on this
                row waits for a human. This is the cell to look for
+    off(restart)
+               the same, and the reason is that the server restarted while
+               the grant was live: Auto-Yes is never turned back on by a
+               restart (Issue #3730). Shown until the grant's own deadline or
+               the next enable / disable; a SIGKILL or crash leaves a plain
+               off. --json: autoYesStopReasonByInstance.<id>
+    blocked    armed, but the contract running on that instance sets
+               autoYes.mode: off, so Auto-Yes answers nothing there either
+               (Issue #3723). --json: autoYesByInstance.<id>.blockedByContract
     -          not known: the server predates the field, or this row is not idle
                and no instance explains its STATUS
 

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

@@ -0,0 +1,42 @@
+/**
+ * prompt Command - Read the screen an agent is stopped on, once (Issue #3755)
+ *
+ * `commandmate prompt <worktree-id> [--instance <id>] [--json]` prints one
+ * observation (`GET /api/worktrees/:id/current-output?observe=1`, field
+ * `promptObservation`): which kind of
+ * screen is open (`lib/prompt-observation/kinds`), what it asks, an
+ * observation token bound to it, and Auto-Yes as it bears on it. A supervising
+ * agent reads this instead of guessing from `capture --pane` (#3746 P4-4).
+ *
+ * Exit codes:
+ * - 0: the screen was read — including when nothing on it asks (`composer` /
+ *      `none`) and when no reader names it (`unknown`)
+ * - 21: the instance has no running session, so there was no screen to read
+ *       (the NOT_STARTED value `wait` uses for the same fact)
+ * - 1 / 2 / 99: infrastructure errors, as every other command
+ */
+import { Command } from 'commander';
+import type { PromptObservation } from '../../lib/prompt-observation/types';
+/**
+ * The `current-output` request that carries an observation: `?observe=1`, and
+ * the instance first so a reader of the URL sees the target where every other
+ * poll puts it.
+ */
+export declare function observedCurrentOutputPath(worktreeId: string, instanceId?: string): string;
+/**
+ * Whether a value is an observation this CLI can read.
+ *
+ * Checked rather than cast: a daemon older than the field sends none, and that
+ * is "no observation", never a payload of another shape passed on as one. A
+ * newer `schemaVersion` passes: `--json` and `wait` hand it on verbatim.
+ */
+export declare function isPromptObservation(value: unknown): value is PromptObservation;
+/**
+ * The last send in the words a human reads (Issue #3759), or null when the
+ * server holds no record or is older than the field.
+ */
+export declare function formatLastSend(lastSend: PromptObservation['lastSend'], now?: number): string | null;
+/** The observation in the words a human reads. */
+export declare function formatPromptObservation(observation: PromptObservation, now?: number): string;
+export declare function createPromptCommand(): Command;
+//# sourceMappingURL=prompt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAgB5E;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAIzF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAW9E;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,iBAAiB,CAAC,UAAU,CAAC,EAAE,GAAG,GAAE,MAAmB,GAAG,MAAM,GAAG,IAAI,CAU/G;AAwED,kDAAkD;AAClD,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,iBAAiB,EAAE,GAAG,GAAE,MAAmB,GAAG,MAAM,CAkBxG;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CA8E7C"}

package/dist/cli/commands/prompt.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * prompt Command - Read the screen an agent is stopped on, once (Issue #3755)
+ *
+ * `commandmate prompt <worktree-id> [--instance <id>] [--json]` prints one
+ * observation (`GET /api/worktrees/:id/current-output?observe=1`, field
+ * `promptObservation`): which kind of
+ * screen is open (`lib/prompt-observation/kinds`), what it asks, an
+ * observation token bound to it, and Auto-Yes as it bears on it. A supervising
+ * agent reads this instead of guessing from `capture --pane` (#3746 P4-4).
+ *
+ * Exit codes:
+ * - 0: the screen was read — including when nothing on it asks (`composer` /
+ *      `none`) and when no reader names it (`unknown`)
+ * - 21: the instance has no running session, so there was no screen to read
+ *       (the NOT_STARTED value `wait` uses for the same fact)
+ * - 1 / 2 / 99: infrastructure errors, as every other command
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observedCurrentOutputPath = observedCurrentOutputPath;
+exports.isPromptObservation = isPromptObservation;
+exports.formatLastSend = formatLastSend;
+exports.formatPromptObservation = formatPromptObservation;
+exports.createPromptCommand = createPromptCommand;
+const commander_1 = require("commander");
+const types_1 = require("../types");
+const kinds_1 = require("../../lib/prompt-observation/kinds");
+const api_client_1 = require("../utils/api-client");
+const command_helpers_1 = require("../utils/command-helpers");
+const instances_1 = require("./instances");
+/** `--instance` description: like the other commands, but this one takes no `--agent`. */
+const PROMPT_INSTANCE_OPTION_DESCRIPTION = 'Agent instance ID: <agent> or <agent>-<n> (e.g. antigravity-2). '
+    + "prompt takes no --agent, so name the instance here. Defaults to the worktree's primary instance.";
+/**
+ * The `current-output` request that carries an observation: `?observe=1`, and
+ * the instance first so a reader of the URL sees the target where every other
+ * poll puts it.
+ */
+function observedCurrentOutputPath(worktreeId, instanceId) {
+    return instanceId
+        ? `/api/worktrees/${worktreeId}/current-output?instance=${encodeURIComponent(instanceId)}&observe=1`
+        : `/api/worktrees/${worktreeId}/current-output?observe=1`;
+}
+/**
+ * Whether a value is an observation this CLI can read.
+ *
+ * Checked rather than cast: a daemon older than the field sends none, and that
+ * is "no observation", never a payload of another shape passed on as one. A
+ * newer `schemaVersion` passes: `--json` and `wait` hand it on verbatim.
+ */
+function isPromptObservation(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const body = value;
+    return (typeof body.schemaVersion === 'number' &&
+        (body.status === 'observed' || body.status === 'unavailable') &&
+        typeof body.target === 'object' &&
+        body.target !== null &&
+        typeof body.autoYes === 'object' &&
+        body.autoYes !== null);
+}
+/**
+ * The last send in the words a human reads (Issue #3759), or null when the
+ * server holds no record or is older than the field.
+ */
+function formatLastSend(lastSend, now = Date.now()) {
+    if (!lastSend)
+        return null;
+    const ago = `${Math.max(0, Math.round((now - lastSend.at) / 1000))}s ago`;
+    const advice = lastSend.state === 'not-sent'
+        ? ' — the message was not typed; it is not resent automatically'
+        : lastSend.state === 'indeterminate'
+            ? ' — part of it may have been typed; do not resend before checking `capture --pane`'
+            : '';
+    return `  last send: ${lastSend.state} (${lastSend.reason}, ${ago})${advice}`;
+}
+/** The `kind:` line and what the screen asks: question, target, options, answer route and token. */
+function formatScreenLines(observation, screen, now) {
+    const lines = [];
+    const kindNote = screen.kind === 'none'
+        ? ' (nothing on screen asks for a decision)'
+        : screen.kind === 'composer'
+            ? ' (at the input box; nothing asks for a decision)'
+            : screen.kind === 'unknown'
+                ? ' (something waits on a human, and no measured reading names it — inspect `capture --pane`)'
+                : '';
+    lines.push(`  kind: ${screen.kind}${kindNote}`);
+    if (observation.session.starting)
+        lines.push('  (the instance is still launching)');
+    if (screen.question !== null)
+        lines.push(`  question: ${screen.question}`);
+    if (screen.approvalTarget !== null)
+        lines.push(`  approval target: ${screen.approvalTarget}`);
+    if (screen.options.length > 0) {
+        lines.push('  options:');
+        for (const option of screen.options) {
+            const marker = option.position === screen.selectedPosition ? '>' : ' ';
+            lines.push(`  ${marker} ${option.position}. ${option.label}`);
+        }
+    }
+    if (screen.answerVia !== 'none') {
+        const note = screen.answerVia === 'strict' ? ' (commandmate respond --expect-screen)' : '';
+        lines.push(`  answer via: ${screen.answerVia}${note}`);
+    }
+    if (screen.token !== null) {
+        const expiresIn = screen.tokenExpiresAt === null ? '' : ` (expires in ${Math.max(0, Math.round((screen.tokenExpiresAt - now) / 1000))}s)`;
+        lines.push(`  token: ${screen.token}${expiresIn}`);
+    }
+    else if (screen.tokenWithheld === 'unknown-screen' || screen.tokenWithheld === 'no-session-generation') {
+        // An older server sends no `tokenWithheld`; `no-decision` needs no line.
+        lines.push(`  token: none (${screen.tokenWithheld})`);
+    }
+    return lines;
+}
+/** The Auto-Yes lines: switch and poller, the poller's last record, and the contract re-evaluated now. */
+function formatAutoYesLines(autoYes) {
+    const lines = [];
+    const enabled = autoYes.enabled === null ? 'unknown' : autoYes.enabled ? 'on' : 'off';
+    const poller = autoYes.pollerActive === null ? 'unknown' : autoYes.pollerActive ? 'running' : 'stopped';
+    lines.push(`  auto-yes: ${enabled}, poller ${poller}${autoYes.stopReason ? `, stopReason=${autoYes.stopReason}` : ''}`);
+    const record = autoYes.pollerRecord;
+    lines.push(record === null
+        ? '  poller record: none (a missing record does not mean Auto-Yes can answer)'
+        : `  poller record: reason=${record.reason} promptType=${record.promptType} ` +
+            `(${record.ageSeconds}s ago; relation to this screen: ${record.screenCorrelation})`);
+    const evaluation = autoYes.contractEvaluation;
+    const evaluationDetail = evaluation.state === 'policy-withholds'
+        ? `policy-withholds reason=${evaluation.reason}${evaluation.pattern !== undefined ? ` pattern=${JSON.stringify(evaluation.pattern)}` : ''}`
+        : evaluation.state === 'not-evaluated'
+            ? `not-evaluated (${evaluation.because})`
+            : evaluation.state;
+    lines.push(`  contract re-evaluation: ${evaluationDetail}` +
+        (evaluation.contract ? ` (task ${evaluation.contract.taskId ?? 'unknown'}, mode=${evaluation.contract.mode ?? 'none'})` : ' (no contract)'));
+    return lines;
+}
+/** The observation in the words a human reads. */
+function formatPromptObservation(observation, now = Date.now()) {
+    const { target, screen, autoYes } = observation;
+    const lines = [];
+    lines.push(`Instance ${target.instanceId} (${target.cliToolId}) on ${target.worktreeId}, pane ${target.sessionName}`);
+    const lastSendLine = formatLastSend(observation.lastSend, now);
+    if (observation.status === 'unavailable' || screen === null) {
+        lines.push('  No running session: there is no screen to read.');
+        if (lastSendLine !== null)
+            lines.push(lastSendLine);
+        return lines.join('\n');
+    }
+    lines.push(...formatScreenLines(observation, screen, now));
+    lines.push(...formatAutoYesLines(autoYes));
+    if (lastSendLine !== null)
+        lines.push(lastSendLine);
+    return lines.join('\n');
+}
+function createPromptCommand() {
+    const cmd = new commander_1.Command('prompt');
+    cmd
+        .description('Show the screen an agent is stopped on: its kind, question, options and an observation token')
+        .argument('<worktree-id>', 'Worktree ID')
+        .option('--instance <id>', `${PROMPT_INSTANCE_OPTION_DESCRIPTION} ${instances_1.INSTANCE_ALIAS_HELP_SUFFIX}`)
+        .option('--json', 'Print the observation payload as JSON (schemaVersion-tagged)')
+        .option('--token <token>', command_helpers_1.TOKEN_WARNING)
+        .addHelpText('after', `
+Kinds (screen.kind):
+  ${kinds_1.PROMPT_OBSERVATION_KINDS.join(', ')}
+  composer / none mean nothing on screen asks for a decision; unknown means
+  something waits on a human and no measured reading names it.
+
+Exit codes:
+  0   the screen was read (also when nothing asks, and for unknown)
+  21  the instance has no running session: nothing to read
+  1/2/99  infrastructure errors
+
+The token is short-lived, single use, and bound to the instance, the session
+generation, the pane, this appearance of the screen, what it asks and the
+highlighted option. None is issued for unknown, or when the server did not
+start the running agent (tokenWithheld says which). Auto-Yes is reported as two separate items:
+the poller's last record (with how it relates to this screen) and the
+contract's policy re-evaluated now. A missing record does not mean Auto-Yes
+can answer.
+
+lastSend says how the last send to the instance ended: not-sent (no key of the
+message was typed, e.g. prompt not ready), sent, or indeterminate (part of it
+may have been typed). Nothing is resent automatically: resend a not-sent
+message yourself, and do not resend an indeterminate one before checking
+\`capture --pane\`.
+
+To answer the screen only if it is still this one (Issue #3756):
+  commandmate respond <worktree-id> --instance <id> --expect-screen <kind> \\
+    --observation <token> [--expect-target <approvalTarget>] <label>`)
+        .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);
+                return;
+            }
+            if (options.instance && !(0, instances_1.isInstanceSelector)(options.instance)) {
+                console.error(instances_1.INSTANCE_SELECTOR_ERROR);
+                process.exit(types_1.ExitCode.CONFIG_ERROR);
+                return;
+            }
+            const client = new api_client_1.ApiClient({ token: options.token });
+            // An alias reaches the route only as the id it names (Issue #2376).
+            const instanceId = options.instance
+                ? (await (0, instances_1.resolveInstanceTarget)(client, worktreeId, options.instance, undefined, 'read-only')).instanceId
+                : undefined;
+            const data = await client.get(observedCurrentOutputPath(worktreeId, instanceId));
+            const body = data.promptObservation;
+            if (!isPromptObservation(body)) {
+                console.error('Error: the server sent no prompt observation. It is older than this CLI '
+                    + '(restart it with `commandmate stop` / `commandmate start` after updating).');
+                process.exit(types_1.ExitCode.UNEXPECTED_ERROR);
+                return;
+            }
+            console.log(options.json ? JSON.stringify(body, null, 2) : formatPromptObservation(body));
+            process.exit(body.status === 'observed' ? types_1.ExitCode.SUCCESS : types_1.VerifyExitCode.NOT_STARTED);
+        }
+        catch (error) {
+            (0, command_helpers_1.handleCommandError)(error);
+        }
+    });
+    return cmd;
+}

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;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,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;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,+EAA+E;AAC/E,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM1F;AAyBD,wBAAgB,mBAAmB,IAAI,OAAO,CA8H7C"}
+{"version":3,"file":"relays.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/relays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,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;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,+EAA+E;AAC/E,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAY1F;AAyBD,wBAAgB,mBAAmB,IAAI,OAAO,CAsI7C"}

package/dist/cli/commands/relays.js

@@ -164,7 +164,13 @@ async function cancelRelayQuietly(client, relayId) {
     try {
         await client.post(`/api/relays/${relayId}/cancel`);
     }
-    catch {
+    catch (error) {
+        // #3732: not withdrawable because its payload is going out right now, so
+        // "it will expire" would be wrong — it will arrive.
+        if (error instanceof api_client_1.ApiError && error.apiCode === 'RELAY_DELIVERING') {
+            console.error(`Warning: relay ${relayId} is already being delivered and was not withdrawn.`);
+            return;
+        }
         console.error(`Warning: could not withdraw relay ${relayId}; it will expire on its own.`);
     }
 }
@@ -282,6 +288,12 @@ Withdraw one with \`commandmate relays cancel <relay-id>\`.
                     console.error(`Error: ${error.payload?.error ?? 'Relay is already closed.'}`);
                     process.exit(types_1.ExitCode.CONFIG_ERROR);
                 }
+                // The send is already under way (#3732): the payload is reaching the
+                // requester as we speak, so this too is a cancel that did not happen.
+                if (error instanceof api_client_1.ApiError && error.apiCode === 'RELAY_DELIVERING') {
+                    console.error(`Error: ${error.payload?.error ?? 'Relay is being delivered and can no longer be cancelled.'}`);
+                    process.exit(types_1.ExitCode.CONFIG_ERROR);
+                }
                 throw error;
             }
         }

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

@@ -0,0 +1,31 @@
+/**
+ * The strict `respond` (Issue #3756):
+ *
+ *   commandmate respond <wt> --instance <id> --expect-screen <kind> \
+ *     --observation <token> [--expect-target <folder>] [--operation-id <id>] [--json] <label>
+ *
+ * Answers only when the server's fresh capture still shows `<kind>` and the
+ * observation token (`commandmate prompt`) still verifies. It goes to its own
+ * endpoint, `POST /api/worktrees/:id/prompt-response/strict`, and NEVER falls
+ * back to `/prompt-response`: a server without the endpoint is a stop (exit 40),
+ * because the old route would send the answer unchecked.
+ *
+ * Exit codes: 0 answered / 40 nothing sent / 41 sent but not confirmed (do not
+ * send again) / 2 bad arguments.
+ */
+import type { RespondOptions } from '../types';
+/** Whether the strict respond was asked for: any of its options. */
+export declare function isStrictRespond(options: RespondOptions): boolean;
+/**
+ * The strict respond's argument errors, or null. Exit 2, with nothing sent:
+ * `--default` and an option number on an unnumbered screen are refused here
+ * (the server refuses them too).
+ */
+export declare function strictRespondArgumentError(answer: string | undefined, options: RespondOptions): string | null;
+/** Who is answering, for the server's record: the agent session the CLI runs in, or `cli`. */
+export declare function strictRespondActor(env?: Record<string, string | undefined>): string;
+/** Whether `fetch` failed before any connection was established. */
+export declare function neverConnected(transportError: unknown): boolean;
+/** Run the strict respond; sets the exit code. */
+export declare function runStrictRespond(worktreeId: string, answer: string | undefined, options: RespondOptions): Promise<void>;
+//# sourceMappingURL=respond-strict.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * The strict `respond` (Issue #3756):
+ *
+ *   commandmate respond <wt> --instance <id> --expect-screen <kind> \
+ *     --observation <token> [--expect-target <folder>] [--operation-id <id>] [--json] <label>
+ *
+ * Answers only when the server's fresh capture still shows `<kind>` and the
+ * observation token (`commandmate prompt`) still verifies. It goes to its own
+ * endpoint, `POST /api/worktrees/:id/prompt-response/strict`, and NEVER falls
+ * back to `/prompt-response`: a server without the endpoint is a stop (exit 40),
+ * because the old route would send the answer unchecked.
+ *
+ * Exit codes: 0 answered / 40 nothing sent / 41 sent but not confirmed (do not
+ * send again) / 2 bad arguments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStrictRespond = isStrictRespond;
+exports.strictRespondArgumentError = strictRespondArgumentError;
+exports.strictRespondActor = strictRespondActor;
+exports.neverConnected = neverConnected;
+exports.runStrictRespond = runStrictRespond;
+const crypto_1 = require("crypto");
+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");
+/** 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}$/;
+/** Whether the strict respond was asked for: any of its options. */
+function isStrictRespond(options) {
+    return (options.expectScreen !== undefined ||
+        options.observation !== undefined ||
+        options.expectTarget !== undefined ||
+        options.operationId !== undefined);
+}
+/**
+ * The strict respond's argument errors, or null. Exit 2, with nothing sent:
+ * `--default` and an option number on an unnumbered screen are refused here
+ * (the server refuses them too).
+ */
+function strictRespondArgumentError(answer, options) {
+    if (options.expectScreen === undefined || options.observation === undefined) {
+        return 'Error: the strict respond needs both --expect-screen <kind> and --observation <token> (from `commandmate prompt`).';
+    }
+    if (!(0, kinds_1.isPromptObservationKind)(options.expectScreen)) {
+        return `Error: --expect-screen must be a screen kind; the strict respond answers: ${kinds_1.STRICT_RESPOND_KINDS.join(', ')}.`;
+    }
+    if (options.default === true) {
+        return 'Error: --default is refused with --expect-screen: name the option by its label.';
+    }
+    if (options.planReview !== undefined) {
+        return 'Error: --plan-review and --expect-screen are mutually exclusive.';
+    }
+    if (answer === undefined || answer.trim() === '') {
+        return 'Error: the strict respond needs the option label as <answer>.';
+    }
+    if (/^\d+$/.test(answer.trim()) &&
+        (0, kinds_1.isStrictRespondKind)(options.expectScreen) &&
+        kinds_1.UNNUMBERED_STRICT_RESPOND_KINDS.includes(options.expectScreen)) {
+        return `Error: ${options.expectScreen} numbers no option: answer with its label (e.g. "Yes").`;
+    }
+    if (options.operationId !== undefined && !OPERATION_ID_PATTERN.test(options.operationId)) {
+        return 'Error: --operation-id must be 8-64 characters of [A-Za-z0-9_-].';
+    }
+    return null;
+}
+/** Who is answering, for the server's record: the agent session the CLI runs in, or `cli`. */
+function strictRespondActor(env = process.env) {
+    const worktree = env.CM_WORKTREE_ID ?? env.CM_AGENT_WORKTREE_ID;
+    const instance = env.CM_INSTANCE_ID ?? env.CM_AGENT_INSTANCE_ID;
+    if (!worktree || !instance)
+        return 'cli';
+    const actor = `agent:${worktree}/${instance}`;
+    return ANSWERED_BY_PATTERN.test(actor) ? actor : 'cli';
+}
+/** A verdict made on this side, in the shape the server's results have. */
+function localResult(options, operationId, code, reason, message) {
+    return {
+        strictRespond: 1,
+        code,
+        delivery: code === 40 ? 'not-sent' : 'indeterminate',
+        reason,
+        message,
+        expectedKind: options.expectScreen ?? '',
+        observedKind: null,
+        expectedTarget: options.expectTarget ?? null,
+        observedTarget: null,
+        operationId,
+        answer: null,
+        keysSent: 0,
+        outcome: null,
+        replayed: false,
+    };
+}
+/**
+ * Error codes of a connection that was never made: the request cannot have
+ * reached the server. A reset, a socket closed by the other side or a timeout
+ * after connecting are not among them.
+ */
+const NEVER_CONNECTED_CODES = new Set([
+    'ECONNREFUSED',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'UND_ERR_CONNECT_TIMEOUT',
+]);
+/** Whether `fetch` failed before any connection was established. */
+function neverConnected(transportError) {
+    let current = transportError;
+    // `fetch failed` carries the socket error as its `cause` (undici), sometimes one level deeper.
+    for (let depth = 0; depth < 3 && typeof current === 'object' && current !== null; depth++) {
+        const code = current.code;
+        if (typeof code === 'string' && NEVER_CONNECTED_CODES.has(code))
+            return true;
+        current = current.cause;
+    }
+    return false;
+}
+/** Whether an error body came from the strict route itself (an older server's 404 has no marker). */
+function fromStrictRoute(error) {
+    return error.payload?.strictRespond === 1;
+}
+/** The HTTP failure as a verdict, or null for a request the server refused as malformed (exit 2). */
+function verdictOfApiError(error, options, operationId) {
+    const status = error.statusCode;
+    if ((status === 404 || status === 405) && !fromStrictRoute(error)) {
+        return localResult(options, operationId, 40, 'strict_endpoint_missing', 'The server has no strict respond endpoint (it is older than this CLI). Nothing was sent, and the ' +
+            'answer was not sent through the unchecked /prompt-response either. Restart the server after updating.');
+    }
+    if (status === 409) {
+        return localResult(options, operationId, 40, 'session_conflict', `Nothing was sent: ${error.message}`);
+    }
+    if (status !== undefined && status >= 400 && status < 500)
+        return null;
+    if (status === undefined && neverConnected(error.transportError)) {
+        return localResult(options, operationId, 40, 'server_unreachable', `The server could not be reached (${error.message}); the request never left this machine, so nothing was sent.`);
+    }
+    // A 5xx, a connection that broke after it was made, or an answer that is not
+    // JSON: the request may have been carried out.
+    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) {
+    if (options.json) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    if (result.code === 0 && result.answer !== null) {
+        console.log(`Answered ${result.expectedKind} with option ${result.answer.position}: ${result.answer.label} ` +
+            `(outcome: ${result.outcome}${result.replayed ? ', replayed' : ''})`);
+        return;
+    }
+    const observed = result.observedKind === null ? '' : ` Observed kind: ${result.observedKind}.`;
+    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.');
+    }
+    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.');
+    }
+}
+/** Run the strict respond; sets the exit code. */
+async function runStrictRespond(worktreeId, answer, options) {
+    const argumentError = strictRespondArgumentError(answer, options);
+    if (argumentError !== null) {
+        console.error(argumentError);
+        process.exit(types_1.ExitCode.CONFIG_ERROR);
+        return;
+    }
+    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 body = {
+        expectScreen: options.expectScreen,
+        observation: options.observation,
+        answer,
+        operationId,
+        answeredBy: strictRespondActor(),
+    };
+    if (options.expectTarget !== undefined)
+        body.expectTarget = options.expectTarget;
+    if (instanceId)
+        body.instanceId = instanceId;
+    if (agent)
+        body.cliTool = agent;
+    let result;
+    try {
+        result = await client.post(`/api/worktrees/${worktreeId}/prompt-response/strict`, body);
+    }
+    catch (error) {
+        if (!(error instanceof api_client_1.ApiError))
+            throw error;
+        const verdict = verdictOfApiError(error, options, operationId);
+        if (verdict === null) {
+            console.error(`Error: ${error.message}`);
+            process.exit(types_1.ExitCode.CONFIG_ERROR);
+            return;
+        }
+        result = verdict;
+    }
+    if (result?.strictRespond !== 1 || ![0, 40, 41].includes(result.code)) {
+        // 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);
+    if (result.code !== types_1.StrictRespondExitCode.SUCCESS)
+        process.exit(result.code);
+}

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;AA8apC,wBAAgB,oBAAoB,IAAI,OAAO,CAyF9C"}
+{"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;AAgbpC,wBAAgB,oBAAoB,IAAI,OAAO,CAmI9C"}