commandmate 0.27.1 → 0.28.0

package/dist/server/src/lib/session/opencode-session-recall.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Learning which opencode session an instance is in, and writing it down before
+ * the pane that knows dies (Issue #2038).
+ *
+ * `./opencode-session-store` persists the answer and `./opencode-session-api`
+ * asks the server; this is the part that decides *what the answer is*, which is
+ * the only genuinely difficult half.
+ *
+ * ## Why the id is not simply "the last sessionID CommandMate saw"
+ *
+ * One opencode server carries several sessions at once and every frame on the
+ * stream is tagged with its own `sessionID` — a sub-agent spawned by the `task`
+ * tool runs in a session of its own, and its frames arrive on the same
+ * connection (#1758 §5.6.1, #1900). `getLastAgentEvent` therefore answers "the
+ * last session anything happened in", which after a sub-agent's turn is the
+ * sub-agent's. Resuming *that* on the next launch would drop the operator into
+ * the middle of a delegated task rather than back into their conversation.
+ *
+ * `../hooks/sources/opencode/turn-gate` already computes the right answer — its
+ * `primarySession()` — but it lives inside one SSE connection's state and is
+ * gone the moment the stream closes, which is precisely when this value is
+ * needed. So the parentage is re-established from the source that survives:
+ * opencode's own `Session.parentID`, read back over HTTP while the server is
+ * still up, and followed upwards to the session that has no parent.
+ *
+ * ## Why this runs at `killSession` rather than on every event
+ *
+ * Because it can only be *verified* while the server is alive, and `killSession`
+ * is the last moment that is true before the launch that wants the answer. The
+ * verification is what makes the entry trustworthy: `Session.directory` is
+ * opencode's own statement of which worktree the conversation belongs to, and
+ * comparing it against the port assignment's worktree is the guard the Issue
+ * asks for ("`ports.ts` の worktreePath 照合と同じ守り"). An event-time write
+ * could not do any of that — `recordAgentEvent` is synchronous, tool-agnostic,
+ * and has no port.
+ *
+ * The cost is bounded and known: an instance that has completed no turn since
+ * this CommandMate process started, and is then killed, records nothing new and
+ * keeps whatever the previous kill recorded. That is a resume that is one
+ * session stale, not a resume of the wrong worktree — the directory guard still
+ * holds — and it is repaired by the next turn.
+ *
+ * @module lib/session/opencode-session-recall
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_OPENCODE_PARENT_HOPS = void 0;
+exports.resolveOpencodeRootSession = resolveOpencodeRootSession;
+exports.captureOpencodeSessionMemory = captureOpencodeSessionMemory;
+exports.resolveOpencodeCurrentSessionId = resolveOpencodeCurrentSessionId;
+const logger_1 = require("../../lib/logger");
+const ports_1 = require("../../lib/hooks/sources/opencode/ports");
+const agent_event_state_1 = require("./agent-event-state");
+const opencode_session_api_1 = require("./opencode-session-api");
+const opencode_session_store_1 = require("./opencode-session-store");
+const logger = (0, logger_1.createLogger)('lib/session/opencode-session-recall');
+/**
+ * How far up a `parentID` chain to walk before giving up.
+ *
+ * opencode nests sub-agents, and a cycle would be a server bug rather than an
+ * expected shape — but this loop runs inside `killSession`, which is inside the
+ * HTTP request that is stopping a session, so it is bounded by a small number
+ * rather than by trust. Three is two more hops than anything measured.
+ */
+exports.MAX_OPENCODE_PARENT_HOPS = 3;
+/**
+ * Follow `parentID` until the session that has none.
+ *
+ * @param port - The instance's server port
+ * @param sessionId - Where to start
+ * @returns The root session, or null when a hop could not be read
+ */
+async function resolveOpencodeRootSession(port, sessionId) {
+    const seen = new Set();
+    let current = await (0, opencode_session_api_1.fetchOpencodeSession)(port, sessionId);
+    for (let hop = 0; hop < exports.MAX_OPENCODE_PARENT_HOPS; hop += 1) {
+        if (current === null)
+            return null;
+        if (current.parentId === null)
+            return current;
+        if (seen.has(current.parentId))
+            return current;
+        seen.add(current.parentId);
+        logger.debug('opencode-session-parent-hop', { from: current.id, to: current.parentId });
+        current = await (0, opencode_session_api_1.fetchOpencodeSession)(port, current.parentId);
+    }
+    return current;
+}
+/**
+ * Write down the session this instance is in, verified against its own server.
+ *
+ * Call while the pane is still alive — from `OpenCodeTool.killSession`, before
+ * the event stream is released and before `/exit` is typed.
+ *
+ * @param target - The instance whose pane is about to go
+ * @returns What was recorded, or why nothing was
+ */
+async function captureOpencodeSessionMemory(target) {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    const port = (0, ports_1.getAssignedOpencodePort)(target);
+    if (port === null)
+        return { captured: false, skipped: 'no-port' };
+    const observed = (0, agent_event_state_1.getLastAgentEvent)(target.worktreeId, 'opencode', target.instanceId)?.sessionId;
+    if (!(0, opencode_session_store_1.isOpencodeSessionId)(observed)) {
+        return { captured: false, skipped: 'no-session-observed' };
+    }
+    const root = await resolveOpencodeRootSession(port, observed);
+    if (root === null)
+        return { captured: false, skipped: 'session-unreadable' };
+    if (root.directory === null)
+        return { captured: false, skipped: 'no-directory' };
+    // The port assignment is the record of "this instance's pane runs there"
+    // (`ports.ts`), so this compares opencode's answer with CommandMate's rather
+    // than CommandMate's with its own. Null only when the assignment has already
+    // been released, in which case there is nothing to contradict.
+    const expected = (0, ports_1.getAssignedOpencodeWorktreePath)(target);
+    if (expected !== null && expected !== root.directory) {
+        logger.warn('opencode-session-capture-directory-mismatch', {
+            worktreeId: target.worktreeId,
+            instanceId,
+            expected,
+            reported: root.directory,
+        });
+        return { captured: false, skipped: 'directory-mismatch' };
+    }
+    const written = (0, opencode_session_store_1.rememberOpencodeSession)(target, {
+        sessionId: root.id,
+        title: root.title,
+        worktreePath: root.directory,
+    });
+    if (!written)
+        return { captured: false, skipped: 'not-persisted' };
+    logger.info('opencode-session-captured', {
+        worktreeId: target.worktreeId,
+        instanceId,
+        sessionId: root.id,
+        viaParentOf: root.id === observed ? null : observed,
+    });
+    return {
+        captured: true,
+        memory: {
+            sessionId: root.id,
+            title: root.title,
+            worktreePath: root.directory,
+            updatedAt: Date.now(),
+        },
+    };
+}
+/**
+ * The session an operator's action (fork, or a title to display) should act on.
+ *
+ * Prefers what the live stream has seen — resolved up to its root, so a fork
+ * branches the conversation rather than a sub-agent — and falls back to what
+ * was persisted when nothing has arrived yet in this process.
+ *
+ * @param target - The instance
+ * @returns The session id, or null when nothing knows
+ */
+async function resolveOpencodeCurrentSessionId(target) {
+    const port = (0, ports_1.getAssignedOpencodePort)(target);
+    const observed = (0, agent_event_state_1.getLastAgentEvent)(target.worktreeId, 'opencode', target.instanceId)?.sessionId;
+    if (port !== null && (0, opencode_session_store_1.isOpencodeSessionId)(observed)) {
+        const root = await resolveOpencodeRootSession(port, observed);
+        if (root !== null)
+            return root.id;
+    }
+    return (0, opencode_session_store_1.getRememberedOpencodeSession)(target)?.sessionId ?? null;
+}

package/dist/server/src/lib/session/opencode-session-store.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * The last opencode session an instance was in, so a relaunch can resume it
+ * (Issue #2038).
+ *
+ * opencode is the one supported agent whose conversation is addressable from
+ * the command line: `opencode -s <id>` continues a session, `-c` continues the
+ * last one and `--fork` branches it (measured on 1.18.22 — the three flags are
+ * in `--help`). CommandMate has always known the id — the turn gate reads
+ * `properties.sessionID` off every frame — and has always thrown it away, so a
+ * `kill-session` followed by a `send` came back on opencode's home screen with
+ * the previous conversation unreachable from CommandMate.
+ *
+ * ## Why a JSON file rather than the database
+ *
+ * The Issue left the choice open ("`~/.commandmate/opencode-ports.json` と同様の
+ * store か DB"). Three properties of the read decide it, and all three are the
+ * same ones `../hooks/sources/opencode/ports.ts` records for the *port*:
+ *
+ *  1. **The reader is the launcher.** `src/lib/cli-tools/opencode.ts` composes
+ *     the launch command line, and that module is deliberately outside the
+ *     database's import graph — `./ingest` goes as far as `await import`-ing
+ *     `@/lib/db` at event time precisely so `better-sqlite3` does not become a
+ *     dependency of every import of `@/lib/hooks/sources`. Putting the id in
+ *     the DB would either pull that graph into the launcher or force the launch
+ *     path to become asynchronous around a dynamic import, for one string.
+ *  2. **It is machine-local runtime state about a process, not project data.**
+ *     A session id means nothing on another machine or under another `HOME`,
+ *     which is exactly the argument `ports.ts` makes for its own file. The
+ *     database holds what a worktree *is*; this holds what a pane *was doing*.
+ *  3. **It has to outlive the port assignment.** `releaseOpencodeEventStream`
+ *     calls `forgetOpencodePort` when the pane is killed, so the entry in
+ *     `opencode-ports.json` is deleted at the exact moment this value becomes
+ *     interesting. Storing the id as a field on that entry would delete it
+ *     together with the port; a separate file is what lets the memory survive
+ *     the kill it exists to survive.
+ *
+ * So: same shape as `ports.ts`, same `~/.commandmate` directory, same
+ * "never throws, a bad file means none" contract, separate lifetime.
+ *
+ * ## The worktree guard
+ *
+ * An entry is only usable when the worktree it was recorded for is the worktree
+ * being launched, which is `recoverOpencodePort`'s rule applied to a different
+ * value. It is not paranoia: sessions belong to opencode's own database rather
+ * than to a server, so one `HOME` holds every worktree's sessions at once —
+ * measured on 1.18.22, `GET /session` on a server started in directory A
+ * returned directory B's sessions too, both under `projectID: "global"`. A
+ * mismatched entry (a worktree id reused at a new path, a home directory copied
+ * between machines) would therefore resume a *different repository's*
+ * conversation into this pane, and opencode would accept it.
+ *
+ * The recorded path is opencode's own `Session.directory`, read back from the
+ * server before the entry is written (see `./opencode-session-recall`), so the
+ * two sides of the comparison are the agent's answer and CommandMate's, not two
+ * copies of CommandMate's.
+ *
+ * @module lib/session/opencode-session-store
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_OPENCODE_SESSION_TITLE_LENGTH = exports.OPENCODE_SESSION_ID_PATTERN = void 0;
+exports.isOpencodeSessionId = isOpencodeSessionId;
+exports.getOpencodeSessionFilePath = getOpencodeSessionFilePath;
+exports.readPersistedOpencodeSessions = readPersistedOpencodeSessions;
+exports.rememberOpencodeSession = rememberOpencodeSession;
+exports.getRememberedOpencodeSession = getRememberedOpencodeSession;
+exports.forgetOpencodeSession = forgetOpencodeSession;
+exports.recoverOpencodeSessionId = recoverOpencodeSessionId;
+exports.withOpencodeResumedSession = withOpencodeResumedSession;
+exports.resetOpencodeSessionMemories = resetOpencodeSessionMemories;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const safe_directory_1 = require("../../config/safe-directory");
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('lib/session/opencode-session-store');
+/**
+ * What an opencode session id looks like.
+ *
+ * `^ses` is the server's own declared pattern (`GET /doc`, 1.18.22, every
+ * `sessionID` path parameter). The rest of the class is tightened to
+ * alphanumerics because this string is interpolated into a **shell command
+ * line** by {@link withOpencodeResumedSession}: a value that reached the pane
+ * with a space or a quote in it would be a command injection into the operator's
+ * own terminal, and the persisted file is writable by anything running as the
+ * user. Anything that does not match is refused rather than escaped, because
+ * there is no legitimate id this rejects.
+ */
+exports.OPENCODE_SESSION_ID_PATTERN = /^ses[A-Za-z0-9_-]{1,128}$/;
+/** Whether a string is usable as an opencode session id. */
+function isOpencodeSessionId(value) {
+    return typeof value === 'string' && exports.OPENCODE_SESSION_ID_PATTERN.test(value);
+}
+/** Longest title kept. Display only; opencode's own titles are one line. */
+exports.MAX_OPENCODE_SESSION_TITLE_LENGTH = 200;
+const memories = (globalThis.__opencodeSessionMemories ??= new Map());
+function keyOf(target) {
+    return (0, auto_yes_state_1.buildCompositeKey)(target.worktreeId, target.cliToolId, target.instanceId);
+}
+/**
+ * Where the memories are persisted. `CM_OPENCODE_SESSION_FILE` overrides.
+ *
+ * Guarded exactly as `getOpencodePortFilePath` is (Issue #1774): the write below
+ * creates this file's directory with a recursive mkdir, and for a path inside
+ * `/proc`, `/sys` or `/dev` that call does not throw — it spins the event loop
+ * forever, so the `try/catch` around it never runs. `resolveSafeDirectory`
+ * refuses such an override and hands back the default.
+ */
+function getOpencodeSessionFilePath() {
+    const fallback = (0, path_1.join)((0, os_1.homedir)(), '.commandmate', 'opencode-sessions.json');
+    return (0, safe_directory_1.resolveSafeDirectory)(process.env.CM_OPENCODE_SESSION_FILE, fallback, 'CM_OPENCODE_SESSION_FILE');
+}
+function isMemory(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const record = value;
+    return (isOpencodeSessionId(record.sessionId) &&
+        typeof record.worktreePath === 'string' &&
+        record.worktreePath.length > 0);
+}
+/** Read the persisted memories. Never throws — a bad file means "none". */
+function readPersistedOpencodeSessions() {
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(getOpencodeSessionFilePath(), 'utf8'));
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+            return {};
+        const result = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!isMemory(value))
+                continue;
+            result[key] = {
+                sessionId: value.sessionId,
+                title: typeof value.title === 'string' ? value.title : null,
+                worktreePath: value.worktreePath,
+                updatedAt: typeof value.updatedAt === 'number' ? value.updatedAt : 0,
+            };
+        }
+        return result;
+    }
+    catch {
+        // Absent on a first run, unreadable if somebody edited it. Both mean the
+        // same thing to a caller: nothing to resume.
+        return {};
+    }
+}
+/** Write the memories back. Never throws — losing the file costs one resume. */
+function writePersistedOpencodeSessions(all) {
+    const path = getOpencodeSessionFilePath();
+    try {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(path), { recursive: true });
+        (0, fs_1.writeFileSync)(path, `${JSON.stringify(all, null, 2)}\n`, { mode: 0o600 });
+    }
+    catch (error) {
+        logger.warn('opencode-session-file-write-failed', {
+            path,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/**
+ * Record what this instance was last talking to.
+ *
+ * @param target - The instance
+ * @param memory - Session id, title and the directory opencode reported for it
+ * @returns Whether anything was written — false for an id this module refuses
+ */
+function rememberOpencodeSession(target, memory, at = Date.now()) {
+    if (!isOpencodeSessionId(memory.sessionId)) {
+        logger.warn('opencode-session-id-rejected', {
+            worktreeId: target.worktreeId,
+            instanceId: target.instanceId ?? target.cliToolId,
+        });
+        return false;
+    }
+    if (memory.worktreePath.length === 0)
+        return false;
+    const entry = {
+        sessionId: memory.sessionId,
+        title: typeof memory.title === 'string'
+            ? memory.title.slice(0, exports.MAX_OPENCODE_SESSION_TITLE_LENGTH)
+            : null,
+        worktreePath: memory.worktreePath,
+        updatedAt: at,
+    };
+    const key = keyOf(target);
+    memories.set(key, entry);
+    const all = readPersistedOpencodeSessions();
+    all[key] = entry;
+    writePersistedOpencodeSessions(all);
+    return true;
+}
+/** What is remembered for this instance, from memory or from disk. */
+function getRememberedOpencodeSession(target) {
+    const key = keyOf(target);
+    const live = memories.get(key);
+    if (live)
+        return live;
+    const persisted = readPersistedOpencodeSessions()[key];
+    if (!persisted)
+        return null;
+    memories.set(key, persisted);
+    return persisted;
+}
+/**
+ * Forget this instance's session.
+ *
+ * Called when the operator deliberately starts a new one: resuming the session
+ * they just walked away from on the next launch would undo the thing they asked
+ * for.
+ */
+function forgetOpencodeSession(target) {
+    const key = keyOf(target);
+    memories.delete(key);
+    const all = readPersistedOpencodeSessions();
+    if (key in all) {
+        delete all[key];
+        writePersistedOpencodeSessions(all);
+    }
+}
+/**
+ * The session id this instance may resume in this worktree, or null.
+ *
+ * The whole of the acceptance condition "別 worktree に紐づく sessionID は復元に
+ * 使われない". A mismatch is logged rather than repaired: the recorded path is
+ * what opencode itself said the session lived in, so a difference is a fact
+ * about the session, not a normalisation problem.
+ *
+ * @param target - The instance about to be launched
+ * @param worktreePath - The directory the pane will be created in
+ */
+function recoverOpencodeSessionId(target, worktreePath) {
+    const memory = getRememberedOpencodeSession(target);
+    if (!memory)
+        return null;
+    if (memory.worktreePath !== worktreePath) {
+        logger.info('opencode-session-recovery-path-mismatch', {
+            worktreeId: target.worktreeId,
+            instanceId: target.instanceId ?? target.cliToolId,
+            recorded: memory.worktreePath,
+        });
+        return null;
+    }
+    if (!isOpencodeSessionId(memory.sessionId))
+        return null;
+    return memory.sessionId;
+}
+/**
+ * Add opencode's resume flag to a launch command line.
+ *
+ * `-s <id>` rather than `-c`: `--continue` means "the last session in this
+ * directory", which on a worktree running two opencode instances is whichever
+ * of them spoke most recently — the two panes would fight over one conversation.
+ * The id is the only spelling that names the instance's own session.
+ *
+ * Deliberately a string append rather than a change to `prepareOpencodeLaunch`:
+ * the resume flag depends on state (what this instance was doing last time)
+ * that the launch *plan* has no business knowing, and every other tool's plan
+ * must come out byte-for-byte unchanged (#2038's third acceptance condition).
+ *
+ * @param commandLine - The rendered launch line, environment prefix included
+ * @param sessionId - The session to continue
+ * @returns The line with `-s <id>` appended, or the line untouched when the id
+ *   is not one this module will put in front of a shell
+ */
+function withOpencodeResumedSession(commandLine, sessionId) {
+    if (!isOpencodeSessionId(sessionId))
+        return commandLine;
+    return `${commandLine} -s ${sessionId}`;
+}
+/** Drop every in-memory entry. Test seam; production only ever forgets one. */
+function resetOpencodeSessionMemories() {
+    memories.clear();
+}

package/dist/server/src/lib/session/provisional-turn.js

@@ -41,12 +41,13 @@
  * @module lib/session/provisional-turn
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NO_TURN = exports.MAX_EXTERNAL_ID_LENGTH = exports.MAX_PENDING_DECISIONS_PER_TURN = exports.SCRAPER_COMPLETION_POLLS = exports.DIALOG_PENDING_MAX_MS = exports.TURN_STALE_AFTER_MS = exports.TURN_CLOSE_REASONS = exports.TURN_ACTIVITY_EVENTS = void 0;
+exports.NO_TURN = exports.MAX_DECISION_PATTERN_LENGTH = exports.MAX_DECISION_PATTERNS = exports.MAX_EXTERNAL_ID_LENGTH = exports.MAX_PENDING_DECISIONS_PER_TURN = exports.SCRAPER_COMPLETION_POLLS = exports.DIALOG_PENDING_MAX_MS = exports.TURN_STALE_AFTER_MS = exports.TURN_CLOSE_REASONS = exports.TURN_ACTIVITY_EVENTS = void 0;
 exports.derivePublishedTurn = derivePublishedTurn;
 exports.acceptExternalId = acceptExternalId;
 exports.boundDisplayText = boundDisplayText;
 exports.boundDecisionMessage = boundDecisionMessage;
 exports.boundDecisionToolName = boundDecisionToolName;
+exports.boundDecisionPatterns = boundDecisionPatterns;
 exports.isDecisionLive = isDecisionLive;
 exports.isDeliveryExpired = isDeliveryExpired;
 exports.closesTurn = closesTurn;
@@ -190,6 +191,32 @@ exports.MAX_PENDING_DECISIONS_PER_TURN = 16;
  * (`idsDiscarded`) so an operator can see it happened.
  */
 exports.MAX_EXTERNAL_ID_LENGTH = 128;
+/**
+ * How many `patterns` are retained with an approval (Issue #2031).
+ *
+ * opencode's `permission.asked` carries the rules answering `Allow always`
+ * would save. They are worth keeping where `message` and `toolName` are — they
+ * are the only statement of what the *durable* verdict grants, and a button
+ * that saves a rule without showing it is asking for a decision whose size the
+ * user cannot see. They are kept under the same discipline as those two: a
+ * count bound and a per-entry length bound, so the record's footprint stays
+ * fixed no matter what the agent sent.
+ *
+ * Eight because the captured approvals carry one (`["/tmp/*"]`) and the shape
+ * that produced them is a directory list; a number this far above the observed
+ * one is a cap on a runaway, not a display limit somebody has to tune.
+ */
+exports.MAX_DECISION_PATTERNS = 8;
+/**
+ * Per-entry bound on a retained pattern (Issue #2031).
+ *
+ * A glob, not prose, so it is bounded well below {@link
+ * MAX_STRUCTURED_PROMPT_MESSAGE_LENGTH}. Truncation is safe here in a way it is
+ * NOT for an id (see {@link acceptExternalId}): nothing matches on these — they
+ * are displayed — so a shortened pattern misinforms visibly rather than
+ * colliding silently with another rule.
+ */
+exports.MAX_DECISION_PATTERN_LENGTH = 200;
 /** Nothing has been reported, so nothing can be said about a turn. */
 exports.NO_TURN = {
     turnId: null,
@@ -254,6 +281,32 @@ function boundDecisionMessage(raw) {
 function boundDecisionToolName(raw) {
     return boundDisplayText(raw, agent_event_types_1.MAX_EVENT_DETAIL_LENGTH);
 }
+/**
+ * Bound the `patterns` of an approval before they are retained (Issue #2031).
+ *
+ * Both axes, because either one alone leaves the footprint unbounded: a
+ * thousand short globs and one enormous glob are the same failure. Non-strings
+ * and empty strings are dropped rather than coerced — this list is displayed
+ * verbatim next to an `Allow always` button, and `"undefined"` rendered there
+ * would be a rule the user believes they are granting.
+ *
+ * @returns The bounded list, or null when nothing survived — so "the approval
+ *   named no rules" and "there were none to begin with" are the same value, and
+ *   a surface can render on presence alone
+ */
+function boundDecisionPatterns(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    const kept = [];
+    for (const entry of raw) {
+        if (typeof entry !== 'string' || entry === '')
+            continue;
+        kept.push(entry.slice(0, exports.MAX_DECISION_PATTERN_LENGTH));
+        if (kept.length >= exports.MAX_DECISION_PATTERNS)
+            break;
+    }
+    return kept.length > 0 ? kept : null;
+}
 /**
  * Whether this decision is still describing something, at `now`.
  *

package/dist/server/src/lib/session/send-user-message.js

@@ -32,6 +32,7 @@ const response_poller_1 = require("../../lib/polling/response-poller");
 const assistant_response_saver_1 = require("../../lib/assistant-response-saver");
 const logger_1 = require("../../lib/logger");
 const prompt_waiting_guard_1 = require("../../lib/session/prompt-waiting-guard");
+const opencode_1 = require("../../lib/cli-tools/opencode");
 const logger = (0, logger_1.createLogger)('session/send-user-message');
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -130,11 +131,11 @@ async function sendUserMessage(db, params) {
                 await cliTool.sendMessageWithImage(worktreeId, content, absoluteImagePath, instanceId);
             }
             else {
-                // Fallback: embed path in message
-                const messageWithPath = content
-                    ? `${content}\n\n[添付画像: ${absoluteImagePath}]`
-                    : `[添付画像: ${absoluteImagePath}]`;
-                await cliTool.sendMessage(worktreeId, messageWithPath, instanceId);
+                // Fallback: embed path in message. Issue #2035 moved the wording to
+                // `@/lib/cli-tools/opencode` so this branch and opencode's own fallback
+                // — reached when a pane has no server to attach through — cannot drift
+                // apart; the behaviour of this line is unchanged.
+                await cliTool.sendMessage(worktreeId, (0, opencode_1.formatImagePathFallbackMessage)(content, absoluteImagePath), instanceId);
             }
         }
         else {

package/dist/server/src/lib/session/structured-prompt.js

@@ -35,6 +35,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_STRUCTURED_PROMPT_MESSAGE_LENGTH = exports.STRUCTURED_DECISION_OPTIONS = void 0;
+exports.isAddressableDecision = isAddressableDecision;
 exports.buildStructuredPromptQuestion = buildStructuredPromptQuestion;
 exports.buildStructuredPromptData = buildStructuredPromptData;
 exports.buildStructuredPromptHistoryRecord = buildStructuredPromptHistoryRecord;
@@ -68,6 +69,26 @@ exports.STRUCTURED_DECISION_OPTIONS = [
 ];
 /** Bound on the agent's `message`, which is prose and only ever displayed. */
 exports.MAX_STRUCTURED_PROMPT_MESSAGE_LENGTH = 500;
+/**
+ * Whether an approval id is one a verdict can actually be addressed to
+ * (Issue #2031).
+ *
+ * The reason this is a function and not an `if` at the one call site: the
+ * publication condition for {@link STRUCTURED_DECISION_OPTIONS} and the
+ * publication condition for `decisionId` have to be the SAME condition, and
+ * #1932 is the record of what happens when they are merely intended to be. The
+ * receiving end (`components/worktree/prompt-decision-id`) applies exactly this
+ * predicate, so a payload the panel would reject as unaddressable can never
+ * have been published with buttons in the first place.
+ *
+ * Deliberately identical to `readPromptDecisionId`'s test — a non-empty string
+ * — and no stricter: the id has already been through `acceptExternalId` by the
+ * time it reaches a payload, and a second, different notion of validity here
+ * would be a way for the two ends to disagree again.
+ */
+function isAddressableDecision(value) {
+    return typeof value === 'string' && value !== '';
+}
 /** How each source reads in the one-line question. */
 const SOURCE_LABEL = {
     notification: 'Notification(permission_prompt)',
@@ -109,10 +130,30 @@ function buildStructuredPromptQuestion(worktreeId, facts) {
     }
     if (facts.askUserQuestion) {
         const { question, labels, questionCount } = facts.askUserQuestion;
+        // Issue #2100: whether these numbers may be QUOTED is the same test the
+        // browser applies before drawing them as buttons — see
+        // `components/worktree/prompt-decision-id`'s `readPromptQuestionChoices`:
+        // an id to deliver an answer to, exactly one question, and no approval
+        // verdicts on the same payload. Claude satisfies none of it (its picker is
+        // read off the screen, renumbered, with entries the payload never
+        // mentioned), so its sentence is the unchanged warning.
+        //
+        // This is not a nicety. `promptData.question` is what PromptPanel renders
+        // ABOVE the choice buttons, so before this Issue an opencode question
+        // showed working numbered buttons under a line telling the reader not to
+        // count the list they were numbered from.
+        const answerable = isAddressableDecision(facts.decisionId) &&
+            questionCount === 1 &&
+            !(facts.decisionOptions && facts.decisionOptions.length > 0);
         parts.push(`The agent asked${questionCount > 1 ? ` ${questionCount} questions, the first being` : ''}: ` +
             `"${question}" — offering: ${labels.join(' / ')}. ` +
-            `The picker renumbers and adds its own entries, so read the option NUMBER off the ` +
-            `terminal rather than counting this list.`);
+            (answerable
+                ? `Answer it with \`commandmate respond ${worktreeId} <number>\`: ` +
+                    labels.map((label, index) => `${index + 1} = ${label}`).join(', ') +
+                    `. The number is this list's own position and the reply goes to the agent's own ` +
+                    `API, so no keys are sent to the terminal (the label works too).`
+                : `The picker renumbers and adds its own entries, so read the option NUMBER off the ` +
+                    `terminal rather than counting this list.`));
     }
     return parts.join(' ');
 }
@@ -130,6 +171,16 @@ function buildStructuredPromptData(worktreeId, facts) {
         ...(facts.decisionOptions && facts.decisionOptions.length > 0
             ? { decisionOptions: facts.decisionOptions }
             : {}),
+        // Issue #2031. Unconditional, unlike every field above it: those are prose
+        // whose absence and emptiness mean the same thing, while this one answers
+        // "is there an approval to address?" and `null` is a real answer. Dropping
+        // this line is the mutation `structured-prompt-decision-id-2031` fires at —
+        // it puts the payload back to #1932's half-built state, where the panel
+        // publishes three verdicts nothing can deliver.
+        decisionId: isAddressableDecision(facts.decisionId) ? facts.decisionId : null,
+        ...(facts.patterns && facts.patterns.length > 0
+            ? { patterns: [...facts.patterns] }
+            : {}),
     };
 }
 /** The prompt-history row for a structured prompt the scraper never saw. */