commandmate 0.49.3 → 0.50.0

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-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 [];
+    }
+}

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

@@ -61,6 +61,7 @@ Object.defineProperty(exports, "findWorkerReply", { enumerable: true, get: funct
 Object.defineProperty(exports, "recoverBoundRelays", { enumerable: true, get: function () { return relay_bound_reply_1.recoverBoundRelays; } });
 const relay_policy_1 = require("../../lib/relay/relay-policy");
 const relay_readiness_1 = require("../../lib/relay/relay-readiness");
+const relay_delivery_block_1 = require("../../lib/relay/relay-delivery-block");
 const relay_session_ref_1 = require("../../lib/relay/relay-session-ref");
 const relay_system_line_1 = require("../../lib/relay/relay-system-line");
 const relay_delivery_claims_1 = require("../../lib/relay/relay-delivery-claims");
@@ -96,6 +97,8 @@ const inFlight = (0, global_state_1.getOrInitGlobal)('__relayDeliveryInFlight',
 function resetRelayDeliveryState() {
     inFlight.clear();
     (0, relay_delivery_claims_1.resetRelayDeliveryClaims)();
+    // Issue #4105: a restart forgets the last attempts' observations too.
+    (0, relay_delivery_block_1.resetRelayDeliveryBlocks)();
     globalThis.__relayPumpRunning = false;
     globalThis.__relayRecoveredBootId = undefined;
     globalThis.__relayAttemptsRecoveredBootId = undefined;
@@ -426,7 +429,19 @@ function reasonForThrow(attempt) {
  * that same synchronous stretch, so no cancel can slip in between the check
  * and the send; from then on `withdrawRelay` answers `delivering`.
  */
-async function deliverOne(db, relayId, kind, body, listedPayloadId) {
+function deliverOne(db, relayId, kind, body, listedPayloadId) {
+    // Issue #4105: what this attempt stopped for, recorded (or cleared) once it
+    // is over, whichever way it ended. Never touches the ledger. The attempt's
+    // own promise is returned as is — the note is a reaction registered before
+    // the caller's await, so it lands first and adds no tick to the pump.
+    const observed = { block: null };
+    const attempt = attemptDelivery(db, relayId, kind, body, listedPayloadId, observed);
+    const note = () => (0, relay_delivery_block_1.noteRelayDeliveryAttempt)(relayId, observed.block);
+    attempt.then(note, note);
+    return attempt;
+}
+/** {@link deliverOne}'s body; `observed.block` is set only for a stop worth showing (Issue #4105). */
+async function attemptDelivery(db, relayId, kind, body, listedPayloadId, observed) {
     const listed = (0, relay_db_1.getRelayById)(db, relayId);
     if (!listed)
         return 'skipped';
@@ -434,6 +449,12 @@ async function deliverOne(db, relayId, kind, body, listedPayloadId) {
     const hold = await (0, relay_readiness_1.findRelayHoldReason)(listedRequester.worktreeId, listedRequester.cliToolId, listedRequester.instanceId, db);
     if (hold) {
         logger.debug('relay-delivery-held', { relayId, kind, reason: hold });
+        // Issue #4105: the readiness check awaited, and a cancel, an expiry or a
+        // replacement may have run meanwhile — only a payload the slot still
+        // carries gets the reason (#3732's re-read, without its claim).
+        if (stillCarriesPayload(db, relayId, kind, body, listedPayloadId)) {
+            observed.block = { reason: hold, kind, payloadId: listedPayloadId, body, observedAt: Date.now() };
+        }
         return 'held';
     }
     // Synchronous from here to the send: re-read, then claim.
@@ -507,6 +528,18 @@ async function deliverOne(db, relayId, kind, body, listedPayloadId) {
         if (!result.ok) {
             const settled = settleUnsentResult(db, ref, relay, requester, kind, result.stage, attempt);
             requeued = settled.requeued;
+            // Issue #4105: A's dialog refused it and the payload is queued again
+            // under the same id. A requeue that failed leaves it `attempting` (a
+            // hold), which must not read as "waiting for the dialog".
+            if (settled.outcome === 'held' && settled.requeued) {
+                observed.block = {
+                    reason: 'prompt_waiting',
+                    kind,
+                    payloadId: ref.payloadId,
+                    body,
+                    observedAt: Date.now(),
+                };
+            }
             return settled.outcome;
         }
         const now = Date.now();
@@ -562,6 +595,26 @@ function rereadDeliverablePayload(db, relayId, kind, body, listedPayloadId) {
     }
     return current;
 }
+/**
+ * Whether the slot still carries the listed payload, deliverable (Issue
+ * #4105): the same test as {@link rereadDeliverablePayload}, unlogged, plus
+ * no delivery hold. Never throws.
+ */
+function stillCarriesPayload(db, relayId, kind, body, listedPayloadId) {
+    try {
+        const current = (0, relay_db_1.getRelayPendingPayload)(db, relayId);
+        if (!current)
+            return false;
+        if (current.kind !== kind || current.body !== body || current.payloadId !== listedPayloadId)
+            return false;
+        if (current.relay.deliveryHold !== null)
+            return false;
+        return kind === 'expired' || (0, types_1.isOpenRelayState)(current.relay.state);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * A send that returned `ok: false`: held as `uncertain`, or queued again when
  * it is known not to have gone out (Issue #4064).
@@ -745,7 +798,11 @@ async function pumpRelayDeliveries() {
             globalThis.__relayPumpAgain = false;
             // Issue #4064: a payload under a delivery hold is not listed, so a pass
             // (or the next pump) never types it again; other relays go on.
-            for (const item of (0, relay_db_1.listDeliverableRelayPayloads)(db)) {
+            const listing = (0, relay_db_1.listDeliverableRelayPayloads)(db);
+            // Issue #4105: an observation of a relay no longer listed (delivered,
+            // closed, emptied, held) is dropped.
+            (0, relay_delivery_block_1.pruneRelayDeliveryBlocks)(new Set(listing.map((item) => item.relay.id)));
+            for (const item of listing) {
                 if (inFlight.has(item.relay.id))
                     continue;
                 inFlight.add(item.relay.id);

package/dist/server/src/lib/response-cleaner.js

@@ -368,16 +368,26 @@ function cleanCopilotResponse(response) {
  *    with a Build marker. Without this trimming, savePendingAssistantResponse
  *    and Layer 2 accumulator would include previous Q&As in the response.
  * 3. Skip empty lines
- * 4. Skip lines matching any OPENCODE_SKIP_PATTERNS (TUI artifacts)
+ * 4. Skip lines matching any of `skipPatterns` (TUI artifacts)
  * 5. Skip Build summary line (OPENCODE_RESPONSE_COMPLETE, the completion indicator)
  * 6. Join remaining lines
  *
+ * Issue #4188: the skip list is the caller's. The default is the whole
+ * `OPENCODE_SKIP_PATTERNS`, which reads the rows only the chrome draws
+ * (`esc interrupt`, `Ask anything...`, `tab agents  ctrl+p commands`, the spinner
+ * run) by their words, wherever they sit. A caller whose rows are known to lie
+ * above the located chrome — the poller's save of an extracted turn and of the
+ * Layer-2 accumulator — passes `OPENCODE_TRANSCRIPT_SKIP_PATTERNS`, so a reply
+ * quoting those rows keeps them. (This replaced `cleanOpenCodeTurnResponse`, a
+ * copy of this function that differed only in that list.)
+ *
  * @param response - Raw OpenCode response (may contain TUI decoration)
+ * @param skipPatterns - Rows to drop; defaults to `OPENCODE_SKIP_PATTERNS`
  * @returns Cleaned response with TUI artifacts removed
  *
  * @internal Exported for unit testing (response-poller-opencode.test.ts)
  */
-function cleanOpenCodeResponse(response) {
+function cleanOpenCodeResponse(response, skipPatterns = cli_patterns_1.OPENCODE_SKIP_PATTERNS) {
     const lines = response.split('\n');
     // Step 2: Trim to latest response by finding Build markers.
     // Each Q&A exchange ends with "square Build . model . time".
@@ -401,7 +411,7 @@ function cleanOpenCodeResponse(response) {
         if (!cleanLine)
             continue;
         // Skip lines matching any OpenCode skip pattern
-        const shouldSkip = cli_patterns_1.OPENCODE_SKIP_PATTERNS.some(pattern => pattern.test(cleanLine));
+        const shouldSkip = skipPatterns.some(pattern => pattern.test(cleanLine));
         if (shouldSkip)
             continue;
         // Skip the Build summary line (completion indicator)

package/dist/server/src/lib/response-extractor.js

@@ -9,6 +9,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveOpenCodeTurnRegion = resolveOpenCodeTurnRegion;
 exports.sliceOpenCodeTurn = sliceOpenCodeTurn;
+exports.sliceOpenCodeTurnWithSkip = sliceOpenCodeTurnWithSkip;
 exports.isOpenCodeComplete = isOpenCodeComplete;
 exports.resolveExtractionStartIndex = resolveExtractionStartIndex;
 const cli_patterns_1 = require("./detection/cli-patterns");
@@ -59,11 +60,35 @@ function resolveOpenCodeTurnRegion(lines) {
  *   on screen yet.
  */
 function sliceOpenCodeTurn(output) {
+    return sliceOpenCodeTurnWithSkip(output).turn;
+}
+/**
+ * {@link sliceOpenCodeTurn} plus the skip list its rows may be cleaned with
+ * (Issue #4188).
+ *
+ * When the chrome was located, the slice ends above it by position, so a row of
+ * the slice with the words only the chrome draws (`esc interrupt`,
+ * `Ask anything...`, `tab agents  ctrl+p commands`, the spinner run) is a reply's
+ * row quoting them: {@link OPENCODE_TRANSCRIPT_SKIP_PATTERNS} keeps it. With no
+ * chrome boundary the slice runs to the end of the pane and the words are the
+ * only reading left: the whole {@link OPENCODE_SKIP_PATTERNS}.
+ *
+ * The Layer-2 accumulator is the caller: its rows reach the save
+ * (`turnHeadTruncated`) one at a time with no position, so the position has to
+ * be read here, where the frame still is.
+ *
+ * @param output - Raw `capture-pane` output.
+ * @returns The region's rows (`''` when none) and the skip list for them
+ *
+ * @internal Exported for unit testing
+ */
+function sliceOpenCodeTurnWithSkip(output) {
     const rawLines = output.split('\n');
     const region = resolveOpenCodeTurnRegion(rawLines.map(cli_patterns_1.stripAnsi));
+    const skipPatterns = region.chromeStart >= 0 ? cli_patterns_1.OPENCODE_TRANSCRIPT_SKIP_PATTERNS : cli_patterns_1.OPENCODE_SKIP_PATTERNS;
     if (region.start >= region.end)
-        return '';
-    return rawLines.slice(region.start, region.end).join('\n');
+        return { turn: '', skipPatterns };
+    return { turn: rawLines.slice(region.start, region.end).join('\n'), skipPatterns };
 }
 /**
  * Check if OpenCode has completed its response.
@@ -119,8 +144,13 @@ function isOpenCodeComplete(output) {
     // processing, and must NOT be blocked on a permission dialog. The last two are
     // read from the WHOLE frame: both live in the chrome the region excludes.
     // The "esc interrupt" indicator appears in the TUI footer during model processing.
+    //
+    // Issue #4188: the hint by position — under the composer's bottom border, where
+    // every measured running frame draws it — as the status reader has read it since
+    // #4175. A reply quoting the hint row whole sits above the border, and kept its
+    // turn from ever completing.
     return (cli_patterns_1.OPENCODE_TURN_COMPLETE_PATTERN.test(turnRegion) &&
-        !cli_patterns_1.OPENCODE_PROCESSING_INDICATOR.test(output) &&
+        !(0, cli_patterns_1.isOpencodeProcessingFooter)(output) &&
         !cli_patterns_1.OPENCODE_PERMISSION_PATTERN.test(output));
 }
 /**
@@ -173,6 +203,11 @@ function resolveExtractionStartIndex(lastCapturedLine, totalLines, bufferReset,
     // doesn't grow -- it's always ~PANE_HEIGHT lines. bufferWasReset is often true because
     // lastCapturedLine = totalLines. Must execute BEFORE Branch 1 to avoid Branch 1's small
     // window (40 lines) which fails to find the second-to-last Build marker in a 200-line pane.
+    // Issue #4187: opencode-v2 is an alternate-screen TUI too, but it is not added here
+    // on purpose. The screen reading never saves a V2 reply (V2 has no rule in
+    // `isTurnComplete`; its replies are written from its own server's document,
+    // `lib/hooks/sources/opencode-v2/history`), so it never reaches a completed
+    // extraction that would read this start.
     if (cliToolId === 'opencode' || cliToolId === 'copilot') {
         const foundUserPrompt = findRecentUserPromptIndex(totalLines);
         return foundUserPrompt >= 0 ? foundUserPrompt + 1 : 0;

package/dist/server/src/lib/session/agent-session-lifecycle.js

@@ -47,6 +47,7 @@ const session_starting_state_1 = require("../../lib/session/session-starting-sta
 const auto_yes_enter_fallback_state_1 = require("../../lib/polling/auto-yes-enter-fallback-state");
 const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const prompt_submit_receipt_1 = require("../../lib/session/prompt-submit-receipt");
+const role_launch_1 = require("../../lib/session/role-launch");
 const session_name_1 = require("../../lib/cli-tools/session-name");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('lib/session/agent-session-lifecycle');
@@ -81,6 +82,9 @@ function beginAgentSession(target, at = Date.now()) {
     // its own. A second call from the same launch (codex's
     // `relaunchIntoSamePane`) rewrites the same launch's record.
     (0, session_starting_state_1.markSessionStarting)(target.worktreeId, target.cliToolId, target.instanceId, at);
+    // Issue #4115: a second call from one launch means its process was replaced,
+    // so the role's generation moves on with it. The role itself does not change.
+    (0, role_launch_1.noteLaunchProcessReplaced)(target);
     const before = (0, agent_event_state_1.getAgentEventDropCounts)(target.worktreeId, target.cliToolId, target.instanceId).decisionEvicted;
     (0, agent_event_state_1.beginAgentEventGeneration)(target.worktreeId, target.cliToolId, target.instanceId, at);
     // Issue #3397: Auto-Yes's Enter belongs to the process whose screen it went
@@ -178,7 +182,11 @@ function prepareAgentLaunch(context) {
  *
  * @param context - The instance, its executable, and the worktree it runs in
  * @returns `NAME='value' … command`, ready for `sendKeys`
+ * @throws {RoleLaunchRefusedError} This launch's role cannot be applied (Issue #4115)
  */
 function buildAgentLaunchCommandLine(context) {
-    return (0, sources_1.renderAgentLaunchCommand)(prepareAgentLaunch(context));
+    // Issue #4115: the role, when this runs inside a launch that has one. Applied
+    // here because every driver gets its line here, and outside `prepareLaunch`
+    // because that one fails open, and a role must not.
+    return (0, role_launch_1.renderLaunchCommandWithRole)(context, prepareAgentLaunch(context));
 }

package/dist/server/src/lib/session/claude-executor.js

@@ -133,6 +133,16 @@ function truncateOutput(output) {
  * @returns Array of CLI arguments
  */
 function buildCliArgs(message, cliToolId, permission, options) {
+    const args = buildCliArgsWithoutRole(message, cliToolId, permission, options);
+    const role = options?.role;
+    if (!role || role.args.length === 0)
+        return args;
+    if (role.headlessPosition === 'trailing')
+        return [...args, ...role.args];
+    // `gh copilot` is the executable's first word, so the role goes after it.
+    return cliToolId === 'copilot' ? [args[0], ...role.args, ...args.slice(1)] : [...role.args, ...args];
+}
+function buildCliArgsWithoutRole(message, cliToolId, permission, options) {
     switch (cliToolId) {
         case 'codex':
             return ['exec', message, '--sandbox', permission ?? 'workspace-write'];
@@ -872,9 +882,11 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
     // `opencode.json` read was the one under `PWD`. `opencode2 run` has no `--dir`
     // (v1 has), so the child's `PWD` is set to `cwd`. Other tools keep the
     // environment they had.
-    const env = cliToolId === 'opencode-v2'
+    const baseEnv = cliToolId === 'opencode-v2'
         ? { ...(0, env_sanitizer_1.sanitizeEnvForChildProcess)(), PWD: cwd }
         : (0, env_sanitizer_1.sanitizeEnvForChildProcess)();
+    // Issue #4115: composed by the caller from this same sanitized environment.
+    const env = options?.role ? { ...baseEnv, ...options.role.env } : baseEnv;
     return new Promise((resolve) => {
         const child = (0, child_process_1.execFile)(command, args, {
             cwd,