@repo-os/repoos 0.5.73 → 0.5.74

package/dist/.build-info.json

@@ -1,5 +1,5 @@
 {
-  "hash": "54182298d418b9bcc12c138af5d99c0470fb3a54a8a573775e600c2e37ab1669",
-  "version": "0.5.73",
+  "hash": "acb4fde7b3c6e297f938786a4607f68999d8c272283c2b7d27f1d821525ef5dd",
+  "version": "0.5.74",
   "devUi": false
 }

package/dist/.build-stamp.json

@@ -1,3 +1,3 @@
 {
-  "generatedAt": "2026-10-29T21:23:55.474Z"
+  "generatedAt": "2026-10-30T16:08:37.438Z"
 }

package/dist/commands/checks.js

@@ -2,8 +2,8 @@ import { getCheckStore } from "../core/check-store.js";
 import { formatSlowestTestFiles } from "../core/test-file-timings.js";
 import { c } from "../cli/colors.js";
 import { loadConfig } from "../core/config.js";
-import { inspectCrossProcessSlots, localCheckLockRoot, releaseLocalCheckSlot, } from "../core/cross-process-slots.js";
-import { readQueueMarkers } from "../core/local-queue-marker.js";
+import { inspectCrossProcessSlots, listSlotWaiterPids, localCheckLockRoot, releaseLocalCheckSlot, } from "../core/cross-process-slots.js";
+import { currentQueueMarkers, readQueueMarkers } from "../core/local-queue-marker.js";
 import { mainCheckoutRoot } from "../core/git.js";
 import { heavySlotLimit } from "../core/resource-limits.js";
 export function cmdChecks(args) {
@@ -73,10 +73,9 @@ export function cmdChecks(args) {
             ? `slot ${holder.slot}: ${task}, pid ${holder.pid}, ${holder.dead ? "dead, reclaiming" : holder.wedged ? "wedged" : "alive"}, held ${Math.round(holder.ageMs / 1000)}s, heartbeat ${Math.round(holder.heartbeatAgeMs / 1000)}s ago`
             : `slot ${holder.slot}: free`);
     }
-    for (const marker of readQueueMarkers(boardRoot, cacheDir)
-        .filter((entry) => entry.kind === "local-check")
-        .sort((a, b) => a.position - b.position)) {
+    const queue = currentQueueMarkers(readQueueMarkers(boardRoot, cacheDir).filter((entry) => entry.kind === "local-check"), listSlotWaiterPids(root));
+    queue.forEach((marker) => {
         const waitingMs = Math.max(0, Date.now() - Date.parse(marker.since));
         console.log(`queue position ${marker.position}: #${marker.taskId}, waiting ${Math.round(waitingMs / 1000)}s`);
-    }
+    });
 }

package/dist/core/attention.d.ts

@@ -12,7 +12,7 @@ export interface CloseOutOutcomeFeedEvent {
 }
 export type AttentionSeverity = "info" | "warning" | "error";
 /** Every attention kind the bell and API expose. */
-export type AttentionKind = "releaseNotesReady" | "releaseSucceeded" | "releaseFailed" | "closeOutSucceeded" | "closeOutFailed" | "closeOutTimedOut" | "taskReview" | "taskNeedsInput" | "taskNeedsMerge" | "taskAssigned" | "providerFailure" | "providerUsageLimit" | "silentRun" | "slowRun" | "slowRunsRecently" | "spendThreshold" | "awaitingVisualCheck" | "remoteFallback" | "remoteHostDegraded" | "ctoAction" | "ctoSilent";
+export type AttentionKind = "releaseNotesReady" | "releaseSucceeded" | "releaseFailed" | "closeOutSucceeded" | "closeOutFailed" | "closeOutTimedOut" | "taskReview" | "taskNeedsInput" | "taskNeedsMerge" | "taskAssigned" | "providerFailure" | "providerUsageLimit" | "silentRun" | "slowRun" | "slowRunsRecently" | "spendThreshold" | "awaitingVisualCheck" | "remoteFallback" | "remoteHostDegraded" | "ctoAction" | "gitLock" | "ctoSilent";
 export interface AttentionItem {
     /** Stable per event — dedupe key for clients and dismiss markers. */
     id: string;
@@ -33,7 +33,7 @@ export interface AttentionFeed {
 /** Durable attention events recorded on the server (provider failures, remote fallback). */
 export interface RecordedAttentionEvent {
     id: string;
-    kind: "providerFailure" | "providerUsageLimit" | "remoteFallback" | "ctoAction";
+    kind: "providerFailure" | "providerUsageLimit" | "remoteFallback" | "ctoAction" | "gitLock";
     taskId: string | null;
     message: string;
     detail: string;

package/dist/core/attention.js

@@ -26,6 +26,7 @@ const SEVERITY = {
     remoteFallback: "warning",
     remoteHostDegraded: "warning",
     ctoAction: "info",
+    gitLock: "warning",
     ctoSilent: "warning",
 };
 /** Attention kinds that imply the CTO (or a driver) should be acting (#0728). */

package/dist/core/check-wait.d.ts

@@ -9,13 +9,16 @@
  * `[queue]` status lines and write queue markers; this recorder turns those
  * lines into (a) a human-readable "waiting: <reason> for Nm" trail on stdout —
  * which the handoff transcript captures — and (b) a `waited` fact persisted on
- * the run's CheckRunRecord. A wait that crosses ten minutes says so once, so
- * the transcript names the escalation instead of hanging silently.
+ * the run's CheckRunRecord. A wait that crosses ten minutes reminds the
+ * engineer to keep waiting.
+ * Queueing is normal and does not itself request human input.
  */
 /** How often the "still waiting" line repeats while the wait continues. */
 export declare const CHECK_WAIT_REMINDER_MS = 60000;
-/** A wait this long is surfaced as needs_input by the task watchdog. */
-export declare const CHECK_WAIT_ESCALATION_MS: number;
+/** A long normal wait gets an explicit keep-waiting reminder. */
+export declare const CHECK_WAIT_REMINDER_THRESHOLD_MS: number;
+/** Missing holder heartbeats for this long indicate an abnormal wait. */
+export declare const CHECK_WAIT_STALLED_MS: number;
 export interface CheckWait {
     /** Latest observed reason, verbatim from the gate's status line. */
     reason: string;

package/dist/core/check-wait.js

@@ -9,17 +9,20 @@
  * `[queue]` status lines and write queue markers; this recorder turns those
  * lines into (a) a human-readable "waiting: <reason> for Nm" trail on stdout —
  * which the handoff transcript captures — and (b) a `waited` fact persisted on
- * the run's CheckRunRecord. A wait that crosses ten minutes says so once, so
- * the transcript names the escalation instead of hanging silently.
+ * the run's CheckRunRecord. A wait that crosses ten minutes reminds the
+ * engineer to keep waiting.
+ * Queueing is normal and does not itself request human input.
  */
 /** How often the "still waiting" line repeats while the wait continues. */
 export const CHECK_WAIT_REMINDER_MS = 60_000;
-/** A wait this long is surfaced as needs_input by the task watchdog. */
-export const CHECK_WAIT_ESCALATION_MS = 10 * 60_000;
+/** A long normal wait gets an explicit keep-waiting reminder. */
+export const CHECK_WAIT_REMINDER_THRESHOLD_MS = 10 * 60_000;
+/** Missing holder heartbeats for this long indicate an abnormal wait. */
+export const CHECK_WAIT_STALLED_MS = 30 * 60_000;
 export function createCheckWaitRecorder(emit, now = Date.now) {
     let current = null;
     let lastAnnouncedAt = 0;
-    let announcedEscalation = false;
+    let announcedLongWait = false;
     return {
         onStatusLine(line) {
             const reason = line.trim();
@@ -37,10 +40,10 @@ export function createCheckWaitRecorder(emit, now = Date.now) {
                 lastAnnouncedAt = now();
                 emit(`waiting: ${reason} for ${formatWaitDuration(waitedMs)}`);
             }
-            if (!announcedEscalation && waitedMs >= CHECK_WAIT_ESCALATION_MS) {
-                announcedEscalation = true;
+            if (!announcedLongWait && waitedMs >= CHECK_WAIT_REMINDER_THRESHOLD_MS) {
+                announcedLongWait = true;
                 emit(`waiting: ${reason} for ${formatWaitDuration(waitedMs)} — ` +
-                    "this wait is being surfaced as needs input");
+                    "queued checks are normal — keep waiting; do not end your turn");
             }
         },
         finish() {

package/dist/core/context-pack.js

@@ -657,6 +657,8 @@ function renderPack(config, task, branch, cwd, cacheHit, bootstrapResult, releva
     push("bun run build:ui     # UI-only build");
     push("```");
     push("");
+    push("A queued check is normal, including a long wait for a live slot holder or the pressure guard. Keep waiting until it passes, then hand off; do not end your turn because of the waiting badge. Only abnormal waits request input.");
+    push("");
     // ---- Managed Preview ----
     push("### Managed Preview");
     push("");

package/dist/core/cross-process-slots.d.ts

@@ -11,6 +11,7 @@ export interface SlotAcquireOptions {
     /** Written into the slot dir for debugging and stale recovery. */
     meta?: Record<string, unknown>;
     onQueued?: (ahead: number, position: number) => void;
+    onWaiterCleared?: () => void;
     onHeartbeat?: () => void;
     staleAfterMs?: number;
     reclaimGraceMs?: number;
@@ -37,6 +38,8 @@ export declare function reapOrphanedLocalCheckGroups(lockRoot: string): number[]
 export declare function acquireCrossProcessSlot(opts: SlotAcquireOptions): Promise<() => void>;
 /** Live waiters parked on this slot root (dead pids are ignored). */
 export declare function countSlotWaiters(lockRoot: string): number;
+/** PIDs that still have a live waiter entry in this slot queue. */
+export declare function listSlotWaiterPids(lockRoot: string): number[];
 export declare function heavyJobCounts(lockRoot: string): {
     running: number;
     queued: number;

package/dist/core/cross-process-slots.js

@@ -352,6 +352,7 @@ export async function acquireCrossProcessSlot(opts) {
             /* already gone */
         }
         waiterPath = null;
+        opts.onWaiterCleared?.();
     };
     const markWaiting = () => {
         if (waiterPath)
@@ -363,6 +364,15 @@ export async function acquireCrossProcessSlot(opts) {
     };
     let heartbeat;
     const signalHandlers = new Map();
+    for (const signal of ["SIGTERM", "SIGINT"]) {
+        const handler = () => {
+            clearWaiter();
+            process.off(signal, handler);
+            process.kill(process.pid, signal);
+        };
+        signalHandlers.set(signal, handler);
+        process.once(signal, handler);
+    }
     const release = () => {
         if (heartbeat)
             clearInterval(heartbeat);
@@ -383,6 +393,9 @@ export async function acquireCrossProcessSlot(opts) {
         held = tryTakeSlot(opts.lockRoot, slots, opts.meta, opts.staleAfterMs, opts.reclaimGraceMs);
         if (held) {
             clearWaiter();
+            for (const [signal, handler] of signalHandlers)
+                process.off(signal, handler);
+            signalHandlers.clear();
             for (const signal of ["SIGTERM", "SIGINT"]) {
                 const handler = () => {
                     release();
@@ -423,20 +436,24 @@ export async function acquireCrossProcessSlot(opts) {
 }
 /** Live waiters parked on this slot root (dead pids are ignored). */
 export function countSlotWaiters(lockRoot) {
+    return listSlotWaiterPids(lockRoot).length;
+}
+/** PIDs that still have a live waiter entry in this slot queue. */
+export function listSlotWaiterPids(lockRoot) {
     const dir = join(lockRoot, ".queue");
     let names = [];
     try {
         names = readdirSync(dir);
     }
     catch {
-        return 0;
+        return [];
     }
-    let n = 0;
+    const pids = [];
     for (const name of names) {
         try {
             const pid = Number(readFileSync(join(dir, name), "utf8").trim());
             if (processIsAlive(pid))
-                n++;
+                pids.push(pid);
             else
                 rmSync(join(dir, name), { force: true });
         }
@@ -444,7 +461,7 @@ export function countSlotWaiters(lockRoot) {
             /* raced */
         }
     }
-    return n;
+    return pids;
 }
 export function heavyJobCounts(lockRoot) {
     const holders = inspectCrossProcessSlots(lockRoot);
@@ -474,7 +491,11 @@ export async function acquireLocalFallbackSerializeSlot(repoRoot, cacheDir, wait
         slots: 1,
         lockRoot: localFallbackSerializeLockRoot(repoRoot, cacheDir),
         waitTimeoutMs,
-        meta: { kind: "local-fallback-serialize", id: randomBytes(4).toString("hex") },
+        meta: {
+            kind: "local-fallback-serialize",
+            pid: process.pid,
+            id: randomBytes(4).toString("hex"),
+        },
         onQueued: (ahead) => onQueued?.(ahead),
     });
 }

package/dist/core/git-maintenance.d.ts

@@ -1,16 +1,31 @@
 import { gitOutputAsync } from "./git.js";
+export interface GitLockMaintenanceOptions {
+    now?: () => number;
+    processHasLockOpen?: (path: string) => boolean | Promise<boolean>;
+    onLock?: (event: {
+        path: string;
+        state: "live" | "removed" | "cleared";
+        ageMs: number;
+    }) => void;
+}
+export declare function setGitMaintenanceLockSink(sink: GitLockMaintenanceOptions["onLock"]): void;
 /** Independent of both worker queues: a history timeout cannot cancel maintenance. */
 export declare class CommitGraphMaintenance {
     private readonly root;
     private readonly git;
     private readonly warn;
+    private readonly lockOptions;
     private debounce;
     private tick;
+    private lockTick;
     private running;
     private closed;
-    constructor(root: string, git?: typeof gitOutputAsync, warn?: (message: string) => void);
+    private liveLocks;
+    constructor(root: string, git?: typeof gitOutputAsync, warn?: (message: string) => void, lockOptions?: GitLockMaintenanceOptions);
     schedule(delayMs?: number): void;
     check(): Promise<void>;
     private rebuildIfNeeded;
+    private recoverIndexLocks;
+    private checkIndexLocks;
     close(): void;
 }

package/dist/core/git-maintenance.js

@@ -1,25 +1,51 @@
 import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import { gitOutputAsync } from "./git.js";
 const TICK_MS = 5 * 60_000;
+const INDEX_LOCK_TICK_MS = 60_000;
 const MAX_GRAPH_AGE_MS = 60 * 60_000;
 const DEBOUNCE_MS = 5_000;
+const STALE_INDEX_LOCK_MS = 2 * 60_000;
+let lockEventSink = undefined;
+export function setGitMaintenanceLockSink(sink) {
+    lockEventSink = sink;
+}
+function processHasLockOpen(path) {
+    try {
+        return (execFileSync("lsof", ["-t", path], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim().length > 0);
+    }
+    catch (error) {
+        // lsof exits 1 when no process has the file open. If the probe itself is
+        // unavailable, fail safe and leave the lock for a later maintenance tick.
+        return error.status !== 1;
+    }
+}
 /** Independent of both worker queues: a history timeout cannot cancel maintenance. */
 export class CommitGraphMaintenance {
     root;
     git;
     warn;
+    lockOptions;
     debounce;
     tick;
+    lockTick;
     running = null;
     closed = false;
-    constructor(root, git = gitOutputAsync, warn = console.warn) {
+    liveLocks = new Set();
+    constructor(root, git = gitOutputAsync, warn = console.warn, lockOptions = {}) {
         this.root = root;
         this.git = git;
         this.warn = warn;
+        this.lockOptions = lockOptions;
         this.tick = setInterval(() => void this.check(), TICK_MS);
         this.tick.unref?.();
+        this.lockTick = setInterval(() => void this.checkIndexLocks(), INDEX_LOCK_TICK_MS);
+        this.lockTick.unref?.();
         this.schedule(0);
     }
     schedule(delayMs = DEBOUNCE_MS) {
@@ -48,6 +74,7 @@ export class CommitGraphMaintenance {
         return this.running;
     }
     async rebuildIfNeeded() {
+        await this.recoverIndexLocks();
         const head = await this.git(this.root, ["rev-parse", "HEAD"]);
         if (!head || this.closed)
             return;
@@ -89,9 +116,63 @@ export class CommitGraphMaintenance {
             await rm(temporary, { force: true }).catch(() => { });
         }
     }
+    async recoverIndexLocks() {
+        const now = this.lockOptions.now ?? Date.now;
+        const listed = await this.git(this.root, ["worktree", "list", "--porcelain"]);
+        const roots = new Set([this.root]);
+        for (const line of (listed ?? "").split("\n")) {
+            if (line.startsWith("worktree "))
+                roots.add(line.slice("worktree ".length).trim());
+        }
+        for (const root of roots) {
+            if (this.closed)
+                return;
+            const gitDir = await this.git(root, ["rev-parse", "--absolute-git-dir"]);
+            if (!gitDir)
+                continue;
+            const path = join(gitDir, "index.lock");
+            const lock = await stat(path).catch(() => null);
+            if (!lock) {
+                if (this.liveLocks.delete(path))
+                    (this.lockOptions.onLock ?? lockEventSink)?.({ path, state: "cleared", ageMs: 0 });
+                continue;
+            }
+            const ageMs = Math.max(0, now() - lock.mtimeMs);
+            if (ageMs <= STALE_INDEX_LOCK_MS)
+                continue;
+            let live = true;
+            try {
+                live = await (this.lockOptions.processHasLockOpen ?? processHasLockOpen)(path);
+            }
+            catch {
+                live = true;
+            }
+            if (live) {
+                if (!this.liveLocks.has(path)) {
+                    this.liveLocks.add(path);
+                    (this.lockOptions.onLock ?? lockEventSink)?.({ path, state: "live", ageMs });
+                }
+                continue;
+            }
+            await rm(path, { force: true });
+            this.liveLocks.delete(path);
+            (this.lockOptions.onLock ?? lockEventSink)?.({ path, state: "removed", ageMs });
+        }
+    }
+    async checkIndexLocks() {
+        if (this.closed)
+            return;
+        try {
+            await this.recoverIndexLocks();
+        }
+        catch (error) {
+            this.warn(`git index.lock maintenance failed: ${error.message}`);
+        }
+    }
     close() {
         this.closed = true;
         clearInterval(this.tick);
+        clearInterval(this.lockTick);
         clearTimeout(this.debounce);
     }
 }

package/dist/core/git.d.ts

@@ -35,6 +35,8 @@ export declare function runGit(root: string, args: string[], timeout: number): P
  * `fsmonitor` daemons running and no known holder).
  */
 export declare function isGitLockContention(text: string): boolean;
+/** Install the server's durable logging hook for fail-soft bookkeeping commits. */
+export declare function setGitLockFailureSink(sink: ((root: string, message: string, detail: string) => void) | null): void;
 /** `retryOnGitLock` predicate for a raw `runGit` result: the lock text, or null. */
 export declare function gitRunLockContention(r: {
     status: number | null;

package/dist/core/git.js

@@ -135,6 +135,11 @@ export function runGit(root, args, timeout) {
 export function isGitLockContention(text) {
     return /Unable to create [^\n]*\.lock|Another git process seems to be running|index\.lock/i.test(text);
 }
+let gitLockFailureSink = null;
+/** Install the server's durable logging hook for fail-soft bookkeeping commits. */
+export function setGitLockFailureSink(sink) {
+    gitLockFailureSink = sink;
+}
 /** `retryOnGitLock` predicate for a raw `runGit` result: the lock text, or null. */
 export function gitRunLockContention(r) {
     return r.status !== 0 && isGitLockContention(r.stderr) ? r.stderr : null;
@@ -1752,12 +1757,19 @@ export function commitFiles(root, absPaths, message) {
         return false;
     if (status.trim() === "")
         return true;
-    if (git(root, ["add", "-A", "--", ...rels]) === null)
+    const add = gitCapture(root, ["add", "-A", "--", ...rels]);
+    if (add.status !== 0) {
+        if (isGitLockContention(add.stderr))
+            gitLockFailureSink?.(root, message, add.stderr.trim());
         return false;
+    }
     // `--only` with a pathspec commits just these files and leaves everything
     // else already in the index staged (#0353): a plain `git commit` would sweep
     // in whatever a human or agent had staged in the checkout under our message.
-    const committed = git(root, ["commit", "-o", "-m", message, "--", ...rels]) !== null;
+    const commit = gitCapture(root, ["commit", "-o", "-m", message, "--", ...rels]);
+    const committed = commit.status === 0;
+    if (!committed && isGitLockContention(commit.stderr))
+        gitLockFailureSink?.(root, message, commit.stderr.trim());
     // RepoOS's own bookkeeping commits are the main reason the sidebar git-state
     // indicator would otherwise flicker stale — tell it to recompute (#0584).
     if (committed)

package/dist/core/local-gates.js

@@ -16,7 +16,7 @@ function taskIdFromEnv(env) {
     const id = env.REPOOS_TASK_ID?.trim() || env.REPOOS_CHECK_TASK_ID?.trim();
     return id && /^\d+$/.test(id) ? id : null;
 }
-function markQueue(repoRoot, cacheDir, env, kind, ahead, position, message) {
+function markQueue(repoRoot, cacheDir, env, kind, ahead, position, message, pool) {
     const taskId = taskIdFromEnv(env);
     if (!taskId)
         return;
@@ -28,6 +28,8 @@ function markQueue(repoRoot, cacheDir, env, kind, ahead, position, message) {
         position,
         message,
         since: since ?? new Date().toISOString(),
+        pool,
+        pid: process.pid,
     });
 }
 function unmarkQueue(repoRoot, cacheDir, env, kind) {
@@ -77,7 +79,7 @@ export async function acquireLocalCheckSlot(opts) {
                 ? "waiting for serialized local fallback slot"
                 : `waiting for serialized local fallback (${ahead} ahead, position ${position})`;
             emit(`[queue] ${msg}`);
-            markQueue(board, cacheDir, opts.env, "local-check", ahead, position, msg);
+            markQueue(board, cacheDir, opts.env, "local-check", ahead, position, msg, "local-fallback-serialize");
         });
     }
     try {
@@ -104,6 +106,7 @@ export async function acquireLocalCheckSlot(opts) {
                 emit(`[queue] ${label}`);
                 markQueue(board, cacheDir, opts.env, "local-check", ahead, position, title);
             },
+            onWaiterCleared: () => unmarkQueue(board, cacheDir, opts.env, "local-check"),
         });
         unmarkQueue(board, cacheDir, opts.env, "local-check");
         return () => {

package/dist/core/local-queue-marker.d.ts

@@ -1,13 +1,17 @@
 export type LocalQueueKind = "local-check" | "playwright" | "pressure";
 export interface LocalQueueMarker {
     taskId: string;
+    pid?: number;
     kind: LocalQueueKind;
     position: number;
     ahead: number;
     message: string;
     since: string;
+    /** Slot pool being waited on; absent on older markers. */
+    pool?: "local-check" | "local-fallback-serialize" | "playwright";
 }
 export declare function queueMarkersDir(repoRoot: string, cacheDir: string): string;
 export declare function writeQueueMarker(repoRoot: string, cacheDir: string, marker: LocalQueueMarker): void;
 export declare function clearQueueMarker(repoRoot: string, cacheDir: string, taskId: string, kind: LocalQueueKind): void;
 export declare function readQueueMarkers(repoRoot: string, cacheDir: string): LocalQueueMarker[];
+export declare function currentQueueMarkers(markers: LocalQueueMarker[], liveWaiterPids: Iterable<number>): LocalQueueMarker[];

package/dist/core/local-queue-marker.js

@@ -39,3 +39,10 @@ export function readQueueMarkers(repoRoot, cacheDir) {
         return [];
     }
 }
+export function currentQueueMarkers(markers, liveWaiterPids) {
+    const live = new Set(liveWaiterPids);
+    return markers
+        .filter((marker) => marker.kind !== "local-check" || (marker.pid && live.has(marker.pid)))
+        .sort((a, b) => Date.parse(a.since) - Date.parse(b.since))
+        .map((marker, index) => marker.kind === "local-check" ? { ...marker, ahead: index, position: index + 1 } : marker);
+}

package/dist/core/needs-input.js

@@ -7,8 +7,8 @@ export function needsInputClearsOnNewEngineerRun(reason) {
         return true;
     if (reason === "review-human-attention")
         return true;
-    // #0974: a check-wait flag was informational — the gate was queued. Once the
-    // engineer runs again the wait is over, so the flag must not linger.
+    // A fresh engineer run retries an abnormal check wait (#0983). If the
+    // underlying holder is still dead/stalled, the watchdog will raise it again.
     if (reason === "check-wait")
         return true;
     return reason === "provider-failure" || reason === "degenerate-output";

package/dist/core/shot-fixtures.d.ts

@@ -3,7 +3,7 @@
  * path appends `?shotState=<id>` to the route; the UI applies the fixture only
  * on preview builds (`isPreviewBuild`).
  */
-export declare const SHOT_PREVIEW_FIXTURE_IDS: readonly ["system:worktreeGc", "closeOut:active", "closeOut:checkProgress", "closeOut:checkProgressUnknown", "checks:progress", "checks:timings", "checks:reuse", "pages:scroll", "closeOut:stalled", "closeOut:uploading", "closeOut:remoteTests", "runners:queued", "integration:median15", "card:doneError", "board:withReviewTask", "drawer:reviewWithBranch", "drawer:landable", "drawer:statusReviewFailed", "drawer:statusReviewFailedNarrow", "drawer:statusHandoffFailed", "drawer:statusChecksRunning", "drawer:statusChecksRunningNarrow", "drawer:statusConfirmingHandoff", "drawer:statusConfirmingHandoffNarrow", "drawer:statusChecksFailed", "drawer:statusChecksFailedNarrow", "drawer:statusDetails", "drawer:landableNarrow", "drawer:tabExpandWarnings", "drawer:activeRequirements", "drawer:nativePreviewBuilding", "drawer:nativePreviewRunning", "drawer:nativePreviewFailed", "drawer:shotEvidence", "drawer:debugLogs", "card:humanStep", "card:held", "drawer:held", "card:reviewRoundsExhausted", "card:handoffConflict", "card:checkpointRecovery", "board:cardChips", "card:noChanges", "board:activeCoding", "board:severalWorkingCards", "board:startWorkPending", "drawer:startWorkPending", "settings:birdQuickTrail", "settings:rgbKeystorm", "settings:wheelieCourier", "settings:booSwoop", "settings:pumpkinSpell", "drawer:queuedMessage", "dev:failed", "dev:loading", "dev:running", "secrets:populated", "secrets:removeDialog", "deployments:environmentBinding", "deployments:loading", "editor:unconfigured", "panel:newInputOutstandingUpload", "panel:freeformFailedScreenshot", "panel:defaultScreenshotPicker", "budget:paused", "schedule:newPanel", "reminders:due"];
+export declare const SHOT_PREVIEW_FIXTURE_IDS: readonly ["system:worktreeGc", "closeOut:active", "closeOut:checkProgress", "closeOut:checkProgressUnknown", "checks:progress", "checks:timings", "checks:reuse", "pages:scroll", "closeOut:stalled", "closeOut:uploading", "closeOut:remoteTests", "runners:queued", "integration:median15", "card:doneError", "board:withReviewTask", "drawer:reviewWithBranch", "drawer:landable", "drawer:statusReviewFailed", "drawer:statusReviewFailedNarrow", "drawer:statusHandoffFailed", "drawer:statusChecksRunning", "drawer:statusChecksRunningNarrow", "drawer:statusConfirmingHandoff", "drawer:statusConfirmingHandoffNarrow", "drawer:statusChecksFailed", "drawer:statusChecksFailedNarrow", "drawer:statusDetails", "drawer:landableNarrow", "drawer:tabExpandWarnings", "drawer:activeRequirements", "drawer:nativePreviewBuilding", "drawer:nativePreviewRunning", "drawer:nativePreviewFailed", "drawer:shotEvidence", "drawer:debugLogs", "card:humanStep", "card:held", "drawer:held", "card:reviewRoundsExhausted", "card:handoffConflict", "card:checkpointRecovery", "board:cardChips", "card:noChanges", "board:activeCoding", "checks:waiting", "board:severalWorkingCards", "board:startWorkPending", "drawer:startWorkPending", "settings:birdQuickTrail", "settings:rgbKeystorm", "settings:wheelieCourier", "settings:booSwoop", "settings:pumpkinSpell", "drawer:queuedMessage", "dev:failed", "dev:loading", "dev:running", "secrets:populated", "secrets:removeDialog", "deployments:environmentBinding", "deployments:loading", "editor:unconfigured", "panel:newInputOutstandingUpload", "panel:freeformFailedScreenshot", "panel:defaultScreenshotPicker", "budget:paused", "schedule:newPanel", "reminders:due"];
 export type ShotPreviewFixtureId = (typeof SHOT_PREVIEW_FIXTURE_IDS)[number];
 export declare const SHOT_PREVIEW_FIXTURE_QUERY = "shotState";
 /** Task id used by card/board fixtures so selectors can target one stable card. */

package/dist/core/shot-fixtures.js

@@ -90,6 +90,7 @@ export const SHOT_PREVIEW_FIXTURE_IDS = [
     // #0787 — active engineer run on the board so captures can show the compact
     // coding indicator on a task card.
     "board:activeCoding",
+    "checks:waiting",
     // #0980 — six active cards for activity-animation captures and profiling.
     "board:severalWorkingCards",
     // #0822 — ready task with Start work in flight so the card shows Starting….

package/dist/server/attention-events.d.ts

@@ -4,5 +4,6 @@ export interface AttentionEventStore {
         id?: string;
     }): RecordedAttentionEvent;
     list(): RecordedAttentionEvent[];
+    remove(id: string): void;
 }
 export declare function createAttentionEventStore(root: string, cacheDir?: string, onPersistError?: (error: unknown) => void): AttentionEventStore;

package/dist/server/attention-events.js

@@ -84,6 +84,13 @@ export function createAttentionEventStore(root, cacheDir = ".repoos", onPersistE
             persist(events);
             return full;
         },
+        remove(id) {
+            const next = load().filter((event) => event.id !== id);
+            if (next.length === load().length)
+                return;
+            events = next;
+            persist(events);
+        },
         list() {
             return [...load()].sort((a, b) => b.at.localeCompare(a.at));
         },

package/dist/server/server.js

@@ -99,7 +99,8 @@ import { ensureStoryNumbers } from "../core/story-definition-files.js";
 import { createLogger } from "../core/logger.js";
 import { watchHttpRequest } from "./request-timing.js";
 import { parseFlatToml, loadConfig, resolveServePort, projectDisplayName, } from "../core/config.js";
-import { commitTaskFile, commitFiles, syncBranchWithMain, shouldTuneRepoForScaleAtStartup, tuneRepoForScale, runGit, } from "../core/git.js";
+import { commitTaskFile, commitFiles, syncBranchWithMain, shouldTuneRepoForScaleAtStartup, tuneRepoForScale, runGit, setGitLockFailureSink, } from "../core/git.js";
+import { setGitMaintenanceLockSink } from "../core/git-maintenance.js";
 import { checkServerRegistryPortConflict, logServerRegistryError, refreshRunningServerProjectName, registerRunningServer, removeServerRegistryEntry, shouldRegisterServerRegistry, updateServerRegistryEngineerCount, } from "../core/server-registry.js";
 import { onGitMutation } from "../core/git-activity.js";
 import { sweepOrphanedBookkeeping } from "./orphan-bookkeeping.js";
@@ -694,6 +695,13 @@ export function startServer(opts = {}) {
         bindHost = "127.0.0.1";
     }
     const logger = createLogger(config.root);
+    setGitLockFailureSink((root, commitMessage, detail) => {
+        const context = { root, commitMessage, detail };
+        logger.system("warn", `git write failed because index.lock is present: ${detail}`, context);
+        const taskId = commitMessage.match(/\b(?:docs|inputs|schedules|stories)\(([^)]+)\)/)?.[1];
+        if (taskId)
+            logger.task(taskId, "warn", `git bookkeeping write failed because index.lock is present: ${detail}`, context);
+    });
     // Best-effort: enable git's fsmonitor + untracked-cache on the main checkout
     // only — preview/shot servers and linked task worktrees share `.git/config`
     // and must not re-enable watchers or spawn another daemon per start (#0958).
@@ -954,6 +962,28 @@ export function startServer(opts = {}) {
     const bumpAttention = () => {
         emitEvent({ type: "attention.updated", at: new Date().toISOString() });
     };
+    setGitMaintenanceLockSink(({ path, state, ageMs }) => {
+        const id = `gitLock:${path}`;
+        if (state === "live") {
+            logger.system("warn", "Live git process still holds stale git index.lock", { path, ageMs });
+            attentionEvents.record({
+                id,
+                kind: "gitLock",
+                taskId: null,
+                message: "Git is still holding a stale index lock",
+                detail: `${path} has been present for ${Math.floor(ageMs / 60_000)} minutes. Git writes may be blocked until the process releases it.`,
+                at: new Date().toISOString(),
+            });
+            bumpAttention();
+            return;
+        }
+        if (state === "removed")
+            logger.system("info", "Removed stale git index.lock", { path, ageMs });
+        if (state === "cleared") {
+            attentionEvents.remove(id);
+            bumpAttention();
+        }
+    });
     wireAttentionNotifications(attentionEvents, bumpAttention);
     const recordRemoteFallbackAttention = (taskId, detail) => {
         const at = new Date().toISOString();

package/dist/server/task-watchdog.d.ts

@@ -206,15 +206,7 @@ export declare class TaskWatchdog {
      */
     private escalateToNeedsInput;
     private readCurrent;
-    /**
-     * #0974: a check that is still waiting — pressure guard, a heavy slot, the
-     * git queue — after ten minutes is surfaced as needs_input instead of
-     * hanging silently (the #0970 incident: 26 minutes behind a stale pressure
-     * guard with nothing on the card). The gates write queue markers while they
-     * wait; this scan reads them. The flag clears itself once the marker is
-     * gone (the wait ended and the check is actually running) or on the next
-     * engineer run — it is informational, not a permanent failure.
-     */
+    /** Queue markers are non-blocking waiting state. Only broken waits need input. */
     private escalateStaleQueueWaits;
     private escalateCheckWait;
     private clearCheckWaitEscalation;