tickmarkr 2.5.9 → 2.6.1

package/dist/graph/graph.d.ts

@@ -24,7 +24,7 @@ export declare function onDiskSpecHash(_repoRoot: string, graph: RunGraph): OnDi
 /** A task's definition minus its files[] (and run state): what a scope amendment must NOT move (OBS-1073). */
 export declare function taskDefinitionFingerprint(task: Task): string;
 export declare function graphDefinitionHash(g: RunGraph): string;
-export declare function taskContentDigest(task: Pick<Task, "goal" | "files" | "acceptance">): string;
+export declare function taskContentDigest(task: Pick<Task, "goal" | "files" | "acceptance" | "outOfScope">): string;
 export declare function tickmarkrDir(repoRoot: string): string;
 export declare function loadGraph(repoRoot: string): RunGraph;
 export declare function saveGraph(repoRoot: string, g: RunGraph): void;
@@ -36,8 +36,12 @@ export declare function addEvidence(g: RunGraph, id: string, patch: {
     gateResults?: unknown[];
 }): RunGraph;
 export declare function chainDepth(g: RunGraph): Map<string, number>;
-export declare function readyTasks(g: RunGraph): Task[];
-export declare function dispatchWaves(g: RunGraph, concurrency: number): Map<string, number>;
+export declare function readyTasks(g: RunGraph, prioritized?: ReadonlySet<string>): Task[];
+export declare function batteryPriority(actions: Iterable<{
+    taskId: string;
+    authority: string;
+}>): Set<string>;
+export declare function dispatchWaves(g: RunGraph, concurrency: number, prioritized?: ReadonlySet<string>): Map<string, number>;
 export declare function isComplete(g: RunGraph): boolean;
 export declare function isStalled(g: RunGraph): boolean;
 export declare function closureReaches(g: RunGraph, taskId: string, pred: (t: Task) => boolean): boolean;

package/dist/graph/graph.js

@@ -94,9 +94,14 @@ export function graphDefinitionHash(g) {
 // 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.
+// OBS-1126: outOfScope joins the identity only when present — an absent list keeps the historical
+// bytes so every digest persisted before the field existed still joins.
 export function taskContentDigest(task) {
     return createHash("sha256")
-        .update(JSON.stringify({ goal: task.goal, files: task.files, acceptance: task.acceptance }))
+        .update(JSON.stringify({
+        goal: task.goal, files: task.files, acceptance: task.acceptance,
+        ...(task.outOfScope ? { outOfScope: task.outOfScope } : {}),
+    }))
         .digest("hex");
 }
 export function tickmarkrDir(repoRoot) {
@@ -186,21 +191,32 @@ export function chainDepth(g) {
 // OBS-1018: admission is critical-path order — deepest chain root first, ties in declaration order.
 // The daemon's dispatch loop slices this list unchanged. Stated limit: resume-restore of previously
 // in-flight attempts keeps its own precedence (src/run/daemon.ts); only fresh admission is ordered here.
-export function readyTasks(g) {
+// OBS-1158: `prioritized` names tasks holding a pending battery (recheck) approval. Among READY tasks
+// of equal depth an approved recheck precedes fresh work; deeper fresh work keeps its rank, and a
+// recheck that is not ready (dependency-blocked) is not admitted at all, so it gains nothing here.
+export function readyTasks(g, prioritized = NO_PRIORITY) {
     const done = new Set(g.tasks.filter((t) => t.status === "done").map((t) => t.id));
     const depth = chainDepth(g);
+    const rank = (t) => (prioritized.has(t.id) ? 1 : 0);
     return g.tasks
         .filter((t) => t.status === "pending" && t.deps.every((d) => done.has(d)))
-        .sort((a, b) => depth.get(b.id) - depth.get(a.id)); // Array#sort is stable: equal depths keep declaration order
+        .sort((a, b) => depth.get(b.id) - depth.get(a.id) || rank(b) - rank(a)); // Array#sort is stable: remaining ties keep declaration order
+}
+const NO_PRIORITY = new Set();
+// OBS-1158: the one seam plan and the daemon share for battery priority — journal approval actions
+// in (src/run/journal.ts pendingApprovalActions), the ids whose pending authority is `battery` out.
+// Waivers, worker-funding approvals and inert releases never qualify; a consumed approval is absent.
+export function batteryPriority(actions) {
+    return new Set([...actions].filter((a) => a.authority === "battery").map((a) => a.taskId));
 }
 // OBS-1018: the dispatch wave each pending task would enter at `concurrency` slots if every wave
 // took one tick — computed by draining readyTasks, so plan and daemon can never disagree on order.
 // Tasks already past pending carry no wave.
-export function dispatchWaves(g, concurrency) {
+export function dispatchWaves(g, concurrency, prioritized = NO_PRIORITY) {
     const waves = new Map();
     let sim = g;
     for (let wave = 1;; wave++) {
-        const batch = readyTasks(sim).slice(0, Math.max(1, concurrency));
+        const batch = readyTasks(sim, prioritized).slice(0, Math.max(1, concurrency));
         if (!batch.length)
             return waves;
         for (const t of batch) {

package/dist/graph/schema.d.ts

@@ -80,6 +80,7 @@ export declare const TaskSchema: z.ZodObject<{
         kind: z.ZodLiteral<"fixture">;
         paths: z.ZodArray<z.ZodString>;
     }, z.core.$strip>], "kind">>>;
+    outOfScope: z.ZodOptional<z.ZodArray<z.ZodString>>;
     gates: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         build: "build";
         test: "test";
@@ -181,6 +182,7 @@ export declare const RunGraphSchema: z.ZodObject<{
             kind: z.ZodLiteral<"fixture">;
             paths: z.ZodArray<z.ZodString>;
         }, z.core.$strip>], "kind">>>;
+        outOfScope: z.ZodOptional<z.ZodArray<z.ZodString>>;
         gates: z.ZodDefault<z.ZodArray<z.ZodEnum<{
             build: "build";
             test: "test";

package/dist/graph/schema.js

@@ -71,6 +71,8 @@ export const TaskSchema = z.object({
     }))
         .optional(),
     pins: z.array(PinSchema).optional(),
+    // OBS-1126: declared bounds the task must not cross; absent ⇒ no key (sealed graph bytes hold).
+    outOfScope: z.array(z.string().min(1)).optional(),
     gates: z
         .array(z.enum(GATE_NAMES))
         .default(["build", "test", "lint", "evidence", "scope", "acceptance", "review"])

package/dist/route/preference.d.ts

@@ -1,5 +1,5 @@
 import { type AuthHealth } from "../adapters/types.js";
-import type { TickmarkrConfig } from "../config/config.js";
+import { type TickmarkrConfig } from "../config/config.js";
 export interface Disallowed {
     by: "deny" | "allow";
     entry: string;

package/dist/route/preference.js

@@ -1,4 +1,5 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
+import { DENY_SCOPES, denyEntriesAt } from "../config/config.js";
 import { validateGraph } from "../graph/schema.js";
 import { route, RoutingError } from "./router.js";
 const PREFERENCE_ROLES = ["worker", "judge", "review", "consult"];
@@ -121,47 +122,17 @@ export function entryMatchesChannel(entry, c, allowFamilyMatching = false) {
 export function exclusionCollector(c, routingOrCfg, role = "worker") {
     const routing = "routing" in routingOrCfg ? routingOrCfg.routing : routingOrCfg;
     const out = [];
-    const { allow, deny } = routing ?? {};
-    for (const entry of deny?.adapters ?? []) {
-        if (entryMatchesChannel(entry, c, true)) {
-            out.push({
-                scope: "routing.deny.adapters",
-                path: "routing.deny.adapters",
-                configPath: "routing.deny.adapters",
-                entry,
-                by: "deny",
-            });
-        }
-    }
-    for (const entry of deny?.models ?? []) {
-        if (entryMatchesChannel(entry, c, true)) {
-            out.push({
-                scope: "routing.deny.models",
-                path: "routing.deny.models",
-                configPath: "routing.deny.models",
-                entry,
-                by: "deny",
-            });
-        }
-    }
-    if (role === "worker") {
-        for (const entry of deny?.workers?.adapters ?? []) {
-            if (entryMatchesChannel(entry, c, true)) {
-                out.push({
-                    scope: "routing.deny.workers.adapters",
-                    path: "routing.deny.workers.adapters",
-                    configPath: "routing.deny.workers.adapters",
-                    entry,
-                    by: "deny",
-                });
-            }
-        }
-        for (const entry of deny?.workers?.models ?? []) {
+    const { allow } = routing ?? {};
+    for (const scope of DENY_SCOPES) {
+        // Lists under workers apply only to worker seats; flat deny lists cover every role.
+        if (scope.path[2] === "workers" && role !== "worker")
+            continue;
+        for (const entry of denyEntriesAt(routing, scope) ?? []) {
             if (entryMatchesChannel(entry, c, true)) {
                 out.push({
-                    scope: "routing.deny.workers.models",
-                    path: "routing.deny.workers.models",
-                    configPath: "routing.deny.workers.models",
+                    scope: scope.dotted,
+                    path: scope.dotted,
+                    configPath: scope.dotted,
                     entry,
                     by: "deny",
                 });

package/dist/route/role-pick.d.ts

@@ -0,0 +1,16 @@
+import { type AuthHealth, type BillingChannel, type WorkerAdapter } from "../adapters/types.js";
+import { type TickmarkrConfig } from "../config/config.js";
+import type { PreferenceRole } from "./preference.js";
+export { preferIndex, rankPreferredChannels, reviewPreferenceTieBreak } from "./router.js";
+export type RolePick = {
+    ok: true;
+    channel: BillingChannel;
+} | {
+    ok: false;
+    reason: "missing-prefer" | "no-eligible-preferred-channel";
+};
+/** Strict role selection: no task, author, pin, or default seat is invented. */
+export declare function pickRole(role: PreferenceRole, cfg: TickmarkrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>, opts?: {
+    excludeVendors?: ReadonlySet<string>;
+    eligible?: (channel: BillingChannel) => boolean;
+}): RolePick;

package/dist/route/role-pick.js

@@ -0,0 +1,15 @@
+import { discoverChannels } from "../adapters/registry.js";
+import { rankPreferredChannels, reviewPreferenceTieBreak } from "./router.js";
+export { preferIndex, rankPreferredChannels, reviewPreferenceTieBreak } from "./router.js";
+/** Strict role selection: no task, author, pin, or default seat is invented. */
+export function pickRole(role, cfg, adapters, health, opts = {}) {
+    // Worker preferences belong to shapes; judge currently has only an explicit pin.
+    const prefer = role === "review" ? cfg.review.prefer : role === "consult" ? cfg.consult.prefer : undefined;
+    if (!prefer?.length)
+        return { ok: false, reason: "missing-prefer" };
+    const pool = discoverChannels(cfg, adapters, health, role).filter((c) => !opts.excludeVendors?.has(c.vendor) && (opts.eligible?.(c) ?? true));
+    const channel = rankPreferredChannels(pool, prefer, {
+        tieBreak: role === "review" ? reviewPreferenceTieBreak : undefined,
+    })[0];
+    return channel ? { ok: true, channel } : { ok: false, reason: "no-eligible-preferred-channel" };
+}

package/dist/route/router.d.ts

@@ -31,6 +31,19 @@ export declare class RoutingError extends Error {
     constructor(msg: string);
 }
 export declare function marginalCostRank(c: BillingChannel): number;
+type ChannelSeat = {
+    adapter: string;
+    model: string;
+};
+/** Shared adapter | adapter:model grammar; unmatched channels follow every declared entry. */
+export declare function preferIndex(c: ChannelSeat, prefer?: readonly string[]): number;
+/** Rank an already eligible pool. Review alone retains its legacy unpreferred tail. */
+export declare function rankPreferredChannels<C extends ChannelSeat>(channels: readonly C[], prefer?: readonly string[], opts?: {
+    includeUnpreferred?: boolean;
+    tieBreak?: (a: C, b: C) => number;
+}): C[];
+/** Review preserves its established tier-then-cost order inside a preference band. */
+export declare const reviewPreferenceTieBreak: (a: BillingChannel, b: BillingChannel) => number;
 export declare function route(task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext, exclude?: ReadonlySet<string>, exploreCtx?: ExploreContext): Route;
 export declare function nextChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile, exclude?: ReadonlySet<string>): Assignment | null;
 export type ClimbPick = Assignment & {
@@ -46,3 +59,4 @@ export type ClimbResult = ClimbPick;
  * returns nextChannel's same-or-higher pick flagged climbed: false naming the reason.
  */
 export declare function climbChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile, exclude?: ReadonlySet<string>): ClimbPick | null;
+export {};

package/dist/route/router.js

@@ -52,10 +52,18 @@ function resolvePin(pin, channels) {
     }
     return c;
 }
-function preferIndex(c, prefer = []) {
+/** Shared adapter | adapter:model grammar; unmatched channels follow every declared entry. */
+export function preferIndex(c, prefer = []) {
     const i = prefer.findIndex((p) => p === c.adapter || p === channelKey(c));
     return i === -1 ? prefer.length : i;
 }
+/** Rank an already eligible pool. Review alone retains its legacy unpreferred tail. */
+export function rankPreferredChannels(channels, prefer = [], opts = {}) {
+    return channels.filter((c) => opts.includeUnpreferred || preferIndex(c, prefer) < prefer.length)
+        .sort((a, b) => preferIndex(a, prefer) - preferIndex(b, prefer) || opts.tieBreak?.(a, b) || 0);
+}
+/** Review preserves its established tier-then-cost order inside a preference band. */
+export const reviewPreferenceTieBreak = (a, b) => TIER_RANK[b.tier] - TIER_RANK[a.tier] || Number(a.channel === "api") - Number(b.channel === "api");
 function ladderFor(task, entry) {
     const escalate = task.routingHints?.escalate ?? entry?.escalate ?? true;
     return escalate ? ["retry", "escalate", "consult", "human"] : ["retry", "consult", "human"];

package/dist/run/consult.js

@@ -4,6 +4,7 @@ import { getAdapter } from "../adapters/registry.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { dewrapPaneVerdict, extractVerdictJson, gateExitTrailer, gatePaneName, generateVerdictNonce, verdictNonceLine } from "../gates/llm.js";
 import { classifyVerdictCause } from "../gates/verdict-cause.js";
+import { rankPreferredChannels } from "../route/role-pick.js";
 import { disallowedBy, routingModelProvider } from "../route/preference.js";
 import { sh } from "./git.js";
 import { redactSecrets } from "./redact.js";
@@ -212,15 +213,10 @@ opts = {}) {
         }
         return parsed;
     };
-    // v1.54 T1: ranked seat failover. Walk consult.prefer (adapter:model entries) to the first entry
-    // whose adapter is in the live channel set; a failed seat or unparseable verdict falls to the next;
-    // the pinned consult.adapter/model is always the final seat. No channels provided (non-daemon
-    // callers) ⇒ empty live set ⇒ pin only, byte-identical to pre-v1.54 behavior. Failover changes
-    // only WHICH seat answers — per-seat parsing and the fail-safe human action below are untouched.
-    const live = new Set((opts.channels ?? []).map((c) => c.adapter));
-    const seats = (cfg.consult.prefer ?? [])
-        .map((entry) => ({ adapter: entry.slice(0, entry.indexOf(":")), model: entry.slice(entry.indexOf(":") + 1) }))
-        .filter((s) => live.has(s.adapter));
+    // Rank only exact live models from the daemon's role-scoped discovery pool.
+    // The explicit pin remains a caller-owned fallback, outside strict preference selection.
+    const live = (opts.channels ?? []).filter((c) => typeof c.model === "string");
+    const seats = rankPreferredChannels(live.filter((c) => disallowedBy(c, cfg.routing, "consult") === null), cfg.consult.prefer);
     seats.push({ adapter: cfg.consult.adapter, model: cfg.consult.model });
     // v1.87 T2: a consult seat reads the code, so it passes through the operator's policy exactly like
     // a worker does. The filter runs AFTER the pin is pushed, so the final pinned seat is checked by

package/dist/run/daemon.d.ts

@@ -5,6 +5,7 @@ import { type ExecutorDriver, type Slot } from "../drivers/types.js";
 import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
 import { type RunGraph } from "../graph/schema.js";
+import { type PreserveProducer } from "./git.js";
 import { Journal, type JournalEvent } from "./journal.js";
 export declare function closeLiveSlot(liveSlots: Set<Slot>, driver: Pick<ExecutorDriver, "close">, slot: Slot): Promise<void>;
 /** Optional authoritative transport receipt. Screen text can prove execution, never nonacceptance. */
@@ -67,6 +68,7 @@ export interface RunSummary {
     /** the accepted approvals that never reached a dispatch — named, never left to the park buckets */
     outstandingApprovals?: string[];
 }
+export declare function pendingDaemonApprovalActions(events: JournalEvent[]): Map<string, import("./journal.js").PendingApprovalAction>;
 /**
  * T14, amended by v2.2 T3: approvals the run accepted and never acted on. `approved` above is still
  * built ONCE at startup — replay determinism depends on it — but a live approval is no longer inert:
@@ -126,6 +128,9 @@ export declare const APPROVAL_POLL_MS = 250;
 export declare const APPROVAL_WINDOW_MS = 120000;
 export declare const setApprovalWindowForTests: (ms: number) => void;
 export declare const resetApprovalWindowForTests: () => void;
+/** Test seam — shrink the capacity backoff without minute-long sleeps. */
+export declare function setCapacityBackoffMsForTests(ms: number): void;
+export declare function resetCapacityBackoffMsForTests(): void;
 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;
@@ -170,6 +175,11 @@ export declare const HARVESTED_RESULT_SUMMARY = "harvested: the worktree carries
 export declare function commandsHash(commands: Record<string, string>): string;
 export interface TipProof {
     kind: "fresh" | "reused" | "failed" | "incomplete";
+    /** Each completed gate keeps its own execution provenance, even in a mixed cycle. */
+    gates?: Array<{
+        gate: string;
+        kind: "fresh" | "reused";
+    }>;
     /** the commit the cycle's start row spoke for */
     tip?: string;
 }
@@ -177,7 +187,8 @@ export interface TipProof {
  * OBS-1077 close rider: what the engagement's LATEST verification cycle proved — its
  * `tip-verify-start` row and what followed, never a commit comparison. Exactly one kind per close:
  * fresh (every tip command ran AND passed), reused (an eligible cached cycle carried forward),
- * failed, or incomplete (cancelled, cut short, mixed or undelimited). Nothing before the start row
+ * failed, or incomplete (cancelled, cut short or undelimited). Completed mixed cycles retain each
+ * gate's kind beside the whole-cycle reused kind. Nothing before the start row
  * is read, so an unfinished cycle inherits nothing from an earlier green one.
  */
 export declare function runEndTipProof(events: readonly JournalEvent[]): TipProof;
@@ -212,5 +223,9 @@ 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;
+/** The attempt whose worker last launched into the task's current checkout; "unknown" once a
+ * recreation replaced that tree without a new launch (recheck, gate-only restore) or when no
+ * dispatch assignment is on record. Never the newest dispatch by itself. */
+export declare function knownProducer(events: readonly JournalEvent[], taskId: string): PreserveProducer;
 export declare function recordFatalRunEnd(journal: Journal, runId: string, branch: string, err: unknown, graph?: RunGraph, phase?: string): TipProof | undefined;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;