specrails-desktop 2.34.1 → 2.35.0

package/server/dist/review-packet.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DRIFT_REVISION_COUNT = exports.DRIFT_COST_SHARE = exports.MAX_VERSION_CHAIN = exports.HUMAN_REVIEW_BAND = void 0;
+exports.selectVariant = selectVariant;
+exports.computeDriftNudges = computeDriftNudges;
+exports.composeReviewPacket = composeReviewPacket;
+exports.packetHasUnsourcedNumericClaim = packetHasUnsourcedNumericClaim;
+const delivery_evidence_1 = require("./delivery-evidence");
+const rail_pr_store_1 = require("./rail-pr-store");
+const pr_body_1 = require("./pr-body");
+const ai_invocations_1 = require("./ai-invocations");
+const TEST_FILE_RE = /(\.test\.|\.spec\.|(^|\/)__tests__\/)/;
+function churnForRuns(db, runIds) {
+    const ids = [...new Set(runIds.filter((id) => typeof id === 'string' && id.length > 0))];
+    if (ids.length === 0)
+        return [];
+    const placeholders = ids.map(() => '?').join(', ');
+    try {
+        return db.prepare(`
+      SELECT job_id, file_path, added_lines, removed_lines
+        FROM file_story_contributions
+       WHERE job_id IN (${placeholders})
+    `).all(...ids);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Variant selection reads ONLY durable outcomes. `no-changes` must win over
+ * `success` (a run that changed nothing has nothing to show), and a mixed batch
+ * is `partial` rather than a success that quietly hides a failed ticket.
+ */
+function selectVariant(row, units) {
+    if (row.decision === 'no_changes' || row.delivery_outcome === 'no_changes' || row.status_code === 'no_changes') {
+        return 'no-changes';
+    }
+    if (row.implementation_outcome === 'failed' || row.decision === 'implementation_failed')
+        return 'failed';
+    const succeeded = units.filter((unit) => unit.implementationOutcome === 'succeeded' || (unit.implementationOutcome == null && unit.succeeded)).length;
+    const failed = units.filter((unit) => unit.implementationOutcome === 'failed' || (unit.implementationOutcome == null && !unit.succeeded)).length;
+    if (row.implementation_outcome === 'partially_succeeded' || row.delivery_outcome === 'partial' || (succeeded > 0 && failed > 0)) {
+        return 'partial';
+    }
+    return 'success';
+}
+function headlineFor(variant, succeeded, total) {
+    switch (variant) {
+        case 'no-changes': return 'headline.noChanges';
+        case 'failed': return succeeded > 0 ? 'headline.failedPartial' : 'headline.failed';
+        case 'partial': return 'headline.partial';
+        default: return total > 1 ? 'headline.successMany' : 'headline.success';
+    }
+}
+/** Reviewer band documented by sr-reviewer's schema: 50-69 ⇒ recommend a human. */
+exports.HUMAN_REVIEW_BAND = { min: 50, max: 69 };
+function buildProof(units, evidence, churn, confidence) {
+    const proof = [];
+    // ── Tier 1: what Specrails measured itself ────────────────────────────────
+    const testFiles = [...new Set(churn.filter((row) => TEST_FILE_RE.test(row.file_path)).map((row) => row.file_path))];
+    const totalFiles = new Set(churn.map((row) => row.file_path)).size;
+    const added = churn.reduce((sum, row) => sum + (row.added_lines || 0), 0);
+    const removed = churn.reduce((sum, row) => sum + (row.removed_lines || 0), 0);
+    if (totalFiles > 0) {
+        proof.push({
+            tier: 'app-verified',
+            code: 'proof.filesChanged',
+            values: { files: totalFiles, added, removed },
+        });
+    }
+    proof.push(testFiles.length > 0
+        ? { tier: 'app-verified', code: 'proof.testFilesChanged', values: { count: testFiles.length } }
+        // The honest negative: silence here would read as "tests fine".
+        : { tier: 'app-verified', code: 'proof.noTestFilesChanged' });
+    const verifiedBranches = units.filter((unit) => unit.finalSha && unit.finalSha !== unit.initialSha).length;
+    if (verifiedBranches > 0) {
+        proof.push({ tier: 'app-verified', code: 'proof.commitsRecorded', values: { branches: verifiedBranches } });
+    }
+    // ── Tier 2: what the agent itself reported ────────────────────────────────
+    const sentinels = (evidence ?? []).filter((unit) => unit.sentinel !== 'absent');
+    if (sentinels.length === 0) {
+        proof.push({ tier: 'ai-reported', code: 'proof.noVerificationReported' });
+    }
+    else {
+        const failed = sentinels.filter((unit) => unit.sentinel === 'fail');
+        if (failed.length > 0) {
+            // Failure leads: a packet must never bury a reported failure under a pass.
+            proof.push({
+                tier: 'ai-reported',
+                code: 'proof.verificationFailed',
+                values: { count: failed.length },
+                ...(failed[0].sentinelDetail ? { rawExcerpt: failed[0].sentinelDetail } : {}),
+            });
+        }
+        const passed = sentinels.filter((unit) => unit.sentinel === 'pass');
+        if (passed.length > 0) {
+            proof.push({ tier: 'ai-reported', code: 'proof.verificationPassed', values: { count: passed.length } });
+        }
+        const tail = sentinels.map((unit) => unit.verifyTail).find((value) => Boolean(value));
+        if (tail)
+            proof.push({ tier: 'ai-reported', code: 'proof.verifyOutput', rawExcerpt: tail });
+    }
+    // ── Tier 3: the reviewer grading its own pipeline ─────────────────────────
+    if (confidence) {
+        if (confidence.overall !== null) {
+            proof.push({
+                tier: 'reviewer-score',
+                code: 'proof.reviewerScore',
+                values: { overall: confidence.overall },
+            });
+        }
+        for (const [aspect, score] of Object.entries(confidence.aspects)) {
+            proof.push({ tier: 'reviewer-score', code: 'proof.reviewerAspect', values: { aspect, score } });
+        }
+    }
+    else {
+        proof.push({ tier: 'reviewer-score', code: 'proof.reviewerScoreUnavailable' });
+    }
+    return proof;
+}
+/**
+ * "What to watch out for" is capped and derived from REAL signals only —
+ * reviewer flags, the human-review band, and a code-changed-without-tests
+ * observation. Confabulated caution would train the user to ignore the section.
+ */
+function buildWatchOut(confidence, churn, variant) {
+    const out = [];
+    if (confidence?.overall !== null && confidence?.overall !== undefined) {
+        if (confidence.overall >= exports.HUMAN_REVIEW_BAND.min && confidence.overall <= exports.HUMAN_REVIEW_BAND.max) {
+            out.push({ tier: 'reviewer-score', code: 'watch.humanReviewRecommended', values: { overall: confidence.overall } });
+        }
+        else if (confidence.overall < exports.HUMAN_REVIEW_BAND.min) {
+            out.push({ tier: 'reviewer-score', code: 'watch.lowConfidence', values: { overall: confidence.overall } });
+        }
+    }
+    for (const flag of (confidence?.flags ?? []).slice(0, 3)) {
+        out.push({ tier: 'reviewer-score', code: 'watch.reviewerFlag', rawExcerpt: flag });
+    }
+    const codeFiles = churn.filter((row) => !TEST_FILE_RE.test(row.file_path));
+    const testFiles = churn.filter((row) => TEST_FILE_RE.test(row.file_path));
+    if (out.length < 3 && variant !== 'no-changes' && codeFiles.length > 0 && testFiles.length === 0) {
+        out.push({ tier: 'app-verified', code: 'watch.noTestsForChangedCode', values: { files: codeFiles.length } });
+    }
+    return out.slice(0, 3);
+}
+/**
+ * Walk the supersession chain back to the original build. Bounded so a corrupted
+ * lineage cannot spin, and tolerant of a missing ancestor (an old row may have
+ * been pruned) — the chain simply starts where the data does.
+ */
+exports.MAX_VERSION_CHAIN = 25;
+function versionChain(db, row) {
+    const chain = [row];
+    const seen = new Set([row.id]);
+    let cursor = row;
+    while (chain.length < exports.MAX_VERSION_CHAIN && cursor.revision_of) {
+        const previous = (0, rail_pr_store_1.getPrDelivery)(db, cursor.revision_of);
+        if (!previous || seen.has(previous.id))
+            break;
+        seen.add(previous.id);
+        chain.push(previous);
+        cursor = previous;
+    }
+    return chain.reverse(); // oldest first: v1 … vN
+}
+/** Fraction of the original build's cost above which revisions are worth flagging. */
+exports.DRIFT_COST_SHARE = 0.5;
+/** Revision count backstop — advisory, never a block. */
+exports.DRIFT_REVISION_COUNT = 3;
+/**
+ * Reshape-the-spec nudges. Every trigger is a real measurement (cumulative cost
+ * vs the original build, churn landing outside the original file set, revision
+ * depth) so the banner can show its own numbers instead of asserting a vibe.
+ * A hard count alone was rejected: it treats a 40-cent typo fix and a nine-dollar
+ * architectural thrash identically.
+ */
+function computeDriftNudges(input) {
+    const nudges = [];
+    const [original, ...revisions] = input.versions;
+    if (revisions.length === 0)
+        return nudges;
+    const originalCost = original?.costUsd ?? null;
+    const revisionCost = revisions.reduce((sum, version) => sum + (version.costUsd ?? 0), 0);
+    if (originalCost !== null && originalCost > 0 && revisionCost > originalCost * exports.DRIFT_COST_SHARE) {
+        nudges.push({
+            code: 'drift.costShare',
+            values: {
+                revisions: revisions.length,
+                revisionCost: revisionCost.toFixed(2),
+                originalCost: originalCost.toFixed(2),
+                share: Math.round((revisionCost / originalCost) * 100),
+            },
+        });
+    }
+    if (input.originalFileSet.size > 0 && input.currentFiles.size > 0) {
+        const outside = [...input.currentFiles].filter((file) => !input.originalFileSet.has(file));
+        if (outside.length * 2 > input.currentFiles.size) {
+            nudges.push({ code: 'drift.outOfScopeChurn', values: { files: outside.length, total: input.currentFiles.size } });
+        }
+    }
+    if (revisions.length >= exports.DRIFT_REVISION_COUNT) {
+        nudges.push({ code: 'drift.revisionCount', values: { revisions: revisions.length } });
+    }
+    return nudges;
+}
+function composeReviewPacket({ db, row }) {
+    const ticketIds = safeParse(row.ticket_ids, []);
+    const units = safeParse(row.branches, []);
+    const runIds = safeParse(row.run_ids, []);
+    const snapshot = (0, rail_pr_store_1.readSpecSnapshot)(row.spec_snapshot);
+    const evidence = (0, delivery_evidence_1.readSettleEvidence)(row.settle_evidence);
+    const churn = churnForRuns(db, runIds);
+    const variant = selectVariant(row, units);
+    const confidence = (evidence?.units ?? [])
+        .map((unit) => unit.confidence)
+        .find((score) => score !== null) ?? null;
+    const sections = ticketIds.map((ticketId) => {
+        const snap = snapshot?.find((entry) => entry.ticketId === ticketId) ?? null;
+        const narrative = (0, pr_body_1.extractSpecNarrative)(snap?.description ?? null);
+        const unitRows = units.filter((unit) => unit.ticketId === ticketId);
+        const unitRunIds = [...new Set(unitRows.map((unit) => unit.runId).filter((id) => Boolean(id)))];
+        // A run that covered several tickets (a batch collapsed into one checkout)
+        // cannot have its files split per ticket: provenance keys them to the run's
+        // primary ticket. Report null rather than repeat delivery totals per section.
+        const sharedRun = unitRunIds.some((runId) => new Set(units.filter((unit) => unit.runId === runId).map((unit) => unit.ticketId)).size > 1);
+        const unitChurn = !sharedRun && unitRunIds.length > 0
+            ? churn.filter((row) => row.job_id != null && unitRunIds.includes(row.job_id))
+            : null;
+        return {
+            ticketId,
+            title: snap?.title ?? null,
+            problem: narrative.problem,
+            solution: narrative.solution,
+            labels: snap?.labels ?? [],
+            implementationOutcome: unitRows[0]?.implementationOutcome ?? null,
+            deliveryOutcome: unitRows[0]?.deliveryOutcome ?? null,
+            changed: unitRows[0]?.changed ?? null,
+            churn: unitChurn === null ? null : {
+                filesTouched: new Set(unitChurn.map((c) => c.file_path)).size,
+                addedLines: unitChurn.reduce((sum, c) => sum + (c.added_lines || 0), 0),
+                removedLines: unitChurn.reduce((sum, c) => sum + (c.removed_lines || 0), 0),
+                testFilesTouched: [...new Set(unitChurn.filter((c) => TEST_FILE_RE.test(c.file_path)).map((c) => c.file_path))],
+            },
+            runIds: unitRunIds,
+        };
+    });
+    const succeededCount = units.length > 0
+        ? units.filter((unit) => unit.implementationOutcome === 'succeeded' || (unit.implementationOutcome == null && unit.succeeded)).length
+        : row.implementation_outcome === 'failed' ? 0 : ticketIds.length;
+    const failedCount = units.length > 0
+        ? units.filter((unit) => unit.implementationOutcome === 'failed' || (unit.implementationOutcome == null && !unit.succeeded)).length
+        : row.implementation_outcome === 'failed' ? ticketIds.length : 0;
+    const costSum = (0, ai_invocations_1.sumInvocationCostForRuns)(db, runIds);
+    const chain = versionChain(db, row);
+    const versions = chain.map((entry, index) => {
+        const entryRunIds = safeParse(entry.run_ids, []);
+        const entryCost = (0, ai_invocations_1.sumInvocationCostForRuns)(db, entryRunIds);
+        return {
+            prDeliveryId: entry.id,
+            version: index + 1,
+            revisionNote: entry.revision_note,
+            decision: entry.decision,
+            costUsd: entryCost?.totalUsd ?? null,
+            costEstimated: entryCost?.estimated ?? false,
+            current: entry.id === row.id,
+        };
+    });
+    const chainCosts = versions.map((version) => version.costUsd).filter((value) => value !== null);
+    // Churn comparison uses the ORIGINAL generation's files as the scope baseline:
+    // a revision touching mostly new files is the honest signal that the spec no
+    // longer describes the work.
+    const originalFiles = chain.length > 1
+        ? new Set(churnForRuns(db, safeParse(chain[0].run_ids, [])).map((entry) => entry.file_path))
+        : new Set();
+    const driftNudges = computeDriftNudges({
+        versions,
+        originalFileSet: originalFiles,
+        currentFiles: new Set(churn.map((entry) => entry.file_path)),
+    });
+    return {
+        schemaVersion: 1,
+        prDeliveryId: row.id,
+        railIndex: row.rail_index,
+        variant,
+        decision: row.decision,
+        statusCode: row.status_code,
+        headlineCode: headlineFor(variant, succeededCount, ticketIds.length),
+        ticketIds,
+        baseBranch: row.base_branch,
+        loopName: row.loop_name,
+        prUrl: row.pr_url,
+        prNumber: row.pr_number,
+        succeededCount,
+        failedCount,
+        totalCount: units.length > 0 ? new Set(units.map((u) => u.ticketId)).size : ticketIds.length,
+        sections,
+        proof: buildProof(units, evidence?.units ?? null, churn, confidence),
+        watchOut: buildWatchOut(confidence, churn, variant),
+        confidence,
+        cost: { totalUsd: costSum?.totalUsd ?? null, estimated: costSum?.estimated ?? false },
+        evidenceUnavailable: evidence === null || evidence.harvest === 'failed',
+        runIds,
+        supersedesDeliveryId: row.supersedes_delivery_id,
+        revisionNote: row.revision_note,
+        versions,
+        chainCostUsd: chainCosts.length > 0 ? chainCosts.reduce((sum, value) => sum + value, 0) : null,
+        chainCostEstimated: versions.some((version) => version.costEstimated),
+        driftNudges,
+    };
+}
+/** Assert-by-construction guard used in tests and by the route: no packet field
+ * may carry a numeric verification claim without a structured source. */
+function packetHasUnsourcedNumericClaim(packet) {
+    return packet.proof.some((item) => item.tier === 'ai-reported'
+        && Object.keys(item.values ?? {}).some((key) => key === 'tests' || key === 'passed' || key === 'failedTests'));
+}
+function safeParse(raw, fallback) {
+    if (!raw)
+        return fallback;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}

package/server/dist/revision-seed.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEED_EVIDENCE_CAP = exports.SEED_DIFF_CAP = exports.SEED_SPEC_BODY_CAP = void 0;
+exports.buildRevisionSeed = buildRevisionSeed;
+/** Bounds keep the seed a briefing, not a transcript. */
+exports.SEED_SPEC_BODY_CAP = 4000;
+exports.SEED_DIFF_CAP = 4000;
+exports.SEED_EVIDENCE_CAP = 1200;
+function clamp(value, cap) {
+    const trimmed = value.trim();
+    return trimmed.length <= cap ? trimmed : `${trimmed.slice(0, cap)}\n…(truncated)`;
+}
+/** One-line digest of what the previous run's verification actually reported. */
+function evidenceLine(evidence) {
+    if (!evidence || evidence.units.length === 0)
+        return 'No verification evidence was captured for the previous run.';
+    const failed = evidence.units.filter((unit) => unit.sentinel === 'fail');
+    const passed = evidence.units.filter((unit) => unit.sentinel === 'pass');
+    const parts = [];
+    if (failed.length > 0) {
+        // Failure first: a revision briefing must not bury it behind a pass.
+        const detail = failed.map((unit) => unit.sentinelDetail).find(Boolean);
+        parts.push(`The previous run REPORTED FAILED verification${detail ? ` (${clamp(detail, 200)})` : ''}.`);
+    }
+    if (passed.length > 0)
+        parts.push('The previous run reported its verification passed.');
+    if (parts.length === 0)
+        parts.push('The previous run did not report a verification verdict.');
+    const score = evidence.units.map((unit) => unit.confidence?.overall).find((value) => typeof value === 'number');
+    if (typeof score === 'number')
+        parts.push(`Its reviewer scored the work ${score}/100.`);
+    return parts.join(' ');
+}
+/**
+ * The briefing a revision run is seeded with. Deterministic (same input ⇒ same
+ * text) so it is cache-friendly and testable, and honest: it never claims the
+ * previous run verified anything the evidence does not say.
+ */
+function buildRevisionSeed(input) {
+    const specs = (input.specSnapshot ?? []).length > 0
+        ? (input.specSnapshot ?? []).map((entry) => [
+            `### #${entry.ticketId} ${entry.title ?? '(untitled)'}`,
+            entry.description ? clamp(entry.description, exports.SEED_SPEC_BODY_CAP) : '(no description recorded)',
+        ].join('\n')).join('\n\n')
+        : input.ticketIds.map((id) => `### #${id}\n(spec text was not captured at launch)`).join('\n\n');
+    return [
+        '## Revision briefing',
+        '',
+        `This is revision ${input.revisionNumber} of work that has ALREADY been delivered for the spec(s) below.`,
+        'The code exists on the branch listed here. Do NOT start over, re-plan, or re-implement it.',
+        '',
+        '## What the user asked to change',
+        '',
+        clamp(input.note, exports.SEED_SPEC_BODY_CAP),
+        '',
+        '## The original request (frozen at launch)',
+        '',
+        specs,
+        '',
+        '## Where the existing work lives',
+        '',
+        input.branches.length > 0
+            ? `Branch(es): ${input.branches.join(', ')} (based on ${input.baseBranch}).`
+            : `Base branch: ${input.baseBranch}.`,
+        ...(input.branchDiffSummary
+            ? ['', 'Already changed on that branch:', '', clamp(input.branchDiffSummary, exports.SEED_DIFF_CAP)]
+            : []),
+        '',
+        '## What the previous run reported',
+        '',
+        clamp(evidenceLine(input.evidence), exports.SEED_EVIDENCE_CAP),
+    ].join('\n');
+}

package/server/dist/run-duration-stats.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_DURATION_SAMPLES = void 0;
+exports.percentileMs = percentileMs;
+exports.rangeFromSamples = rangeFromSamples;
+exports.getLoopDurationRange = getLoopDurationRange;
+exports.jobCommandShape = jobCommandShape;
+exports.getJobCommandDurationRange = getJobCommandDurationRange;
+/** Fewer settled runs than this and no band is returned. */
+exports.MIN_DURATION_SAMPLES = 5;
+/**
+ * Nearest-rank percentile over an ASCENDING sample. Deliberately not
+ * interpolated: an interpolated value is a number no run actually took, and
+ * every figure this module emits must be traceable to a real measurement.
+ */
+function percentileMs(sortedAsc, fraction) {
+    if (sortedAsc.length === 0)
+        return 0;
+    const rank = Math.ceil(fraction * sortedAsc.length);
+    const index = Math.min(sortedAsc.length - 1, Math.max(0, rank - 1));
+    return sortedAsc[index];
+}
+function rangeFromSamples(samplesMs) {
+    const usable = samplesMs.filter((ms) => Number.isFinite(ms) && ms > 0).sort((a, b) => a - b);
+    if (usable.length < exports.MIN_DURATION_SAMPLES)
+        return null;
+    return {
+        p25Ms: percentileMs(usable, 0.25),
+        medianMs: percentileMs(usable, 0.5),
+        p75Ms: percentileMs(usable, 0.75),
+        sampleCount: usable.length,
+    };
+}
+/** Cap the history window so a long-lived project's ancient runs (different
+ * codebase, different model) cannot skew the band a user is shown today. */
+const HISTORY_LIMIT = 50;
+/** Measured band for a loop id, or null below the sample floor. */
+function getLoopDurationRange(db, projectId, loopId) {
+    const rows = db.prepare(`
+    SELECT total_duration_ms AS ms
+      FROM loop_runs
+     WHERE project_id = ? AND loop_id = ? AND finished_at IS NOT NULL AND total_duration_ms > 0
+     ORDER BY started_at DESC
+     LIMIT ?
+  `).all(projectId, loopId, HISTORY_LIMIT);
+    return rangeFromSamples(rows.map((row) => row.ms));
+}
+/**
+ * Commands carry per-run arguments (`loop:<uuid>`, `/specrails:implement #12`),
+ * so history is grouped by a stable SHAPE rather than the literal string:
+ * the command's leading token with ticket refs and ids stripped.
+ */
+function jobCommandShape(command) {
+    const head = command.trim().split(/\s+/)[0] ?? '';
+    if (head.startsWith('loop:'))
+        return 'loop:';
+    return head;
+}
+/** Measured band for a job command shape, or null below the sample floor. */
+function getJobCommandDurationRange(db, commandShape) {
+    const rows = db.prepare(`
+    SELECT duration_ms AS ms, command
+      FROM jobs
+     WHERE status = 'completed' AND duration_ms > 0
+     ORDER BY started_at DESC
+     LIMIT 500
+  `).all();
+    return rangeFromSamples(rows.filter((row) => jobCommandShape(row.command ?? '') === commandShape)
+        .slice(0, HISTORY_LIMIT)
+        .map((row) => row.ms));
+}

package/server/dist/stuck-run-detector.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StuckRunDetector = exports.STUCK_SWEEP_INTERVAL_MS = exports.STUCK_FLOOR_MS = void 0;
+exports.resolveStuckThresholdMs = resolveStuckThresholdMs;
+exports.findStuckCandidates = findStuckCandidates;
+const loop_runs_store_1 = require("./loop-runs-store");
+/** Never notify sooner than this, however the threshold is configured. */
+exports.STUCK_FLOOR_MS = 10 * 60 * 1000;
+/** How often the sweep runs while the server is up. */
+exports.STUCK_SWEEP_INTERVAL_MS = 60 * 1000;
+/**
+ * `SPECRAILS_STUCK_THRESHOLD_MS` raises (never lowers) the floor; `0`/`false`/
+ * `off` disables detection entirely.
+ */
+function resolveStuckThresholdMs(env = process.env) {
+    const raw = env.SPECRAILS_STUCK_THRESHOLD_MS;
+    if (raw === undefined || raw === '')
+        return exports.STUCK_FLOOR_MS;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === '0' || normalized === 'false' || normalized === 'off')
+        return null;
+    const parsed = Number(normalized);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return exports.STUCK_FLOOR_MS;
+    return Math.max(exports.STUCK_FLOOR_MS, Math.trunc(parsed));
+}
+function lastActivityMs(payload) {
+    const candidates = [payload.lastActivityAtMs, payload.activeTurnStartedAtMs]
+        .filter((value) => Number.isFinite(value) && value > 0);
+    return candidates.length > 0 ? Math.max(...candidates) : null;
+}
+function defaultIsRunActive(db, runId) {
+    const row = db.prepare(`SELECT status FROM loop_runs WHERE id = ?`).get(runId);
+    return row?.status === 'running';
+}
+/**
+ * One pass over the persisted step checkpoints. Pure with respect to the
+ * database (reads only) so the caller owns broadcasting and episode memory.
+ */
+function findStuckCandidates(io) {
+    const threshold = io.thresholdMs === undefined ? resolveStuckThresholdMs() : io.thresholdMs;
+    if (threshold === null)
+        return [];
+    const now = io.now?.() ?? Date.now();
+    const isRunActive = io.isRunActive ?? ((runId) => defaultIsRunActive(io.db, runId));
+    const out = [];
+    let rows;
+    try {
+        rows = (0, loop_runs_store_1.listLoopStepRecoveries)(io.db);
+    }
+    catch {
+        return [];
+    }
+    for (const row of rows) {
+        let payload;
+        try {
+            payload = JSON.parse(row.payload);
+        }
+        catch {
+            continue;
+        }
+        const last = lastActivityMs(payload);
+        if (last === null)
+            continue;
+        const staleMs = now - last;
+        if (staleMs < threshold)
+            continue;
+        try {
+            if (!isRunActive(row.run_id))
+                continue;
+        }
+        catch {
+            continue;
+        }
+        out.push({
+            runId: row.run_id,
+            stepKey: row.step_key,
+            projectId: payload.projectId,
+            staleMs,
+            episode: `${row.run_id}:${row.step_key}:${last}`,
+        });
+    }
+    return out;
+}
+/**
+ * Owns episode memory across sweeps and emits at most one message per stall.
+ * Constructed per project context so the broadcast is already project-scoped.
+ */
+class StuckRunDetector {
+    projectId;
+    io;
+    broadcast;
+    notified = new Set();
+    timer = null;
+    constructor(projectId, io, broadcast) {
+        this.projectId = projectId;
+        this.io = io;
+        this.broadcast = broadcast;
+    }
+    /** One sweep; returns the messages actually emitted (for tests/diagnostics). */
+    sweep() {
+        const candidates = findStuckCandidates(this.io);
+        const live = new Set(candidates.map((candidate) => candidate.episode));
+        // Forget episodes that ended so a later stall of the same step re-notifies.
+        for (const episode of [...this.notified]) {
+            if (!live.has(episode))
+                this.notified.delete(episode);
+        }
+        const emitted = [];
+        for (const candidate of candidates) {
+            if (this.notified.has(candidate.episode))
+                continue;
+            this.notified.add(candidate.episode);
+            const message = {
+                type: 'job.stuck',
+                projectId: this.projectId,
+                jobId: candidate.runId,
+                stepKey: candidate.stepKey,
+                staleMs: candidate.staleMs,
+                timestamp: new Date(this.io.now?.() ?? Date.now()).toISOString(),
+            };
+            try {
+                this.broadcast(message);
+                emitted.push(message);
+            }
+            catch {
+                // A failed broadcast must not wedge the sweep; the next pass retries
+                // because the episode is only remembered after a successful send.
+                this.notified.delete(candidate.episode);
+            }
+        }
+        return emitted;
+    }
+    start(intervalMs = exports.STUCK_SWEEP_INTERVAL_MS) {
+        if (this.timer)
+            return;
+        if ((this.io.thresholdMs === undefined ? resolveStuckThresholdMs() : this.io.thresholdMs) === null)
+            return;
+        this.timer = setInterval(() => {
+            try {
+                this.sweep();
+            }
+            catch { /* never let a sweep crash the server */ }
+        }, intervalMs);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+}
+exports.StuckRunDetector = StuckRunDetector;

package/server/dist/telemetry-receiver.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.awaitTelemetryAppendQuiescence = awaitTelemetryAppendQuiescence;
 exports.dropBlobState = dropBlobState;
 exports.dropBlobStatesForProject = dropBlobStatesForProject;
 exports.createTelemetryRouter = createTelemetryRouter;
@@ -35,6 +36,27 @@ function getBlobState(key) {
 function blobKey(projectId, jobId) {
     return `${projectId}:${jobId}`;
 }
+/**
+ * Await full append-queue quiescence (every blob: idle writer + empty queue).
+ * Test seam: the ingest handler ACKs 200 while queued gzip appends are still
+ * in flight; a suite that removes the telemetry dir in afterEach races them —
+ * the orphaned append then console.errors DURING vitest environment teardown
+ * ("Closing rpc while onUserConsoleLog was pending", flaked in CI 2026-07-27).
+ * Bounded so a wedged writer can never hang a suite.
+ */
+async function awaitTelemetryAppendQuiescence(maxWaitMs = 2000) {
+    const deadline = Date.now() + maxWaitMs;
+    const busy = () => {
+        for (const state of _blobState.values()) {
+            if (state.writing || state.queue.length > 0)
+                return true;
+        }
+        return false;
+    };
+    while (busy() && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+}
 /** Evict the in-memory BlobState for one job (bounds the per-(project,job) leak —
  *  the map otherwise grew for the whole process lifetime). */
 function dropBlobState(projectId, jobId) {

package/client/dist/assets/ActivityFeedPage-B4yaoZsD.js

@@ -1 +0,0 @@
-import{a as e}from"./rolldown-runtime-CNC7AqOf.js";import{n as t,t as n}from"./jsx-runtime-zu2_FqZY.js";import{o as r}from"./i18n-nJQvD5zJ.js";import{n as i,t as a}from"./createLucideIcon-Bjbbp_KS.js";import{t as o}from"./circle-x-CMYsN4ZH.js";import{t as s}from"./loader-circle-DcygOQpC.js";import{t as c}from"./zap-CHo3aCD1.js";import{r as l}from"./useSharedWebSocket-DK96ctb7.js";import{t as u}from"./api-B2M7CtDw.js";import{r as d}from"./useDesktop-B6Du2N83.js";import{Dt as f,Pt as p}from"./index-DdC_faQv.js";var m=a(`ban`,[[`circle`,{cx:`12`,cy:`12`,r:`10`,key:`1mglay`}],[`path`,{d:`M4.929 4.929 19.07 19.071`,key:`196cmz`}]]),h=e(t(),1);function g(e){let t=new Set;return e.filter(e=>{let n=`${e.type}:${e.jobId}`;return t.has(n)?!1:(t.add(n),!0)})}function _({activeProjectId:e,limit:t=50}){let[n,i]=(0,h.useState)([]),[a,o]=(0,h.useState)(!1),[s,c]=(0,h.useState)(!0),d=(0,h.useRef)(e);(0,h.useEffect)(()=>{d.current=e},[e]);let{registerHandler:f,unregisterHandler:p}=l();(0,h.useEffect)(()=>{if(!e){i([]),c(!0);return}let n=!1;o(!0),i([]),c(!0);async function r(){let e=u();try{let r=await fetch(`${e}/activity?limit=${t}`);if(!r.ok||n)return;let a=await r.json();if(n)return;i(a),c(a.length===t)}catch{}finally{n||o(!1)}}return r(),()=>{n=!0}},[e,t]);let m=(0,h.useCallback)(async()=>{if(a||!s)return;o(!0);let e=u(),n=d.current;try{i(r=>{let a=r[r.length-1];if(!a)return r;let s=encodeURIComponent(a.timestamp);return fetch(`${e}/activity?limit=${t}&before=${s}`).then(e=>e.json()).then(e=>{if(d.current!==n){o(!1);return}i(t=>g([...t,...e])),c(e.length===t),o(!1)}).catch(()=>o(!1)),r})}catch{o(!1)}},[a,s,t]),_=(0,h.useCallback)(e=>{let t=e,n=d.current;if(!(!t||typeof t.type!=`string`)&&!(t.projectId&&t.projectId!==n)){if(t.type===`queue`&&Array.isArray(t.jobs)){let e=[];for(let n of t.jobs){let t=n.status===`completed`?`job_completed`:n.status===`failed`?`job_failed`:n.status===`canceled`?`job_canceled`:`job_started`;e.push({id:`${t}:${n.id}`,type:t,jobId:n.id,jobCommand:n.command??``,timestamp:n.startedAt??new Date().toISOString(),summary:`${t.replace(`_`,` `)}: ${n.command??``}`,costUsd:null})}e.length>0&&i(t=>g([...e,...t]))}if(t.type===`phase`&&t.phase&&t.state&&t.timestamp){let e={id:`phase:${t.phase}:${t.state}:${t.timestamp}`,type:`job_started`,jobId:`phase-${t.phase}`,jobCommand:r.t(`activity:feed.phaseCommand`,{phase:t.phase,state:t.state}),timestamp:t.timestamp,summary:`Phase ${t.phase} is ${t.state}`,costUsd:null};i(t=>g([e,...t]))}}},[]);return(0,h.useLayoutEffect)(()=>(f(`activity`,_),()=>p(`activity`)),[_,f,p]),{items:n,loading:a,hasMore:s,loadMore:m}}var v=n();function y(e,t){let n=Date.now()-new Date(e).getTime(),r=Math.floor(n/1e3);if(r<60)return t(`feed.relativeTime.seconds`,{value:r});let i=Math.floor(r/60);if(i<60)return t(`feed.relativeTime.minutes`,{value:i});let a=Math.floor(i/60);return a<24?t(`feed.relativeTime.hours`,{value:a}):t(`feed.relativeTime.days`,{value:Math.floor(a/24)})}function b({type:e}){switch(e){case`job_completed`:return(0,v.jsx)(f,{className:`w-4 h-4 text-green-500 aurora-light:text-accent-success flex-shrink-0`});case`job_failed`:return(0,v.jsx)(o,{className:`w-4 h-4 text-red-500 aurora-light:text-destructive flex-shrink-0`});case`job_canceled`:return(0,v.jsx)(m,{className:`w-4 h-4 text-muted-foreground flex-shrink-0`});default:return(0,v.jsx)(c,{className:`w-4 h-4 text-blue-500 aurora-light:text-accent-info flex-shrink-0`})}}function x(e,t){switch(e){case`job_completed`:return t(`common:status.completed`);case`job_failed`:return t(`common:status.failed`);case`job_canceled`:return t(`common:status.canceled`);default:return t(`feed.typeStarted`)}}function S(e){switch(e){case`job_completed`:return`text-green-500 aurora-light:text-accent-success`;case`job_failed`:return`text-red-500 aurora-light:text-destructive`;case`job_canceled`:return`text-muted-foreground`;default:return`text-blue-500 aurora-light:text-accent-info`}}function C(){let{t:e}=i(`activity`),{activeProjectId:t}=d(),{items:n,loading:r,hasMore:a,loadMore:o}=_({activeProjectId:t}),c=(0,h.useRef)(null);return(0,h.useEffect)(()=>{let e=c.current;if(!e)return;let t=new IntersectionObserver(e=>{e[0].isIntersecting&&a&&!r&&o()},{threshold:.1});return t.observe(e),()=>t.disconnect()},[a,r,o]),(0,v.jsxs)(`div`,{className:`flex flex-col h-full overflow-hidden`,children:[(0,v.jsxs)(`div`,{className:`flex items-center gap-2 px-4 py-3 border-b border-border bg-background/50`,children:[(0,v.jsx)(p,{className:`w-4 h-4 text-muted-foreground`}),(0,v.jsx)(`h1`,{className:`text-sm font-medium`,children:e(`feed.title`)})]}),(0,v.jsxs)(`div`,{className:`flex-1 overflow-y-auto`,children:[r&&n.length===0?(0,v.jsx)(`div`,{className:`flex items-center justify-center h-32`,children:(0,v.jsx)(s,{className:`w-4 h-4 animate-spin text-muted-foreground`})}):n.length===0?(0,v.jsxs)(`div`,{className:`flex flex-col items-center justify-center h-48 gap-2 text-muted-foreground`,children:[(0,v.jsx)(p,{className:`w-8 h-8 opacity-40`}),(0,v.jsx)(`p`,{className:`text-sm`,children:e(`feed.emptyTitle`)}),(0,v.jsx)(`p`,{className:`text-xs opacity-70`,children:e(`feed.emptyHint`)})]}):(0,v.jsx)(`ul`,{className:`divide-y divide-border/50`,children:n.map(t=>(0,v.jsxs)(`li`,{className:`flex items-center gap-3 px-4 py-2.5 hover:bg-accent/30 transition-colors`,children:[(0,v.jsx)(b,{type:t.type}),(0,v.jsxs)(`div`,{className:`flex-1 min-w-0`,children:[(0,v.jsx)(`p`,{className:`text-xs text-foreground truncate`,title:t.jobCommand,children:t.jobCommand}),(0,v.jsxs)(`div`,{className:`flex items-center gap-2 mt-0.5`,children:[(0,v.jsx)(`span`,{className:`text-xs font-medium ${S(t.type)}`,children:x(t.type,e)}),t.costUsd!=null&&(0,v.jsxs)(`span`,{className:`text-xs text-muted-foreground`,children:[`$`,t.costUsd.toFixed(4)]})]})]}),(0,v.jsx)(`span`,{className:`text-xs text-muted-foreground flex-shrink-0 tabular-nums`,children:y(t.timestamp,e)})]},`${t.type}:${t.jobId}`))}),(0,v.jsx)(`div`,{ref:c,className:`h-1`}),r&&n.length>0&&(0,v.jsx)(`div`,{className:`flex justify-center py-3`,children:(0,v.jsx)(s,{className:`w-4 h-4 animate-spin text-muted-foreground`})}),!a&&n.length>0&&(0,v.jsx)(`p`,{className:`text-center text-xs text-muted-foreground py-3`,children:e(`feed.allLoaded`)})]})]})}export{C as default};