tickmarkr 2.6.1 → 2.6.2

package/dist/route/router.js

@@ -44,6 +44,7 @@ export function marginalCostRank(c) {
 }
 const toAssignment = (c) => ({
     adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier,
+    ...(c.effort ? { effort: c.effort } : {}),
 });
 function resolvePin(pin, channels) {
     const c = channels.find((c) => c.adapter === pin.via && c.model === pin.model);
@@ -150,6 +151,13 @@ const maybeSlaLint = (lints, task, profile, slaMinutes, c) => {
     lints.push(`${task.id} (${task.shape}): median ${medianMin}m exceeds sla ${slaMinutes}m — learned perf term references sla ${slaMinutes}m ref`);
 };
 export function route(task, cfg, channels, profile, preferCtx, exclude, exploreCtx) {
+    // OBS-1143: deny checks below read the probed identity the offered channels carry — the identity
+    // discovery admitted them under. A seat no channel vouches for stays unknown (conservative).
+    const observed = new Map(channels.flatMap((c) => (c.identity ? [[channelKey(c), c.identity]] : [])));
+    const seat = (adapter, model) => {
+        const identity = observed.get(channelKey({ adapter, model }));
+        return identity ? { adapter, model, identity } : { adapter, model };
+    };
     channels = withoutExcluded(channels, exclude);
     const lints = [];
     const advisoryFloor = cfg.routing.floors[task.shape];
@@ -161,7 +169,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     const prefer = effectivePrefer(entry);
     const prefActive = !!(cfg.routing.allow || cfg.routing.deny);
     const disallowedPin = (via, model, kind) => {
-        const d = disallowedBy({ adapter: via, model }, cfg.routing);
+        const d = disallowedBy(seat(via, model), cfg.routing);
         if (d) {
             throw new RoutingError(`${task.id}: ${kind} ${via}:${model} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or re-pin to an allowed channel`);
         }
@@ -174,8 +182,8 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }
         if (cfg.tiers[p]) {
             const expanded = channelsFromConfig(p, cfg);
-            if (expanded.length && expanded.every((c) => disallowedBy(c, cfg.routing) !== null)) {
-                const d = disallowedBy(expanded[0], cfg.routing);
+            if (expanded.length && expanded.every((c) => disallowedBy(seat(c.adapter, c.model), cfg.routing) !== null)) {
+                const d = disallowedBy(seat(expanded[0].adapter, expanded[0].model), cfg.routing);
                 throw new RoutingError(`${task.id}: prefer entry ${p} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or re-pin to an allowed channel`);
             }
             return;
@@ -228,21 +236,28 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     // single-channel pool) and the open floor/auto path. Exhaustion stays fail-loud (pin precedent).
     if (entry?.pool) {
         const pool = entry.pool;
-        if (prefActive) {
-            for (const p of pool.channels) {
-                const i = p.indexOf(":");
-                const d = disallowedBy({ adapter: p.slice(0, i), model: p.slice(i + 1) }, cfg.routing);
-                if (d) {
-                    throw new RoutingError(`${task.id}: pool entry ${p} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or drop it from the pool`);
-                }
-            }
+        // OBS-1144: a disallowed entry is skipped, named in provenance, never fatal for the pool; only an
+        // empty admitted remainder refuses. Filtering keeps declaration order, so ordered stays ordered.
+        const skipped = [];
+        const admitted = pool.channels.filter((p) => {
+            if (!prefActive)
+                return true;
+            const i = p.indexOf(":");
+            const d = disallowedBy(seat(p.slice(0, i), p.slice(i + 1)), cfg.routing);
+            if (d)
+                skipped.push(`${p} (disallowed by routing.${d.by} (${d.entry}))`);
+            return d === null;
+        });
+        const skippedNote = skipped.length ? `; skipped ${skipped.join(", ")}` : "";
+        if (!admitted.length) {
+            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool is exhausted — no admitted entry remains: ${skipped.join(", ")} — remove the deny/allow entry or add an admitted channel to the pool`);
         }
         // live preserves pool declaration order — ordered mode and any-mode stable-sort ties depend on it
-        const live = pool.channels
+        const live = admitted
             .map((id) => channels.find((c) => channelKey(c) === id))
             .filter((c) => c !== undefined && (!taskFloor || TIER_RANK[c.tier] >= TIER_RANK[taskFloor]));
         if (!live.length) {
-            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool has no live channel${taskFloor ? ` at task floor ${taskFloor}` : ""} — declared: ${pool.channels.join(", ")}; doctor found: ${channels.map(channelKey).join(", ") || "(nothing)"}`);
+            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool has no live channel${taskFloor ? ` at task floor ${taskFloor}` : ""} — declared: ${pool.channels.join(", ")}${skippedNote}; doctor found: ${channels.map(channelKey).join(", ") || "(nothing)"}`);
         }
         // No learned/explore inside pools: any spreads deterministically; ordered keeps declaration order.
         const chosen = pool.mode === "ordered"
@@ -250,7 +265,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
             : rankAnyPool(live, task)[0];
         lintMapPinFloor(chosen.tier, "pool");
         maybeSlaLint(lints, task, profile, slaMinutes, chosen);
-        return { assignment: toAssignment(chosen), ladder: ladderFor(task, entry), lints, provenance: `${degraded}pool ${pool.mode} ${channelKey(chosen)} (config routing.map)` };
+        return { assignment: toAssignment(chosen), ladder: ladderFor(task, entry), lints, provenance: `${degraded}pool ${pool.mode} ${channelKey(chosen)} (config routing.map${skippedNote})` };
     }
     const baseTier = floor ?? "cheap";
     // A task floor is hard on pool and floor/auto paths; the map-pin branch above stays supreme.
@@ -268,7 +283,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         let msg = `${task.id}: no channel at tier>=${minTier}; available: ${channels.map(channelKey).join(", ") || "(none)"}`;
         if (prefActive) {
             const excluded = Object.keys(cfg.tiers).flatMap((id) => channelsFromConfig(id, cfg))
-                .filter((c) => disallowedBy(c, cfg.routing) !== null && TIER_RANK[c.tier] >= TIER_RANK[minTier])
+                .filter((c) => disallowedBy(seat(c.adapter, c.model), cfg.routing) !== null && TIER_RANK[c.tier] >= TIER_RANK[minTier])
                 .map(channelKey);
             if (excluded.length)
                 msg += `; ${excluded.length} channel(s) excluded by routing.allow/deny: ${excluded.join(", ")}`;

package/dist/run/consult.d.ts

@@ -1,5 +1,6 @@
-import type { WorkerAdapter } from "../adapters/types.js";
+import { type WorkerAdapter } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
+import type { Effort } from "../graph/schema.js";
 import type { ExecutorDriver, Slot } from "../drivers/types.js";
 import type { GateResult } from "../gates/types.js";
 import { type VerdictUnparseableCause } from "../gates/verdict-cause.js";
@@ -13,6 +14,16 @@ export interface ConsultVerdict {
     adapter?: string;
     model?: string;
     vendor?: string;
+    effort?: Effort;
+    invocations?: ConsultInvocation[];
+}
+export interface ConsultInvocation {
+    adapter: string;
+    model: string;
+    vendor: string;
+    effort?: Effort;
+    outcome: "completed" | "failed";
+    reason: string;
 }
 export declare function renderRetryGuidance(v: ConsultVerdict): string;
 export declare function augmentRetryBrief(feedback: string, opts: {
@@ -37,6 +48,7 @@ export declare function buildDossierPrompt(d: Dossier, nonce: string): string;
 export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: WorkerAdapter[], driver: ExecutorDriver, cwd: string, runDir: string, opts?: {
     keep?: boolean;
     onSlot?: (slot: Slot) => void;
+    onInvocation?: (inv: ConsultInvocation) => void;
     runId?: string;
     channels?: Array<{
         adapter: string;

package/dist/run/consult.js

@@ -1,6 +1,7 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { getAdapter } from "../adapters/registry.js";
+import { configuredEffort } from "../adapters/types.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";
@@ -145,6 +146,8 @@ export async function consult(d, cfg, adapters, driver, cwd, runDir,
 // via SlotOpts.owned; without it the legacy gatePaneName shape survives (non-daemon callers/tests).
 // v1.54 T1: channels — the daemon's doctor-filtered live channel list; prefer-seat liveness is
 // judged against it only (never rebuilt from config, which would select installed-but-unauthed seats).
+// OBS-1182: onInvocation hears every launched seat — its identity, effort and outcome — failed seats
+// included, so a seat that never produced the verdict still reaches the journal.
 opts = {}) {
     const n = ++consultSeq;
     const nonce = generateVerdictNonce();
@@ -157,11 +160,11 @@ opts = {}) {
     // One seat = the WHOLE invoke-and-parse unit, both visibility branches (OBS-69 class: a headless-only
     // failover would leave the production pane path hard-failing on seat one). A null verdict retains
     // the classifier's cause when extraction failed; parsed content rejections deliberately have none.
-    const invokeSeat = async (seatAdapter, seatModel, seatIdx) => {
+    const invokeSeat = async (seatAdapter, seatModel, seatIdx, effort) => {
         const adapter = getAdapter(seatAdapter, adapters);
         let out;
         if (cfg.visibility.llm === "headless") {
-            const r = await sh(adapter.headlessCommand(promptFile, seatModel), cwd, cfg.consult.stallMinutes * 60_000);
+            const r = await sh(adapter.headlessCommand(promptFile, seatModel, effort), cwd, cfg.consult.stallMinutes * 60_000);
             out = r.stdout + r.stderr;
         }
         else {
@@ -169,7 +172,7 @@ opts = {}) {
             // but never exits, so the exit trailer after it never runs, the wait runs to the stall cap and
             // the 300-line read is a TUI frame. The headless command exits, the trailer prints, and the
             // pane is harvested through dewrap exactly like a judge or review seat.
-            const command = adapter.headlessCommand(promptFile, seatModel);
+            const command = adapter.headlessCommand(promptFile, seatModel, effort);
             // 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}`,
@@ -242,8 +245,12 @@ opts = {}) {
         };
     }
     for (const [i, seat] of allowedSeats.entries()) {
+        // OBS-1182: each seat launches at its own configured effort, never the worker's.
+        const effort = configuredEffort(cfg, seat);
+        const record = (outcome, reason) => opts.onInvocation?.({ ...seatIdentity(seat), ...(effort ? { effort } : {}), outcome, reason });
         try {
-            const parsed = await invokeSeat(seat.adapter, seat.model, i);
+            const parsed = await invokeSeat(seat.adapter, seat.model, i, effort);
+            record(parsed.verdict ? "completed" : "failed", parsed.verdict ? "verdict" : `verdict unparseable${parsed.cause ? ` (${parsed.cause})` : ""}`);
             if (parsed.verdict) {
                 const excludeProvider = parsed.verdict.excludeAdapter
                     ? excludedProviderFromDossier(d, parsed.verdict.excludeAdapter)
@@ -255,11 +262,13 @@ opts = {}) {
                         notes: `${parsed.verdict.notes} — excluded provider ${excludeProvider}`,
                     } : {}),
                     ...seatIdentity(seat),
+                    ...(effort ? { effort } : {}),
                 };
             }
         }
-        catch {
+        catch (e) {
             // failed seat (unknown adapter, dead driver/pane, shell error) — fall to the next entry
+            record("failed", `seat error: ${e instanceof Error ? e.message : String(e)}`.slice(0, 200));
         }
     }
     return {

package/dist/run/daemon.d.ts

@@ -2,12 +2,14 @@ import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
 import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
-import { type Baseline } from "../gates/baseline.js";
+import { type Baseline, type BaselineProvenance } 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>;
+export declare function setContactUnreadableDeadlineMsForTests(ms: number): void;
+export declare function resetContactUnreadableDeadlineMsForTests(): void;
 /** Optional authoritative transport receipt. Screen text can prove execution, never nonacceptance. */
 export interface DispatchObservation {
     slotId: string;
@@ -67,7 +69,34 @@ export interface RunSummary {
     approvalDisposition?: "complete" | "outstanding";
     /** the accepted approvals that never reached a dispatch — named, never left to the park buckets */
     outstandingApprovals?: string[];
+    /** OBS-1123: every baseline-recorded red a standing green carried, with the capture that recorded it */
+    forgiven?: ForgivenFingerprints[];
 }
+/** OBS-1123: one forgiveness — the fingerprints a green carried and the capture that recorded them. */
+export interface ForgivenFingerprints {
+    /** the task whose gate forgave them; absent for the integration tip */
+    taskId?: string;
+    gate: string;
+    /** absent: a legacy row that named no fingerprints */
+    fingerprints?: string[];
+    /** absent: a legacy capture or row that recorded no provenance — rendered unknown, never dated */
+    baseline?: BaselineProvenance;
+}
+/** Journal rows are untrusted input: a malformed field reads as not recorded, never as a value. */
+export declare const fingerprintsOf: (v: unknown) => string[] | undefined;
+export declare const baselineProvenanceOf: (v: unknown) => BaselineProvenance | undefined;
+/** A forgiven battery green: the structured field, or the battery's own "(forgiven)" wording on a legacy row. */
+export declare const forgivenGateRow: (data: Record<string, unknown>) => boolean;
+/**
+ * OBS-1123: the forgiveness standing at this point in the journal — each task gate's LATEST verdict
+ * where it is a forgiven green, then the latest verification cycle's forgiven tip rows. A legacy row
+ * keeps what it never recorded absent, so the reader says "unknown" instead of borrowing a date.
+ */
+export declare function forgivenFingerprints(events: readonly JournalEvent[]): ForgivenFingerprints[];
+/** The capture a forgiveness rests on, or an explicit unknown — never a time read off another clock. */
+export declare function formatBaselineProvenance(p: BaselineProvenance | undefined): string;
+export declare function formatFingerprints(fingerprints: string[] | undefined): string;
+export declare function formatForgiven(f: ForgivenFingerprints): 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
@@ -131,6 +160,9 @@ 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;
+/** Test seam — shrink the bootstrap backoff. */
+export declare function setBootstrapBackoffMsForTests(ms: number): void;
+export declare function resetBootstrapBackoffMsForTests(): 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;
@@ -154,8 +186,11 @@ export interface StartupFailureEvidence {
 /** One seat, one startup prefix. Once execution or its input box is seen, later panes are ineligible. */
 export declare class StartupFailureDetector {
     private readonly adapter;
+    private readonly pattern;
+    private readonly wholePrefix;
     private closed;
-    constructor(adapter: Pick<WorkerAdapter, "inputBox" | "harnessBannerRows">);
+    constructor(adapter: Pick<WorkerAdapter, "inputBox" | "harnessBannerRows">, pattern?: RegExp, // OBS-1169: or known bootstrap text
+    wholePrefix?: boolean);
     sample(output: string, launchedAt: number | undefined): StartupFailureEvidence | undefined;
 }
 /** Test seam — shrink the quota-banner silence gate without minute-long sleeps. */