tickmarkr 2.6.6 → 2.6.8

package/dist/gates/review.js

@@ -5,7 +5,7 @@ import { criticalPathHits, DEFAULT_DIFF_CAP, DEFAULT_REVIEW_CRITICAL_PATHS, decl
 import { filesGlob } from "../graph/files-glob.js";
 import { renderAcceptanceItem, TIERS } from "../graph/schema.js";
 import { getAdapter } from "../adapters/registry.js";
-import { shOk } from "../run/git.js";
+import { shGitOk } from "../run/git.js";
 import { carryReviewFindings, isDeferredFinding, observedReviewFingerprints, reviewFingerprintMatches, structuredFindings, UNIDENTIFIED } from "../run/journal.js";
 import { redactSecrets } from "../run/redact.js";
 import { rankPreferredChannels, reviewPreferenceTieBreak } from "../route/role-pick.js";
@@ -81,7 +81,7 @@ const DIFF_CAP_REMEDY = "split the task, or raise gates.diffCap";
  * the leaf class must be visible to the promotion test, and rename detection would hide the old side.
  */
 export async function changedPaths(worktree, baseRef) {
-    const out = await shOk(`git diff --name-only --no-renames -z '${baseRef}..HEAD'`, worktree);
+    const out = await shGitOk(`git diff --name-only --no-renames -z '${baseRef}..HEAD'`, worktree);
     return [...new Set(out.split("\0").map((p) => p.trim()).filter(Boolean))].sort();
 }
 /**
@@ -95,7 +95,7 @@ const VERSION_FIELD_LINE_RE = /^[+-]\s*"version":\s*"[^"]*",?\s*$/;
 export async function mirrorsVersionOnly(worktree, baseRef, path) {
     let diff;
     try {
-        diff = await shOk(`git diff --full-index -U0 '${baseRef}..HEAD' -- ${shq(path)}`, worktree);
+        diff = await shGitOk(`git diff --full-index -U0 '${baseRef}..HEAD' -- ${shq(path)}`, worktree);
     }
     catch {
         return false;
@@ -109,8 +109,8 @@ export async function fetchTaskDiff(worktree, baseRef, files = []) {
     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),
+        shGitOk(`git diff --full-index '${baseRef}..HEAD'${pathspec}`, worktree),
+        shGitOk(`git diff --full-index -U0 '${baseRef}..HEAD'${pathspec}`, worktree),
     ]);
     const fullMeasurement = measureArtifactDiff(rawFull);
     const capMeasurement = measureArtifactDiff(rawForCap);
@@ -324,6 +324,52 @@ export function renderDeclaredWriteScope(files) {
 The task DECLARED these write-scope patterns:
 ${files.map((path) => `- ${path}`).join("\n")}`;
 }
+// v2.6.8 T7: syntax only, never a filesystem glob. Explicit alternatives are finite at any count.
+// ponytail: no expansion ceiling; the operator authors files[], so its product of alternatives is theirs to size.
+const TEST_FILE_RE = /(?:^|\/)[^/]*\.(?:test|spec)\.[cm]?[jt]sx?$/;
+/** Every finite, explicit `{a,b}` alternative of one entry, deduplicated; null when any part is not finite. */
+function expandFiniteBraces(pattern) {
+    const open = pattern.indexOf("{");
+    if (open < 0)
+        return pattern.includes("}") ? null : [pattern];
+    if (pattern.slice(0, open).includes("}"))
+        return null;
+    const cuts = [open];
+    let depth = 0;
+    for (let i = open; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === "{")
+            depth++;
+        else if (c === "," && depth === 1)
+            cuts.push(i);
+        else if (c === "}" && --depth === 0) {
+            if (cuts.length < 2)
+                return null; // `{}`, `{a}`, `{1..3}`: no finite alternation
+            cuts.push(i);
+            const out = new Set();
+            for (let k = 0; k + 1 < cuts.length; k++) {
+                const alt = pattern.slice(cuts[k] + 1, cuts[k + 1]);
+                const sub = alt ? expandFiniteBraces(pattern.slice(0, open) + alt + pattern.slice(i + 1)) : null;
+                if (!sub)
+                    return null;
+                for (const path of sub)
+                    out.add(path);
+            }
+            return [...out];
+        }
+    }
+    return null; // unclosed brace
+}
+/**
+ * The test files one files[] entry names explicitly. A wildcard, escape, malformed or empty brace, or
+ * a path leaving the repository anywhere in the expansion grants nothing for the whole entry.
+ */
+function explicitSuitePaths(entry) {
+    const paths = expandFiniteBraces(entry);
+    const explicit = paths?.every((path) => !/[*?[\]{}()!\\]/.test(path)
+        && path.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".."));
+    return explicit ? paths.filter((path) => TEST_FILE_RE.test(path)) : [];
+}
 /**
  * OBS-1033: the vendors of the seats that authored commits inside the accumulated diff. A seat is
  * never handed its own earlier work to approve. Unresolved channels are refused by reviewGate.
@@ -433,7 +479,10 @@ artifactDir, reviewHistory, demotedReviewers, carriedFindings = [],
 // never the run-wide rotation history nor excludeReviewers; the seat holds the highest of their tiers.
 priorReviewers = [], 
 // Closed list of actual subject authors; empty preserves legacy callers' single-author contract.
-carriedAuthors = [], operatorContext) {
+carriedAuthors = [], 
+// v2.6.8 T7: kept for compatible callers and read as empty. An approve reason is the repair worker's
+// standing instruction; a reviewer handed "the previous finding is resolved" graded the reason, not the diff.
+_operatorContext) {
     // R3 (OBS-186): participation is keyed on PATHS. The compiler's assignment comes from the DECLARED
     // files[]; the operator's floor may RAISE it to full and can never lower it. `complexityThreshold` is
     // retired — the branch that returned a green skip on a complexity comparison is gone, and with it the
@@ -529,12 +578,20 @@ carriedAuthors = [], operatorContext) {
         return capFail;
     const nonce = generateVerdictNonce();
     const repoRoot = daemonRepoRoot(worktree, artifactDir);
-    // OBS-880 add.1: guidance only. Do not expand scope globs into permission to run suites.
-    const ownTestFiles = [...new Set(task.files.filter((file) => !/[*?[\]{}()!]/.test(file) && /(?:^|\/)[^/]*\.(?:test|spec)\.[cm]?[jt]sx?$/.test(file)))];
+    // OBS-880 add.1: guidance only. Do not expand scope globs into permission to run suites; v2.6.8 T7:
+    // finite explicit brace alternatives are explicit files and each one is named.
+    const ownTestFiles = [...new Set(task.files.flatMap(explicitSuitePaths))];
     const suiteBudget = ownTestFiles.length
         ? `You may run at most the task's own test files explicitly named in files[]; these are the only suites you may run: ${ownTestFiles.map((file) => `\`${file}\``).join(", ")}.`
         : "No suite may be run: files[] names no explicit test file owned by this task.";
     const responseRequirement = reviewResponseRequirement(nonce);
+    // D-966 (T3 E): a reviewer that stopped at the first example of a class drip-fed it one round at a
+    // time — T5's rounds carried 2→1→1→1→2→1 findings and T10's 3→2→1→1→1, each round's repair fixing
+    // the case it was shown while its same-class siblings waited for the next review. The closed note
+    // tuple asks for every counterexample ACTUALLY FOUND in scope at once, plus the boundary searched and
+    // what stays uncertain, so the repair sees the class and the next round knows what was covered. It
+    // rides the existing note text (details → repair brief unchanged) and never asks for an exhaustive
+    // search the reviewer cannot honestly make; uncertainty alone stays out of the material bar.
     const prompt = `TICKMARKR-REVIEW
 ${responseRequirement}
 
@@ -555,10 +612,6 @@ ${suiteBudget} Never run the whole suite (including an unfiltered npm test or vi
 
 ${priorMaterials.length ? `${renderPriorMaterials(priorMaterials)}
 
-` : ""}${operatorContext?.trim() ? `## Operator context
-Context only: this never substitutes for an acceptance criterion or closes a prior material.
-${operatorContext.trim()}
-
 ` : ""}${task.outOfScope?.length ? `## Out of scope
 The task declares these items out of scope. A finding inside these declared bounds is not material and must not block approval.
 ${task.outOfScope.map((item) => `- ${item}`).join("\n")}
@@ -580,6 +633,14 @@ acceptance criterion it violates (or to the regression this diff introduces), st
 and marks its evidence executed (you ran the reproducer), static (you traced it by reading) or blocked (it
 could not run here). Blocked evidence never turns a finding into a pass, and a worker's own case table or
 enumeration never resolves a finding: judge the diff itself.
+Report the whole class in this one review, never only its first example. Each material finding's "note" is one
+line carrying the closed tuple "rule: <the goal clause, criterion or regressed behaviour violated> | found:
+<every counterexample you ACTUALLY FOUND inside the declared scope, each as path:line input → consequence,
+joined by "; "> | searched: <the boundary you actually searched: files, symbols, call sites> | uncertain:
+<what lies outside that boundary or could not be established inside it>". Found one counterexample, list one;
+found several, list every one in the same finding. Never list a case you did not find. Your search is bounded:
+never claim it covered every input, caller or path beyond the boundary you name, and remaining uncertainty
+alone is never a material finding — record it under uncertain, or as a deferred minor with its rationale.
 
 Respond with ONLY this JSON:
 {"nonce": "${nonce}", "approve": true|false, "resolved": [], "reraised": [], "findings": [{"note": "...", "severity": "material"|"minor", "defer": false, "rationale": ""}], "comments": [{"path": "path/to/file", "line": 42, "body": "actionable feedback", "finding": 1}]}
@@ -668,7 +729,10 @@ ${responseRequirement}
     // a genuinely wrapped verdict behind it is reconstructed here, exactly as llm.ts would have.
     const echoFree = withoutExampleEcho(raw, nonce);
     const seat = via ? dewrapPaneVerdict(echoFree, nonce) : echoFree;
-    const v = extractVerdictJson(seat, nonce);
+    const parsed = extractVerdictJson(seat, nonce);
+    // v2.6.8 T7: with zero carried ids nothing was asked to close, so volunteered closure ids are ignored —
+    // a material red stays red, never no-verdict. With carried ids the closure protocol binds unchanged.
+    const v = parsed && !priorMaterials.length ? { ...parsed, resolved: undefined, reraised: undefined } : parsed;
     const findings = v && Array.isArray(v.findings) ? v.findings : null;
     const priorIds = priorMaterials;
     const closureInvalid = isReviewClosureInvalid(v, priorIds);

package/dist/gates/run-gates.d.ts

@@ -73,6 +73,9 @@ export interface GateContext {
     excludeReviewers?: string[];
     demotedReviewers?: Set<string>;
     reviewNoVerdicts?: Map<string, string[]>;
+    /** v2.6.8 T1: review seats whose one same-seat launch retry this candidate already spent (the daemon
+     * replays them from the journal), so a resume or recheck never re-grants it by forgetting. */
+    launchRetried?: readonly string[];
     recheck?: boolean;
     /** Explicit worker funding requires fresh red measurements, never a gate waiver. OBS-1106: so does
      * a retry that landed nothing on a timeout-class red — its one fresh re-observation. C: and one whose
@@ -98,14 +101,26 @@ export interface GateContext {
  * a command that already has `--` takes them directly. Every path is quoted — config flows into a shell.
  */
 export declare function testCommandForFiles(testCmd: string, files: string[]): string;
-/** OBS-635: a screen costing at least this share of the full suite runs the full suite instead. */
-export declare const SCREEN_PROMOTION_RATIO = 0.75;
+/** v2.6.7 T1 (closed order table): an attributed test-red diagnostic is admitted only when BOTH hold. */
+export declare const DIAGNOSTIC_MAX_RATIO = 0.15;
+export declare const DIAGNOSTIC_MAX_ESTIMATE_MS = 60000;
+export interface DiagnosticAdmission {
+    admitted: boolean;
+    reason: "diagnostic-admitted" | "diagnostic-unknown-cost" | "diagnostic-capacity-mismatch" | "diagnostic-cost-ratio" | "diagnostic-cost-estimate";
+    costRatio?: number;
+    estimatedMs?: number;
+}
 /**
- * The screen's share of the full suite's cost, from the per-file durations the harness measured at
- * baseline capture — never a worker's timing. Undefined (unknown) unless every selected file has a
- * measured duration and the measured total is positive; unknown keeps the conservative screen path.
+ * The diagnostic's admission evidence, from the per-file durations the harness measured at baseline
+ * capture — never a worker's timing. Unknown (any selected file unmeasured, any measurement that is not a
+ * finite number > 0 ms, an infra baseline, or no positive total) skips: an expensive or unknown screen must
+ * never become a full suite before semantics.
+ * So does timing recorded under a malformed or different capacity (git.ts sameCapacity): it divided the
+ * machine by another number, so it is not comparable evidence about this one.
+ * `estimatedMs` is the serial sum of those files: admission evidence, not a kill ceiling and not a
+ * claim about the parallel-plus-serial wall time the runner will actually take.
  */
-export declare function screenCostRatio(baseline: Baseline, selected: readonly string[]): number | undefined;
+export declare function diagnosticAdmission(baseline: Baseline, selected: readonly string[]): DiagnosticAdmission;
 /** A retry base no runner invocation parses. evaluateManifestedTest builds its stranded single-fork
  * retry from the base it is handed, and one it cannot parse throws before any spawn — so this base
  * disables that inner recovery: a worker-RPC-stranded re-observation comes back infra (the caller