tickmarkr 2.2.1 → 2.3.0

package/dist/gates/review.js

@@ -2,12 +2,13 @@ import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { channelKey, shq } from "../adapters/types.js";
 import { criticalPathHits, DEFAULT_DIFF_CAP, DEFAULT_REVIEW_CRITICAL_PATHS, declaredReviewPolicy, isReviewLeafPath, raiseReviewPolicy, REVIEW_VERSION_MIRRORS, TIER_RANK, } from "../config/config.js";
+import { filesGlob } from "../graph/files-glob.js";
 import { renderAcceptanceItem } from "../graph/schema.js";
 import { getAdapter } from "../adapters/registry.js";
 import { shOk } from "../run/git.js";
 import { redactSecrets } from "../run/redact.js";
 import { marginalCostRank } from "../route/router.js";
-import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlm, verdictNonceLine } from "./llm.js";
+import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlmDetailed, verdictNonceLine } from "./llm.js";
 import { classifyVerdictCause } from "./verdict-cause.js";
 import { captureDiffCapFor, measureArtifactDiff, reviewableLogicDiff, } from "./artifact-manifest.js";
 export { isProtectedEvidence, PROTECTED_EVIDENCE_PREFIXES, REGENERABLE_CAPTURE_PATHS, setAsideReceiptPath, setAsideRegenerableCaptures, } from "./artifact-manifest.js";
@@ -99,12 +100,14 @@ export async function mirrorsVersionOnly(worktree, baseRef, path) {
     const changed = diff.split("\n").filter((l) => /^[+-]/.test(l) && !/^(?:\+\+\+|---)/.test(l));
     return changed.length > 0 && changed.every((l) => VERSION_FIELD_LINE_RE.test(l));
 }
-export async function fetchTaskDiff(worktree, baseRef) {
+export async function fetchTaskDiff(worktree, baseRef, files = []) {
     // --full-index: abbreviated index lines vary with object-store density, so two measurements of
     // the same diff could disagree by a few bytes between invocations (CI-only red, release 1.89.0).
-    const [rawFull, rawForCap] = await Promise.all([
-        shOk(`git diff --full-index '${baseRef}..HEAD'`, worktree),
-        shOk(`git diff --full-index -U0 '${baseRef}..HEAD'`, worktree),
+    const matched = files.length ? (await changedPaths(worktree, baseRef)).filter(filesGlob([...files])) : [];
+    const pathspec = matched.length ? ` -- ${matched.map(shq).join(" ")}` : "";
+    const [rawFull, rawForCap] = files.length && matched.length === 0 ? ["", ""] : await Promise.all([
+        shOk(`git diff --full-index '${baseRef}..HEAD'${pathspec}`, worktree),
+        shOk(`git diff --full-index -U0 '${baseRef}..HEAD'${pathspec}`, worktree),
     ]);
     const fullMeasurement = measureArtifactDiff(rawFull);
     const capMeasurement = measureArtifactDiff(rawForCap);
@@ -162,6 +165,24 @@ export function diffCapParkReason(results) {
 export function modelId(model) {
     return model.slice(model.lastIndexOf("/") + 1);
 }
+/** Provider identity comes from the served model, not a gateway adapter's stamped vendor. */
+export function modelProvider(model, fallback = "unknown") {
+    const id = model.toLowerCase();
+    const prefix = id.includes("/") ? id.slice(0, id.indexOf("/")) : "";
+    if (prefix === "openai" || prefix === "openai-codex" || /^(?:gpt|o\d)/.test(id))
+        return "openai";
+    if (prefix === "anthropic" || /^(?:claude|opus|sonnet|haiku|fable)(?:-|$)/.test(id))
+        return "anthropic";
+    if (prefix === "google" || /^gemini(?:-|$)/.test(id))
+        return "google";
+    if (prefix === "xai" || /^grok(?:-|$)/.test(id))
+        return "xai";
+    if (["zai", "zhipu", "zai-coding-plan"].includes(prefix) || /^glm(?:-|$)/.test(id))
+        return "zhipu";
+    if (["kimi-code", "moonshot"].includes(prefix) || /^kimi(?:-|$)/.test(id))
+        return "moonshot";
+    return fallback;
+}
 // v1.53 T2: same entry grammar as routing.map.prefer (router.ts preferIndex — router is out of this
 // module's dependency direction for a private fn, so the 3 lines live here too): `adapter` matches
 // every channel of that adapter, `adapter:model` exactly one; unmatched channels sort after all entries.
@@ -179,11 +200,14 @@ floor) {
     const authorChannel = channels.find((c) => c.adapter === author.adapter && c.model === author.model);
     if (!authorChannel)
         return null;
+    // Failover also guards true provider; the initial pick keeps the established stamped-vendor contract.
+    const authorProvider = modelProvider(author.model, authorChannel.vendor);
     return (channels
         // two independent axes: different vendor AND different base-model identity (ADDED TO the vendor
         // rule, never replacing it — a future edit can't silently drop either). The diversity filter runs
         // BEFORE preference ranking: prefer sorts survivors only, so no entry can resurrect an excluded channel.
         .filter((c) => c.vendor !== authorChannel.vendor
+        && (exclude.length === 0 || modelProvider(c.model, c.vendor) !== authorProvider)
         && modelId(c.model) !== modelId(author.model)
         && !exclude.includes(channelKey(c))
         && (floor === undefined || TIER_RANK[c.tier] >= TIER_RANK[floor]))
@@ -285,10 +309,10 @@ artifactDir) {
             ? `no cross-vendor reviewer available at or above task-declared ${reviewerFloor} floor (diversity rule)`
             : "no cross-vendor reviewer available (diversity rule)";
         return cfg.review.required
-            ? { gate: "review", pass: false, details: `${reason}; set review.required:false to waive`, meta: { noEligibleReviewer: true, ...(reviewerFloor ? { reviewerFloor } : {}) } }
+            ? { gate: "review", pass: false, details: `unreadable — ${reason}; set review.required:false to waive`, meta: { noEligibleReviewer: true, unreadable: true, ...(reviewerFloor ? { reviewerFloor } : {}) } }
             : { gate: "review", pass: true, details: `WARNING: ${reason} — review waived by config`, meta: { noEligibleReviewer: true, ...(reviewerFloor ? { reviewerFloor } : {}) } };
     }
-    const measuredDiff = await fetchTaskDiff(worktree, baseRef);
+    const measuredDiff = await fetchTaskDiff(worktree, baseRef, task.files);
     // Keep the reader payload identical to the text charged to the strict cap:
     // whole-file source deletions are represented by their citable operation fact.
     const diff = reviewableLogicDiff(measuredDiff.full);
@@ -327,7 +351,7 @@ Approve iff no material finding remains; an empty findings list is a clean appro
 The top-level comments array is optional. Use it only for actionable line-anchored feedback.
 `;
     let concludedOnInactivity = false;
-    const raw = await runLlm(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? {
+    const llm = await runLlmDetailed(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? {
         driver: via.driver,
         keep: via.keep,
         onSlot: via.onSlot,
@@ -341,13 +365,15 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     // (run-20260709-104447 P87-09). ponytail: literal 15min; make it cfg.review.timeoutMs if a
     // second knob-turner appears.
     900_000);
+    const raw = llm.output;
+    const provider = modelProvider(reviewer.model, reviewer.vendor);
     const v = extractVerdictJson(raw, nonce);
     const findings = v && Array.isArray(v.findings) ? v.findings : null;
     // findings decides the verdict on its own; the legacy path still needs approve + issues to parse.
     if (!v || (findings === null && (typeof v.approve !== "boolean" || !Array.isArray(v.issues)))) {
         // OBS-196: name the cause and persist the raw bytes — a ruled-on "unparseable" without its
         // evidence cannot be audited, and a cutoff must never be indistinguishable from a parse defect.
-        const cause = classifyVerdictCause(raw, nonce, "approve");
+        const cause = classifyVerdictCause(raw, nonce, "approve", llm);
         const bytes = Buffer.byteLength(raw, "utf8");
         let saved;
         if (artifactDir) {
@@ -367,10 +393,12 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         return {
             gate: "review",
             pass: false,
-            details: `${failure} (reviewer ${reviewer.adapter}:${reviewer.model}; cause: ${cause}${saved ? `; raw saved: ${saved}` : ""}) — failing closed`,
+            details: `${failure} (reviewer ${reviewer.adapter}:${reviewer.model}; vendor: ${reviewer.vendor}; provider: ${provider}; cause: ${cause}${saved ? `; raw saved: ${saved}` : ""}) — failing closed`,
             meta: {
                 ...policyMeta,
                 reviewer: channelKey(reviewer),
+                vendor: reviewer.vendor,
+                provider,
                 unparseable: true,
                 cause,
                 ...(cause === "empty-output" ? { bytes } : {}),
@@ -381,11 +409,11 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     const decided = findings !== null
         ? classifyReviewFindings(findings)
         : classifyReviewIssues(v.approve, v.issues);
-    const prose = `reviewer ${reviewer.adapter}:${reviewer.model} (${reviewer.vendor}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`;
+    const prose = `reviewer ${reviewer.adapter}:${reviewer.model} (vendor: ${reviewer.vendor}; provider: ${provider}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`;
     return {
         gate: "review",
         pass: decided.pass,
         details: appendAnchoredReview(prose, v),
-        meta: { ...policyMeta, reviewer: channelKey(reviewer) },
+        meta: { ...policyMeta, reviewer: channelKey(reviewer), vendor: reviewer.vendor, provider },
     };
 }

package/dist/gates/run-gates.js

@@ -11,7 +11,7 @@ import { evidenceGate } from "./evidence.js";
 import { captureLlmOutput } from "./llm.js";
 import { disallowedBy } from "../route/preference.js";
 import { marginalCostRank } from "../route/router.js";
-import { reviewGate } from "./review.js";
+import { pickReviewer, reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
 import { shGit } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
@@ -540,7 +540,7 @@ export async function runGates(task, ctx) {
                 .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y))[0];
             // v1.87 T2: the failover seat obeys the same policy the primary judge just passed — a denied
             // channel is refused here too, never reached by falling through the exclusion arms below.
-            const judgePool = (ctx.judgeChannels ?? ctx.channels).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
+            const judgePool = (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
             const crossAdapter = pick(judgePool.filter((c) => c.adapter !== flakedAdapter));
             const sameAdapter = pick(judgePool.filter((c) => c.adapter === flakedAdapter && channelKey(c) !== flakedKey));
             // Prefer a different adapter; if the fleet only has one adapter, retry on a different channel of
@@ -576,11 +576,9 @@ export async function runGates(task, ctx) {
             return captured.value;
         };
         let rv = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, ctx.via, ctx.excludeReviewers, ctx.artifactDir));
-        // OBS-193: an unparseable review verdict retries the REVIEW exactly once on a different reviewer —
-        // never the worker (GATE-09's judge-retry shape: straight-line single `if`, meta-only detection,
-        // the flaked verdict never enters results). The exclusion rides reviewGate's own excludeReviewers
-        // parameter, so pickReviewer's diversity rules still govern the retry seat; a fleet with no second
-        // eligible seat keeps the ORIGINAL result so the recorded cause stays truthful (OBS-196).
+        // OBS-193/574: an unparseable review verdict retries the REVIEW exactly once, preferring a
+        // different adapter. Only a single-adapter eligible pool may fall back to another channel on the
+        // flaked adapter. The flaked verdict never enters results; an exhausted pool preserves its cause.
         if (rv.meta?.unparseable === true && typeof rv.meta.reviewer === "string") {
             const flaked = rv.meta.reviewer;
             const emptyOutput = rv.meta.cause === "empty-output";
@@ -594,15 +592,24 @@ export async function runGates(task, ctx) {
             const retryVia = ctx.via
                 ? { ...ctx.via, nameFor: (role, adapter) => ctx.via.nameFor(role, adapter) + "-r1" }
                 : undefined;
-            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, [...(ctx.excludeReviewers ?? []), flaked], ctx.artifactDir));
+            const priorExclusions = ctx.excludeReviewers ?? [];
+            const flakedAdapter = flaked.slice(0, flaked.indexOf(":"));
+            const adapterExclusions = ctx.channels.filter((c) => c.adapter === flakedAdapter).map(channelKey);
+            const crossAdapter = pickReviewer(ctx.author, ctx.channels, [...priorExclusions, ...adapterExclusions], ctx.cfg.review.prefer ?? [], task.routingHints?.floor);
+            const exclusion = crossAdapter ? "adapter" : "channel";
+            const retryExclusions = [...priorExclusions, ...(crossAdapter ? adapterExclusions : [flaked])];
+            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, retryExclusions, ctx.artifactDir));
             if (second.meta?.noEligibleReviewer !== true) {
                 const retried = typeof second.meta?.reviewer === "string" ? second.meta.reviewer : "none";
+                const route = exclusion === "adapter"
+                    ? `different-adapter retry; excluded flaked adapter ${flakedAdapter}`
+                    : `same-adapter fallback; excluded flaked channel ${flaked}`;
                 rv = {
                     ...second,
                     // `details` is lifted onto the journal's gate-result row; meta.reviewRetry is not. Keep the
                     // re-route visible in the result text a reader actually opens, including on a red retry.
-                    details: `review re-route: ${flaked} produced ${emptyOutput ? "EMPTY output" : "no parseable verdict"}; replaced by ${retried}\n${second.details}`,
-                    meta: { ...second.meta, reviewRetry: { flaked, retried } },
+                    details: `review re-route (${route}): ${flaked} produced ${emptyOutput ? "EMPTY output" : "no parseable verdict"}; replaced by ${retried}\n${second.details}`,
+                    meta: { ...second.meta, reviewRetry: { flaked, retried, exclusion } },
                 };
             }
             else if (task.routingHints?.floor) {

package/dist/gates/verdict-cause.d.ts

@@ -1,4 +1,8 @@
 export type VerdictDiscriminator = "approve" | "pass" | "ok" | "action";
-export type VerdictUnparseableCause = "empty-output" | "no-verdict" | "malformed-verdict";
+export type VerdictUnparseableCause = "empty-output" | "no-verdict" | "malformed-verdict" | "timeout" | "startup-failure";
+export interface VerdictProcessFacts {
+    timedOut?: boolean;
+    exitCode?: number;
+}
 export declare function hasVerdictParticipationWitness(raw: string, nonce: string, discriminator: VerdictDiscriminator): boolean;
-export declare function classifyVerdictCause(raw: string, nonce: string, discriminator: VerdictDiscriminator): VerdictUnparseableCause;
+export declare function classifyVerdictCause(raw: string, nonce: string, discriminator: VerdictDiscriminator, process?: VerdictProcessFacts): VerdictUnparseableCause;

package/dist/gates/verdict-cause.js

@@ -54,10 +54,14 @@ export function hasVerdictParticipationWitness(raw, nonce, discriminator) {
     const discriminatorPattern = new RegExp(String.raw `"${discriminator}"\s*:\s*${valuePattern}\s*[,}]`);
     return objectPrefixes(raw).some((prefix) => noncePattern.test(prefix) && discriminatorPattern.test(prefix));
 }
-export function classifyVerdictCause(raw, nonce, discriminator) {
+export function classifyVerdictCause(raw, nonce, discriminator, process = {}) {
+    if (process.timedOut)
+        return "timeout";
     if (raw.trim().length === 0)
         return "empty-output";
-    return hasVerdictParticipationWitness(raw, nonce, discriminator)
-        ? "malformed-verdict"
-        : "no-verdict";
+    if (hasVerdictParticipationWitness(raw, nonce, discriminator))
+        return "malformed-verdict";
+    if (process.exitCode !== undefined && process.exitCode !== 0)
+        return "startup-failure";
+    return "no-verdict";
 }

package/dist/run/consult.js

@@ -147,6 +147,10 @@ opts = {}) {
             out = r.stdout + r.stderr;
         }
         else {
+            // Preserve the adapter contract for CLIs that cannot seed their TUI: supported adapters use
+            // the interactive form, while a declared null keeps the existing visible print fallback.
+            const command = adapter.interactiveCommand(promptFile, seatModel)
+                ?? adapter.headlessCommand(promptFile, seatModel);
             // T8: role-first pane name for fleet visibility (consult · T2); consultSeq stays on the dossier artifact only
             const slot = await driver.slot(cwd, gatePaneName("consult", d.taskId), {
                 label: `CONSULT ${d.taskId}`,
@@ -158,7 +162,7 @@ opts = {}) {
             writeFileSync(scriptPath, [
                 "export BASH_SILENCE_DEPRECATION_WARNING=1",
                 bannerShell(),
-                adapter.headlessCommand(promptFile, seatModel),
+                command,
                 gateExitTrailer(nonce),
             ].join("\n"));
             try {

package/dist/run/daemon.d.ts

@@ -102,6 +102,8 @@ export declare const gateSatisfied: (g: GateResult) => boolean;
  * A round is the gate-result span opened by each `gates` phase-start, per task.
  */
 export declare function decisiveReviewRounds(events: JournalEvent[]): JournalEvent[];
+export declare const SUITE_POLL_MS = 250;
+export declare const APPROVAL_POLL_MS = 250;
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
 export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;
@@ -141,6 +143,16 @@ export declare function verifyIntegrationTipCached(intWt: string, commands: Reco
     lastMergedTask?: string;
     baseline?: Baseline;
 }): Promise<boolean>;
+type SuitePidProbe = (pid: number) => number | undefined;
+/** Count full-suite roots in one process-table snapshot. The probes are arguments so the ownership
+ * rules remain testable on hosts that forbid process inspection; production supplies cwd and the
+ * inherited TICKMARKR_SUITE_PARENT marker from the process itself. */
+export declare function countLiveSuites(snapshot: string, repoRoot: string, daemonPid?: number, cwdForPid?: (pid: number) => string | undefined, suiteParentForPid?: SuitePidProbe): number;
+export declare const setLiveSuiteCountForTests: (probe: (repoRoot: string) => Promise<number>) => void;
+export declare const resetLiveSuiteCountForTests: () => void;
+/** Live full-suite roots attributable to this repository or this daemon. Ancestors are excluded so
+ * a daemon invoked by vitest does not wait on its own test harness forever. */
+export declare function liveSuiteCount(repoRoot: string): Promise<number>;
 /** Test seam — exercise the production observer's total read bound with a small real tree. */
 export declare function setObserveBudgetBytesForTests(bytes: number): void;
 export declare function resetObserveBudgetBytesForTests(): void;