tickmarkr 1.44.0 → 1.46.0

package/dist/run/journal.d.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { type Assignment } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
 import { type TaskStatus } from "../graph/schema.js";
-import { type RoutingProfile } from "../route/profile.js";
+import { type ProfileDiscount, type RoutingProfile } from "../route/profile.js";
 export interface JournalEvent {
     ts: string;
     event: string;
@@ -16,10 +16,21 @@ export interface ResumeState {
     lastAssignment?: Assignment;
 }
 export declare const ATTEMPT_CAP_RELEASE: "attempt-cap";
-export declare const PARK_KINDS: readonly ["ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict"];
+export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved"];
 export type ParkKind = (typeof PARK_KINDS)[number];
 export declare const RETRY_MODES: readonly ["resume", "fresh"];
 export type RetryMode = (typeof RETRY_MODES)[number];
+export declare const WORKER_RESULT_CAUSES: readonly ["provider-death", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
+export type WorkerResultCause = (typeof WORKER_RESULT_CAUSES)[number];
+/** OBS-53: classify worker-result failures so retries and routing see the true signal, not one lumped bucket. */
+export declare function classifyWorkerResultCause(opts: {
+    output: string;
+    ok: boolean;
+    finished: boolean;
+    exitCode: number | null;
+    summary: string;
+    timedOut: boolean;
+}): WorkerResultCause | undefined;
 export declare const TelemetryRowSchema: z.ZodObject<{
     taskId: z.ZodString;
     shape: z.ZodString;
@@ -42,9 +53,11 @@ export declare const TelemetryRowSchema: z.ZodObject<{
         "attempt-cap": "attempt-cap";
         "gate-fail": "gate-fail";
         quota: "quota";
+        "human-gate": "human-gate";
         "reroute-exhausted": "reroute-exhausted";
         stall: "stall";
         "merge-conflict": "merge-conflict";
+        "tip-moved": "tip-moved";
     }>>;
     tokens: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         input: z.ZodNumber;
@@ -60,11 +73,44 @@ export declare const TelemetryRowSchema: z.ZodObject<{
         resume: "resume";
         fresh: "fresh";
     }>>;
+    signalQuality: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<0.25>, z.ZodLiteral<0.5>, z.ZodLiteral<0.75>, z.ZodLiteral<1>]>>;
+    signalBasis: z.ZodOptional<z.ZodEnum<{
+        proved: "proved";
+        "review-agree": "review-agree";
+        "judge-only": "judge-only";
+        legacy: "legacy";
+        vacuous: "vacuous";
+        skipped: "skipped";
+    }>>;
 }, z.core.$strip>;
 export type TelemetryRow = z.infer<typeof TelemetryRowSchema>;
-export declare function recordedGraphHash(events: JournalEvent[]): string | undefined;
-export declare function journalComparable(events: JournalEvent[], loadedHash: string): boolean;
+export declare const SIGNAL_BASIS: readonly ["proved", "review-agree", "judge-only", "legacy", "vacuous", "skipped"];
+export type SignalBasis = (typeof SIGNAL_BASIS)[number];
+export declare const SIGNAL_QUALITY: Record<SignalBasis, 0 | 0.25 | 0.5 | 0.75 | 1>;
+export declare function signalQualityFromBasis(basis: SignalBasis): 0 | 0.25 | 0.5 | 0.75 | 1;
+export declare function deriveSignalBasis(gate: string, pass: boolean, details: string, meta?: Record<string, unknown>): SignalBasis;
+export declare function gateResultJournalData(gate: string, pass: boolean, details: string, meta?: Record<string, unknown>): {
+    gate: string;
+    pass: boolean;
+    details: string;
+    signalBasis: SignalBasis;
+    signalQuality: number;
+} & Record<string, unknown>;
+export declare function recordedGraphDefinitionHash(events: JournalEvent[]): string | undefined;
+export type EngagementCompare = {
+    comparable: true;
+    recorded: string;
+} | {
+    comparable: false;
+    reason: "mismatch";
+    recorded: string;
+} | {
+    comparable: false;
+    reason: "unbound";
+};
+export declare function engagementComparable(events: JournalEvent[], loadedHash: string): EngagementCompare;
 export declare function newRunId(now?: Date): string;
+export declare function parseRunId(runId: string): string;
 export declare function readAllTelemetry(repoRoot: string, lastK: number, opts?: {
     after?: string;
 }): (TelemetryRow & {
@@ -72,6 +118,9 @@ export declare function readAllTelemetry(repoRoot: string, lastK: number, opts?:
 })[];
 export declare const RUNS_WINDOW = 50;
 export declare function readProfileCursor(repoRoot: string): string | undefined;
+export declare function profileDiscountsPath(repoRoot: string): string;
+export declare function readProfileDiscounts(repoRoot: string): ProfileDiscount[];
+export declare function appendProfileDiscount(repoRoot: string, discount: ProfileDiscount): void;
 export declare function loadRoutingProfile(repoRoot: string, cfg: TickmarkrConfig, opts?: {
     preview?: boolean;
 }): RoutingProfile | undefined;

package/dist/run/journal.js

@@ -2,7 +2,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from
 import { join } from "node:path";
 import { z } from "zod";
 import { channelKey, TokenUsageSchema } from "../adapters/types.js";
-import { stateDirName } from "../graph/graph.js";
+import { stateDirName, tickmarkrDir } from "../graph/graph.js";
 import { TIERS } from "../graph/schema.js";
 import { buildProfile } from "../route/profile.js";
 export function formatJournalNarration({ event, taskId, data }) {
@@ -38,9 +38,28 @@ const DispatchAssignmentSchema = z.object({
     channel: z.enum(["sub", "api"]),
     tier: z.enum(TIERS),
 });
-export const PARK_KINDS = ["ladder-exhausted", "attempt-cap", "gate-fail", "quota",
-    "reroute-exhausted", "setup", "stall", "merge-conflict"];
+export const PARK_KINDS = ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota",
+    "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved"];
 export const RETRY_MODES = ["resume", "fresh"];
+export const WORKER_RESULT_CAUSES = ["provider-death", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
+// OBS-53: provider-outage signatures in dead worker output ("Unable to reach the model provider" and kin).
+const PROVIDER_OUTAGE_RE = /Unable to reach the model provider|cannot reach the model provider|model provider.*(?:unavailable|unreachable)/i;
+/** OBS-53: classify worker-result failures so retries and routing see the true signal, not one lumped bucket. */
+export function classifyWorkerResultCause(opts) {
+    if (opts.ok && opts.finished)
+        return undefined;
+    if (PROVIDER_OUTAGE_RE.test(opts.output))
+        return "provider-death";
+    if (opts.summary === "unparseable TICKMARKR_RESULT trailer")
+        return "malformed-trailer";
+    if (!opts.finished && opts.timedOut)
+        return "stall-timeout";
+    if (!opts.finished && opts.exitCode !== null)
+        return "clean-exit-no-trailer";
+    if (!opts.finished)
+        return "stall-timeout";
+    return undefined;
+}
 export const TelemetryRowSchema = z.object({
     // v1.5 core — required; every old row has all eight (daemon.ts writes all eight)
     taskId: z.string(), shape: z.string(), adapter: z.string(), model: z.string(), channel: z.string(),
@@ -71,23 +90,88 @@ export const TelemetryRowSchema = z.object({
     overrun: z.literal(true).optional(),
     // v1.29 additive: mode of the attempt represented by this row. Absent on old telemetry.
     retryMode: z.enum(RETRY_MODES).optional(),
+    // v1.46 additive (T5): gate-signal quality for routing hygiene — OPTIONAL, absent = legacy (0.25 at fold).
+    signalQuality: z.union([z.literal(0), z.literal(0.25), z.literal(0.5), z.literal(0.75), z.literal(1)]).optional(),
+    signalBasis: z.enum(["proved", "review-agree", "judge-only", "legacy", "vacuous", "skipped"]).optional(),
 });
-// OBS-52: graph hash on run-start binds status replay to the compiled graph that started the run.
-export function recordedGraphHash(events) {
+// v1.46 T5 (Sol signal telemetry): gate-result rows carry explicit signalQuality so future defect windows
+// are identifiable without forensics. Basis is the provenance claim; quality is the dyadic h-fold weight.
+export const SIGNAL_BASIS = ["proved", "review-agree", "judge-only", "legacy", "vacuous", "skipped"];
+export const SIGNAL_QUALITY = {
+    proved: 1,
+    "review-agree": 0.75,
+    "judge-only": 0.5,
+    legacy: 0.25,
+    vacuous: 0,
+    skipped: 0,
+};
+export function signalQualityFromBasis(basis) {
+    return SIGNAL_QUALITY[basis];
+}
+export function deriveSignalBasis(gate, pass, details, meta = {}) {
+    if (meta.skipped === true)
+        return "skipped";
+    if (meta.unparseable === true)
+        return "vacuous";
+    if (gate === "acceptance")
+        return "judge-only";
+    if (gate === "review")
+        return pass ? "review-agree" : "vacuous";
+    if (gate === "test" || gate === "build") {
+        if (!pass)
+            return "vacuous";
+        if (/no test files|0 tests|tests\s+0\s/i.test(details))
+            return "vacuous";
+        return "proved";
+    }
+    return pass ? "proved" : "vacuous";
+}
+// The canonical gate-result journal payload — daemon should spread this into append("gate-result", …).
+export function gateResultJournalData(gate, pass, details, meta = {}) {
+    const signalBasis = deriveSignalBasis(gate, pass, details, meta);
+    return { gate, pass, details, ...meta, signalBasis, signalQuality: signalQualityFromBasis(signalBasis) };
+}
+// T3 (Sol #2 / Fable F2): one canonical engagement identity, shared by status AND resume. The run-start
+// event records graphDefinitionHash (over compiled task definitions only — see graph.graphDefinitionHash);
+// this is the single field both consumers read, and the single comparator below is the single place the
+// journal↔graph join is decided. unbound (no recorded definition hash, e.g. a pre-v1.44 journal) and
+// mismatch are both not-comparable — status renders the notice either way; resume refuses either way and
+// distinguishes the reason only for its message and the --graph-changed release event.
+export function recordedGraphDefinitionHash(events) {
     for (const e of events) {
-        if (e.event === "run-start" && typeof e.data.graphHash === "string")
-            return e.data.graphHash;
+        if (e.event === "run-start" && typeof e.data.graphDefinitionHash === "string")
+            return e.data.graphDefinitionHash;
     }
     return undefined;
 }
-export function journalComparable(events, loadedHash) {
-    const recorded = recordedGraphHash(events);
-    return recorded !== undefined && recorded === loadedHash;
+// THE shared comparator (criterion: status and resume decide through one comparator). status reads
+// .comparable; resume reads .comparable plus .reason/.recorded for its refusal message and the release.
+export function engagementComparable(events, loadedHash) {
+    const recorded = recordedGraphDefinitionHash(events);
+    if (recorded === undefined)
+        return { comparable: false, reason: "unbound" };
+    return recorded === loadedHash ? { comparable: true, recorded } : { comparable: false, reason: "mismatch", recorded };
 }
 export function newRunId(now = new Date()) {
     const p = (n, w = 2) => String(n).padStart(w, "0");
     return `run-${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
 }
+// Sol #4: one strict parser for every journal open/create path — generated run-… ids plus test
+// suffix chars only; forbid path separators, dot-segments, and empty ids.
+export function parseRunId(runId) {
+    const id = runId.trim();
+    if (!id)
+        throw new Error("invalid run id: empty");
+    if (id.includes("/") || id.includes("\\"))
+        throw new Error(`invalid run id: ${runId}`);
+    for (const seg of id.split(/[/\\]/)) {
+        if (seg === "." || seg === "..")
+            throw new Error(`invalid run id: ${runId}`);
+    }
+    if (!/^run-[A-Za-z0-9][A-Za-z0-9_-]*$/.test(id))
+        throw new Error(`invalid run id: ${runId}`);
+    return id;
+}
 const runsDir = (repoRoot) => join(repoRoot, stateDirName(repoRoot), "runs");
 // One JSONL reader for every append-only log: skip blanks, drop any line that
 // won't parse, keeping everything before it intact.
@@ -143,6 +227,38 @@ export function readProfileCursor(repoRoot) {
         return undefined;
     return readFileSync(path, "utf8").trim() || undefined;
 }
+// v1.46 T5 evidence hygiene state — one line per mark: `<runId> [<taskId>] <weight> # <reason>`.
+// Follows the profile-since precedent: state file in .tickmarkr/, never config, never git.
+const PROFILE_DISCOUNTS_RE = /^(run-[A-Za-z0-9][A-Za-z0-9_-]*)(?:\s+(\S+))?\s+(0|0\.5)\s+#\s+(.+)$/;
+export function profileDiscountsPath(repoRoot) {
+    return join(repoRoot, stateDirName(repoRoot), "profile-discounts");
+}
+export function readProfileDiscounts(repoRoot) {
+    const path = profileDiscountsPath(repoRoot);
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const m = PROFILE_DISCOUNTS_RE.exec(trimmed);
+        if (!m)
+            continue;
+        out.push({
+            runId: m[1],
+            ...(m[2] ? { taskId: m[2] } : {}),
+            weight: m[3] === "0" ? 0 : 0.5,
+            reason: m[4].trim(),
+        });
+    }
+    return out;
+}
+export function appendProfileDiscount(repoRoot, discount) {
+    tickmarkrDir(repoRoot);
+    const line = `${discount.runId}${discount.taskId ? ` ${discount.taskId}` : ""} ${discount.weight} # ${discount.reason}\n`;
+    appendFileSync(profileDiscountsPath(repoRoot), line);
+}
 // The one shared profile builder (criterion 4: plan and daemon share ONE code path).
 // preview:true bypasses the routing.learned:off short-circuit so `tickmarkr plan` can render the
 // trust-ramp preview while the daemon (no preview) stays inert (VALIDATION 13-01-11).
@@ -151,7 +267,8 @@ export function loadRoutingProfile(repoRoot, cfg, opts = {}) {
         return undefined; // never built, never passed
     const rows = readAllTelemetry(repoRoot, RUNS_WINDOW, { after: readProfileCursor(repoRoot) });
     // ROUTE-15: halfLifeRuns threads from config as a pure param; undefined ⇒ module default (byte-identical).
-    return rows.length ? buildProfile(rows, { halfLifeRuns: cfg.routing.learnedTuning?.halfLifeRuns }) : undefined; // cold ⇒ undefined ⇒ v1.5 dead-code path
+    const discounts = readProfileDiscounts(repoRoot);
+    return rows.length ? buildProfile(rows, { halfLifeRuns: cfg.routing.learnedTuning?.halfLifeRuns, discounts }) : undefined; // cold ⇒ undefined ⇒ v1.5 dead-code path
 }
 export class Journal {
     dir;
@@ -163,15 +280,19 @@ export class Journal {
         this.narrate = narrate;
     }
     static create(repoRoot, runId, narrate) {
-        const dir = join(runsDir(repoRoot), runId);
+        const id = parseRunId(runId);
+        const dir = join(runsDir(repoRoot), id);
+        if (existsSync(join(dir, "journal.jsonl")))
+            throw new Error(`journal already exists for ${id}`);
         mkdirSync(dir, { recursive: true });
-        return new Journal(dir, runId, narrate);
+        return new Journal(dir, id, narrate);
     }
     static open(repoRoot, runId, narrate) {
-        const dir = join(runsDir(repoRoot), runId);
+        const id = parseRunId(runId);
+        const dir = join(runsDir(repoRoot), id);
         if (!existsSync(join(dir, "journal.jsonl")))
-            throw new Error(`no journal for ${runId} at ${dir}`);
-        return new Journal(dir, runId, narrate);
+            throw new Error(`no journal for ${id} at ${dir}`);
+        return new Journal(dir, id, narrate);
     }
     // withJournal: journal.jsonl appears at first append, after Journal.create mkdirs — a caller that
     // will Journal.open the result (status, report) must fall back to the newest run that is actually

package/dist/run/lock.js

@@ -141,9 +141,9 @@ export function releaseRunLock(repoRoot) {
     unlinkIfOurs(lockPath(repoRoot)); // never delete a reclaiming successor's lock — only ours
     heldPath = undefined;
 }
-// Read-only check for compile: true iff a lock exists that the decision table would REFUSE on
-// (alive, EPERM, or ANY garbage). A provably-dead holder (ESRCH) reads not-live — compile proceeds
-// in step with resume (LOCK-02/OBS-05). Never mutates the lock.
+// Read-only predicate: true iff a lock exists that the decision table would REFUSE on (alive,
+// EPERM, or ANY garbage). A provably-dead holder (ESRCH) reads not-live (LOCK-02/OBS-05). Never
+// mutates the lock. compile now acquires via acquireRunLock; this remains for drift oracles/tests.
 export function isRunLockLive(repoRoot) {
     try {
         return shouldRefuse(inspect(lockPath(repoRoot)));

package/dist/run/merge.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { shq } from "../adapters/types.js";
 import { fingerprint } from "../gates/baseline.js";
 import { tickmarkrDir } from "../graph/graph.js";
-import { gitHead, linkNodeModules, resolveIntegrationBranch, sh, shOk, WORKTREES_DIR } from "./git.js";
+import { gitHead, linkNodeModules, resolveIntegrationBranch, sh, shGit, shGitOk, WORKTREES_DIR } from "./git.js";
 export function integrationBranch(cfg, runId) {
     return `${cfg.integrationBranchPrefix}${runId}`;
 }
@@ -12,12 +12,12 @@ export async function ensureIntegration(repo, branch, baseRef) {
     branch = await resolveIntegrationBranch(repo, branch);
     const dir = join(tickmarkrDir(repo), WORKTREES_DIR, sanitize(branch));
     if (!existsSync(join(dir, ".git"))) {
-        const exists = (await sh(`git rev-parse --verify refs/heads/${shq(branch)}`, repo)).code === 0;
+        const exists = (await shGit(`git rev-parse --verify refs/heads/${shq(branch)}`, repo)).code === 0;
         if (exists) {
-            await shOk(`git worktree add ${shq(dir)} ${shq(branch)}`, repo);
+            await shGitOk(`git worktree add ${shq(dir)} ${shq(branch)}`, repo);
         }
         else {
-            await shOk(`git worktree add -b ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);
+            await shGitOk(`git worktree add -b ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);
         }
     }
     linkNodeModules(repo, dir);
@@ -27,21 +27,21 @@ export function integrationHead(intWt) {
     return gitHead(intWt);
 }
 export async function mergeTask(intWt, taskBranch, message, gatedCommit) {
-    const tip = await sh(`git rev-parse --verify ${shq(`refs/heads/${taskBranch}`)}`, intWt);
+    const tip = await shGit(`git rev-parse --verify ${shq(`refs/heads/${taskBranch}`)}`, intWt);
     if (tip.code !== 0)
         return { ok: false, conflict: tip.stderr || tip.stdout };
     const branchTip = tip.stdout.trim();
     if (branchTip !== gatedCommit)
         return { ok: false, tipMoved: { gatedCommit, branchTip } };
     // Merge the verified hash, not the mutable branch name: a move after the comparison cannot land ungated content.
-    const r = await sh(`git merge --no-ff ${shq(gatedCommit)} -m ${shq(message)}`, intWt);
+    const r = await shGit(`git merge --no-ff ${shq(gatedCommit)} -m ${shq(message)}`, intWt);
     if (r.code === 0)
         return { ok: true };
-    const conflict = (await sh("git status --porcelain", intWt)).stdout
+    const conflict = (await shGit("git status --porcelain", intWt)).stdout
         .split("\n")
         .filter((l) => l.startsWith("UU") || l.startsWith("AA"))
         .join("\n") || r.stderr || r.stdout;
-    await sh("git merge --abort", intWt);
+    await shGit("git merge --abort", intWt);
     return { ok: false, conflict };
 }
 // OBS-34: strict exit-code verify on the integration tip — no baseline forgiveness.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.44.0",
+  "version": "1.46.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",