specrails-desktop 2.36.0 → 2.42.2

package/server/dist/delivery-evidence.js

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIDENCE_RAW_CAP = exports.VERIFY_TAIL_CAP = void 0;
-exports.parseVerificationSentinel = parseVerificationSentinel;
+exports.CONFIDENCE_RAW_CAP = exports.VERIFY_TAIL_CAP = exports.parseVerificationSentinel = void 0;
 exports.extractVerifyStepText = extractVerifyStepText;
 exports.parseConfidenceScore = parseConfidenceScore;
 exports.harvestDeliveryEvidence = harvestDeliveryEvidence;
@@ -15,36 +14,30 @@ exports.readSettleEvidence = readSettleEvidence;
  * calls: the `VERIFICATION: PASS/FAIL` sentinel from the run's persisted
  * stream (the rail-merge-orchestrator regex precedent), a bounded tail of the
  * verify step's output, and the reviewer's `confidence-score.json` written
- * into the worktree's `openspec/changes/<name>/` (core ≥4.12 — previously read
- * by nothing). Harvest NEVER throws and never blocks settle: every missing or
+ * into either the worktree's `openspec/changes/<name>/` or the Codex reviewer
+ * agent-memory path. Harvest NEVER throws and never blocks settle: every missing or
  * malformed source degrades to an absent value on the evidence record, so the
  * packet can always state honestly what it does and does not know.
  */
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const loop_factory_1 = require("./loop-factory");
+const verification_sentinel_1 = require("./verification-sentinel");
+var verification_sentinel_2 = require("./verification-sentinel");
+Object.defineProperty(exports, "parseVerificationSentinel", { enumerable: true, get: function () { return verification_sentinel_2.parseVerificationSentinel; } });
 /** Bounded tail of the verify step's raw output persisted per unit. */
 exports.VERIFY_TAIL_CAP = 4096;
 /** Raw confidence-score.json payloads are capped before persistence. */
 exports.CONFIDENCE_RAW_CAP = 8192;
-/** Last sentinel wins: the verify prompt itself quotes the format, so earlier
- * mentions in assistant reasoning must not shadow the final verdict line. */
-const SENTINEL_RE = /VERIFICATION:\s*(PASS|FAIL)\b[ \t]*(?:[—:-][ \t]*)?([^\n]*)/gi;
-function parseVerificationSentinel(text) {
-    let verdict = 'absent';
-    let detail = null;
-    for (const match of text.matchAll(SENTINEL_RE)) {
-        verdict = match[1].toUpperCase() === 'PASS' ? 'pass' : 'fail';
-        const tail = (match[2] ?? '').trim();
-        detail = verdict === 'fail' && tail ? tail.slice(0, 512) : null;
-    }
-    return { verdict, detail };
-}
 function parseLoopStepPayload(payload) {
     try {
         const parsed = JSON.parse(payload);
         return {
             index: typeof parsed.index === 'number' ? parsed.index : null,
             nodeId: typeof parsed.nodeId === 'string' ? parsed.nodeId : null,
+            startedAtMs: typeof parsed.startedAtMs === 'number' && Number.isFinite(parsed.startedAtMs)
+                ? parsed.startedAtMs
+                : null,
         };
     }
     catch {
@@ -55,8 +48,18 @@ function parseLoopStepPayload(payload) {
  * hold the raw provider JSONL line; log rows hold plain text. Everything else
  * contributes nothing (structured/loop events are boundaries, not output). */
 function eventText(event) {
-    if (event.event_type === 'log')
+    if (event.event_type === 'log') {
+        // LoopRunManager persists the visible transcript as { line }, including
+        // Codex/Gemini output. Decode it before matching line-based verdicts and
+        // collecting the review excerpt; legacy plain-text rows still work.
+        try {
+            const value = JSON.parse(event.payload);
+            if (value && typeof value.line === 'string')
+                return value.line;
+        }
+        catch { /* legacy plain-text log */ }
         return event.payload;
+    }
     if (event.event_type !== 'assistant')
         return '';
     try {
@@ -83,6 +86,8 @@ function extractVerifyStepText(events) {
     let start = -1;
     let end = events.length;
     let stepIndex = null;
+    let startedAtMs = null;
+    let status = null;
     for (let i = 0; i < events.length; i++) {
         const event = events[i];
         if (event.event_type === 'loop_step') {
@@ -91,6 +96,11 @@ function extractVerifyStepText(events) {
                 start = i;
                 stepIndex = step.index;
                 end = events.length;
+                // Legacy DB timestamps are second-precision SQLite text with no timezone.
+                // They cannot prove artifact ordering within that second, so freshness
+                // deliberately requires the high-resolution boundary in the payload.
+                startedAtMs = step.startedAtMs;
+                status = null;
             }
             else if (start >= 0 && i > start) {
                 // A later non-verify step closes the previous verify range unless a
@@ -102,11 +112,17 @@ function extractVerifyStepText(events) {
         else if (start >= 0 && end === events.length && event.event_type === 'loop_step_end' &&
             stepIndex !== null && parseLoopStepPayload(event.payload)?.index === stepIndex) {
             end = i;
+            try {
+                const payload = JSON.parse(event.payload);
+                if (payload.status === 'ok' || payload.status === 'failed')
+                    status = payload.status;
+            }
+            catch { /* missing/malformed completion is not successful evidence */ }
         }
     }
     const range = start >= 0 ? events.slice(start, end) : events;
     const text = range.map(eventText).filter(Boolean).join('\n');
-    return { text, scoped: start >= 0 };
+    return { text, scoped: start >= 0, startedAtMs, status };
 }
 function toNumberRecord(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -134,42 +150,120 @@ function parseConfidenceScore(rawJson, changeName) {
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
         return null;
     const obj = parsed;
+    // The DOCUMENTED schema says `overall`/`flags`; the reviewer Codex actually
+    // installs writes `overall_score`/`issues[].note`. Accept both additively
+    // rather than pick a winner — an unread score reads as "no reviewer score",
+    // which is the one thing the packet must never say when one exists.
+    const overall = [obj.overall, obj.overall_score].find((candidate) => typeof candidate === 'number' && Number.isFinite(candidate));
+    const explicitFlags = Array.isArray(obj.flags)
+        ? obj.flags.filter((flag) => typeof flag === 'string')
+        : [];
+    const issueFlags = Array.isArray(obj.issues)
+        ? obj.issues.flatMap((issue) => {
+            if (!issue || typeof issue !== 'object' || Array.isArray(issue))
+                return [];
+            const note = issue.note;
+            return typeof note === 'string' && note.trim() ? [note.trim().slice(0, 512)] : [];
+        })
+        : [];
     return {
         changeName,
-        overall: typeof obj.overall === 'number' && Number.isFinite(obj.overall) ? obj.overall : null,
+        overall: typeof overall === 'number' ? overall : null,
         aspects: toNumberRecord(obj.aspects ?? obj.scores),
-        flags: Array.isArray(obj.flags) ? obj.flags.filter((f) => typeof f === 'string').slice(0, 20) : [],
+        flags: [...new Set([...explicitFlags, ...issueFlags])].slice(0, 20),
         raw: rawJson.length > exports.CONFIDENCE_RAW_CAP ? null : parsed,
     };
 }
-/** Newest confidence-score.json under `<worktree>/openspec/changes/<name>/`.
- * A worktree hosts at most a handful of change dirs; when several carry a
- * score (unusual), the lexicographically last dir wins deterministically. */
-function readConfidenceFromWorktree(worktreePath, io) {
+function listOpenSpecScoreCandidates(worktreePath, io) {
     const changesDir = path_1.default.join(worktreePath, 'openspec', 'changes');
     let dirs;
     try {
         dirs = io.listDir(changesDir);
     }
+    catch {
+        return [];
+    }
+    return [...dirs].sort().map((dir) => ({
+        filePath: path_1.default.join(changesDir, dir, 'confidence-score.json'),
+        changeName: dir,
+    }));
+}
+/** The reviewer's OTHER landing site. The filename contract is exact on purpose:
+ *  a looser match would let another ticket's review — or an unrelated memory
+ *  file — be presented as this delivery's score. */
+function listAgentMemoryScoreCandidates(worktreePath, ticketId, io) {
+    const explanationsDir = path_1.default.join(worktreePath, '.specrails', 'agent-memory', 'explanations');
+    let files;
+    try {
+        files = io.listDir(explanationsDir);
+    }
+    catch {
+        return [];
+    }
+    const exactName = new RegExp(`^\\d{4}-\\d{2}-\\d{2}-reviewer-ticket-${ticketId}\\.confidence-score\\.json$`);
+    return files
+        .filter((file) => exactName.test(file))
+        .sort()
+        .map((file) => ({ filePath: path_1.default.join(explanationsDir, file), changeName: null }));
+}
+function readCandidate(candidate, io) {
+    try {
+        if (!io.fileExists(candidate.filePath))
+            return null;
+        return parseConfidenceScore(io.readFile(candidate.filePath), candidate.changeName);
+    }
     catch {
         return null;
     }
+}
+/** Newest confidence-score.json under `<worktree>/openspec/changes/<name>/`.
+ * A worktree hosts at most a handful of change dirs; when several carry a
+ * score (unusual), the lexicographically last dir wins deterministically.
+ *
+ * `revision` switches on the strict gate: a Revision's reviewer evidence is
+ * accepted ONLY when the artifact was written during the LATEST read-only verify
+ * epoch. Without it, a fix followed by a reviewer that failed to write anything
+ * would silently re-present the previous candidate's clean score as this one's. */
+function readConfidenceFromWorktree(worktreePath, io, revision) {
+    const openSpecCandidates = listOpenSpecScoreCandidates(worktreePath, io);
+    if (!revision) {
+        let found = null;
+        for (const candidate of openSpecCandidates) {
+            const parsed = readCandidate(candidate, io);
+            if (parsed)
+                found = parsed;
+        }
+        return found;
+    }
+    // Fail closed: no high-resolution boundary ⇒ freshness is unprovable ⇒ no score.
+    if (revision.verifyStartedAtMs === null)
+        return null;
+    const candidates = [
+        ...openSpecCandidates,
+        ...listAgentMemoryScoreCandidates(worktreePath, revision.ticketId, io),
+    ];
     let found = null;
-    for (const dir of [...dirs].sort()) {
-        const scorePath = path_1.default.join(changesDir, dir, 'confidence-score.json');
+    for (const candidate of candidates) {
         try {
-            if (!io.fileExists(scorePath))
+            if (!io.fileExists(candidate.filePath))
                 continue;
-            const raw = io.readFile(scorePath);
-            const parsed = parseConfidenceScore(raw, dir);
-            if (parsed)
-                found = parsed;
+            const mtimeMs = io.fileMtimeMs(candidate.filePath);
+            if (!Number.isFinite(mtimeMs) || mtimeMs < revision.verifyStartedAtMs)
+                continue;
+            const score = parseConfidenceScore(io.readFile(candidate.filePath), candidate.changeName);
+            if (!score)
+                continue;
+            if (found === null ||
+                mtimeMs > found.mtimeMs ||
+                (mtimeMs === found.mtimeMs && candidate.filePath > found.filePath)) {
+                found = { score, mtimeMs, filePath: candidate.filePath };
+            }
         }
         catch {
-            /* unreadable file = absent, not fatal */
+            /* unreadable freshness/content = unavailable, never stale */
         }
     }
-    return found;
+    return found?.score ?? null;
 }
 /**
  * Harvest evidence for every unit of a settling delivery. Never throws; the
@@ -180,7 +274,8 @@ function harvestDeliveryEvidence(io, units) {
     const readFile = io.readFile ?? ((p) => fs_1.default.readFileSync(p, 'utf8'));
     const listDir = io.listDir ?? ((p) => fs_1.default.readdirSync(p));
     const fileExists = io.fileExists ?? ((p) => fs_1.default.existsSync(p));
-    const fsIo = { readFile, listDir, fileExists };
+    const fileMtimeMs = io.fileMtimeMs ?? ((p) => fs_1.default.statSync(p).mtimeMs);
+    const fsIo = { readFile, listDir, fileExists, fileMtimeMs };
     let errored = 0;
     const harvested = units.map((unit) => {
         const evidence = {
@@ -192,13 +287,19 @@ function harvestDeliveryEvidence(io, units) {
             confidence: null,
         };
         let unitErrored = false;
+        let verifyStartedAtMs = null;
         try {
             if (unit.runId) {
                 const events = io.readEvents(unit.runId);
-                const { text } = extractVerifyStepText(events);
+                const { text, startedAtMs, scoped, status } = extractVerifyStepText(events);
+                verifyStartedAtMs = startedAtMs;
                 if (text) {
-                    const sentinel = parseVerificationSentinel(text);
-                    evidence.sentinel = sentinel.verdict;
+                    const sentinel = (0, verification_sentinel_1.parseVerificationSentinel)(text);
+                    // A PASS printed before a crash/cancel is not a completed
+                    // verification. Keep its raw excerpt but never advertise it as green.
+                    evidence.sentinel = sentinel.verdict === 'pass' && scoped && status !== 'ok'
+                        ? 'absent'
+                        : sentinel.verdict;
                     evidence.sentinelDetail = sentinel.detail;
                     evidence.verifyTail = text.slice(-exports.VERIFY_TAIL_CAP);
                 }
@@ -209,7 +310,9 @@ function harvestDeliveryEvidence(io, units) {
         }
         try {
             if (unit.worktreePath) {
-                evidence.confidence = readConfidenceFromWorktree(unit.worktreePath, fsIo);
+                evidence.confidence = readConfidenceFromWorktree(unit.worktreePath, fsIo, unit.loopId === loop_factory_1.FACTORY_REVISION_LOOP_ID
+                    ? { ticketId: unit.ticketId, verifyStartedAtMs }
+                    : undefined);
             }
         }
         catch {