commandmate 0.27.1 → 0.29.0

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

@@ -1 +1 @@
-{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/report.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiFpC,wBAAgB,mBAAmB,IAAI,OAAO,CA6K7C"}
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/report.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwFpC,wBAAgB,mBAAmB,IAAI,OAAO,CA6K7C"}

package/dist/cli/commands/report.js

@@ -11,8 +11,15 @@ const types_1 = require("../types");
 const api_client_1 = require("../utils/api-client");
 const command_helpers_1 = require("../utils/command-helpers");
 const spinner_1 = require("../utils/spinner");
-/** Allowed tool values for report generation */
-const ALLOWED_TOOLS = ['claude', 'codex', 'copilot', 'antigravity'];
+/**
+ * Allowed tool values for report generation.
+ *
+ * Issue #2044: mirrors `SUMMARY_ALLOWED_TOOLS` (`src/config/review-config.ts`),
+ * which the server validates against. Duplicated rather than imported because
+ * the CLI bundle does not pull `@/config` — the cost of that is this comment,
+ * and `report-opencode-2044.test.ts` asserts the two lists still agree.
+ */
+const ALLOWED_TOOLS = ['claude', 'codex', 'copilot', 'antigravity', 'opencode'];
 /** Validate YYYY-MM-DD date format (client-side) */
 function isValidDate(date) {
     if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
@@ -74,8 +81,8 @@ function createReportCommand() {
         .command('generate')
         .description('Generate a daily report')
         .option('--date <date>', 'Target date (YYYY-MM-DD, default: today)')
-        .option('--tool <tool>', 'AI tool to use (claude, codex, copilot, antigravity)', 'claude')
-        .option('--model <model>', 'Model name (for copilot)')
+        .option('--tool <tool>', `AI tool to use (${ALLOWED_TOOLS.join(', ')})`, 'claude')
+        .option('--model <model>', 'Model name (copilot: --model, opencode: provider/model)')
         .option('--template <id>', 'Template ID to use as instruction')
         .option('--instruction <text>', 'Custom instruction text')
         .option('--token <token>', command_helpers_1.TOKEN_WARNING)

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;AAUpC,wBAAgB,oBAAoB,IAAI,OAAO,CA6H9C"}
+{"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;AAsJpC,wBAAgB,oBAAoB,IAAI,OAAO,CAqK9C"}

package/dist/cli/commands/respond.js

@@ -14,6 +14,112 @@ const command_helpers_1 = require("../utils/command-helpers");
 const cli_tool_ids_1 = require("../config/cli-tool-ids");
 const agent_target_options_1 = require("../config/agent-target-options");
 const instances_1 = require("./instances");
+/**
+ * Whether this instance's agent can be answered by naming a decision
+ * (Issue #2040).
+ *
+ * The declared capability, read off the server, never inferred from a tool id —
+ * §4 D3 of `docs/design/multi-agent-state-architecture.md` puts every such
+ * property on the source so exactly this kind of caller does not have to keep a
+ * list. `eventIdentity` non-null means the agent publishes a per-decision id,
+ * which is what makes an option number a VERDICT that can be POSTed rather than
+ * a key that has to be typed.
+ *
+ * One extra GET, on a command a human or an orchestrator runs once per dialog —
+ * not in a poll loop. It buys the thing the probe is for: `respond` never sends
+ * a side-effecting request to the endpoint that cannot serve it.
+ *
+ * **Fail-open, on every failure.** An older daemon (no `structuredEvents`), a
+ * server that is not reachable, a worktree that does not exist: all of them
+ * answer false, which is the pre-#2040 path, byte for byte. The real request is
+ * a step away and will report the same failure properly.
+ *
+ * @param agent - The resolved CLI tool, when the caller named or resolved one
+ * @param instance - `--instance`, when the caller gave one
+ */
+async function addressesDecisionsById(client, worktreeId, agent, instance) {
+    const query = new URLSearchParams();
+    if (agent)
+        query.set('cliTool', agent);
+    if (instance)
+        query.set('instance', instance);
+    const suffix = query.toString();
+    try {
+        const output = await client.get(`/api/worktrees/${worktreeId}/current-output${suffix ? `?${suffix}` : ''}`);
+        return output.structuredEvents?.source?.capabilities?.eventIdentity != null;
+    }
+    catch {
+        return false;
+    }
+}
+function readAmbiguousDecisions(payload) {
+    const list = payload?.decisions;
+    if (!Array.isArray(list))
+        return [];
+    return list.flatMap((entry) => {
+        if (typeof entry !== 'object' || entry === null)
+            return [];
+        const { id, kind, toolName } = entry;
+        if (typeof id !== 'string' || typeof kind !== 'string')
+            return [];
+        return [{ id, kind, toolName: typeof toolName === 'string' ? toolName : null }];
+    });
+}
+/**
+ * Answer the one decision this instance is holding (Issue #2040).
+ *
+ * `POST /api/worktrees/:id/respond` with neither `messageId` nor `decisionId`.
+ * Nothing is typed at the pane on this path — the verdict, or the question's
+ * chosen label, goes to the agent's own API — which is why every refusal below
+ * can say plainly that the terminal is untouched.
+ *
+ * @returns The server's answer; `'fallback'` when the server says this target
+ *   has no addressable decision after all (see below); or null when this
+ *   function has already reported a refusal and set the exit code
+ */
+async function answerSolePendingDecision(client, worktreeId, body) {
+    try {
+        return await client.post(`/api/worktrees/${worktreeId}/respond`, body);
+    }
+    catch (error) {
+        if (!(error instanceof api_client_1.ApiError))
+            throw error;
+        if (error.apiCode === 'decision_not_found') {
+            console.error('Error: Answer was not sent. Reason: decision_not_found ' +
+                '(this agent instance is not waiting on an approval or a question).');
+            process.exit(types_1.ExitCode.UNEXPECTED_ERROR);
+            return null;
+        }
+        if (error.apiCode === 'multiple_pending_decisions') {
+            const decisions = readAmbiguousDecisions(error.payload);
+            console.error(`Error: Answer was not sent. Reason: multiple_pending_decisions ` +
+                `(${decisions.length || 'several'} are open, and an option number names a ` +
+                'position in one of them). Answer them in the terminal, or one at a time by id.');
+            // The ids are what `{ decisionId, answer }` takes, so the refusal has
+            // somewhere to go rather than being a dead end.
+            for (const decision of decisions) {
+                console.error(`  ${decision.id}  ${decision.kind}${decision.toolName ? `  ${decision.toolName}` : ''}`);
+            }
+            process.exit(types_1.ExitCode.UNEXPECTED_ERROR);
+            return null;
+        }
+        if (error.apiCode === 'decision_source_unaddressable') {
+            // The probe and this POST disagreed about which agent the target resolves
+            // to — a roster edit between the two requests does it. The server's own
+            // instruction for this code is "answer it through /prompt-response", so
+            // that is what happens, rather than failing a `respond` over a race.
+            return 'fallback';
+        }
+        if (error.apiCode === 'answer_out_of_range') {
+            // Issue #1726's rule, unchanged: a number the agent's own list does not
+            // offer is a bad argument, and nothing was sent.
+            console.error(`Error: Answer was not sent. Reason: answer_out_of_range${error.payload?.error ? ` (${error.payload.error})` : ''}`);
+            process.exit(types_1.ExitCode.CONFIG_ERROR);
+            return null;
+        }
+        throw error;
+    }
+}
 function createRespondCommand() {
     const cmd = new commander_1.Command('respond');
     cmd
@@ -68,7 +174,33 @@ function createRespondCommand() {
             if (options.instance) {
                 body.instanceId = options.instance;
             }
-            const result = await client.post(`/api/worktrees/${worktreeId}/prompt-response`, body);
+            // Issue #2040: for an agent that publishes per-decision ids (opencode
+            // today, and only opencode), a bare `respond <worktree> 3` names the ONE
+            // decision that agent is holding, and the number is resolved against
+            // THAT decision's own options — the three verdicts for an approval, the
+            // published choices for a question. Nothing is typed at the pane, and
+            // nothing is sent at all unless the count is exactly one.
+            //
+            // `--default` deliberately stays on the keystroke route. There is a
+            // highlighted option in the TUI and nothing on the wire says which, so
+            // the structured path refuses it (`answerStructuredDecision` says so in
+            // as many words) — while Enter at a `keys` dialog is a real answer that
+            // this command has always been able to give.
+            const structured = !useDefault && (await addressesDecisionsById(client, worktreeId, agent, options.instance));
+            let result = null;
+            if (structured) {
+                const outcome = await answerSolePendingDecision(client, worktreeId, body);
+                // Null means the refusal has already been reported and the exit code
+                // set; a mocked `process.exit` returns, so this is the line that keeps
+                // the reporting below from running on nothing.
+                if (outcome === null)
+                    return;
+                if (outcome !== 'fallback')
+                    result = outcome;
+            }
+            if (result === null) {
+                result = await client.post(`/api/worktrees/${worktreeId}/prompt-response`, body);
+            }
             if (result && !result.success) {
                 // [DR2-06] Check reason for failure
                 const reason = result.reason || 'unknown';
@@ -107,6 +239,19 @@ function createRespondCommand() {
                     console.log(`Answered approval ${resolved.decisionId ?? '(unknown id)'} with ` +
                         `option ${resolved.optionNumber}: ${resolved.optionLabel}`);
                 }
+                else if (resolved.via === 'structured-question') {
+                    // Issue #2040: a question, answered over `POST /question/:id/reply`.
+                    // What is printed is what reached the AGENT — the labels — rather
+                    // than the number that was typed: `respond <id> 2` at a question is
+                    // a position in the agent's own list, and an operator reconciling
+                    // what they meant against what was sent needs the other end of that
+                    // mapping. `freeText` prints the text for the same reason.
+                    const chosen = resolved.optionLabels ?? [];
+                    console.log(`Answered question ${resolved.decisionId ?? '(unknown id)'} with ` +
+                        (chosen.length > 0
+                            ? chosen.map((label, index) => `${resolved.optionNumbers?.[index] ?? '?'}: ${label}`).join(', ')
+                            : `free text: ${(resolved.answers?.[0] ?? []).join(', ')}`));
+                }
                 else if (resolved.via === 'semantic') {
                     console.log(`Resolved "${answer}" to option ${resolved.optionNumber}: ${resolved.optionLabel}`);
                 }

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;AA+IlF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2F9E"}
+{"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;AA0PlF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiG9E"}

package/dist/cli/commands/status.js

@@ -16,6 +16,11 @@ const env_setup_1 = require("../utils/env-setup");
 const package_info_1 = require("../utils/package-info");
 const input_validators_1 = require("../utils/input-validators");
 const version_probes_1 = require("../../lib/detection/version-probes");
+const localhost_self_check_1 = require("../../lib/server/localhost-self-check");
+// Relative, NOT `@/lib/push/vapid`: tsconfig.cli.json resets `paths` to {}, so an alias
+// import here breaks `npm run build:cli`. The module file, not the '@/lib/push' barrel —
+// that barrel pulls in web-push and better-sqlite3, neither of which belongs in the CLI.
+const vapid_1 = require("../../lib/push/vapid");
 const logger = new logger_1.CLILogger();
 /**
  * Print the running daemon's version and, when it differs from the installed CLI, a warning.
@@ -33,6 +38,97 @@ function printVersionInfo(status) {
             'Restart the server ("commandmate stop && commandmate start") to run the current version.');
     }
 }
+/**
+ * Surface the startup self-check's verdict (Issue #2113).
+ *
+ * The server probes `http://localhost:<port>` after `listen` and, when something OTHER
+ * than itself answers, drops a record under `<configDir>/logs/self-check-<port>.json`. That
+ * is the only situation this prints in — the record is deleted on every clean check and
+ * on shutdown, so silence here means the advertised URL really does reach the server.
+ *
+ * Why a file rather than the PID file or a re-probe:
+ * - the PID file is written by the CLI parent with O_EXCL *before* the child binds, and
+ *   its hybrid layout is a forward-compatibility contract (#1632) — the server cannot
+ *   append to it without racing the parent and perturbing that format;
+ * - a re-probe from here cannot reproduce the verdict. Identity is established by the
+ *   server OBSERVING its own probe request in-process; a separate CLI process has no
+ *   way to tell "CommandMate answered" from "some other server answered", short of
+ *   platform-specific `lsof` parsing.
+ *
+ * Staleness is guarded on `startedAt`, NOT on the PID, and that distinction was measured
+ * rather than reasoned: `daemon.start()` spawns `npm run start`, so the state file holds
+ * the WRAPPER's PID while the record holds the PID of the `node dist/server/server.js`
+ * child that actually binds the port (2026-08-27, port 3902: state file 58882, listener
+ * 58937). A PID comparison here therefore never matched and the warning never reached
+ * `status` — the whole point of the Issue's "log AND status" acceptance condition.
+ * A record predating the current daemon's launch cannot be the current daemon's; one
+ * written after it can only have come from it, because the record is keyed by port and
+ * every startup either overwrites it or deletes it.
+ *
+ * A state file with no `startedAt` (written before #1354) leaves nothing to compare, so
+ * the record is reported: it is refreshed on every start, and hiding a real conflict is
+ * the worse failure.
+ *
+ * Never throws — a diagnostic must not be able to turn `status` into a failure.
+ */
+function printLocalhostConflict(status) {
+    try {
+        if (status.port === undefined)
+            return;
+        const record = (0, localhost_self_check_1.readLocalhostConflict)(status.port);
+        if (record === null)
+            return;
+        if (status.startedAt !== undefined && record.detectedAt < status.startedAt)
+            return;
+        console.log('');
+        logger.warn(`Startup self-check (${record.detectedAt}):`);
+        for (const line of (0, localhost_self_check_1.formatLocalhostConflictWarning)(record)) {
+            console.log(`  ${line}`);
+        }
+    }
+    catch {
+        // Config dir unreadable, record unparsable: report the server, drop the hint.
+    }
+}
+/**
+ * Report the server's Web Push configuration, or nothing when it is healthy
+ * (Issues #2123 / #2124).
+ *
+ * The Issues' acceptance condition is "the startup log OR `commandmate status`",
+ * and this is the half that is still readable a week later — a daemon started in
+ * the background writes its stdout wherever the launcher put it, and the reader
+ * who notices "my phone stopped buzzing" reaches for `status`.
+ *
+ * Read from the env the DAEMON runs with (`getEffectiveEnv()`), not from this
+ * process's own environment: `.env` outranks exported variables for the server
+ * child (Issue #1266), so `process.env` here would report this shell's idea of
+ * the configuration rather than the server's. Exactly what the `CM_ALLOWED_IPS`
+ * line below already does.
+ *
+ * The residual imprecision is the same one that line carries: a variable exported
+ * into the daemon's environment at launch and absent from `.env` is invisible
+ * here. `commandmate init` writes all three VAPID variables into `.env`, so the
+ * supported setup is covered; a hand-exported key pair would be reported as
+ * unconfigured, which is why the startup log carries the same lines.
+ *
+ * Silent on a healthy install — that silence is the negative control both Issues
+ * ask for. Never throws: a diagnostic must not turn `status` into a failure.
+ */
+function printVapidStatus(env) {
+    try {
+        const lines = (0, vapid_1.formatVapidReportLines)((0, vapid_1.inspectVapidConfig)(env));
+        if (lines.length === 0)
+            return;
+        console.log('');
+        logger.warn(lines[0]);
+        for (const line of lines.slice(1)) {
+            console.log(line);
+        }
+    }
+    catch {
+        // Unreadable .env, unparsable value: report the server, drop the hint.
+    }
+}
 /**
  * Warn when this build's detection rules were read off an older CLI than the one
  * installed (Issue #1929, design §4 D2).
@@ -103,6 +199,10 @@ async function showSingleStatus(issueNo) {
     if (status.url) {
         console.log(`URL:     ${status.url}`);
     }
+    // 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
+    printVapidStatus(daemonManager.getEffectiveEnv());
 }
 /**
  * Show status for all servers (main + all worktrees)
@@ -192,6 +292,10 @@ async function statusCommand(options = {}) {
         if (status.url) {
             console.log(`URL:     ${status.url}`);
         }
+        // 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
+        printVapidStatus(daemonManager.getEffectiveEnv());
         // Issue #332: Show IP restriction status
         // Issue #1266: read the env the server actually runs with. An exported CM_ALLOWED_IPS
         // shadowed the .env one here, reporting an ACL the server does not enforce.

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;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6DpC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAIvD,CAAC;AAy5BH,wBAAgB,iBAAiB,IAAI,OAAO,CAmJ3C"}
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/wait.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6DpC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAIvD,CAAC;AAk8BH,wBAAgB,iBAAiB,IAAI,OAAO,CAmJ3C"}

package/dist/cli/commands/wait.js

@@ -139,6 +139,39 @@ const TURN_ADOPTION_GRACE_MS = POLL_INTERVAL_MS;
  *     for working around a detector bug, and the bug is the thing to fix.
  */
 const UNCLASSIFIED_DWELL_MS = 60_000;
+/**
+ * The keystroke that closes opencode's sidebar, in opencode's own notation
+ * (Issue #2095).
+ *
+ * A local copy of `OPENCODE_SIDEBAR_RECOVERY_CHORD` from
+ * `src/lib/detection/opencode-pane-obstruction.ts` and not an import: the CLI
+ * builds with `"paths": {}` (tsconfig.cli.json) and cannot reach `@/lib` at all,
+ * which is why `api-responses.ts` mirrors payload shapes rather than importing
+ * them. Taken from opencode's own keybind table, which its `ctrl+p` palette
+ * prints as `Show sidebar   ctrl+x b`.
+ */
+const OPENCODE_SIDEBAR_RECOVERY_CHORD = 'ctrl+x b';
+/**
+ * The cause sentence to append when the frame carries a pane obstruction, or ''
+ * (Issue #2095).
+ *
+ * Appended rather than substituted, and no exit code moves: the frame is
+ * genuinely unclassified and `wait` was already right to stop on it. What it
+ * could not say before is WHY, which left an operator with `capture --pane` and
+ * a screenful of box drawing to work it out from.
+ *
+ * Empty for a server too old to publish the field, which is the same output
+ * `wait` produced before this Issue.
+ */
+function describePaneObstruction(data) {
+    const obstruction = data.paneObstruction;
+    if (!obstruction)
+        return '';
+    return (` Cause: paneObstruction=${obstruction.id} — a second column is sharing rows with the ` +
+        `transcript (it reads ${JSON.stringify(obstruction.matchedText)}), which covers the marker ` +
+        `that ends a turn. Press \`${OPENCODE_SIDEBAR_RECOVERY_CHORD}\` in the pane to close ` +
+        `opencode's sidebar.`);
+}
 /**
  * How recent `autoYes.lastSuppression` must be to be reported as the reason this
  * wait is blocked (Issue #1699).
@@ -671,7 +704,12 @@ async function pollWorktree(client, worktreeId, options) {
                     const question = `Unclassified interactive frame on ${worktreeId} for ${dwellSeconds}s ` +
                         `(status=${data.sessionStatus ?? 'unknown'}/${data.sessionStatusReason ?? 'unknown'}). ` +
                         `The detection layer could not parse it; inspect the raw pane with ` +
-                        `\`commandmate capture ${worktreeId} --pane\`.`;
+                        `\`commandmate capture ${worktreeId} --pane\`.` +
+                        // Issue #2095: the sidebar is exactly this frame's reason, and the
+                        // one recovery is a keystroke in the pane. Riding the message keeps
+                        // the exit-code table (10, `type: unclassified`) unchanged for every
+                        // caller that already branches on it.
+                        describePaneObstruction(data);
                     if (options.onPrompt === 'human') {
                         console.error(question);
                         console.error('Waiting for human response...');

package/dist/cli/config/agent-target-options.d.ts

@@ -43,4 +43,16 @@ export declare const INSTANCE_OPTION_DESCRIPTION: string;
  * agent on `send` and nothing on `wait` waits on the wrong session in silence.
  */
 export declare const WAIT_INSTANCE_OPTION_DESCRIPTION: string;
+/**
+ * `--instance` description for `interrupt` (Issue #2101).
+ *
+ * `interrupt` takes no `--agent`, on the `wait` precedent and for the same
+ * reason #1629 gave: the flag would have to say *which* session, and a bare
+ * `--agent codex` does not. The default here is not "the primary instance"
+ * either — `POST /api/worktrees/:id/interrupt` with no `instanceId` stops EVERY
+ * running session of the worktree, so the flag is what narrows a multi-instance
+ * worktree to one, and its absence is a deliberate broadcast rather than a
+ * fallback.
+ */
+export declare const INTERRUPT_INSTANCE_OPTION_DESCRIPTION: string;
 //# sourceMappingURL=agent-target-options.d.ts.map

package/dist/cli/config/agent-target-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-target-options.d.ts","sourceRoot":"","sources":["../../../src/cli/config/agent-target-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,QAGoD,CAAC;AAE1F,+EAA+E;AAC/E,eAAO,MAAM,2BAA2B,QAGO,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,QAEgB,CAAC"}
+{"version":3,"file":"agent-target-options.d.ts","sourceRoot":"","sources":["../../../src/cli/config/agent-target-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,QAGoD,CAAC;AAE1F,+EAA+E;AAC/E,eAAO,MAAM,2BAA2B,QAGO,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,QAEgB,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qCAAqC,QAGkB,CAAC"}

package/dist/cli/config/agent-target-options.js

@@ -31,7 +31,7 @@
  * codex` does not say *which* codex session to wait on.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WAIT_INSTANCE_OPTION_DESCRIPTION = exports.INSTANCE_OPTION_DESCRIPTION = exports.AGENT_OPTION_DESCRIPTION = void 0;
+exports.INTERRUPT_INSTANCE_OPTION_DESCRIPTION = exports.WAIT_INSTANCE_OPTION_DESCRIPTION = exports.INSTANCE_OPTION_DESCRIPTION = exports.AGENT_OPTION_DESCRIPTION = void 0;
 const cli_tool_ids_1 = require("./cli-tool-ids");
 /**
  * `--agent` description for send / respond / capture / auto-yes.
@@ -52,3 +52,17 @@ exports.INSTANCE_OPTION_DESCRIPTION = 'Agent instance ID: <agent> or <agent>-<n>
  */
 exports.WAIT_INSTANCE_OPTION_DESCRIPTION = `${exports.INSTANCE_OPTION_DESCRIPTION} wait takes no --agent, so name the instance here `
     + '(e.g. --instance codex for the codex primary instance).';
+/**
+ * `--instance` description for `interrupt` (Issue #2101).
+ *
+ * `interrupt` takes no `--agent`, on the `wait` precedent and for the same
+ * reason #1629 gave: the flag would have to say *which* session, and a bare
+ * `--agent codex` does not. The default here is not "the primary instance"
+ * either — `POST /api/worktrees/:id/interrupt` with no `instanceId` stops EVERY
+ * running session of the worktree, so the flag is what narrows a multi-instance
+ * worktree to one, and its absence is a deliberate broadcast rather than a
+ * fallback.
+ */
+exports.INTERRUPT_INSTANCE_OPTION_DESCRIPTION = 'Agent instance ID: <agent> or <agent>-<n> (e.g. claude-2). '
+    + 'interrupt takes no --agent, so name the instance here. '
+    + 'Omitted, every running session of the worktree is interrupted.';

package/dist/cli/config/security-messages.d.ts

@@ -12,4 +12,29 @@
  * Issue #331: Added --auth as a recommended option
  */
 export declare const REVERSE_PROXY_WARNING: string;
+/**
+ * Approval prompt shown before a public Cloudflare Quick Tunnel is created
+ * (Issue #1937, R9 — design §6.4).
+ *
+ * Lives here, beside {@link REVERSE_PROXY_WARNING}, because it is the same kind
+ * of statement: "this next step puts the machine somewhere it was not". Keeping
+ * the two together is also what stops the wording from drifting into the
+ * orchestrator, where a future refactor could quietly reword or skip it.
+ *
+ * The Provider never prints this. Selection and approval are the orchestrator's
+ * responsibility (§6.2): a prompt inside a Provider would have to re-derive
+ * interactive-vs-not per Provider, and its answer would be invisible to the
+ * caller that has to honour `--yes`.
+ */
+export declare const QUICK_TUNNEL_APPROVAL_WARNING: string;
+/** The yes/no question asked after {@link QUICK_TUNNEL_APPROVAL_WARNING}. */
+export declare const QUICK_TUNNEL_APPROVAL_QUESTION = "Create a public Cloudflare Quick Tunnel now?";
+/**
+ * Refusal shown when approval cannot be asked for (no TTY) and `--yes` is absent.
+ *
+ * Defaulting to "yes" here would make a scripted invocation publish the machine
+ * without anyone having said so, which is why this path is a CONFIG_ERROR
+ * rather than a prompt-less approval.
+ */
+export declare const QUICK_TUNNEL_APPROVAL_REQUIRED = "Creating a public Quick Tunnel requires explicit approval. Re-run with --yes to approve it, or use --provider tailscale.";
 //# sourceMappingURL=security-messages.d.ts.map

package/dist/cli/config/security-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"security-messages.d.ts","sourceRoot":"","sources":["../../../src/cli/config/security-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAkBjC,CAAC"}
+{"version":3,"file":"security-messages.d.ts","sourceRoot":"","sources":["../../../src/cli/config/security-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAkBjC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,6BAA6B,QAiBzC,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,8BAA8B,iDACK,CAAC;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,6HACiF,CAAC"}

package/dist/cli/config/security-messages.js

@@ -8,7 +8,7 @@
  * [SF-002] GitHub URLs imported from github-links.ts (DRY)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REVERSE_PROXY_WARNING = void 0;
+exports.QUICK_TUNNEL_APPROVAL_REQUIRED = exports.QUICK_TUNNEL_APPROVAL_QUESTION = exports.QUICK_TUNNEL_APPROVAL_WARNING = exports.REVERSE_PROXY_WARNING = void 0;
 const github_links_1 = require("../../config/github-links");
 /**
  * Warning message displayed when CM_BIND=0.0.0.0 and --auth is not enabled
@@ -34,3 +34,45 @@ or built-in token auth is a serious security risk.
 
 Details: ${github_links_1.GITHUB_SECURITY_GUIDE_URL}
 `;
+/**
+ * Approval prompt shown before a public Cloudflare Quick Tunnel is created
+ * (Issue #1937, R9 — design §6.4).
+ *
+ * Lives here, beside {@link REVERSE_PROXY_WARNING}, because it is the same kind
+ * of statement: "this next step puts the machine somewhere it was not". Keeping
+ * the two together is also what stops the wording from drifting into the
+ * orchestrator, where a future refactor could quietly reword or skip it.
+ *
+ * The Provider never prints this. Selection and approval are the orchestrator's
+ * responsibility (§6.2): a prompt inside a Provider would have to re-derive
+ * interactive-vs-not per Provider, and its answer would be invisible to the
+ * caller that has to honour `--yes`.
+ */
+exports.QUICK_TUNNEL_APPROVAL_WARNING = `
+\x1b[1m\x1b[33mWARNING: A Cloudflare Quick Tunnel exposes this machine on the public internet\x1b[0m
+
+cloudflared creates a temporary https://<random>.trycloudflare.com address.
+Anyone who learns that address can reach it, and the traffic passes through
+Cloudflare. CommandMate answers with token authentication enabled, so a visitor
+without the pairing code is refused - but the listener itself is public.
+
+\x1b[1mWhat is exposed:\x1b[0m
+  - The CommandMate server on 127.0.0.1 only, and nothing else on this machine
+  - Until the tunnel is closed (see --expires and "commandmate remote stop")
+
+\x1b[1mA narrower option:\x1b[0m
+  Tailscale Serve publishes to your own tailnet instead of the public internet:
+    commandmate remote --provider tailscale
+
+Details: ${github_links_1.GITHUB_SECURITY_GUIDE_URL}
+`;
+/** The yes/no question asked after {@link QUICK_TUNNEL_APPROVAL_WARNING}. */
+exports.QUICK_TUNNEL_APPROVAL_QUESTION = 'Create a public Cloudflare Quick Tunnel now?';
+/**
+ * Refusal shown when approval cannot be asked for (no TTY) and `--yes` is absent.
+ *
+ * Defaulting to "yes" here would make a scripted invocation publish the machine
+ * without anyone having said so, which is why this path is a CONFIG_ERROR
+ * rather than a prompt-less approval.
+ */
+exports.QUICK_TUNNEL_APPROVAL_REQUIRED = 'Creating a public Quick Tunnel requires explicit approval. Re-run with --yes to approve it, or use --provider tailscale.';