commandmate 0.46.1 → 0.47.2

package/dist/cli/commands/respond.js

@@ -15,6 +15,8 @@ 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 command_target_1 = require("./command-target");
+const respond_strict_1 = require("./respond-strict");
+const kinds_1 = require("../../lib/prompt-observation/kinds");
 /**
  * Whether this instance's agent can be answered by naming a decision
  * (Issue #2040).
@@ -367,8 +369,44 @@ function createRespondCommand() {
         .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)
+        .option('--expect-screen <kind>', `Strict respond (Issue #3756): answer only if the screen is still this kind (${kinds_1.STRICT_RESPOND_KINDS.join(', ')}). ` +
+        'Needs --observation; never falls back to the unchecked route')
+        .option('--observation <token>', 'Strict respond: the observation token `commandmate prompt` printed for the screen (not the auth --token)')
+        .option('--expect-target <folder>', 'Strict respond: the folder a trust screen must name (omit it to be shown the folder; nothing is sent)')
+        .option('--operation-id <id>', 'Strict respond: reuse this id to retry without sending twice (default: a new random id)')
+        .option('--json', 'Strict respond: print the result object as JSON on stdout')
+        .addHelpText('after', `
+Strict respond (--expect-screen <kind> --observation <token> <label>):
+  Run \`commandmate prompt <worktree-id> --instance <id>\` first, then answer with its
+  token. The server takes a fresh capture and sends nothing unless the kind, the
+  token (same pane, generation, appearance, options and highlight) and, on a
+  trust screen, --expect-target all match. Unnumbered screens (antigravity-trust)
+  are answered by label only — sent as Up/Down and Enter; a number and --default
+  are refused, and so are labels that match two options or no visible one.
+  Residual race: a key typed at the pane between the last check and a key is not
+  seen. While the instance's Auto-Yes is on, antigravity-permission is refused
+  (run auto-yes <worktree-id> --disable first). This is not a way to get auto
+  mode's permission for an approval.
+
+  Exit codes: 0 answered / 40 nothing sent (re-observe first) /
+  41 keys sent, result not confirmed (do NOT send again) / 2 bad arguments`)
         .action(async (worktreeId, answer, options) => {
         try {
+            // Issue #3756: its own endpoint, and never the unchecked one below.
+            if ((0, respond_strict_1.isStrictRespond)(options)) {
+                if (!(0, api_client_1.isValidWorktreeId)(worktreeId)) {
+                    console.error('Error: Invalid worktree ID format.');
+                    process.exit(types_1.ExitCode.CONFIG_ERROR);
+                    return;
+                }
+                await (0, respond_strict_1.runStrictRespond)(worktreeId, answer, options);
+                return;
+            }
+            if (options.json) {
+                console.error('Error: --json applies to the strict respond (--expect-screen) only.');
+                process.exit(types_1.ExitCode.CONFIG_ERROR);
+                return;
+            }
             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

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

@@ -1 +1 @@
-{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/send.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoUpC,wBAAgB,iBAAiB,IAAI,OAAO,CA2J3C"}
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/send.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyWpC,wBAAgB,iBAAiB,IAAI,OAAO,CA8J3C"}

package/dist/cli/commands/send.js

@@ -16,6 +16,7 @@ const model_validation_1 = require("../config/model-validation");
 const agent_instances_1 = require("../utils/agent-instances");
 const instances_1 = require("./instances");
 const command_target_1 = require("./command-target");
+const auto_yes_1 = require("./auto-yes");
 const relays_1 = require("./relays");
 const message_dispatch_1 = require("./message-dispatch");
 /** Auto-yes duration used when --duration is omitted. */
@@ -63,8 +64,9 @@ function resolveAutoYesDurationMs(duration) {
  * @param options - Send command options containing auto-yes settings
  * @param durationMs - Duration already validated by resolveAutoYesDurationMs()
  * @param agent - CLI tool resolved for --instance (Issue #1629), else --agent
+ * @param contractPolicy - The policy of the contract this send created (Issue #3723), else null
  */
-async function enableAutoYes(client, worktreeId, options, durationMs, agent, instanceId) {
+async function enableAutoYes(client, worktreeId, options, durationMs, agent, instanceId, contractPolicy = null) {
     const autoYesBody = {
         enabled: true,
         duration: durationMs,
@@ -81,8 +83,19 @@ async function enableAutoYes(client, worktreeId, options, durationMs, agent, ins
     if (options.stopPattern) {
         autoYesBody.stopPattern = options.stopPattern;
     }
-    await client.post(`/api/worktrees/${worktreeId}/auto-yes`, autoYesBody);
+    // Issue #3723: the response is read now. It names what the contract on the
+    // instance lets Auto-Yes answer; with `autoYes.mode: off` the poller this
+    // armed answers nothing, and "Auto-yes enabled." alone said otherwise.
+    const result = await client.post(`/api/worktrees/${worktreeId}/auto-yes`, autoYesBody);
     console.error('Auto-yes enabled.');
+    // The server's reading wins when it has one. It has none for a `--contract`
+    // send armed before the message goes out: the task is still `pending`, which
+    // the server does not count as governing the instance (ACTIVE_TASK_STATUSES).
+    // The contract this send just created is what will govern it, so its policy
+    // is the one to describe then — a null from the server is not "no contract".
+    for (const line of (0, auto_yes_1.describeContractPolicy)(result?.contractPolicy ?? contractPolicy)) {
+        console.error(line);
+    }
 }
 /**
  * Register an ad-hoc --instance session into the agent-instance roster
@@ -102,6 +115,22 @@ async function registerInstance(client, worktreeId, instanceId, cliTool) {
     await (0, agent_instances_1.saveAgentInstances)(client, worktreeId, next);
     console.error(`Instance registered in roster: ${instanceId}`);
 }
+/**
+ * The `autoYes` block of a just-created task in the shape `describeContractPolicy`
+ * reads (Issue #3723), or null when the response carries none. Read defensively:
+ * `contract_json` is replayed verbatim, never re-validated.
+ */
+function contractPolicyOf(task) {
+    const autoYes = task.contract?.autoYes;
+    if (!autoYes || typeof autoYes !== 'object')
+        return null;
+    return {
+        taskId: task.id,
+        mode: typeof autoYes.mode === 'string' ? autoYes.mode : null,
+        allowPromptTypes: Array.isArray(autoYes.allowPromptTypes) ? autoYes.allowPromptTypes : [],
+        denyPatternCount: Array.isArray(autoYes.denyPatterns) ? autoYes.denyPatterns.length : 0,
+    };
+}
 /**
  * Create the task row for `--contract` and get the message to send back.
  *
@@ -121,7 +150,11 @@ async function createContractTask(client, worktreeId, options, agent, instanceId
     try {
         const response = await client.post(`/api/worktrees/${worktreeId}/tasks`, body);
         const created = (0, api_client_1.assertResponseShape)(response, ['task', 'message'], 'POST /api/worktrees/:id/tasks');
-        return { taskId: created.task.id, message: created.message };
+        return {
+            taskId: created.task.id,
+            message: created.message,
+            contractPolicy: contractPolicyOf(created.task),
+        };
     }
     catch (error) {
         if (error instanceof api_client_1.ApiError && error.statusCode === 400 && error.payload?.issues?.length) {
@@ -312,11 +345,14 @@ worktree and send a short message that tells the agent to read that file.
             // so an invalid contract cannot leave auto-yes enabled for a message
             // that was never sent.
             let taskId;
+            // Issue #3723: what the created contract lets Auto-Yes answer.
+            let contractPolicy = null;
             let content = message;
             if (options.contract) {
                 const task = await createContractTask(client, worktreeId, options, agent, instanceId);
                 taskId = task.taskId;
                 content = task.message;
+                contractPolicy = task.contractPolicy;
                 console.error(`Task created: ${taskId}`);
                 console.log(taskId);
             }
@@ -344,7 +380,7 @@ worktree and send a short message that tells the agent to read that file.
                 // that never went out, which is the state #1608 removed for a bad
                 // --duration.
                 try {
-                    await enableAutoYes(client, worktreeId, options, autoYesDurationMs, agent, instanceId);
+                    await enableAutoYes(client, worktreeId, options, autoYesDurationMs, agent, instanceId, contractPolicy);
                 }
                 catch (error) {
                     await failTask();
@@ -391,7 +427,7 @@ worktree and send a short message that tells the agent to read that file.
             // A failure here does not fail the task: the message was delivered and
             // the task is running, which is what the row already says.
             if (options.autoYes && deferAutoYes) {
-                await enableAutoYes(client, worktreeId, options, autoYesDurationMs, agent, instanceId);
+                await enableAutoYes(client, worktreeId, options, autoYesDurationMs, agent, instanceId, contractPolicy);
             }
         }
         catch (error) {

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

@@ -1 +1 @@
-{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/start.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAmB,MAAM,UAAU,CAAC;AA4CnE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,QAAQ,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,wFAAwF;IACxF,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAgU1E;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CASvE"}
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/start.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAmB,MAAM,UAAU,CAAC;AA4CnE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,QAAQ,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,wFAAwF;IACxF,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAiU1E;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CASvE"}

package/dist/cli/commands/start.js

@@ -95,7 +95,8 @@ async function runStart(options) {
             logger.info('Run "commandmate init" to create a configuration file');
             return { ok: false, exitCode: types_1.ExitCode.CONFIG_ERROR };
         }
-        const daemonManager = new daemon_1.DaemonManager(pidFilePath);
+        // Issue #3731: --daemon appends the server's stdout/stderr to <configDir>/logs/server[-N].log
+        const daemonManager = new daemon_1.DaemonManager(pidFilePath, undefined, () => (0, paths_1.getServerLogPath)(options.issue));
         // Issue #136: Handle auto-port allocation for worktree servers
         let port = options.port;
         if (options.autoPort && options.issue !== undefined) {

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

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/status.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAA2C,aAAa,EAAE,MAAM,UAAU,CAAC;AAwZlF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkG9E"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/status.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAA2C,aAAa,EAAE,MAAM,UAAU,CAAC;AAyalF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqG9E"}

package/dist/cli/commands/status.js

@@ -12,6 +12,7 @@ const fs_1 = require("fs");
 const types_1 = require("../types");
 const logger_1 = require("../utils/logger");
 const daemon_1 = require("../utils/daemon");
+const paths_1 = require("../utils/paths");
 const env_setup_1 = require("../utils/env-setup");
 const server_url_1 = require("../utils/server-url");
 const package_info_1 = require("../utils/package-info");
@@ -39,6 +40,19 @@ function printVersionInfo(status) {
             'Restart the server ("commandmate stop && commandmate start") to run the current version.');
     }
 }
+/**
+ * Issue #3731: print where `start --daemon` writes this server's stdout/stderr.
+ * Marks a path that does not exist (a server started in the foreground or by an older CLI).
+ */
+function printServerLogPath(issueNo) {
+    try {
+        const logPath = (0, paths_1.getServerLogPath)(issueNo);
+        console.log(`Log:     ${logPath}${(0, fs_1.existsSync)(logPath) ? '' : ' (not created yet)'}`);
+    }
+    catch {
+        // The log path is a hint; failing to resolve it changes nothing about server status.
+    }
+}
 /**
  * Surface the startup self-check's verdict (Issue #2113).
  *
@@ -318,6 +332,7 @@ async function showSingleStatus(issueNo) {
     }
     if (!status.running) {
         console.log('Status:  Not running (stale PID file)');
+        printServerLogPath(issueNo);
         console.log('');
         const startCmd = issueNo !== undefined
             ? `commandmate start --issue ${issueNo}`
@@ -336,6 +351,7 @@ async function showSingleStatus(issueNo) {
     if (status.url) {
         console.log(`URL:     ${status.url}`);
     }
+    printServerLogPath(issueNo);
     // Issue #2113: the advertised localhost URL may not reach this server at all
     printLocalhostConflict(status);
     // Issue #2123 / #2124: whether Web Push can work at all on this server
@@ -411,6 +427,7 @@ async function statusCommand(options = {}) {
         }
         if (!status.running) {
             console.log('Status:  Not running (stale PID file)');
+            printServerLogPath(options.issue);
             console.log('');
             const startCmd = options.issue !== undefined
                 ? `commandmate start --issue ${options.issue}`
@@ -430,6 +447,7 @@ async function statusCommand(options = {}) {
         if (status.url) {
             console.log(`URL:     ${status.url}`);
         }
+        printServerLogPath(options.issue);
         // Issue #2113: the advertised localhost URL may not reach this server at all
         printLocalhostConflict(status);
         // Issue #2123 / #2124: whether Web Push can work at all on this server

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

@@ -22,7 +22,7 @@
  */
 import { Command } from 'commander';
 import type { WaitOptions } from '../types';
-import type { WaitPromptOutput } from '../types/api-responses';
+import type { CurrentOutputResponse, WaitPromptOutput } from '../types/api-responses';
 import { ApiClient } from '../utils/api-client';
 /**
  * Structured event types that mean "a turn is under way" (Issue #1839).
@@ -50,6 +50,26 @@ import { ApiClient } from '../utils/api-client';
  * `"paths": {}`), so the test is the only thing holding the two together.
  */
 export declare const TURN_OPENING_EVENT_TYPES: ReadonlySet<string>;
+/**
+ * One stderr line saying Auto-Yes is off on this instance because the server
+ * restarted (Issue #3730), or null.
+ *
+ * Only words: the prompt was going to be reported either way — an instance
+ * whose grant the restart released is an instance with Auto-Yes off, and exit
+ * 10 for it is exactly the hand-back it always was. What this adds is the WHY,
+ * so a delegating agent re-enables Auto-Yes instead of guessing. A server
+ * older than the reason sends none, and nothing is printed.
+ *
+ * The command it suggests names the instance this wait is about: without
+ * `--instance`, `auto-yes --enable` arms the worktree's default primary, which
+ * for an alias (or a non-default tool) is another instance — the waited-on one
+ * would stay off while a grant went somewhere nobody asked for. The instance is
+ * the resolved `--instance` when one was given, else the CLI tool the server
+ * answered for (a primary's instance ID is its tool ID).
+ *
+ * @param instanceId - The resolved `--instance` of this wait, if any
+ */
+export declare function formatRestartReleaseNotice(worktreeId: string, data: CurrentOutputResponse, instanceId?: string): string | null;
 /**
  * The `stop` detail meaning "the agent ended its turn with its own background
  * work still running, and resumes by itself when that work finishes"

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

@@ -1 +1 @@
-{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/wait.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAOV,gBAAgB,EACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,SAAS,EAA+B,MAAM,qBAAqB,CAAC;AA6E7E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAIvD,CAAC;AA+YH;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,wBAAwB,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,0BAA0B,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB,QAAiB,CAAC;AA2JlD;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA2zBD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,6EAA6E;IAC7E,aAAa,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD,CAAC,CAwID;AAwKD,wBAAgB,iBAAiB,IAAI,OAAO,CAqM3C"}
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/wait.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAGV,qBAAqB,EAKrB,gBAAgB,EACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,SAAS,EAA+B,MAAM,qBAAqB,CAAC;AA8E7E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAIvD,CAAC;AAwOH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,qBAAqB,EAC3B,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,IAAI,CAMf;AAyMD;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,wBAAwB,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,0BAA0B,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB,QAAiB,CAAC;AA2JlD;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA21BD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,6EAA6E;IAC7E,aAAa,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD,CAAC,CAyID;AAwKD,wBAAgB,iBAAiB,IAAI,OAAO,CA6M3C"}

package/dist/cli/commands/wait.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SELF_RESUME_HOLD_MS = exports.SELF_RESUME_CAPABILITY = exports.SELF_RESUME_PENDING_DETAIL = exports.TURN_OPENING_EVENT_TYPES = void 0;
+exports.formatRestartReleaseNotice = formatRestartReleaseNotice;
 exports.pollWorktree = pollWorktree;
 exports.createWaitCommand = createWaitCommand;
 const commander_1 = require("commander");
@@ -31,6 +32,7 @@ const api_client_1 = require("../utils/api-client");
 const command_helpers_1 = require("../utils/command-helpers");
 const verify_runner_1 = require("../utils/verify-runner");
 const agent_target_options_1 = require("../config/agent-target-options");
+const prompt_1 = require("./prompt");
 const prompt_view_1 = require("../../lib/session/prompt-view");
 const instances_1 = require("./instances");
 /** [IA3-02] Polling interval 5 seconds (matches tmux-capture-cache TTL=2s) */
@@ -239,22 +241,36 @@ const CONTRACT_POLICY_CAUSE = 'by contract policy';
  * say about it is a compile error here, which is the point. Until #1843 the
  * notice hard-coded "by contract policy" for every reason, so #1829's
  * `agent-launch-dialog` — a product-side decision the poller makes with no
- * contract in sight (`src/lib/auto-yes-poller.ts`, the `getCodexLifecycleDialog`
- * branch) — sent operators of contract-less worktrees hunting for a
- * `denyPatterns` entry that did not exist.
+ * contract in sight (`suppressIfNotOursToAnswer` in
+ * `src/lib/polling/auto-yes-prompt-suppression.ts`: codex's lifecycle dialogs,
+ * gemini's folder trust since #3776 and copilot's since #3790) — sent operators
+ * of contract-less worktrees hunting for a `denyPatterns` entry that did not
+ * exist.
  *
  * The three sites that record a suppression are covered: the poller's launch-dialog
  * branch (`agent-launch-dialog`), the poller's policy branch and
  * `lib/hooks/permission-decision-service.ts` (both the four `evaluatePolicyAgainstTexts`
  * verdicts, which is why those four keep the pre-#1843 wording exactly), and
- * the poller's stopped-answer branch (`partial-answer`, Issue #3706 / #3713).
+ * the poller's stopped-answer branch (`partial-answer`, Issue #3706 / #3713),
+ * and the poller's agy trust-screen branch (`startup-trust-unhandled`, Issue #3757),
+ * and the poller's question confirm-page branch (`question-confirm-page`, Issue #3748),
+ * and the poller's agy receipt-gate branch (`no-hook-receipt`, Issue #3767),
+ * and a contract lookup that failed on either of the policy paths
+ * (`policy-lookup-failed`, Issue #3822).
  */
 const SUPPRESSION_CAUSE = {
     'mode-off': CONTRACT_POLICY_CAUSE,
     'deny-pattern': CONTRACT_POLICY_CAUSE,
     'deny-pattern-unusable': CONTRACT_POLICY_CAUSE,
     'type-not-allowed': CONTRACT_POLICY_CAUSE,
-    'agent-launch-dialog': "while the agent's launch dialog was on screen",
+    // Issue #3822. Not "by contract policy": the contract could not be read at
+    // all, so nothing it says was applied. Withheld rather than answered, since
+    // the contract may state `off`; it clears once the server reads it again.
+    'policy-lookup-failed': 'because the server could not read the execution contract (the database lookup failed), so Auto-Yes does not answer until it can; check the server log for policy-lookup-failed',
+    // Issue #3790: after the launch window the poller still leaves copilot's and
+    // gemini's trust dialogs alone when the cursor is not on the safe row, and
+    // nobody else answers them then.
+    'agent-launch-dialog': "while the agent's launch dialog was on screen; if it stays after the launch (copilot's cursor on 2. or 3., gemini's not on 1. Trust folder), answer it at the pane",
     // Issue #1924. Deliberately not "by contract policy": no contract was
     // consulted. The frame looked like a numbered list to the generic estimator
     // and like prose to the tool's own detector, and an operator who reads this
@@ -264,6 +280,19 @@ const SUPPRESSION_CAUSE = {
     // Auto-Yes answer was stopped with some of its keys already in the input, and
     // typing it again would append to them, so the prompt waits for a human.
     'partial-answer': 'because an earlier answer left partial input; Auto-Yes is waiting for a human',
+    // Issue #3757. agy's startup folder-trust screen: the launch's to confirm, not
+    // Auto-Yes's, and agy drew it after the launch window had ended.
+    'startup-trust-unhandled': "because agy's startup folder-trust confirmation is the launch's to answer, not Auto-Yes's; the next send confirms it once, or answer it at the pane",
+    // Issue #3748. The AskUserQuestion confirm page (`Submit` / `Cancel`): the
+    // tool's own reader recognised it, and `Submit` commits whatever stands as the
+    // answers, so it waits for a human. Was recorded as `unclassified-frame`,
+    // whose wording above says the opposite (nothing recognised the frame).
+    'question-confirm-page': "because the question's Submit/Cancel confirmation commits the answers as they stand, so Auto-Yes leaves it to a human",
+    // Issue #3767. agy's approval dialog has no matching hook question (none, too
+    // late, already on screen, or the hook stopped arriving). Not a contract verdict.
+    // Issue #3789: nor one left unused — the last was spent on keys Auto-Yes sent,
+    // and a dialog is still up past the grace — so "no unused question" covers both.
+    'no-hook-receipt': "because there is no unused agy hook permission question for this dialog (none arrived in time, or the last one was spent on keys that did not clear it); answer it yourself (auto-yes --disable, prompt --json, respond --expect-screen) or check hooks.json",
 };
 /**
  * {@link SUPPRESSION_CAUSE} for a reason that arrived over the wire.
@@ -303,6 +332,33 @@ function formatSuppressionNotice(suppression, ageSeconds) {
     const cause = suppressionCause(suppression.reason);
     return `  auto-yes suppressed this prompt ${cause}: ${parts.join(' ')} (${ageSeconds}s ago)`;
 }
+/**
+ * One stderr line saying Auto-Yes is off on this instance because the server
+ * restarted (Issue #3730), or null.
+ *
+ * Only words: the prompt was going to be reported either way — an instance
+ * whose grant the restart released is an instance with Auto-Yes off, and exit
+ * 10 for it is exactly the hand-back it always was. What this adds is the WHY,
+ * so a delegating agent re-enables Auto-Yes instead of guessing. A server
+ * older than the reason sends none, and nothing is printed.
+ *
+ * The command it suggests names the instance this wait is about: without
+ * `--instance`, `auto-yes --enable` arms the worktree's default primary, which
+ * for an alias (or a non-default tool) is another instance — the waited-on one
+ * would stay off while a grant went somewhere nobody asked for. The instance is
+ * the resolved `--instance` when one was given, else the CLI tool the server
+ * answered for (a primary's instance ID is its tool ID).
+ *
+ * @param instanceId - The resolved `--instance` of this wait, if any
+ */
+function formatRestartReleaseNotice(worktreeId, data, instanceId) {
+    if (data.autoYes?.enabled !== false || data.autoYes.stopReason !== 'server-restart')
+        return null;
+    const target = instanceId ?? data.cliToolId;
+    const command = `commandmate auto-yes ${worktreeId} --enable${target ? ` --instance ${target}` : ''}`;
+    return `  auto-yes was released by a server restart on ${worktreeId} (it is not turned back on ` +
+        `automatically); re-enable it with \`${command}\` if this session should keep answering.`;
+}
 /**
  * One stderr line saying Auto-Yes pressed Enter on THIS prompt (Issue #3397), or
  * null when the record is absent or about another screen.
@@ -805,6 +861,23 @@ function buildUnclassifiedOutput(worktreeId, data, question) {
         answerVia: 'terminal',
     };
 }
+/**
+ * The exit-10 result with the poll's prompt observation added as `observation`
+ * (Issue #3755), or the result untouched.
+ *
+ * Only words added to a payload that is reported anyway: no exit code, hold or
+ * grace reads the observation, and a daemon older than the field (no
+ * `promptObservation`) gets the payload it always got. `autoYesSuppression`
+ * keeps its #1699 meaning beside it; the observation is where the poller's
+ * record and the contract's re-evaluation are told apart.
+ */
+function withObservation(result, data) {
+    if (result.exitCode !== types_1.WaitExitCode.PROMPT_DETECTED || !result.output)
+        return result;
+    if (!(0, prompt_1.isPromptObservation)(data.promptObservation))
+        return result;
+    return { ...result, output: { ...result.output, observation: data.promptObservation } };
+}
 /** The stderr line for a session this wait never saw running (Issue #1628). */
 function describeNotStarted(worktreeId, data, options) {
     return (`Not started: ${worktreeId} has no running ${data.cliToolId ?? 'agent'} session` +
@@ -868,6 +941,10 @@ function promptStage(poll, state, data) {
             const enterNotice = formatEnterFallbackNotice(data, Date.now());
             if (enterNotice)
                 console.error(enterNotice);
+            // Issue #3730: and whether a restart is why nothing is answering it.
+            const restartNotice = formatRestartReleaseNotice(worktreeId, data, poll.options.instance);
+            if (restartNotice)
+                console.error(restartNotice);
             return { kind: 'wait' };
         }
         // Issue #2463: the one case `decidePromptPush()` stays quiet about —
@@ -908,6 +985,10 @@ function promptStage(poll, state, data) {
         const enterNotice = formatEnterFallbackNotice(data, Date.now());
         if (enterNotice)
             console.error(enterNotice);
+        // Issue #3730: stderr only as well.
+        const restartNotice = formatRestartReleaseNotice(worktreeId, data, poll.options.instance);
+        if (restartNotice)
+            console.error(restartNotice);
         return exitWith({ exitCode: types_1.WaitExitCode.PROMPT_DETECTED, output: promptOutput });
     }
     return { kind: 'next' };
@@ -929,8 +1010,16 @@ function selectionListStage(poll, data) {
             if (suppressed) {
                 console.error(formatSuppressionNotice(suppressed.suppression, suppressed.ageSeconds));
             }
+            // Issue #3730
+            const restartNotice = formatRestartReleaseNotice(worktreeId, data, poll.options.instance);
+            if (restartNotice)
+                console.error(restartNotice);
             return { kind: 'wait' };
         }
+        // Issue #3730: stderr only; the exit-10 payload is unchanged.
+        const restartNotice = formatRestartReleaseNotice(worktreeId, data, poll.options.instance);
+        if (restartNotice)
+            console.error(restartNotice);
         return exitWith({
             exitCode: types_1.WaitExitCode.PROMPT_DETECTED,
             output: buildSelectionListOutput(worktreeId, data),
@@ -986,12 +1075,18 @@ function unclassifiedStage(poll, state, data) {
         const dwellMs = Date.now() - state.unclassifiedSince;
         if (dwellMs >= UNCLASSIFIED_DWELL_MS) {
             const question = describeUnclassifiedFrame(worktreeId, data, dwellMs);
+            // Issue #3730: why Auto-Yes is not there to answer it, if a restart is why.
+            const restartNotice = formatRestartReleaseNotice(worktreeId, data, poll.options.instance);
             if (options.onPrompt === 'human') {
                 console.error(question);
+                if (restartNotice)
+                    console.error(restartNotice);
                 console.error('Waiting for human response...');
                 return { kind: 'wait' };
             }
             console.error(question);
+            if (restartNotice)
+                console.error(restartNotice);
             return exitWith({
                 exitCode: types_1.WaitExitCode.PROMPT_DETECTED,
                 output: buildUnclassifiedOutput(worktreeId, data, question),
@@ -1330,10 +1425,9 @@ async function pollWorktree(client, worktreeId, options) {
             return deadlineOutcome.result;
         try {
             // Issue #868: scope polling to a specific agent instance when provided.
-            const path = options.instance
-                ? `/api/worktrees/${worktreeId}/current-output?instance=${encodeURIComponent(options.instance)}`
-                : `/api/worktrees/${worktreeId}/current-output`;
-            const data = await client.get(path);
+            // Issue #3755: `observe=1` so an exit 10 carries the observation of the
+            // very capture it was decided on (see {@link withObservation}).
+            const data = await client.get((0, prompt_1.observedCurrentOutputPath)(worktreeId, options.instance));
             // Track content changes for stall detection
             if (data.content !== state.lastContent) {
                 state.lastContent = data.content;
@@ -1372,7 +1466,7 @@ async function pollWorktree(client, worktreeId, options) {
             }
             const promptOutcome = promptStage(poll, state, data);
             if (promptOutcome.kind === 'exit')
-                return promptOutcome.result;
+                return withObservation(promptOutcome.result, data);
             if (promptOutcome.kind === 'wait') {
                 await sleep(POLL_INTERVAL_MS);
                 continue;
@@ -1387,14 +1481,14 @@ async function pollWorktree(client, worktreeId, options) {
             }
             const selectionListOutcome = selectionListStage(poll, data);
             if (selectionListOutcome.kind === 'exit')
-                return selectionListOutcome.result;
+                return withObservation(selectionListOutcome.result, data);
             if (selectionListOutcome.kind === 'wait') {
                 await sleep(POLL_INTERVAL_MS);
                 continue;
             }
             const unclassifiedOutcome = unclassifiedStage(poll, state, data);
             if (unclassifiedOutcome.kind === 'exit')
-                return unclassifiedOutcome.result;
+                return withObservation(unclassifiedOutcome.result, data);
             if (unclassifiedOutcome.kind === 'wait') {
                 await sleep(POLL_INTERVAL_MS);
                 continue;
@@ -1646,6 +1740,14 @@ A prompt the target's Auto-Yes is answering (Issue #2463):
   would lapse during the grace ends it early with exit 10, not 124.
   --auto-yes-grace 0 restores the immediate exit; --on-prompt human is
   unchanged.
+
+The observation on exit 10 (Issue #3755):
+  The exit-10 payload also carries "observation": the same payload
+  \`commandmate prompt <id> --json\` prints, read off the capture the exit was
+  decided on — the screen's kind, an observation token, and Auto-Yes as two
+  separate items (the poller's record, the contract re-evaluated now). It
+  changes no exit code, hold or grace. autoYesSuppression keeps its meaning (a
+  record under a minute old); a missing record does not mean Auto-Yes can answer.
 `)
         .action(async (worktreeIds, options) => {
         try {