commandmate 0.29.2 → 0.30.1

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

@@ -6,13 +6,15 @@
  * Issue #479: Extracted from db.ts for single-responsibility separation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACTIVE_FILTER = void 0;
+exports.UNKEYED_USER_MESSAGE_LIMIT = exports.ACTIVE_FILTER = void 0;
 exports.getLastAssistantMessageAt = getLastAssistantMessageAt;
 exports.createMessage = createMessage;
 exports.updateMessageContent = updateMessageContent;
 exports.getMessages = getMessages;
 exports.getLastUserMessage = getLastUserMessage;
 exports.findMessageByRequestId = findMessageByRequestId;
+exports.findUnkeyedUserMessages = findUnkeyedUserMessages;
+exports.setMessageRequestId = setMessageRequestId;
 exports.getLastMessage = getLastMessage;
 exports.deleteAllMessages = deleteAllMessages;
 exports.deleteMessageById = deleteMessageById;
@@ -125,7 +127,7 @@ function updateMessageContent(db, messageId, content, options) {
  * Get messages for a worktree, optionally filtered by CLI tool
  */
 function getMessages(db, worktreeId, options = {}) {
-    const { before, limit = 50, cliToolId, instanceId, includeArchived = false, messageType, limitUnit = 'messages' } = options;
+    const { before, limit = 50, cliToolId, instanceId, includeArchived = false, messageType, limitUnit = 'messages', matchResolvedInstance = false } = options;
     // Build the shared scope clause (worktree + before cursor + archived + instance/cli
     // filter) and its bound params. Used for both the message-unit and pair-unit paths
     // so their filtering stays identical.
@@ -138,7 +140,19 @@ function getMessages(db, worktreeId, options = {}) {
             clause += ` ${exports.ACTIVE_FILTER}`;
         }
         // Issue #868: instance filter takes precedence; otherwise fall back to CLI tool filter.
-        if (instanceId) {
+        // Issue #2219: `matchResolvedInstance` reads both columns through the same
+        // COALESCE defaults `mapChatMessage` applies, so pre-#868 rows
+        // (`instance_id IS NULL`) count as the primary instance instead of
+        // vanishing. See the option's doc comment for why the tool filter joins in.
+        if (instanceId && matchResolvedInstance) {
+            if (cliToolId) {
+                clause += ` AND COALESCE(cli_tool_id, 'claude') = ?`;
+                params.push(cliToolId);
+            }
+            clause += ` AND COALESCE(instance_id, cli_tool_id, 'claude') = ?`;
+            params.push(instanceId);
+        }
+        else if (instanceId) {
             clause += ` AND instance_id = ?`;
             params.push(instanceId);
         }
@@ -229,6 +243,80 @@ function findMessageByRequestId(db, worktreeId, requestId) {
     const row = stmt.get(worktreeId, requestId);
     return row ? mapChatMessage(row) : null;
 }
+/**
+ * How many candidate rows {@link findUnkeyedUserMessages} returns.
+ *
+ * The caller compares content in JavaScript, so this bounds the work rather than
+ * the correctness. Twenty is far above the number of user rows one instance can
+ * accumulate inside the caller's few-minute window and still small enough that
+ * the query is never the expensive part of a poll.
+ */
+exports.UNKEYED_USER_MESSAGE_LIMIT = 20;
+/**
+ * User rows for one instance that no producer has claimed yet (Issue #2196).
+ *
+ * The lookup behind "the operator's input is already in History — `/send` put it
+ * there". A row qualifies when it is this instance's, is a `user` row, sits in
+ * the caller's time window, and has **no `request_id`**: that last condition is
+ * what makes the query safe to answer a *claim* with, because a row that already
+ * carries a key belongs to whoever wrote it and must not be re-pointed at
+ * another turn.
+ *
+ * Content is deliberately not compared here. "The same text" is a normalisation
+ * question (trailing whitespace, `\r\n`, a composer that reflowed the body), and
+ * SQL is the wrong place to decide it — see `normalizeUserTurnContent` in
+ * `lib/history/user-turn-recorder`, which owns that rule and is the only thing
+ * that has to change when the rule does.
+ *
+ * `COALESCE` on both tool columns is not defensive noise: rows written before
+ * Issue #868 carry `instance_id IS NULL`, and `mapChatMessage` reads those as
+ * the primary instance. A bare `instance_id = ?` would make those rows
+ * invisible here while the UI still shows them, so the operator would see their
+ * `/send` row *and* a second row this Issue inserted.
+ *
+ * `ACTIVE_FILTER` applies: an archived row has been cleared out of History, and
+ * adopting one would key a turn to a row nobody can see.
+ *
+ * @returns Candidate rows, newest first
+ */
+function findUnkeyedUserMessages(db, query) {
+    const stmt = db.prepare(`
+    SELECT id, worktree_id, role, content, summary, timestamp, log_file_name, request_id, message_type, prompt_data, cli_tool_id, instance_id, archived
+    FROM chat_messages
+    WHERE worktree_id = ?
+      AND role = 'user'
+      AND request_id IS NULL
+      AND COALESCE(cli_tool_id, 'claude') = ?
+      AND COALESCE(instance_id, cli_tool_id, 'claude') = ?
+      AND timestamp >= ? AND timestamp <= ?
+      ${exports.ACTIVE_FILTER}
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `);
+    const rows = stmt.all(query.worktreeId, query.cliToolId, query.instanceId, query.fromMs, query.toMs, query.limit ?? exports.UNKEYED_USER_MESSAGE_LIMIT);
+    return rows.map(mapChatMessage);
+}
+/**
+ * Claim an unkeyed row for a producer, without touching anything else on it
+ * (Issue #2196).
+ *
+ * A compare-and-set and not an `UPDATE … WHERE id = ?`: the `request_id IS NULL`
+ * in the predicate is what makes two pollers racing on the same row safe, since
+ * the loser changes nothing and is told so. {@link updateMessageContent} could
+ * set the column too, but it also rewrites `content`, and rewriting the
+ * operator's own words as a side effect of keying their row is exactly the
+ * failure this Issue is trying not to introduce.
+ *
+ * @returns Whether this call is the one that claimed the row
+ */
+function setMessageRequestId(db, messageId, requestId) {
+    const stmt = db.prepare(`
+    UPDATE chat_messages
+    SET request_id = ?
+    WHERE id = ? AND request_id IS NULL
+  `);
+    return stmt.run(requestId, messageId).changes > 0;
+}
 /**
  * Fetch the most recent message for a worktree (any role).
  * Used to determine if waiting for Claude's response.
@@ -431,14 +519,27 @@ function updatePromptData(db, messageId, promptData) {
  * Mark all pending prompts as answered for a worktree/CLI tool
  * This is called when we detect Claude has started processing (new response detected)
  * which means any pending prompts must have been answered via terminal
+ *
+ * @param onUpdated - Issue #2195. Invoked once per row that was actually
+ *   stamped, with the row as it now reads. This sweep is the one prompt-status
+ *   writer that produced no realtime frame, so a prompt card stayed "pending"
+ *   in every open pane until the next history poll — up to 15s once #2195
+ *   demoted that poll to a fallback. The caller supplies the broadcast rather
+ *   than this module reaching for `ws-server`: the DB layer has no business
+ *   importing the socket, and the two sweep callers that are *not* a poller
+ *   (the worktree list/detail routes) have no room to broadcast into anyway.
+ *   Throwing from the callback is the caller's problem; it is not caught here.
  */
-function markPendingPromptsAsAnswered(db, worktreeId, cliToolId, instanceId) {
+function markPendingPromptsAsAnswered(db, worktreeId, cliToolId, instanceId, onUpdated) {
     // Find all pending prompt messages for this worktree/CLI tool.
     // Issue #868: When instanceId is provided, scope to that instance only;
     // otherwise fall back to the legacy cli_tool_id scoping.
     const resolvedInstanceId = instanceId ?? cliToolId;
+    // Issue #2195: the full column set, not just (id, prompt_data) — `onUpdated`
+    // publishes a `ChatMessage`, and re-reading each row afterwards would be a
+    // second query per prompt for data this statement already has to visit.
     const selectStmt = db.prepare(`
-    SELECT id, prompt_data
+    SELECT id, worktree_id, role, content, summary, timestamp, log_file_name, request_id, message_type, prompt_data, cli_tool_id, instance_id, archived
     FROM chat_messages
     WHERE worktree_id = ?
       AND instance_id = ?
@@ -458,9 +559,12 @@ function markPendingPromptsAsAnswered(db, worktreeId, cliToolId, instanceId) {
     WHERE id = ?
   `);
     let updatedCount = 0;
+    const updated = [];
     for (const row of rows) {
         try {
-            const promptData = JSON.parse(row.prompt_data);
+            const promptData = JSON.parse(row.prompt_data ?? 'null');
+            if (!promptData || typeof promptData !== 'object')
+                continue;
             promptData.status = 'answered';
             promptData.answer = '(answered via terminal)';
             promptData.answeredAt = new Date().toISOString();
@@ -468,13 +572,22 @@ function markPendingPromptsAsAnswered(db, worktreeId, cliToolId, instanceId) {
             // prompts nothing else claimed, so all that is known is that the agent
             // moved on — i.e. someone acted in the terminal.
             promptData.answeredBy = 'terminal';
-            updateStmt.run(JSON.stringify(promptData), row.id);
+            const serialized = JSON.stringify(promptData);
+            updateStmt.run(serialized, row.id);
             updatedCount++;
+            if (onUpdated) {
+                updated.push(mapChatMessage({ ...row, prompt_data: serialized }));
+            }
         }
         catch {
             // Skip if prompt_data is invalid JSON
         }
     }
+    // Published after every write lands, so a listener that reacts by reading the
+    // table back cannot observe a half-swept instance.
+    for (const message of updated) {
+        onUpdated?.(message);
+    }
     return updatedCount;
 }
 /**

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

@@ -72,8 +72,9 @@ exports.SELECTION_LIST_REASONS = new Set([
  * one: branch A of the opencode block answers `opencode_processing_indicator`
  * for the footer that reads `esc interrupt`, which is opencode's ONLY signal
  * while it is between the submitted prompt and the first transcript row. A
- * scraper-only session (no hooks) therefore showed no thinking indicator in
- * `MessageList` for exactly the stretch where one is wanted.
+ * scraper-only session (no hooks) therefore showed no thinking indicator on the
+ * chat surface for exactly the stretch where one is wanted. The consumer is
+ * `ChatSurface`, which reads this through `current-output`'s `thinking` flag.
  *
  * `DEFAULT` is deliberately absent: it is the "output changed recently" fallback
  * and says nothing about the agent having announced itself, so promoting it

package/dist/server/src/lib/env.js

@@ -8,6 +8,9 @@
  *
  * Issue #135: DB path resolution fix
  * Uses getDefaultDbPath() from db-path-resolver.ts for consistent DB path handling
+ *
+ * Issue #2132: startup self-check for ".env exists but nothing was loaded"
+ * See {@link runDotenvSelfCheck}.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -17,12 +20,17 @@ exports.ENV_MAPPING = void 0;
 exports.resetWarnedKeys = resetWarnedKeys;
 exports.getEnvWithFallback = getEnvWithFallback;
 exports.getEnvByKey = getEnvByKey;
+exports.parseDotenvKeys = parseDotenvKeys;
+exports.inspectDotenvLoad = inspectDotenvLoad;
+exports.formatDotenvReportLines = formatDotenvReportLines;
+exports.runDotenvSelfCheck = runDotenvSelfCheck;
 exports.resetDatabasePathWarning = resetDatabasePathWarning;
 exports.getDatabasePathWithDeprecationWarning = getDatabasePathWithDeprecationWarning;
 exports.getLogConfig = getLogConfig;
 exports.getServerPort = getServerPort;
 exports.getEnv = getEnv;
 exports.validateEnv = validateEnv;
+const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const db_path_resolver_1 = require("./db/db-path-resolver");
 // ============================================================
@@ -84,6 +92,120 @@ function getEnvWithFallback(newKey, oldKey) {
 function getEnvByKey(key) {
     return getEnvWithFallback(key, exports.ENV_MAPPING[key]);
 }
+/** `KEY`, `export KEY`, ` KEY ` — the assignment forms a `.env` line can take. */
+const DOTENV_ASSIGNMENT = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
+/**
+ * The variable names a `.env` file declares, in file order, without duplicates.
+ *
+ * Values are never returned. `CM_VAPID_PRIVATE_KEY` lives in this file, and the
+ * only reason to parse it here is to count how many of its NAMES arrived.
+ */
+function parseDotenvKeys(contents) {
+    const keys = [];
+    const seen = new Set();
+    for (const line of contents.split(/\r?\n/)) {
+        const match = DOTENV_ASSIGNMENT.exec(line);
+        if (!match)
+            continue;
+        const key = match[1];
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        keys.push(key);
+    }
+    return keys;
+}
+/**
+ * Compare the `.env` on disk against the environment this process actually got.
+ *
+ * @returns `null` when there is nothing to compare — no `.env`, an unreadable
+ *   one, or one that declares no variables. None of those is a fault worth a
+ *   line of startup output.
+ */
+function inspectDotenvLoad(options = {}) {
+    const { cwd = process.cwd(), env = process.env } = options;
+    const envPath = path_1.default.join(cwd, '.env');
+    let contents;
+    try {
+        if (!fs_1.default.existsSync(envPath))
+            return null;
+        contents = fs_1.default.readFileSync(envPath, 'utf8');
+    }
+    catch {
+        // Unreadable is a permissions question, not a loading question.
+        return null;
+    }
+    const declaredKeys = parseDotenvKeys(contents);
+    if (declaredKeys.length === 0)
+        return null;
+    const presentKeys = declaredKeys.filter((key) => env[key] !== undefined);
+    return {
+        envPath,
+        declaredKeys,
+        presentKeys,
+        loadFailed: presentKeys.length === 0,
+    };
+}
+/** How many key names the report is willing to print before it says "and N more". */
+const DOTENV_REPORT_KEY_LIMIT = 8;
+/**
+ * The lines {@link runDotenvSelfCheck} prints — empty when the load worked.
+ *
+ * Exported so the wording is pinned by a test rather than by a screenshot.
+ */
+function formatDotenvReportLines(inspection) {
+    if (!inspection.loadFailed)
+        return [];
+    const shown = inspection.declaredKeys.slice(0, DOTENV_REPORT_KEY_LIMIT);
+    const omitted = inspection.declaredKeys.length - shown.length;
+    const names = omitted > 0 ? `${shown.join(', ')}, and ${omitted} more` : shown.join(', ');
+    return [
+        `[env] ${inspection.envPath} declares ${inspection.declaredKeys.length} variable(s) `
+            + 'and NOT ONE of them is set in this process: '
+            + `${names}.`,
+        '[env] The server is running on defaults. Web Push, the database path and the '
+            + 'worktree root are all configured through those variables, so this is very '
+            + 'unlikely to be what you wanted.',
+        '[env] Most likely cause (Issue #2132): the server was started by hand after '
+            + '`source scripts/load-env.sh` from a shell that is not bash. That script now '
+            + 'refuses instead of exporting nothing, so re-run it and read what it says.',
+        '[env] Supported restart, no rebuild: ./scripts/restart-nobuild.sh  '
+            + '(or ./scripts/start.sh --daemon)',
+    ];
+}
+/**
+ * Report, in one place at startup, that `.env` exists and none of it arrived.
+ *
+ * Same contract as `runVapidSelfCheck` in `lib/push/vapid.ts`, deliberately:
+ * fail-open, never throws, never blocks `listen`, and a healthy install prints
+ * NOTHING — which is what makes the presence of a line meaningful.
+ *
+ * It exists because the failure it names is invisible from inside the process.
+ * Every consumer of these variables has a defensible default, so a server that
+ * received none of them starts, listens, and answers requests; what it does not
+ * do is send a single push notification, and it may open a different database
+ * than the one the operator believes they are looking at. During the Epic #2002
+ * device UAT the only signal was the VAPID warning, and reading it as "push is
+ * broken" rather than "the environment is empty" cost two UAT rounds.
+ *
+ * @returns The inspection, or `null` when there was nothing to check.
+ */
+function runDotenvSelfCheck(options = {}) {
+    const { warn = (message) => console.warn(message) } = options;
+    try {
+        const inspection = inspectDotenvLoad(options);
+        if (!inspection)
+            return null;
+        for (const line of formatDotenvReportLines(inspection)) {
+            warn(line);
+        }
+        return inspection;
+    }
+    catch {
+        // A diagnostic must never be the reason a server fails to start.
+        return null;
+    }
+}
 // ============================================================
 // [Issue #135] DATABASE_PATH Deprecation Support
 // ============================================================

package/dist/server/src/lib/git/worktrees.js

@@ -16,6 +16,8 @@ exports.scanMultipleRepositories = scanMultipleRepositories;
 exports.deriveIdIgnoringOwnHistory = deriveIdIgnoringOwnHistory;
 exports.syncWorktreesToDB = syncWorktreesToDB;
 exports.repositoryExistsOnDisk = repositoryExistsOnDisk;
+exports.directoryIsConfirmedAbsent = directoryIsConfirmedAbsent;
+exports.reclaimGhostRepositories = reclaimGhostRepositories;
 exports.pruneStaleRepositoryWorktrees = pruneStaleRepositoryWorktrees;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
@@ -179,6 +181,27 @@ function getRepositoryPaths() {
  */
 async function scanWorktrees(rootDir) {
     const execAsync = (0, util_1.promisify)(child_process_1.exec);
+    // Issue #2165: a repository whose directory has been removed used to reach
+    // `execAsync` with a `cwd` that no longer exists, and Node reports that as
+    // `spawn /bin/sh ENOENT` — an error about the *shell*, not about the missing
+    // directory. It is neither `not a git repository` nor exit 128, so the catch
+    // below re-threw it and `scanMultipleRepositories` logged it at ERROR. Two
+    // costs: a wasted child process per repository per scan, and a permanent
+    // ERROR line whose text sends the reader after `/bin/sh` and `PATH` (that
+    // misdiagnosis actually happened — see the Issue).
+    //
+    // Deliberately {@link directoryIsConfirmedAbsent} rather than
+    // `fs.existsSync`: only a positively-confirmed absence is allowed to skip the
+    // scan. An unreadable or unreachable path (EACCES, EIO, a hung network mount)
+    // still goes to git, still fails, and is still reported at ERROR — that IS a
+    // real failure and must not be silently downgraded to "the directory is gone".
+    //
+    // A directory that exists but is no longer a git repository is untouched by
+    // this guard: it keeps taking the git exit-128 path below and returns [].
+    if (directoryIsConfirmedAbsent(rootDir)) {
+        logger.warn('repository:scan-skipped-missing-dir', { repoPath: rootDir });
+        return [];
+    }
     try {
         const { stdout } = await execAsync('git worktree list', {
             cwd: rootDir,
@@ -479,6 +502,137 @@ function repositoryExistsOnDisk(repoPath) {
         return true;
     }
 }
+/**
+ * Whether a path is **positively confirmed** not to exist.
+ *
+ * Issue #2165. `fs.existsSync()` cannot answer this: it collapses "the entry is
+ * not there" and "I could not find out" into the same `false`. It is
+ * `accessSync(F_OK)` underneath, so an unreadable parent directory (EACCES), a
+ * hung or disconnected network mount (EIO / ETIMEDOUT / ESTALE / EHOSTDOWN) and
+ * a genuinely deleted directory are indistinguishable through it. That
+ * distinction is the whole safety question for {@link reclaimGhostRepositories}:
+ * a repository on an unreachable volume must never be treated as gone.
+ *
+ * `lstatSync` keeps the errno, so the answer can be narrowed to the two codes
+ * that mean the kernel walked the path successfully and the entry was not
+ * there:
+ *
+ * - `ENOENT` — a component of the path does not exist;
+ * - `ENOTDIR` — a component that must be a directory is a file, so no such
+ *   entry can exist under it either.
+ *
+ * Every other outcome — the path resolved, or the lookup failed for any other
+ * reason — answers `false`, i.e. "not confirmed absent, leave it alone".
+ * `lstat` rather than `stat` so a dangling symlink is reported as present: the
+ * link is a real entry that the user still has to remove.
+ *
+ * @param repoPath - Absolute path to test
+ * @returns `true` only when the path is confirmed to be absent
+ */
+function directoryIsConfirmedAbsent(repoPath) {
+    if (!repoPath)
+        return false;
+    try {
+        fs_1.default.lstatSync(repoPath);
+        return false;
+    }
+    catch (error) {
+        const code = error.code;
+        return code === 'ENOENT' || code === 'ENOTDIR';
+    }
+}
+/**
+ * Take ghost `repositories` rows out of the scan set (Issue #2165).
+ *
+ * A row whose directory has been deleted stays `enabled = 1` forever: nothing
+ * removes it, so every server start and every sync re-derives the scan set from
+ * it, spawns a shell into a `cwd` that does not exist and logs an ERROR. Rows
+ * registered under `/tmp` were still doing this seven months after the
+ * directory they name was collected by the OS.
+ *
+ * {@link pruneStaleRepositoryWorktrees} cannot reach them. It deletes *worktree*
+ * rows, and it iterates {@link getRepositories}, which is a `GROUP BY` over the
+ * `worktrees` table — a repository with no worktree rows is not in its result
+ * at all, and its `ids.length === 0` early-continue would skip it even if it
+ * were. This function is the missing half: it works the `repositories` table.
+ *
+ * ## What it does — demote, not delete
+ *
+ * The row is set to `enabled = 0`, exactly as the Repositories screen's Scan
+ * toggle does (#1658). It is NOT deleted. `enabled` is the flag that decides
+ * what gets scanned, so demotion is sufficient — the row leaves `allPaths` at
+ * the next startup and sync, and the ERROR stops for good. Choosing it over
+ * `deleteRepository()` buys three things:
+ *
+ * 1. **Reversibility.** No filesystem test can prove a directory is gone
+ *    *forever* — an unmounted volume looks exactly like a deleted one from
+ *    userspace. A demoted row keeps its id, display name, `visible` flag and
+ *    clone URL, is listed on the Repositories screen with a Disabled badge, and
+ *    is one click from coming back. A wrong delete is unrecoverable.
+ * 2. **Agreement with #1666.** That Issue settled that exclusion is where the
+ *    app *stops*, not where it deletes; startup used to purge excluded
+ *    repositories and that was the bug. Reclaiming by deletion would re-open
+ *    the same argument from the other end.
+ * 3. **No dangling references.** `clone_jobs.repository_id` points at this row.
+ *
+ * ## The line — what is NOT reclaimed
+ *
+ * Every guard fails toward keeping the row enabled:
+ *
+ * - **Already disabled** — nothing to fix; it is out of the scan set already,
+ *   and touching it would rewrite state the user owns.
+ * - **Still listed in `WORKTREE_REPOS`** — the environment is a live
+ *   declaration that the operator wants this path scanned. Same reasoning as
+ *   migration v43's guard 2 (#1339): never overrule a path the env still asks
+ *   for. Such a path is re-registered on every boot anyway.
+ * - **Not confirmed absent** — see {@link directoryIsConfirmedAbsent}. This is
+ *   the "temporarily invisible" line: a repository under an unreachable network
+ *   mount answers EIO / ETIMEDOUT / ESTALE / EACCES, not ENOENT, and is kept.
+ * - **Owns worktree rows** — the condition the Issue names, and the one that
+ *   makes this provably lossless. Chat history, memos, todos, timers,
+ *   schedules, tasks and verification runs all hang off `worktrees`, so a
+ *   repository with zero worktree rows has no history to lose by definition.
+ *   It is also good evidence that the directory was never successfully scanned:
+ *   a scan of a present repository always yields at least its main worktree.
+ *
+ * @param db - Database instance
+ * @param envRepositoryPaths - Paths the environment still declares
+ *   (`getRepositoryPaths()`); rows at these paths are never demoted
+ * @returns The rows that were demoted, in `getAllRepositories` order
+ */
+function reclaimGhostRepositories(db, envRepositoryPaths = []) {
+    const envPaths = new Set(envRepositoryPaths.filter(p => !!p).map(p => path_1.default.resolve(p)));
+    const reclaimed = [];
+    for (const repo of (0, db_1.getAllRepositories)(db)) {
+        if (!repo.path)
+            continue;
+        if (!repo.enabled)
+            continue;
+        if (envPaths.has(repo.path))
+            continue;
+        if (!directoryIsConfirmedAbsent(repo.path))
+            continue;
+        if ((0, db_1.countWorktreesByRepositoryPath)(db, repo.path) > 0)
+            continue;
+        try {
+            (0, db_1.setRepositoryEnabled)(db, repo.id, false);
+        }
+        catch (error) {
+            // SEC-SF-004's disabled-row ceiling is the only expected failure. It
+            // guards against unbounded *growth* of the table, which this pass cannot
+            // cause — it creates no rows — so a refusal here just means one ghost
+            // keeps logging. Report it and move on rather than aborting startup.
+            logger.warn('repository:ghost-row-reclaim-failed', {
+                repoPath: repo.path,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        reclaimed.push({ id: repo.id, path: repo.path });
+        logger.info('repository:ghost-row-reclaimed', { repoPath: repo.path });
+    }
+    return reclaimed;
+}
 /**
  * Prune DB worktree rows for repositories that have vanished from disk.
  *

package/dist/server/src/lib/history/transcript-tail.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Reading the end of an agent's own transcript file (Issue #2197).
+ *
+ * The second half of the pull-mode reader that is the same whatever the agent
+ * is, alongside `./user-turn-recorder`: every one of them keeps a file that
+ * grows for the life of a session, and every one of them only ever needs its
+ * newest turn.
+ *
+ * The shape is `lib/hooks/sources/claude/history`'s, which #2121 wrote inline
+ * because it was the only reader. It is here rather than there because #2197
+ * added the second and #2198 adds the third, and three private copies of "read
+ * the last 4 MiB and drop the partial first line" is how the bound and the
+ * partial-line rule quietly stop agreeing with each other.
+ *
+ * @module lib/history/transcript-tail
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSCRIPT_TAIL_BYTES = void 0;
+exports.readTranscriptTail = readTranscriptTail;
+const promises_1 = require("fs/promises");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('lib/history/transcript-tail');
+/**
+ * How much of a transcript's tail is read.
+ *
+ * These files grow for the life of a session and a long one is tens of
+ * megabytes — the largest claude transcript on this machine was 23 MB on
+ * 2026-08-31, and the largest codex rollout was **273 MB** on 2026-09-01 — so
+ * reading one whole on every finished turn would be the most expensive thing the
+ * poller does. Only the newest turn is ever written, so only the newest turn has
+ * to be in the window.
+ *
+ * 4 MiB is roughly two orders of magnitude above the measured size of a single
+ * turn and still small enough to read and parse in one tick. A turn that
+ * genuinely does not fit produces a turn with no prompt in it, which each reader
+ * detects and reports rather than writing as a headless reply.
+ */
+exports.TRANSCRIPT_TAIL_BYTES = 4 * 1024 * 1024;
+/**
+ * The last {@link TRANSCRIPT_TAIL_BYTES} of a file, as UTF-8.
+ *
+ * Read at an offset rather than whole, and the first line of a windowed read is
+ * dropped: starting mid-line would hand the caller's parser a fragment that it
+ * would count as malformed anyway, and dropping it deliberately keeps that
+ * counter meaning "the writer was mid-append", which is the thing worth seeing.
+ *
+ * Never throws.
+ *
+ * @param path - An absolute path the caller has already validated
+ * @returns The text, or null when the file could not be read
+ */
+async function readTranscriptTail(path) {
+    let handle;
+    try {
+        handle = await (0, promises_1.open)(path, 'r');
+        const { size } = await handle.stat();
+        const offset = Math.max(0, size - exports.TRANSCRIPT_TAIL_BYTES);
+        const length = size - offset;
+        if (length <= 0)
+            return '';
+        const buffer = Buffer.alloc(length);
+        const { bytesRead } = await handle.read(buffer, 0, length, offset);
+        const text = buffer.subarray(0, bytesRead).toString('utf8');
+        if (offset === 0)
+            return text;
+        const firstBreak = text.indexOf('\n');
+        return firstBreak === -1 ? '' : text.slice(firstBreak + 1);
+    }
+    catch (error) {
+        logger.warn('transcript-tail-read-failed', {
+            path,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => { });
+    }
+}