commandmate 0.29.1 → 0.29.2

package/dist/server/src/lib/db/worktree-db.js

@@ -18,6 +18,8 @@ exports.updateFavorite = updateFavorite;
 exports.updateStatus = updateStatus;
 exports.updateCliToolId = updateCliToolId;
 exports.updateSelectedAgents = updateSelectedAgents;
+exports.findUnchangedAgentWorktrees = findUnchangedAgentWorktrees;
+exports.applySelectedAgentsToUnchanged = applySelectedAgentsToUnchanged;
 exports.updateVibeLocalModel = updateVibeLocalModel;
 exports.updateVibeLocalContextWindow = updateVibeLocalContextWindow;
 exports.saveInitialBranch = saveInitialBranch;
@@ -29,6 +31,8 @@ exports.getWorktreesByRepository = getWorktreesByRepository;
 exports.deleteRepositoryWorktrees = deleteRepositoryWorktrees;
 exports.deleteWorktreesByIds = deleteWorktreesByIds;
 const selected_agents_validator_1 = require("../../lib/selected-agents-validator");
+const agents_config_1 = require("../../lib/repo-config/agents-config");
+const app_settings_db_1 = require("./app-settings-db");
 const chat_db_1 = require("./chat-db");
 const worktree_id_rename_1 = require("./migrations/worktree-id-rename");
 /**
@@ -82,6 +86,38 @@ function getLastMessagesByCliBatch(db, worktreeIds) {
     }
     return result;
 }
+/** Shared empty set, so the common "no repository declares anything" path allocates nothing. */
+const EMPTY_ID_SET = new Set();
+/**
+ * IDs of every worktree that already owns an `agent_instances` roster.
+ *
+ * One query for the whole list rather than one per row (Issue #2066): the
+ * sidebar poll must not grow N point queries. `agent_instances` holds a handful
+ * of rows per registered worktree, and only the distinct worktree ids are read.
+ */
+function worktreeIdsWithAgentInstances(db) {
+    const rows = db
+        .prepare('SELECT DISTINCT worktree_id FROM agent_instances')
+        .all();
+    return new Set(rows.map((row) => row.worktree_id));
+}
+/** Whether one worktree already owns an `agent_instances` roster (Issue #2066). */
+function hasAgentInstances(db, worktreeId) {
+    return (db.prepare('SELECT 1 FROM agent_instances WHERE worktree_id = ? LIMIT 1').get(worktreeId) !==
+        undefined);
+}
+/**
+ * The repository layer for ONE worktree, withheld when that worktree already
+ * owns a roster (Issue #2066). The single-row twin of the batch logic in
+ * `getWorktrees()`; see the long comment there for why the withholding exists
+ * and why it is narrowed to this layer.
+ */
+function repoDefaultWithheldFromRoster(db, worktreeId, repositoryPath) {
+    const declared = (0, agents_config_1.getRepoDefaultSelectedAgents)(repositoryPath);
+    if (declared === null)
+        return null;
+    return hasAgentInstances(db, worktreeId) ? null : declared;
+}
 /**
  * Get all worktrees sorted by updated_at (desc)
  * Optionally filter by repository path
@@ -111,6 +147,52 @@ function getWorktrees(db, repositoryPath) {
     // Batch fetch last messages for all worktrees (N+1 optimization)
     const worktreeIds = rows.map(row => row.id);
     const lastMessagesByCliMap = getLastMessagesByCliBatch(db, worktreeIds);
+    // Issue #2065: read the server-wide default ONCE. `upsertWorktree` never
+    // writes `selected_agents`, so on a scan/sync-populated install every row
+    // below takes the fallback path — resolving it per row would turn one point
+    // query into one per worktree on the sidebar's poll.
+    const appSettingsDefault = (0, app_settings_db_1.getDefaultSelectedAgents)(db);
+    // Issue #2066: the repository layer, resolved ONCE per distinct
+    // `repository_path` rather than per row. `getRepoDefaultSelectedAgents()` is
+    // itself served from a process-wide cache filled at sync — see its module
+    // header for why the read does not belong on this (polled) path.
+    const repoDefaults = new Map();
+    for (const repositoryPath of new Set(rows.map((row) => row.repository_path))) {
+        if (!repositoryPath)
+            continue;
+        repoDefaults.set(repositoryPath, (0, agents_config_1.getRepoDefaultSelectedAgents)(repositoryPath));
+    }
+    // Issue #2066: a worktree that ALREADY has an `agent_instances` roster is not
+    // offered the repository declaration.
+    //
+    // `resolveAgentInstances()` protects the roster itself with an early return,
+    // but `selectedAgents` is a SECOND channel: `/sessions` and the Review tab
+    // render `wt.selectedAgents ?? clientDefault` and never look at
+    // `agentInstances`. Without this, committing an `agents.yaml` would repaint
+    // the chips of a branch whose tabs it cannot and must not change — and the
+    // running agent would drop out of "active agents" because it is not in the
+    // declared list. `PATCH /api/worktrees/[id]` writes `agentInstances` and
+    // `selectedAgents` from independent branches, so "has a roster, column still
+    // NULL" is a state the product produces routinely, not an edge case.
+    //
+    // Deliberately narrowed to the repository layer. The `app_settings` layer has
+    // the same shape (#2065) and the same gap, but changing it is a change to
+    // #2065's behaviour; what #2066 has to answer for is that it widened the gap
+    // from "an admin who can reach server settings" to "anyone who can commit to
+    // the repository". See docs/design/repo-agents-config.md §2.
+    //
+    // The roster query runs only when some repository actually declares
+    // something, so an install with no `agents.yaml` anywhere issues exactly the
+    // queries it issued before this Issue.
+    const anyRepoDeclares = [...repoDefaults.values()].some((value) => value !== null);
+    const withRoster = anyRepoDeclares ? worktreeIdsWithAgentInstances(db) : EMPTY_ID_SET;
+    const repoDefaultFor = (row) => {
+        if (!row.repository_path)
+            return null;
+        if (withRoster.has(row.id))
+            return null;
+        return repoDefaults.get(row.repository_path) ?? null;
+    };
     return rows.map((row) => {
         const lastMessagesByCli = lastMessagesByCliMap.get(row.id) || {};
         return {
@@ -133,7 +215,7 @@ function getWorktrees(db, repositoryPath) {
             status: row.status || null,
             link: row.link || undefined,
             cliToolId: row.cli_tool_id ?? 'claude',
-            selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents),
+            selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents, appSettingsDefault, repoDefaultFor(row)),
             vibeLocalModel: row.vibe_local_model ?? null,
             vibeLocalContextWindow: row.vibe_local_context_window ?? null,
         };
@@ -216,7 +298,10 @@ function getWorktreeById(db, id) {
         status: row.status || null,
         link: row.link || undefined,
         cliToolId: row.cli_tool_id ?? 'claude',
-        selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents),
+        // Issue #2066: same layers, and the same withholding, as getWorktrees().
+        // The roster probe runs only when this repository actually declares
+        // something, so a tree with no `agents.yaml` issues no extra query.
+        selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents, (0, app_settings_db_1.getDefaultSelectedAgents)(db), repoDefaultWithheldFromRoster(db, row.id, row.repository_path)),
         vibeLocalModel: row.vibe_local_model ?? null,
         vibeLocalContextWindow: row.vibe_local_context_window ?? null,
     };
@@ -359,7 +444,7 @@ function updateCliToolId(db, id, cliToolId) {
  *
  * @param db - Database instance
  * @param id - Worktree ID
- * @param selectedAgents - Array of 2-4 CLIToolType values
+ * @param selectedAgents - Array of 2-6 CLIToolType values (MIN/MAX_SELECTED_AGENTS)
  */
 function updateSelectedAgents(db, id, selectedAgents) {
     const stmt = db.prepare(`
@@ -369,6 +454,96 @@ function updateSelectedAgents(db, id, selectedAgents) {
   `);
     stmt.run(JSON.stringify(selectedAgents), id);
 }
+/**
+ * The worktrees of ONE repository whose agent list is still UNCHANGED by its
+ * user (Issue #2067).
+ *
+ * ## The repository argument is not optional, and that is the point
+ *
+ * The action this serves lives in the agent pane of ONE worktree, so its blast
+ * radius has to be the repository that worktree belongs to. An earlier revision
+ * of this function took no repository and scanned `worktrees` whole: pressing
+ * "apply to unchanged branches" from a worktree of repository B rewrote the
+ * unchanged worktrees of repository A as well. Requiring the argument is what
+ * makes that impossible to reintroduce by omission.
+ *
+ * ## "Unchanged"
+ *
+ * `selected_agents IS NULL` **and** no `agent_instances` row — deliberately the
+ * same two facts #2066 checks before it lets a repository declaration reach a
+ * worktree, checked with the same helper (`worktreeIdsWithAgentInstances`)
+ * rather than a second query that says the same thing. The two channels are
+ * independent: `PATCH /api/worktrees/[id]` writes `agentInstances` and
+ * `selectedAgents` from separate branches, so "has a roster, column still NULL"
+ * and "column set, no roster" are both states the product produces routinely,
+ * and a worktree in EITHER of them has been touched by a human.
+ *
+ * ## Why a declaring repository yields nothing
+ *
+ * `SELECTED_AGENTS_LAYERS` puts the `worktree` column ABOVE the repository file,
+ * so writing `selected_agents` onto a worktree of a repository that ships
+ * `.commandmate/agents.yaml` does not merely win once — it retires the
+ * declaration for that branch permanently, and editing the file afterwards has
+ * no effect and no explanation. A committed declaration is a more deliberate
+ * answer to "which agents does this branch open with" than a button press in one
+ * branch's settings pane, so the declaration wins and the caller is told why
+ * (`repoDeclares`) instead of being handed a count of zero it cannot explain.
+ *
+ * @param db - Database instance
+ * @param repositoryPath - The repository to scope to (`worktrees.repository_path`)
+ * @returns The scope, whether the repository declares, and the eligible IDs
+ */
+function findUnchangedAgentWorktrees(db, repositoryPath) {
+    // Served from #2066's process-wide cache; see `agents-config.ts` for why this
+    // is not a filesystem probe on a hot path.
+    const repoDeclares = (0, agents_config_1.getRepoDefaultSelectedAgents)(repositoryPath) !== null;
+    if (repoDeclares) {
+        return { repositoryPath, repoDeclares, ids: [] };
+    }
+    const withRoster = worktreeIdsWithAgentInstances(db);
+    const rows = db
+        .prepare('SELECT id FROM worktrees WHERE repository_path = ? AND selected_agents IS NULL ORDER BY id ASC')
+        .all(repositoryPath);
+    return {
+        repositoryPath,
+        repoDeclares,
+        ids: rows.map((row) => row.id).filter((id) => !withRoster.has(id)),
+    };
+}
+/**
+ * Write `selectedAgents` onto every worktree {@link findUnchangedAgentWorktrees}
+ * reports for `repositoryPath`, in ONE transaction (Issue #2067).
+ *
+ * The eligible set is recomputed INSIDE the transaction rather than taken as an
+ * argument: the UI shows a count before it asks for confirmation, and the number
+ * it shows has to be the number of rows this actually writes. Passing the ids in
+ * would make the caller's snapshot authoritative and turn a worktree created
+ * between the count and the confirmation into a silent miss.
+ *
+ * The transaction is not decoration. Without it, a write that fails partway —
+ * a locked database, a constraint, a trigger — leaves a repository split between
+ * branches that took the new order and branches that did not, with nothing on
+ * screen saying which. `tests/unit/db/apply-default-agents-2067.test.ts` pins
+ * this by aborting a middle row and asserting the earlier ones rolled back.
+ *
+ * Rows are written through `updateSelectedAgents()` so the column's one writer
+ * stays its one writer.
+ *
+ * @param db - Database instance
+ * @param repositoryPath - The repository to scope to; never server-wide
+ * @param selectedAgents - Ordered, already-validated agents; `[0]` is the primary
+ * @returns The IDs that were written, in the order they were written
+ */
+function applySelectedAgentsToUnchanged(db, repositoryPath, selectedAgents) {
+    const apply = db.transaction(() => {
+        const { ids } = findUnchangedAgentWorktrees(db, repositoryPath);
+        for (const id of ids) {
+            updateSelectedAgents(db, id, selectedAgents);
+        }
+        return ids;
+    });
+    return apply();
+}
 /**
  * Update vibe_local_model for a worktree
  * Issue #368: Persists the user's Ollama model selection for vibe-local

package/dist/server/src/lib/detection/status-reason.js

@@ -56,6 +56,23 @@ exports.STATUS_REASON = {
     OPENCODE_RESPONSE_COMPLETE: 'opencode_response_complete',
     INPUT_PROMPT: 'input_prompt',
     NO_RECENT_OUTPUT: 'no_recent_output',
+    /**
+     * Issue #2070: the tmux session is there, and the TOOL is not.
+     *
+     * Published by `worktree-status-helper` when the liveness probe reads a bare
+     * shell prompt at the bottom of a pane whose agent quit, updated itself or
+     * crashed (`judgeToolLiveness`). It is the ONE reason on this list that
+     * accompanies `isRunning: false` — every other one describes a frame a live
+     * agent drew — which is exactly why it is worth a token of its own: without
+     * it the sidebar and `commandmate ls` render such a session as plain `idle`,
+     * indistinguishable from one that was never started, and the operator has no
+     * way to tell "start it" from "it died under you".
+     *
+     * ADDITIVE, in the strict sense: no existing reason's value or meaning
+     * changes, and no surface that does not know the token behaves differently —
+     * a reader that does not recognise it sees the same `idle` it saw before.
+     */
+    EXITED: 'exited',
     /**
      * A tool's own detector looked at this frame and recognised nothing
      * (Issue #1927, §6.1).

package/dist/server/src/lib/detection/tool-liveness.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * "Did the TOOL exit and leave a bare shell behind?" — the shared rule
+ * (Issue #2070).
+ *
+ * A tmux session outlives the process it was created for more often than the
+ * code used to admit. codex's own update dialog replaces codex with `npm
+ * install` and exits; `Ctrl+C` twice quits it; a crash does the same thing
+ * without asking. In each case `has-session` keeps answering yes, so `isRunning`
+ * stayed true, the sidebar kept its dot, and the next `send` sat in
+ * `waitForPrompt` until it timed out — recoverable only by killing the session
+ * by hand.
+ *
+ * CommandMate already had the answer to this, written for claude and reachable
+ * from exactly one `cliToolId === 'claude'` branch (`isSessionHealthy`). What
+ * was claude-specific about it was not the rule but the two patterns it was
+ * spelled in terms of. This module is that rule with the patterns lifted out
+ * into {@link ToolLivenessSpec}; `lib/cli-tools/liveness-spec` is where each
+ * tool fills them in.
+ *
+ * Pure and synchronous on purpose: no tmux, no capture, nothing to mock. The
+ * probe that feeds it a frame is `probeSessionLiveness` in
+ * `lib/cli-tools/session-liveness`, which is where the tmux round trip belongs
+ * (§4 D4 keeps `src/lib/detection/**` off the transport).
+ *
+ * @module lib/detection/tool-liveness
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FATAL_PATTERN_TAIL_LINES = exports.SHELL_PROMPT_LINE_PATTERNS = exports.MAX_SHELL_PROMPT_LENGTH = exports.SHELL_PROMPT_ENDINGS = void 0;
+exports.findFatalPattern = findFatalPattern;
+exports.findShellPromptTail = findShellPromptTail;
+exports.judgeToolLiveness = judgeToolLiveness;
+const ansi_1 = require("./ansi");
+/**
+ * Trailing characters that make a short last row a shell prompt.
+ *
+ * `$` bash/sh, `%` zsh, `#` root. Verbatim the list `claude-session.ts` has
+ * carried as its private `SHELL_PROMPT_ENDINGS` since the health check was
+ * written — moved, not redesigned.
+ */
+exports.SHELL_PROMPT_ENDINGS = ['$', '%', '#'];
+/**
+ * Longest a last row may be and still be read as a shell prompt by the endings
+ * rule alone.
+ *
+ * claude's number, kept as claude's default (`MAX_SHELL_PROMPT_LENGTH`, "40 is
+ * an empirical threshold with safety margin"). Issue #2070 measured why it
+ * cannot be the whole rule: the zsh default prompt of the machine the Issue was
+ * reproduced on renders as `maenokota@MAENOnoMac-Studio work-codex %` — forty
+ * characters exactly, i.e. one past this gate — so a codex session that had
+ * genuinely fallen back to the shell read as alive. See
+ * {@link SHELL_PROMPT_LINE_PATTERNS}.
+ */
+exports.MAX_SHELL_PROMPT_LENGTH = 40;
+/**
+ * Whole-line forms that positively identify a shell prompt, independent of
+ * length (Issue #2070).
+ *
+ * Checked BEFORE the length gate, so a long-but-real prompt is still a prompt.
+ * Both are anchored at both ends and require a `user@host` head, which is what
+ * keeps them off TUI content: an agent's transcript row that happens to end in
+ * `$` does not begin with `name@host`.
+ *
+ * Deliberately NOT extended to the bare `❯` / `>` prompts starship, pure and
+ * agnoster draw. Those glyphs are the composer of claude, copilot and gemini —
+ * `COPILOT_PROMPT_PATTERN` matching a starship prompt is a measured hazard
+ * (#1907) — so a rule that read them as "shell" would relaunch a tool into its
+ * own live pane. The cost is a false NEGATIVE on those prompts (the exit is not
+ * noticed), which is the direction this rule is allowed to be wrong in.
+ */
+exports.SHELL_PROMPT_LINE_PATTERNS = [
+    // zsh / bash defaults: `user@host dir %`, `user@host:~/dir$`
+    /^[\w.-]+@[\w.-]+[\s:].*[$%#]$/,
+    // RHEL-style bash: `[user@host dir]$`
+    /^\[[\w.-]+@[\w.-]+[^\]]*\][$#]$/,
+];
+/**
+ * How many content rows from the bottom a fatal-pattern search may read.
+ *
+ * claude's `HEALTH_CHECK_ERROR_TAIL_LINES`, unchanged: an error that has already
+ * scrolled up describes a session that recovered, and must not condemn it.
+ */
+exports.FATAL_PATTERN_TAIL_LINES = 10;
+/** `cleanOutput` split into rows, blank ones dropped. */
+function contentRows(cleanTrimmedOutput) {
+    return cleanTrimmedOutput.split('\n').filter((line) => line.trim() !== '');
+}
+/**
+ * The fatal pattern visible in the tail of `cleanOutput`, or null.
+ *
+ * Only the last {@link FATAL_PATTERN_TAIL_LINES} content rows are searched.
+ * Exported because claude's launch loop applies the same judgement while it is
+ * still waiting for the prompt (Issue #1637) — a session already showing
+ * "Claude Code cannot be launched inside another Claude Code session" must not
+ * burn the whole 60 s budget before saying so.
+ *
+ * @param cleanOutput - ANSI-stripped pane output
+ * @param spec - The tool's liveness declaration
+ * @returns The matched pattern (or regex source) for the log, or null
+ */
+function findFatalPattern(cleanOutput, spec) {
+    const tailText = contentRows(cleanOutput.trim())
+        .slice(-exports.FATAL_PATTERN_TAIL_LINES)
+        .join('\n');
+    for (const pattern of spec.fatalPatterns) {
+        if (tailText.includes(pattern))
+            return pattern;
+    }
+    for (const regex of spec.fatalRegexPatterns) {
+        if (regex.test(tailText))
+            return regex.source;
+    }
+    return null;
+}
+/**
+ * Whether `line` ends in one of `endings`, applying claude's own exclusion.
+ *
+ * `Context left until auto-compact: 7%` ends in `%` and is not a prompt; the
+ * `\d+%$` carve-out is the one claude has always had, and it is kept here
+ * character for character because claude's verdicts must not move (Issue #2070
+ * 受入条件).
+ */
+function endsWithShellPromptChar(line, endings) {
+    return endings.some((ending) => {
+        if (!line.endsWith(ending))
+            return false;
+        if (ending === '%' && /\d+%$/.test(line))
+            return false;
+        return true;
+    });
+}
+/**
+ * The bottom row of `cleanOutput`, when it reads as a shell prompt.
+ *
+ * Steps 4-6 of {@link judgeToolLiveness}, lifted out verbatim so there is one
+ * definition of "this pane is a bare shell" rather than two. Note what is NOT
+ * here: the alive-pattern window of step 2. That is the difference between the
+ * two questions, and it is why this is exported (Issue #2068).
+ *
+ * `judgeToolLiveness` asks **"is the tool gone?"** and answers conservatively —
+ * any alive pattern anywhere in the bottom window vetoes the exit, because a
+ * relaunch hangs off its verdict. That veto is right for the general case and
+ * wrong for exactly one measured frame: the pane codex leaves behind after its
+ * own `1. Update now`. codex-cli 0.149.1 exits into `npm install -g
+ * @openai/codex`, which prints three rows and returns to the shell — so the
+ * dead `› 1. Update now` option row is still SEVEN content rows above the live
+ * shell prompt, inside `LIVENESS_ALIVE_TAIL_LINES`, and `CODEX_PROMPT_PATTERN`
+ * reads it as codex still drawing the pane (measured 2026-08-31, private tmux
+ * socket, 200x1000, isolated `CODEX_HOME`).
+ *
+ * `CodexTool.waitForReady` therefore asks this narrower question instead, and
+ * only about a pane it has just watched answer the update dialog — where the
+ * scrollback above the prompt is known to be spent and position is the whole
+ * story, exactly as it is for every other codex classifier since Issue #892.
+ * Widening `judgeToolLiveness` itself to agree would be a change to the shared
+ * rule every tool is judged by, and it is not made here.
+ *
+ * @param cleanOutput - ANSI-stripped pane output
+ * @param spec - The tool's liveness declaration
+ * @returns The prompt row and how it was recognised, or null
+ */
+function findShellPromptTail(cleanOutput, spec) {
+    const rows = contentRows(cleanOutput.trim());
+    const lastLine = rows[rows.length - 1]?.trim() ?? '';
+    if (!/\d+%$/.test(lastLine) && spec.shellPromptPatterns.some((p) => p.test(lastLine))) {
+        return { line: lastLine, via: 'pattern' };
+    }
+    // The length gate is a NEGATIVE result, not a fall-through: a row this long is
+    // not a prompt, and the endings rule below must not get to claim it.
+    if (lastLine.length >= spec.maxShellPromptLength) {
+        return null;
+    }
+    if (endsWithShellPromptChar(lastLine, spec.shellPromptEndings)) {
+        return { line: lastLine, via: 'ending' };
+    }
+    return null;
+}
+/**
+ * Decide whether the tool this spec describes is still drawing the pane.
+ *
+ * The rule, in the order the branches run — which is claude's order, because
+ * claude's spec must produce claude's historical answers:
+ *
+ *  1. **nothing on the pane** → exited only if the spec says an unreadable
+ *     frame counts (claude alone; see {@link ToolLivenessSpec.unreadableIsExited});
+ *  2. **an alive pattern matches the bottom window** → alive. This is the
+ *     tool's prompt-ready rule and its busy/dialog chrome, and it is checked
+ *     against a WINDOW rather than the frame for every tool but claude: a tool's
+ *     chrome does not vanish when it quits, it scrolls up;
+ *  3. **a fatal pattern in the tail** → exited;
+ *  4. **the last row positively reads as a shell prompt** → exited;
+ *  5. **the last row is too long to be a prompt** → alive;
+ *  6. **the last row ends in `$` / `%` / `#`** → exited;
+ *  7. otherwise **alive** — the honest answer when nothing said either way.
+ *
+ * Steps 4-6 are the positive half of the verdict and they are not optional.
+ * A frame that merely fails step 2 (a tool mid-launch, a screen nobody has
+ * measured) must come out ALIVE, because Issue #2070 puts a relaunch behind
+ * this answer and a relaunch into a live pane types the launch command into the
+ * agent's composer.
+ *
+ * @param rawOutput - Pane capture, ANSI intact (stripped here)
+ * @param spec - The tool's liveness declaration
+ * @returns Whether the tool is there, and — when it is not — why not
+ */
+function judgeToolLiveness(rawOutput, spec) {
+    const trimmed = (0, ansi_1.stripAnsi)(rawOutput).trim();
+    if (trimmed === '') {
+        return spec.unreadableIsExited
+            ? { alive: false, reason: 'empty output' }
+            : { alive: true };
+    }
+    const rows = contentRows(trimmed);
+    const aliveWindow = spec.aliveTailLines === null ? trimmed : rows.slice(-spec.aliveTailLines).join('\n');
+    if (spec.alivePatterns.some((pattern) => pattern.test(aliveWindow))) {
+        return { alive: true };
+    }
+    const fatal = findFatalPattern(trimmed, spec);
+    if (fatal !== null) {
+        return { alive: false, reason: `error pattern: ${fatal}` };
+    }
+    // Steps 4-6, via the predicate they were lifted into (Issue #2068). The two
+    // reason strings are unchanged, and so is the verdict for every frame: a
+    // `null` here is the old "too long" and "nothing matched" branches, which both
+    // came out alive.
+    const shellTail = findShellPromptTail(trimmed, spec);
+    if (shellTail !== null) {
+        return shellTail.via === 'pattern'
+            ? { alive: false, reason: `shell prompt detected: ${shellTail.line}` }
+            : { alive: false, reason: `shell prompt ending detected: ${shellTail.line}` };
+    }
+    return { alive: true };
+}