commandmate 0.49.2 → 0.50.0

package/dist/server/src/lib/job-executor.js

@@ -23,6 +23,8 @@ exports.resolveScheduleExecuteOptions = resolveScheduleExecuteOptions;
 exports.executeSchedule = executeSchedule;
 const crypto_1 = require("crypto");
 const claude_executor_1 = require("./session/claude-executor");
+const role_launch_1 = require("./session/role-launch");
+const env_sanitizer_1 = require("../lib/security/env-sanitizer");
 const cmate_cli_tool_parser_1 = require("../lib/cmate-cli-tool-parser");
 const logger_1 = require("../lib/logger");
 const logger = (0, logger_1.createLogger)('job-executor');
@@ -191,7 +193,22 @@ async function executeSchedule(state) {
         }
         // Resolve the CLI options via the centralized helper (DR1-004, #2044)
         const options = resolveScheduleExecuteOptions(state.entry, worktree);
-        const result = await (0, claude_executor_1.executeClaudeCommand)(state.entry.message, worktree.path, state.entry.cliToolId, state.entry.permission, options);
+        // Issue #4115: the defaults for this worktree and tool, resolved here and not in
+        // `executeClaudeCommand`, which the daily summary shares (D2). A role that cannot
+        // be applied fails the run: it must not go ahead without one.
+        const scheduleRole = await (0, role_launch_1.resolveScheduleRole)(db, {
+            worktreeId: state.worktreeId,
+            cliToolId: state.entry.cliToolId,
+            worktreePath: worktree.path,
+            explicitAgent: options?.agent,
+            env: (0, env_sanitizer_1.sanitizeEnvForChildProcess)(),
+        });
+        if (scheduleRole.kind === 'refused') {
+            updateExecutionLog(logId, 'failed', scheduleRole.refusal.message, null);
+            logger.warn('execution:role-refused', { name: state.entry.name, reason: scheduleRole.refusal.reason });
+            return;
+        }
+        const result = await (0, claude_executor_1.executeClaudeCommand)(state.entry.message, worktree.path, state.entry.cliToolId, state.entry.permission, scheduleRole.kind === 'role' ? { ...options, role: scheduleRole.role } : options);
         // Issue #2253: `result.status` is not always "did the process exit 0".
         // command-code writes a `{"type":"result","subtype":…}` line even on a
         // non-zero exit and can pair `subtype: "success"` with exit 9, so

package/dist/server/src/lib/polling/response-checker-extraction-steps.js

@@ -10,6 +10,7 @@ exports.isTurnComplete = isTurnComplete;
 exports.extractCompletedResponse = extractCompletedResponse;
 exports.extractPartialResponse = extractPartialResponse;
 const cli_patterns_1 = require("../../lib/detection/cli-patterns");
+const patterns_1 = require("../../lib/detection/tools/opencode-v2/patterns");
 const logger_1 = require("../../lib/logger");
 const thinking_constants_1 = require("../../config/thinking-constants");
 const logger = (0, logger_1.createLogger)('response-poller');
@@ -59,6 +60,20 @@ function findChromeStart(cliToolId, lines, openCodeCleanLines) {
     // that one row. `findCodexChromeStart` reads the composer by its SGR
     // attributes (#2310) rather than by its placeholder wording, which is what the
     // previous guard did and why it stopped working at codex 0.15x.
+    //
+    // Issue #4175: opencode-v2 is the sixth. It draws V1's box — `┃` gutter rows
+    // over a `╹▀▀▀` border, the footer under it — and had no boundary: the
+    // composer's rows went into every reply, and the footer was kept out only by
+    // its column in the skip list (#4161), which a reply drawn further left would
+    // lose and a footer drawn further right would beat. opencode-v2 has no rule in
+    // `isTurnComplete`, so today this boundary reaches only the partial reading,
+    // which the poller does not save. Issue #4187 made that the design: V2's
+    // replies are never saved from the screen — the event stream's turn end and,
+    // for a stream that was down, the recovery sync on reconnect write them from
+    // the server's document (`lib/hooks/sources/opencode-v2/history`).
+    if (cliToolId === 'opencode-v2') {
+        return (0, patterns_1.findOpencodeV2ChromeStart)(lines.map(cli_patterns_1.stripAnsi));
+    }
     return cliToolId === 'claude'
         ? (0, cli_patterns_1.findClaudeChromeStart)(lines)
         : cliToolId === 'copilot'
@@ -532,6 +547,13 @@ function collectCompletedResponse(ctx) {
     // real content on the following poll. So the cursor stops where the content
     // stops, which is what it did before.
     let endIndex = cliToolId === 'codex' ? contentEnd : totalLines;
+    // Issue #4188: the opencode fallback cut below, by position. A completed turn
+    // ends on its `▣ Build · … · 2.5s` row and the chrome is drawn under it, so a
+    // row ABOVE the newest finished-turn row is the reply's, whatever words it
+    // holds. -1 (no such row in the window) leaves every row eligible, as before.
+    const openCodeTurnCompleteRow = cliToolId === 'opencode' && chromeStart < 0
+        ? findLastOpenCodeTurnCompleteRow(lines, startIndex, contentEnd)
+        : -1;
     for (let i = startIndex; i < contentEnd; i++) {
         const line = lines[i];
         const cleanLine = (0, cli_patterns_1.stripAnsi)(line);
@@ -556,7 +578,11 @@ function collectCompletedResponse(ctx) {
         // one boundary available — and #1883 measured that a REPLY can contain
         // `Ask anything...`, so cutting the turn on it is a last resort, not the
         // primary rule.
-        if (cliToolId === 'opencode' && chromeStart < 0) {
+        //
+        // Issue #4188: and only below the turn's finished-turn row. Both patterns are
+        // words matched anywhere in the row, so a reply row quoting them (`Ask
+        // anything... is the placeholder`) above that row cut the reply short there.
+        if (cliToolId === 'opencode' && chromeStart < 0 && i > openCodeTurnCompleteRow) {
             if (cli_patterns_1.OPENCODE_PROMPT_PATTERN.test(cleanLine) || cli_patterns_1.OPENCODE_PROMPT_AFTER_RESPONSE.test(cleanLine)) {
                 endIndex = i;
                 break;
@@ -571,6 +597,22 @@ function collectCompletedResponse(ctx) {
     const response = responseLines.join('\n').trim();
     return { response, endIndex };
 }
+/**
+ * The newest opencode finished-turn row (`▣ Build · <model> · 2.5s`) in
+ * `[from, to)`, or -1 (Issue #4188).
+ *
+ * @param lines - The trimmed tmux buffer lines (ANSI intact)
+ * @param from - First row to search
+ * @param to - Exclusive end of the search
+ * @returns Index into `lines`, or -1
+ */
+function findLastOpenCodeTurnCompleteRow(lines, from, to) {
+    for (let i = to - 1; i >= from; i--) {
+        if (cli_patterns_1.OPENCODE_TURN_COMPLETE_PATTERN.test((0, cli_patterns_1.stripAnsi)(lines[i])))
+            return i;
+    }
+    return -1;
+}
 /**
  * Build the result for a frame the completion rules accepted.
  *
@@ -584,7 +626,7 @@ function collectCompletedResponse(ctx) {
  * @returns What `extractResponse` returns for this frame
  */
 function extractCompletedResponse(ctx) {
-    const { cliToolId, totalLines, openCodeCleanLines, bufferReset, captureWindowSaturated, thinkingPattern, skipPatterns, findRecentUserPromptIndex, } = ctx;
+    const { cliToolId, lines, totalLines, chromeStart, openCodeCleanLines, bufferReset, captureWindowSaturated, thinkingPattern, skipPatterns, findRecentUserPromptIndex, } = ctx;
     const { response, endIndex } = collectCompletedResponse(ctx);
     // DR-004: Check only the tail of the response for thinking indicators.
     //
@@ -595,8 +637,20 @@ function extractCompletedResponse(ctx) {
     // that never scrolls away. `COPILOT_THINKING_PATTERN`'s braille alternative
     // matches any spinner glyph a reply happens to quote, and the turn would then
     // be reported unfinished for the rest of the session.
-    const responseTailLines = response.split('\n').slice(-thinking_constants_1.THINKING_TAIL_LINE_COUNT).join('\n');
-    if (cliToolId !== 'copilot' && thinkingPattern.test(responseTailLines)) {
+    //
+    // Issue #4188: not the reply's tail on an opencode frame whose chrome was
+    // located. Its reply keeps the rows quoting the chrome's words by position
+    // (`OPENCODE_TRANSCRIPT_SKIP_PATTERNS`), so a reply ending on `Ask anything...
+    // is the input box, Thinking: is the progress row` would be read here as a
+    // running turn and the finished reply never saved. There the progress is read
+    // where the TUI draws it while a turn runs: under the composer's bottom border,
+    // as `isOpenCodeComplete` reads the busy hint, and as whole progress rows: the
+    // footer there also draws the cwd, which may hold the word (`/tmp/Thinking:demo`).
+    const stillRunning = cliToolId === 'opencode' && chromeStart >= 0
+        ? (0, cli_patterns_1.isOpenCodeProgressBelowComposer)(lines.slice(chromeStart).map(cli_patterns_1.stripAnsi))
+        : cliToolId !== 'copilot' &&
+            thinkingPattern.test(response.split('\n').slice(-thinking_constants_1.THINKING_TAIL_LINE_COUNT).join('\n'));
+    if (stillRunning) {
         return (0, response_checker_extraction_result_1.incompleteResult)(totalLines);
     }
     // Startup-screen defenses, one per tool and in this order. Each answers only

package/dist/server/src/lib/polling/response-checker.js

@@ -407,7 +407,15 @@ function extractResponse(output, lastCapturedLine, cliToolId, captureWindowLines
         ? openCodeCleanLines.join('\n')
         : linesToCheck.join('\n');
     // Get tool-specific patterns from shared module
-    const { promptPattern, separatorPattern, thinkingPattern, skipPatterns } = (0, cli_patterns_1.getCliToolPatterns)(cliToolId);
+    const { promptPattern, separatorPattern, thinkingPattern, skipPatterns: toolSkipPatterns } = (0, cli_patterns_1.getCliToolPatterns)(cliToolId);
+    // Issue #4188: on an opencode frame whose chrome was located, `contentEnd` has
+    // already cut off the rows only the chrome draws (`esc interrupt`,
+    // `Ask anything...`, `tab agents  ctrl+p commands`, the spinner run), so a row
+    // above it with those words is the reply's and is kept. With no boundary the
+    // words are the only reading left, and the whole list applies as before.
+    const skipPatterns = cliToolId === 'opencode' && chromeStart >= 0
+        ? [...cli_patterns_1.OPENCODE_TRANSCRIPT_SKIP_PATTERNS]
+        : toolSkipPatterns;
     const findRecentUserPromptIndex = (windowSize = 60) => (0, response_checker_extraction_steps_1.findRecentUserPromptIndexInFrame)(cliToolId, lines, openCodeCleanLines, chromeStart, contentEnd, windowSize);
     // Early check for interactive prompts (before extraction logic)
     //
@@ -560,14 +568,26 @@ function extractCompletedTurn(ctx, output, lastCapturedLine, owns) {
         observeUpstreamFaultForPush(worktreeId, cliToolId, instanceId, output);
     // Layer 2: Accumulate TUI content for full-screen TUI tools, so a turn that
     // outgrows the alternate-screen pane keeps the head that has scrolled away.
+    // Issue #4187: not opencode-v2. The screen reading never completes a V2 turn
+    // (its replies are written from its server's document, including the turns a
+    // lost stream missed, on reconnect), so there is no save for the head to reach.
     if (owns && (cliToolId === 'opencode' || cliToolId === 'copilot')) {
         // Issue #1911: opencode is accumulated from the CURRENT TURN'S REGION
         // rather than the whole frame. Feeding the raw pane seeded the accumulator
         // with the previous turn's transcript, the echoed prompt and the bottom
         // chrome on the very first poll, so the accumulated content could never be
         // used as a response source without re-introducing defect 1.
-        const accumulatorSource = cliToolId === 'opencode' ? (0, response_extractor_1.sliceOpenCodeTurn)(output) : output;
-        (0, tui_accumulator_1.accumulateTuiContent)(pollerKey, accumulatorSource, cliToolId);
+        //
+        // Issue #4188: with the skip list the slice's position allows — the rows only
+        // the chrome draws are kept when the slice ends above the located chrome, so a
+        // reply quoting them survives into the accumulator (and the save below).
+        if (cliToolId === 'opencode') {
+            const { turn, skipPatterns } = (0, response_extractor_1.sliceOpenCodeTurnWithSkip)(output);
+            (0, tui_accumulator_1.accumulateTuiContent)(pollerKey, turn, cliToolId, skipPatterns);
+        }
+        else {
+            (0, tui_accumulator_1.accumulateTuiContent)(pollerKey, output, cliToolId);
+        }
     }
     // Extract response
     const result = extractResponse(output, lastCapturedLine, cliToolId, tmux_capture_cache_1.CACHE_MAX_CAPTURE_LINES);
@@ -873,11 +893,16 @@ function cleanCompletedResponse(cliToolId, result, pollerKey, owns) {
         // `result.response` already holds exactly. When the echo is off screen the
         // frame is missing content outright, and a possible duplicate beats a
         // guaranteed truncation.
+        //
+        // Issue #4188: both sources are cleaned with `OPENCODE_TRANSCRIPT_SKIP_PATTERNS`,
+        // which keeps a reply's rows quoting the chrome's words (`esc interrupt`,
+        // `Ask anything...`). The extraction already left the chrome out by position
+        // (or, on a frame whose chrome it could not locate, skipped those rows with
+        // the whole list itself). The accumulator was filtered the same way when each
+        // frame was read (`sliceOpenCodeTurnWithSkip`): the shorter list only for
+        // rows cut above the located chrome, the whole list otherwise.
         const accumulatedContent = (0, tui_accumulator_1.getAccumulatedContent)(pollerKey);
-        const sourceContent = result.turnHeadTruncated && accumulatedContent
-            ? accumulatedContent
-            : result.response;
-        cleanedResponse = (0, response_cleaner_1.cleanOpenCodeResponse)(sourceContent);
+        cleanedResponse = (0, response_cleaner_1.cleanOpenCodeResponse)(result.turnHeadTruncated && accumulatedContent ? accumulatedContent : result.response, cli_patterns_1.OPENCODE_TRANSCRIPT_SKIP_PATTERNS);
         if (owns)
             (0, tui_accumulator_1.clearTuiAccumulator)(pollerKey);
     }

package/dist/server/src/lib/relay/relay-bound-reply.js

@@ -216,7 +216,7 @@ function stashReplyForOpenRelays(db, worker, now) {
         if (!reply)
             continue;
         const body = (0, relay_messages_1.buildRelayReplyMessage)(senderLabel(db, relay), reply.content);
-        if (stashReply(db, relay.id, { candidateId: reply.id, body, overlap: null, basis: 'legacy' }, now)) {
+        if (stashReply(db, relay.id, { candidateId: reply.id, body, overlap: null, basis: 'legacy' }, now) !== null) {
             stashed += 1;
         }
     }
@@ -232,6 +232,11 @@ function stashReplyForOpenRelays(db, worker, now) {
  * requester for nothing. The notice is being typed: the reply waits in the
  * second slot and is promoted once the notice is out. A reply already holds
  * it: nothing (two producers, one delivery).
+ *
+ * Issue #4082: when a reply already waits in the second slot (it finished
+ * while the notice was held, and the hold was retried), the replacement puts
+ * THAT reply first and drops this later one — the first reply to finish is
+ * the one kept, as the second slot always kept it.
  */
 function stashReply(db, relayId, reply, now) {
     const decided = { ...reply, payloadId: (0, crypto_1.randomUUID)() };
@@ -239,16 +244,21 @@ function stashReply(db, relayId, reply, now) {
         payloadId: decided.payloadId,
         overlap: decided.overlap ?? undefined,
     })) {
-        return true;
+        return 'stashed';
     }
     const current = (0, relay_db_1.getRelayPendingPayload)(db, relayId);
     if (!current || current.kind !== 'prompt')
-        return false;
+        return null;
     if (!(0, relay_delivery_claims_1.isRelayDeliveryClaimed)(relayId)) {
-        if ((0, relay_db_1.replaceRelayPromptWithReply)(db, relayId, current.payloadId, decided, now))
-            return true;
+        const replaced = (0, relay_db_1.replaceRelayPromptWithReply)(db, relayId, current.payloadId, decided, now);
+        if (replaced === 'reply')
+            return 'stashed';
+        if (replaced === 'waiting-reply') {
+            logger.info('relay-earlier-reply-kept', { relayId, laterCandidateId: reply.candidateId });
+            return 'earlier-reply';
+        }
     }
-    return (0, relay_db_1.setRelayPendingReply)(db, relayId, decided, now);
+    return (0, relay_db_1.setRelayPendingReply)(db, relayId, decided, now) ? 'stashed' : null;
 }
 /**
  * Whether the session's observation still matches the one the send recorded.
@@ -382,8 +392,8 @@ function stashBoundReply(db, worker, binding, reply, now) {
     const verdict = (0, relay_overlap_1.judgeRelayOverlap)(db, binding, worker, reply);
     const note = (0, relay_messages_1.buildRelayOverlapNote)((0, model_change_push_notifier_1.resolveReadersLocale)(db), verdict.overlap);
     const body = (0, relay_messages_1.buildRelayReplyMessage)(senderLabel(db, binding.relay), reply.content, note);
-    const stashed = stashReply(db, binding.relay.id, { candidateId: reply.id, body, overlap: verdict.overlap, basis: verdict.basis }, now);
-    if (stashed) {
+    const outcome = stashReply(db, binding.relay.id, { candidateId: reply.id, body, overlap: verdict.overlap, basis: verdict.basis }, now);
+    if (outcome === 'stashed') {
         logger.info('relay-reply-decided', {
             relayId: binding.relay.id,
             candidateId: reply.id,
@@ -391,7 +401,8 @@ function stashBoundReply(db, worker, binding, reply, now) {
             basis: verdict.basis,
         });
     }
-    return stashed;
+    // An earlier reply taking the slot is still a payload for the pump.
+    return outcome !== null;
 }
 /**
  * Whether a prompt row may be told to this relay's requester (Issue #3957).

package/dist/server/src/lib/relay/relay-delivery-block.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * Why the last delivery attempt of a relay payload stopped (Issue #4105).
+ *
+ * While the requester A shows a confirmation dialog, every pump tick refuses
+ * the delivery (`prompt_waiting`) and nothing in the ledger said so: the relay
+ * read the same as one that was simply queued. This module keeps, in the
+ * server process, the reason the LAST attempt stopped for — tied to the
+ * payload it was for and the time it was observed — and attaches it to the
+ * relay APIs' answers as `lastDeliveryBlock`.
+ *
+ * ## Rules
+ *
+ *  - **One writer.** Only `deliverOne` (via the single-flight pump) records or
+ *    clears an entry, so every entry point that ends in a pump — a turn
+ *    completion, a prompt notice, the maintenance tick, a resolve — follows the
+ *    same rule.
+ *  - **Tied to the payload.** An entry is shown only while the slot still
+ *    carries the same payload (kind, id, body) and no delivery hold. A payload
+ *    replaced, delivered, cancelled, expired, held or taken answers `null`, and
+ *    the stale entry is dropped.
+ *  - **An observation, not a state.** `observedAt` is the attempt's time; the
+ *    next attempt replaces or clears it. `null` means "no observation", never
+ *    "deliverable" (a restart forgets every entry on purpose).
+ *  - **Never in the database**, and never in `held` / `heldCount` /
+ *    `holdReason` / `deliveryHold`.
+ *  - **Never throws.** A failure here costs the label, never the delivery or
+ *    the API answer that carries it.
+ *
+ * @module lib/relay/relay-delivery-block
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetRelayDeliveryBlocks = resetRelayDeliveryBlocks;
+exports.noteRelayDeliveryAttempt = noteRelayDeliveryAttempt;
+exports.pruneRelayDeliveryBlocks = pruneRelayDeliveryBlocks;
+exports.readRelayLastDeliveryBlock = readRelayLastDeliveryBlock;
+exports.withLastDeliveryBlock = withLastDeliveryBlock;
+exports.withLastDeliveryBlocks = withLastDeliveryBlocks;
+exports.listClosedBlockedRelays = listClosedBlockedRelays;
+const relay_db_1 = require("../../lib/db/relay-db");
+const logger_1 = require("../../lib/logger");
+const global_state_1 = require("../global-state");
+const logger = (0, logger_1.createLogger)('relay-delivery-block');
+/** On `globalThis` for the reason the pump's own sets are (#1736). */
+const blocks = (0, global_state_1.getOrInitGlobal)('__relayLastDeliveryBlocks', () => new Map());
+/** Forget every observation (what a restart does). Test seam. */
+function resetRelayDeliveryBlocks() {
+    blocks.clear();
+}
+/**
+ * Record what the last attempt of `relayId` observed, or clear it (`null`:
+ * the attempt did not stop for one of the reasons — delivered, uncertain,
+ * superseded, failed for another reason).
+ */
+function noteRelayDeliveryAttempt(relayId, entry) {
+    try {
+        if (entry === null)
+            blocks.delete(relayId);
+        else
+            blocks.set(relayId, entry);
+    }
+    catch (error) {
+        logger.warn('relay-delivery-block-note-failed', {
+            relayId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/** Drop the entries of relays the pump no longer lists (closed, held, emptied). */
+function pruneRelayDeliveryBlocks(listed) {
+    try {
+        for (const relayId of [...blocks.keys()]) {
+            if (!listed.has(relayId))
+                blocks.delete(relayId);
+        }
+    }
+    catch {
+        // Best-effort: an entry left behind is still checked against the payload.
+    }
+}
+/**
+ * The observation for the payload `relay` carries now, or `null`.
+ *
+ * Re-reads the slot rather than trusting the row the caller has: the entry
+ * must describe THIS payload. A mismatch drops the entry.
+ */
+function readRelayLastDeliveryBlock(db, relay) {
+    try {
+        const entry = blocks.get(relay.id);
+        if (!entry)
+            return null;
+        const current = (0, relay_db_1.getRelayPendingPayload)(db, relay.id);
+        if (!current ||
+            current.kind !== entry.kind ||
+            current.payloadId !== entry.payloadId ||
+            current.body !== entry.body) {
+            blocks.delete(relay.id);
+            return null;
+        }
+        // Under a delivery hold (`attempting` / `uncertain`) the hold is what
+        // describes the payload; the entry is kept in case the attempt is queued
+        // again, but not shown.
+        if (current.relay.deliveryHold !== null)
+            return null;
+        return {
+            reason: entry.reason,
+            kind: entry.kind,
+            payloadId: entry.payloadId,
+            observedAt: entry.observedAt,
+        };
+    }
+    catch (error) {
+        logger.warn('relay-delivery-block-read-failed', {
+            relayId: relay.id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+/** `relay` with its {@link readRelayLastDeliveryBlock} attached. */
+function withLastDeliveryBlock(db, relay) {
+    return { ...relay, lastDeliveryBlock: readRelayLastDeliveryBlock(db, relay) };
+}
+/** {@link withLastDeliveryBlock} over a list. */
+function withLastDeliveryBlocks(db, relays) {
+    return relays.map((relay) => withLastDeliveryBlock(db, relay));
+}
+/**
+ * Closed relays whose undelivered payload's last attempt stopped (Issue #4193).
+ *
+ * An expired relay keeps its expiry notice in the slot until it reaches the
+ * requester, and the pump records why that delivery stopped like any other —
+ * but the list's `open` / `awaiting` (rightly) leave closed relays out, so the
+ * reason was readable through `relays --id` only. This is the list of those
+ * relays, each with its `lastDeliveryBlock`; one that carries no observation
+ * (nothing stopped it, or this process has not tried) is not listed. Never
+ * counted in `counts` / `heldCount`, never added to `open` / `awaiting`, and
+ * never throws (an empty list costs the label only).
+ */
+function listClosedBlockedRelays(db, scope = {}) {
+    try {
+        return withLastDeliveryBlocks(db, (0, relay_db_1.listClosedRelaysWithPendingPayload)(db, scope)).filter((relay) => relay.lastDeliveryBlock != null);
+    }
+    catch (error) {
+        logger.warn('relay-closed-blocked-list-failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return [];
+    }
+}