tickmarkr 1.97.0 → 2.1.0

package/dist/gates/scope.js

@@ -1,3 +1,4 @@
+import { classifyScopeOffenders } from "../compile/collateral.js";
 import { filesGlob } from "../graph/files-glob.js";
 import { shGitOk } from "../run/git.js";
 // OBS-61: the live integration tip can advance between attempts (sibling merge) while a resumed
@@ -22,7 +23,12 @@ export function dispositionOffenders(offenders, allowDeviations) {
     }
     return { hard, allowed };
 }
-export async function scopeGate(worktree, integrationTip, files, result, allowDeviations = []) {
+/**
+ * OBS-547: `collateral` is this task's slice of the run's ONE full prediction map (computed at run
+ * start, uncapped — src/compile/collateral.ts). Absent ⇒ no classification, today's behaviour; the
+ * gate never computes a map of its own, so what it classifies on is always what the run predicted.
+ */
+export async function scopeGate(worktree, integrationTip, files, result, allowDeviations = [], collateral) {
     if (!files.length)
         return { gate: "scope", pass: true, details: "no file scope declared — unrestricted" };
     const baseRef = await scopeDiffBase(worktree, integrationTip);
@@ -38,5 +44,19 @@ export async function scopeGate(worktree, integrationTip, files, result, allowDe
     if (!hard.length) {
         return { gate: "scope", pass: true, details: `out-of-scope but operator-allowlisted:\n${allowed.join("\n")}${note}` };
     }
-    return { gate: "scope", pass: false, details: `out-of-scope edits not covered by scope.allowDeviations:\n${hard.join("\n")}${note}` };
+    // OBS-547: cross-reference at the red — the red supplies the paths, the prediction the classification.
+    const verdict = collateral
+        ? classifyScopeOffenders(collateral.taskId, hard, collateral.predicted)
+        : undefined;
+    const classification = verdict?.authoring
+        ? `\nauthoring defect (OBS-547): the collateral lint named every one of these paths before dispatch. Repair:\n${verdict.repair}`
+        : verdict && verdict.missed.length
+            ? `\ncollateral lint did not predict: ${verdict.missed.join(", ")}`
+            : "";
+    return {
+        gate: "scope",
+        pass: false,
+        details: `out-of-scope edits not covered by scope.allowDeviations:\n${hard.join("\n")}${note}${classification}`,
+        ...(verdict ? { meta: { collateral: verdict } } : {}),
+    };
 }

package/dist/graph/graph.d.ts

@@ -2,6 +2,7 @@ import { type RunGraph, type Task, type TaskStatus } from "./schema.js";
 export declare function stateDirName(_repoRoot: string): string;
 export declare function graphPath(repoRoot: string): string;
 export declare function graphDefinitionHash(g: RunGraph): string;
+export declare function taskContentDigest(task: Pick<Task, "goal" | "files" | "acceptance">): string;
 export declare function tickmarkrDir(repoRoot: string): string;
 export declare function loadGraph(repoRoot: string): RunGraph;
 export declare function saveGraph(repoRoot: string, g: RunGraph): void;

package/dist/graph/graph.js

@@ -19,6 +19,16 @@ export function graphDefinitionHash(g) {
     const definitions = g.tasks.map(({ status: _status, evidence: _evidence, ...def }) => def);
     return createHash("sha256").update(JSON.stringify({ version: g.version, spec: g.spec, tasks: definitions })).digest("hex").slice(0, 16);
 }
+// OBS-543: cross-run evidence belongs to the artifact one task describes, not to the whole compiled
+// graph. A sibling task, dependency, routing hint or status change therefore cannot expire a useful
+// finding; changing the goal, write surface or acceptance contract does. Keep the full digest here:
+// unlike graphDefinitionHash this value is persisted beside evidence and is the fail-closed join a
+// later run uses, so there is no benefit in making collision diagnosis less explicit.
+export function taskContentDigest(task) {
+    return createHash("sha256")
+        .update(JSON.stringify({ goal: task.goal, files: task.files, acceptance: task.acceptance }))
+        .digest("hex");
+}
 export function tickmarkrDir(repoRoot) {
     const dir = join(repoRoot, stateDirName(repoRoot));
     mkdirSync(dir, { recursive: true });
@@ -59,7 +69,14 @@ export function setStatus(g, id, status) {
     return { ...g, tasks: g.tasks.map((t) => (t.id === id ? { ...t, status } : t)) };
 }
 export function addEvidence(g, id, patch) {
-    getTask(g, id);
+    const subject = getTask(g, id);
+    const digest = taskContentDigest(subject);
+    // This is the graph-evidence boundary where a gate result meets the task it measured. Stamp a
+    // copy, never mutate the gate result runGates returned: callers still use that live object for
+    // predicates, while durable evidence gains the content identity a later run can compare.
+    const gateResults = (patch.gateResults ?? []).map((result) => result !== null && typeof result === "object" && !Array.isArray(result)
+        ? { ...result, taskContentDigest: digest }
+        : result);
     return {
         ...g,
         tasks: g.tasks.map((t) => t.id === id
@@ -68,7 +85,7 @@ export function addEvidence(g, id, patch) {
                 evidence: {
                     commits: [...t.evidence.commits, ...(patch.commits ?? [])],
                     artifacts: [...t.evidence.artifacts, ...(patch.artifacts ?? [])],
-                    gateResults: [...t.evidence.gateResults, ...(patch.gateResults ?? [])],
+                    gateResults: [...t.evidence.gateResults, ...gateResults],
                 },
             }
             : t),

package/dist/report/compare.js

@@ -21,7 +21,21 @@ export function recordedEnvironment(events) {
                 return undefined;
             adapterVersions[k] = v;
         }
-        return { tickmarkrVersion: o.tickmarkrVersion, configHash: o.configHash, adapterVersions };
+        // Capacity arrived in v2.0 as a pair. Two absent fields are an honest older record; one without
+        // the other is a malformed new record and fails closed instead of being compared as legacy.
+        const hasCores = Object.hasOwn(o, "cores");
+        const hasForkCap = Object.hasOwn(o, "forkCap");
+        if (hasCores !== hasForkCap)
+            return undefined;
+        if (hasCores && (typeof o.cores !== "number" || !Number.isFinite(o.cores) || o.cores <= 0
+            || typeof o.forkCap !== "number" || !Number.isFinite(o.forkCap) || o.forkCap <= 0))
+            return undefined;
+        return {
+            tickmarkrVersion: o.tickmarkrVersion,
+            configHash: o.configHash,
+            adapterVersions,
+            ...(hasCores ? { cores: o.cores, forkCap: o.forkCap } : {}),
+        };
     }
     return undefined;
 }
@@ -31,7 +45,8 @@ function envFingerprint(env) {
     return env.configHash;
 }
 function envEqual(a, b) {
-    if (a.tickmarkrVersion !== b.tickmarkrVersion || a.configHash !== b.configHash)
+    if (a.tickmarkrVersion !== b.tickmarkrVersion || a.configHash !== b.configHash
+        || a.cores !== b.cores || a.forkCap !== b.forkCap)
         return false;
     const ak = Object.keys(a.adapterVersions).sort();
     const bk = Object.keys(b.adapterVersions).sort();

package/dist/run/daemon.d.ts

@@ -4,6 +4,7 @@ import { type ExecutorDriver } from "../drivers/types.js";
 import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
 import { Journal, type JournalEvent } from "./journal.js";
+export { harvestCpuFlatWindowMs, resetHarvestCpuFlatMsForTests, setHarvestCpuFlatMsForTests, workerTreeCpuMs, } from "./stall.js";
 export interface RunOptions {
     runId?: string;
     resume?: boolean;
@@ -117,10 +118,6 @@ export declare function resetDeadChannelFastKillMsForTests(): void;
 /** Test seam — shrink the harvest silence gate without minute-long sleeps. */
 export declare function setHarvestSilentMsForTests(ms: number): void;
 export declare function resetHarvestSilentMsForTests(): void;
-export declare function harvestCpuFlatWindowMs(resolutionMs: number): number;
-/** Test seam — pin the flat window so a probe case need not sit through a real one. */
-export declare function setHarvestCpuFlatMsForTests(ms: number): void;
-export declare function resetHarvestCpuFlatMsForTests(): void;
 export declare const HARVESTED_RESULT_SUMMARY = "harvested: the worktree carries committed work; the worker emitted no TICKMARKR_RESULT trailer";
 /** T4 (OBS-266): identity of the command SET a tip verify ran — a changed command is a different verify. */
 export declare function commandsHash(commands: Record<string, string>): string;
@@ -139,10 +136,6 @@ export declare function verifyIntegrationTipCached(intWt: string, commands: Reco
     lastMergedTask?: string;
     baseline?: Baseline;
 }): Promise<boolean>;
-export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
-    ms: number;
-    resolutionMs: number;
-} | undefined>;
 /** 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;