@lcv-ideas-software/cross-review 4.2.4 → 4.3.0

package/dist/scripts/smoke.js

@@ -1096,6 +1096,345 @@ assert.equal(Object.hasOwn(metrics.decision_quality, "undefined"), false);
     assert.equal(entry?.chronic_blockers?.[0], "ask-codex-1", "chronic_blockers must contain the codex round_count=4 item id");
     console.log("[smoke] evidence_checklist_drilldown_test: PASS");
 }
+// v4.2.5 — terminal events, cost split and not_resurfaced audit visibility.
+// The 2026-06-05 disk audit found sessions whose meta.json had a terminal
+// outcome without a matching terminal event, cost reports that blurred peer
+// calls with lead-generation artifacts, and converged sessions with
+// not_resurfaced checklist items that were too easy to misread as satisfied.
+{
+    const { SessionStore } = await import("../src/core/session-store.js");
+    const { sessionReportMarkdown } = await import("../src/core/reports.js");
+    const auditStore = new SessionStore({
+        ...config,
+        data_dir: smokeTmpDir("terminal-cost-evidence-audit"),
+    });
+    const finalizedSession = await auditStore.init("terminal event fixture", "operator", []);
+    await auditStore.finalize(finalizedSession.session_id, "aborted", "smoke_terminal_abort");
+    const finalizedEvents = auditStore.readEvents(finalizedSession.session_id);
+    assert.ok(finalizedEvents.some((event) => event.type === "session.finalized" &&
+        event.data?.outcome === "aborted" &&
+        event.data?.reason === "smoke_terminal_abort"), "v4.2.5 / terminal_events: finalize() must persist a session.finalized event");
+    const cancelledSession = await auditStore.init("cancelled terminal event fixture", "operator", []);
+    await auditStore.markCancelled(cancelledSession.session_id, "session_cancelled");
+    const cancelledEvents = auditStore.readEvents(cancelledSession.session_id);
+    assert.ok(cancelledEvents.some((event) => event.type === "session.cancelled" && event.data?.reason === "session_cancelled"), "v4.2.5 / terminal_events: markCancelled() must persist a session.cancelled event");
+    const sweptSession = await auditStore.init("idle sweep terminal event fixture", "operator", []);
+    const sweptMeta = auditStore.read(sweptSession.session_id);
+    sweptMeta.updated_at = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString();
+    fs.writeFileSync(auditStore.metaPath(sweptSession.session_id), JSON.stringify(sweptMeta));
+    const swept = await auditStore.sweepIdle(0, "aborted", "smoke_idle_sweep");
+    assert.equal(swept.some((session) => session.session_id === sweptSession.session_id), true, "v4.2.5 / terminal_events: sweepIdle() must finalize stale sessions");
+    const sweptEvents = auditStore.readEvents(sweptSession.session_id);
+    assert.ok(sweptEvents.some((event) => event.type === "session.finalized" &&
+        event.data?.outcome === "aborted" &&
+        event.data?.reason === "smoke_idle_sweep" &&
+        typeof event.data?.idle_ms === "number"), "v4.2.5 / terminal_events: sweepIdle() must persist a session.finalized event");
+    const reportSession = await auditStore.init("cost split report fixture", "operator", []);
+    const reportMeta = auditStore.read(reportSession.session_id);
+    const nowIso = new Date().toISOString();
+    reportMeta.rounds = [
+        {
+            round: 1,
+            started_at: nowIso,
+            completed_at: nowIso,
+            caller_status: "READY",
+            prompt_file: "agent-runs/round-1-prompt.md",
+            peers: [
+                {
+                    peer: "codex",
+                    provider: "openai",
+                    model: "gpt-5",
+                    status: "READY",
+                    structured: { status: "READY", summary: "ready", confidence: "verified" },
+                    text: '{"status":"READY","summary":"ready","confidence":"verified"}',
+                    raw: { fixture: true },
+                    decision_quality: "clean",
+                    parser_warnings: [],
+                    attempts: 1,
+                    latency_ms: 10,
+                    usage: { input_tokens: 10, output_tokens: 5, total_tokens: 15 },
+                    cost: {
+                        currency: "USD",
+                        estimated: false,
+                        source: "configured-rate",
+                        total_cost: 14.652426,
+                    },
+                },
+            ],
+            rejected: [],
+            convergence: {
+                converged: true,
+                reason: "unanimous",
+                ready_peers: ["codex"],
+                not_ready_peers: [],
+                needs_evidence_peers: [],
+                rejected_peers: [],
+                skipped_peers: [],
+                decision_quality: {
+                    codex: "clean",
+                    claude: "clean",
+                    gemini: "clean",
+                    deepseek: "clean",
+                    grok: "clean",
+                    perplexity: "clean",
+                },
+                blocking_details: [],
+            },
+        },
+    ];
+    reportMeta.generation_files = [
+        {
+            round: 0,
+            peer: "gemini",
+            label: "initial_draft",
+            path: "agent-runs/round-0-initial-draft.md",
+            ts: nowIso,
+            usage: { input_tokens: 6, output_tokens: 4, total_tokens: 10 },
+            cost: {
+                currency: "USD",
+                estimated: false,
+                source: "configured-rate",
+                total_cost: 1.876718,
+            },
+        },
+    ];
+    reportMeta.totals.cost = {
+        currency: "USD",
+        estimated: false,
+        source: "configured-rate",
+        total_cost: 16.529144,
+    };
+    fs.writeFileSync(auditStore.metaPath(reportSession.session_id), JSON.stringify(reportMeta));
+    const reportMarkdown = sessionReportMarkdown(auditStore.read(reportSession.session_id), []);
+    assert.ok(reportMarkdown.includes("- Peer call cost: $14.652426 USD"), "v4.2.5 / cost_split: session report must show peer-call cost separately");
+    assert.ok(reportMarkdown.includes("- Generation cost: $1.876718 USD"), "v4.2.5 / cost_split: session report must show lead-generation cost separately");
+    assert.ok(reportMarkdown.includes("$16.529144 USD = $14.652426 peer + $1.876718 generation"), "v4.2.5 / cost_split: session report must explicitly reconcile total = peer + generation");
+    const notResurfacedSession = await auditStore.init("not resurfaced visibility fixture", "operator", []);
+    const notResurfacedMeta = auditStore.read(notResurfacedSession.session_id);
+    notResurfacedMeta.evidence_checklist = [
+        {
+            id: "nr-1",
+            peer: "deepseek",
+            first_round: 1,
+            last_round: 1,
+            round_count: 1,
+            ask: "attach raw npm ci output",
+            first_seen_at: nowIso,
+            last_seen_at: nowIso,
+            status: "not_resurfaced",
+            addressed_at_round: 2,
+            address_method: "resurfacing",
+        },
+    ];
+    fs.writeFileSync(auditStore.metaPath(notResurfacedSession.session_id), JSON.stringify(notResurfacedMeta));
+    const legacyGapSession = await auditStore.init("legacy terminal event gap fixture", "operator", []);
+    const legacyGapMeta = auditStore.read(legacyGapSession.session_id);
+    legacyGapMeta.outcome = "aborted";
+    legacyGapMeta.outcome_reason = "legacy_without_terminal_event";
+    legacyGapMeta.updated_at = nowIso;
+    legacyGapMeta.convergence_health = {
+        state: "stale",
+        last_event_at: nowIso,
+        detail: "legacy_without_terminal_event",
+    };
+    fs.writeFileSync(auditStore.metaPath(legacyGapSession.session_id), JSON.stringify(legacyGapMeta));
+    const notResurfacedDoctor = await auditStore.sessionDoctor(20);
+    assert.equal(notResurfacedDoctor.totals.not_resurfaced_evidence_sessions, 1, "v4.2.5 / not_resurfaced: session_doctor totals must count not_resurfaced sessions separately");
+    assert.equal(notResurfacedDoctor.findings.not_resurfaced_evidence_sessions[0]?.session_id, notResurfacedSession.session_id, "v4.2.5 / not_resurfaced: session_doctor must enumerate not_resurfaced sessions");
+    assert.equal(notResurfacedDoctor.totals.terminal_event_missing_sessions, 1, "v4.2.5 / terminal_event_missing: session_doctor totals must count legacy terminal-event gaps");
+    assert.equal(notResurfacedDoctor.findings.terminal_event_missing_sessions[0]?.session_id, legacyGapSession.session_id, "v4.2.5 / terminal_event_missing: session_doctor must enumerate legacy terminal-event gaps");
+    assert.equal(notResurfacedDoctor.findings.terminal_event_missing_sessions[0]?.terminal_event_expected, "session.finalized", "v4.2.5 / terminal_event_missing: session_doctor must report the expected terminal event");
+    const notResurfacedReport = sessionReportMarkdown(auditStore.read(notResurfacedSession.session_id), []);
+    assert.ok(notResurfacedReport.includes("not_resurfaced means the ask was not repeated; it is not proof that evidence was satisfied."), "v4.2.5 / not_resurfaced: session report must state the not_resurfaced semantics");
+    console.log("[smoke] terminal_cost_evidence_audit_test: PASS");
+}
+// v4.3.0 / P1: unanimous READY with unresolved evidence must not look like a
+// plain unanimous_ready close-out. `not_resurfaced` is inference-only: it may
+// allow convergence, but the final metadata/report must keep that disposition
+// visible for operators.
+{
+    const { sessionReportMarkdown } = await import("../src/core/reports.js");
+    const unresolvedEvents = [];
+    const unresolvedConfig = {
+        ...loadConfig(),
+        data_dir: smokeTmpDir("unresolved-evidence-finalize"),
+        budget: {
+            ...loadConfig().budget,
+            max_session_cost_usd: 10000,
+            preflight_max_round_cost_usd: 10000,
+            until_stopped_max_cost_usd: 10000,
+        },
+        evidence_judge_autowire: {
+            ...loadConfig().evidence_judge_autowire,
+            mode: "off",
+            active: false,
+        },
+    };
+    const unresolvedOrch = new CrossReviewOrchestrator(unresolvedConfig, (event) => unresolvedEvents.push(event.type));
+    const unresolvedR1 = await unresolvedOrch.askPeers({
+        task: "P1 unresolved evidence finalization guard fixture.",
+        draft: "FORCE_NEEDS_EVIDENCE",
+        caller: "operator",
+        peers: ["claude"],
+    });
+    const unresolvedR2 = await unresolvedOrch.askPeers({
+        session_id: unresolvedR1.session.session_id,
+        task: "P1 unresolved evidence finalization guard fixture.",
+        draft: "Clean revised draft, no test marker present.",
+        caller: "operator",
+        peers: ["claude"],
+    });
+    assert.equal(unresolvedR2.converged, true);
+    assert.equal(unresolvedR2.session.outcome, "converged");
+    assert.equal(unresolvedR2.session.outcome_reason, "unanimous_ready_with_unresolved_evidence", "v4.3.0 / P1: convergence with not_resurfaced evidence must not finalize as plain unanimous_ready");
+    assert.ok(unresolvedEvents.includes("session.evidence_checklist_unresolved_on_finalize"), "v4.3.0 / P1: unresolved evidence close-out must emit an audit event");
+    const unresolvedReport = sessionReportMarkdown(unresolvedOrch.store.read(unresolvedR2.session.session_id), unresolvedOrch.store.readEvents(unresolvedR2.session.session_id));
+    assert.ok(unresolvedReport.includes("## Unresolved Evidence Disposition"), "v4.3.0 / P1: session_report must include unresolved-evidence disposition table");
+    assert.ok(unresolvedReport.includes("not_resurfaced"), "v4.3.0 / P1: session_report must name not_resurfaced unresolved items");
+    console.log("[smoke] unresolved_evidence_finalization_guard_test: PASS");
+}
+// v4.3.0 / P3: read-only peer reliability telemetry. This is deliberately
+// observational; it must not change peer selection or mutate sessions.
+{
+    const { SessionStore } = await import("../src/core/session-store.js");
+    const reliabilityStore = new SessionStore({
+        ...config,
+        data_dir: smokeTmpDir("peer-reliability"),
+    });
+    const reliabilitySession = await reliabilityStore.init("peer reliability report fixture", "operator", []);
+    const reliabilityMeta = reliabilityStore.read(reliabilitySession.session_id);
+    const ts = new Date().toISOString();
+    reliabilityMeta.rounds = [
+        {
+            round: 1,
+            started_at: ts,
+            completed_at: ts,
+            caller_status: "READY",
+            prompt_file: "agent-runs/round-1-prompt.md",
+            peers: [
+                {
+                    peer: "claude",
+                    provider: "anthropic",
+                    model: "claude-opus-4-8",
+                    status: "NEEDS_EVIDENCE",
+                    structured: {
+                        status: "NEEDS_EVIDENCE",
+                        summary: "needs log",
+                        confidence: "verified",
+                        evidence_sources: ["src/core/session-store.ts:1"],
+                        caller_requests: ["attach raw npm test output"],
+                        follow_ups: [],
+                    },
+                    text: "{}",
+                    raw: { fixture: true },
+                    decision_quality: "clean",
+                    parser_warnings: [],
+                    attempts: 1,
+                    latency_ms: 50,
+                    usage: { input_tokens: 10, output_tokens: 5, total_tokens: 15 },
+                    cost: { currency: "USD", estimated: false, source: "configured-rate", total_cost: 1 },
+                },
+                {
+                    peer: "grok",
+                    provider: "xai",
+                    model: "grok-4.3",
+                    status: "READY",
+                    structured: {
+                        status: "READY",
+                        summary: "ready",
+                        confidence: "verified",
+                        evidence_sources: ["server_info: version 4.2.5"],
+                        caller_requests: [],
+                        follow_ups: [],
+                    },
+                    text: "{}",
+                    raw: { fixture: true },
+                    decision_quality: "format_warning",
+                    parser_warnings: ["verified_without_concrete_evidence_sources"],
+                    attempts: 1,
+                    latency_ms: 100,
+                    usage: { input_tokens: 20, output_tokens: 10, total_tokens: 30 },
+                    cost: { currency: "USD", estimated: false, source: "configured-rate", total_cost: 2 },
+                },
+            ],
+            rejected: [
+                {
+                    peer: "perplexity",
+                    provider: "perplexity",
+                    model: "sonar-reasoning-pro",
+                    failure_class: "provider_error",
+                    message: "fixture provider error",
+                    retryable: false,
+                    attempts: 1,
+                    latency_ms: 0,
+                },
+            ],
+            convergence: {
+                converged: false,
+                reason: "fixture",
+                ready_peers: ["grok"],
+                not_ready_peers: [],
+                needs_evidence_peers: ["claude"],
+                rejected_peers: ["perplexity"],
+                skipped_peers: [],
+                decision_quality: {
+                    codex: "clean",
+                    claude: "clean",
+                    gemini: "clean",
+                    deepseek: "clean",
+                    grok: "format_warning",
+                    perplexity: "failed",
+                },
+                blocking_details: ["claude:NEEDS_EVIDENCE", "perplexity:provider_error"],
+            },
+        },
+    ];
+    reliabilityMeta.evidence_checklist = [
+        {
+            id: "rel-1",
+            peer: "claude",
+            first_round: 1,
+            last_round: 1,
+            round_count: 1,
+            ask: "attach raw npm test output",
+            first_seen_at: ts,
+            last_seen_at: ts,
+            status: "not_resurfaced",
+            addressed_at_round: 2,
+            address_method: "resurfacing",
+        },
+    ];
+    fs.writeFileSync(reliabilityStore.metaPath(reliabilitySession.session_id), JSON.stringify(reliabilityMeta));
+    await reliabilityStore.appendEvent({
+        ts,
+        type: "session.lead_meta_audit_fabrication_detected",
+        session_id: reliabilitySession.session_id,
+        message: "fixture fabrication event",
+        data: { peer: "grok" },
+    });
+    const reliability = reliabilityStore.peerReliabilityReport();
+    assert.equal(reliability.scope, "all");
+    assert.equal(reliability.by_peer.claude?.needs_evidence, 1);
+    assert.equal(reliability.by_peer.claude?.not_resurfaced_asks, 1);
+    assert.equal(reliability.by_peer.grok?.ready, 1);
+    assert.equal(reliability.by_peer.grok?.parser_warnings_total, 1);
+    assert.equal(reliability.by_peer.grok?.fabrication_events, 1);
+    assert.equal(reliability.by_peer.perplexity?.provider_errors, 1);
+    console.log("[smoke] peer_reliability_report_test: PASS");
+}
+// v4.3.0 / P2: offline declarative eval harness. This pins the existence of a
+// no-provider-call fixture runner so regressions found in real sessions can be
+// replayed without growing the ad hoc smoke body indefinitely.
+{
+    const pkg = JSON.parse(fs.readFileSync("package.json", "utf8"));
+    assert.equal(pkg.scripts?.["eval:fixtures"], "tsx scripts/eval-fixtures.ts", "v4.3.0 / P2: package.json must expose the offline fixture eval runner");
+    const evalHarness = fs.readFileSync("scripts/eval-fixtures.ts", "utf8");
+    assert.ok(/truthfulnessCases/.test(evalHarness) &&
+        /parserCases/.test(evalHarness) &&
+        /reportCases/.test(evalHarness), "v4.3.0 / P2: eval-fixtures must use declarative truthfulness/parser/report case tables");
+    assert.ok(!/askPeers\(|runUntilUnanimous\(|session_start_round/.test(evalHarness), "v4.3.0 / P2: eval-fixtures must stay offline and avoid provider-review entry points");
+    console.log("[smoke] offline_fixture_eval_contract_test: PASS");
+}
 // v2.22.0 (B.P3): session.budget_warning event emit + idempotency. The
 // orchestrator emits a one-shot warning when cumulative cost crosses
 // 75% of cost_ceiling_usd; the budget_warning_emitted flag persists
@@ -5264,6 +5603,16 @@ assert.equal(Object.hasOwn(metrics.decision_quality, "undefined"), false);
         narrativeCorpus: "",
     });
     assert.equal(genericConfirmation.fabricated, false, "v4.2.2 / truthfulness_guardrails: generic 'confirmed' prose without a dispatch/authorization claim must not trip fabrication detection");
+    const fabricatedReviewReferences = detectFabricatedEvidence([
+        "R2 evidence confirms sessions 604dcecc-df8d-483c-b598-733b8cbb64b0 and 37929ed7-3b71-454c-8231-5e1657ad17af.",
+        "The external comparison used https://github.com/qhjqhj00/GossipCat and https://github.com/alibaba/mira.",
+    ].join("\n"), {
+        provenanceCorpus: "",
+        priorDraftCorpus: "The prior artifact did not contain session IDs or GitHub repository URLs.",
+        narrativeCorpus: "Audit cross-review improvements.",
+    });
+    assert.ok(fabricatedReviewReferences.fabricated === true &&
+        fabricatedReviewReferences.suspicious_assertion_count >= 2, `v4.2.5 / fabrication_lock: net-new session IDs and GitHub URLs in relator text must trip fabricated=true (got count=${fabricatedReviewReferences.suspicious_assertion_count}, fabricated=${fabricatedReviewReferences.fabricated})`);
     // Source-level: threshold constants pinned at the documented values.
     assert.ok(/FABRICATED_NET_NEW_HEX_THRESHOLD\s*=\s*3/.test(orchSrc), "v2.24.0 / fabrication_lock: net-new hex threshold pinned at 3");
     assert.ok(/FABRICATED_SUSPICIOUS_ASSERTION_THRESHOLD\s*=\s*2/.test(orchSrc), "v2.24.0 / fabrication_lock: suspicious assertion threshold pinned at 2");