tickmarkr 1.97.0 → 2.0.0

package/dist/run/environment.d.ts

@@ -4,9 +4,26 @@ export interface RunEnvironment {
     tickmarkrVersion: string;
     configHash: string;
     adapterVersions: Record<string, string>;
+    cores?: number;
+    forkCap?: number;
+}
+/** A record this run wrote: capacity is present by construction, so "absent" cannot compile. */
+export type StampedRunEnvironment = RunEnvironment & {
+    cores: number;
+    forkCap: number;
+};
+/**
+ * Both capacity readings come through providers so a test can state the host it is describing.
+ * The defaults are the same two surfaces production already uses — `availableParallelism` (the one
+ * `deriveForkCap` divides) and `resolvedForkCap`, the run-scoped cap every gate shell inherits —
+ * so nothing here is a second mechanism, and neither number is hardcoded.
+ */
+export interface CapacityProviders {
+    cores?: () => number;
+    forkCap?: () => number;
 }
 export declare const UNKNOWN_ADAPTER_VERSION = "unknown";
 export declare function tickmarkrVersion(): string;
 export declare function configHash(cfg: TickmarkrConfig): string;
 export declare function adapterVersions(channels: BillingChannel[], health: Record<string, AuthHealth>): Record<string, string>;
-export declare function runEnvironment(cfg: TickmarkrConfig, channels: BillingChannel[], health: Record<string, AuthHealth>): RunEnvironment;
+export declare function runEnvironment(cfg: TickmarkrConfig, channels: BillingChannel[], health: Record<string, AuthHealth>, capacity?: CapacityProviders): StampedRunEnvironment;

package/dist/run/environment.js

@@ -1,7 +1,18 @@
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
+import { availableParallelism } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { FORK_CAP_ENV, resolvedForkCap } from "./git.js";
+/**
+ * The cap a gate suite ACTUALLY runs under — the same precedence `sh` applies when it builds a child's
+ * environment (src/run/git.ts): an operator export of VITEST_MAX_FORKS wins, and only when there is
+ * none does the run's own derived cap apply. Recording the derived number while children run at the
+ * operator's would describe a host this run never used.
+ * resolvedForkCap is an AsyncLocalStorage read: it must run INSIDE the run's fork budget (daemon.ts
+ * enters it around the whole run body) or it reports the standalone default instead of this run's cap.
+ */
+const defaultForkCap = () => Number(FORK_CAP_ENV in process.env ? process.env[FORK_CAP_ENV] : resolvedForkCap());
 // An adapter whose version probe failed is recorded, not dropped — "unknown", never a fabricated string.
 export const UNKNOWN_ADAPTER_VERSION = "unknown";
 // Same package.json read as src/cli/commands/version.ts (one resolution pattern, two consumers).
@@ -36,6 +47,12 @@ export function adapterVersions(channels, health) {
     }
     return out;
 }
-export function runEnvironment(cfg, channels, health) {
-    return { tickmarkrVersion: tickmarkrVersion(), configHash: configHash(cfg), adapterVersions: adapterVersions(channels, health) };
+export function runEnvironment(cfg, channels, health, capacity = {}) {
+    return {
+        tickmarkrVersion: tickmarkrVersion(),
+        configHash: configHash(cfg),
+        adapterVersions: adapterVersions(channels, health),
+        cores: (capacity.cores ?? availableParallelism)(),
+        forkCap: (capacity.forkCap ?? defaultForkCap)(),
+    };
 }

package/dist/run/journal.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { type Assignment } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
-import { type GateName, type TaskStatus } from "../graph/schema.js";
+import { type GateName, type Task, type TaskStatus } from "../graph/schema.js";
 import { type ProfileDiscount, type RoutingProfile } from "../route/profile.js";
 import { type DecisionEventWrite, type TrackedJournalRow } from "./protocol.js";
 export interface JournalEvent {
@@ -52,6 +52,36 @@ export declare const UNIDENTIFIED = "<unidentified>";
  * normalized words (see toFinding).
  */
 export declare function structuredFindings(gate: string, details: string, _scopeFiles?: string[]): StructuredFinding[];
+export interface PriorRunJournal {
+    runId: string;
+    events: JournalEvent[];
+}
+export interface PriorFindingEvidence {
+    runId: string;
+    taskId: string;
+    gate: "acceptance" | "review";
+    taskContentDigest: string;
+    finding: StructuredFinding;
+}
+export interface PriorMergeEvidence {
+    runId: string;
+    taskId: string;
+    commit: string;
+    taskContentDigest: string;
+}
+export interface PriorRunEvidence {
+    findings: PriorFindingEvidence[];
+    merges: PriorMergeEvidence[];
+}
+/**
+ * Pure chronological fold over already-bounded journals. Its retirement set is deliberately closed:
+ * task completion or any ordinary approval retires prior findings; review-upheld retains them. A
+ * dispatch failure, a later run-start, a pass, or a merge is inert. Completion is digest-scoped, so
+ * proof for one version of a task cannot clear evidence for another version that reused the id.
+ */
+export declare function foldPriorEvidence(runs: readonly PriorRunJournal[]): PriorRunEvidence;
+/** One rendering shared verbatim by compile diagnostics and the fresh worker's feedback seam. */
+export declare function formatPriorFindingEvidence(evidence: PriorFindingEvidence): string;
 /** Normalized identity of a gate failure: the same defect, seen twice, normalizes to the same bytes. */
 export declare function normalizeGateFailure(details: string): string;
 export declare const GATE_FINGERPRINT_CAP = 2;
@@ -82,11 +112,11 @@ export declare function pendingRepairFindings(events: JournalEvent[], taskId: st
  * a channel it is no longer using, and a later unrelated failure is not parked under a stale reason.
  */
 export declare function activeRetryBan(events: JournalEvent[], taskId: string, channel: string): string | undefined;
-export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch"];
+export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch", "authoring"];
 export type ParkKind = (typeof PARK_KINDS)[number];
 export declare const RETRY_MODES: readonly ["resume", "fresh", "repair"];
 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 declare const WORKER_RESULT_CAUSES: readonly ["provider-death", "dead-channel", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
 export type WorkerResultCause = (typeof WORKER_RESULT_CAUSES)[number];
 export declare function isQualityFailureParkKind(kind: ParkKind): boolean;
 export declare function classifyTaskFailure(taskEvents: JournalEvent[]): ParkKind;
@@ -100,6 +130,8 @@ export declare function classifyWorkerResultCause(opts: {
     exitCode: number | null;
     summary: string;
     timedOut: boolean;
+    /** OBS-548: the daemon's dead-channel fast-kill ended this attempt, not the rolling stall window. */
+    deadChannel?: boolean;
 }): WorkerResultCause | undefined;
 export declare const TelemetryRowSchema: z.ZodObject<{
     taskId: z.ZodString;
@@ -130,6 +162,7 @@ export declare const TelemetryRowSchema: z.ZodObject<{
         stall: "stall";
         "merge-conflict": "merge-conflict";
         "tip-moved": "tip-moved";
+        authoring: "authoring";
     }>>;
     tokens: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         input: z.ZodNumber;
@@ -204,6 +237,10 @@ export declare function readAllTelemetry(repoRoot: string, lastK: number, opts?:
     runId: string;
 })[];
 export declare const RUNS_WINDOW = 50;
+export declare const PRIOR_JOURNAL_RUN_WINDOW = 50;
+export declare function readPriorRunEvidence(repoRoot: string, tasks: readonly Pick<Task, "id" | "goal" | "files" | "acceptance">[], opts?: {
+    suppressRunId?: string;
+}): PriorRunEvidence;
 export declare function readProfileCursor(repoRoot: string): string | undefined;
 export declare function profileDiscountsPath(repoRoot: string): string;
 export declare function readProfileDiscounts(repoRoot: string): ProfileDiscount[];
@@ -228,6 +265,16 @@ export declare class Journal {
     read(): JournalEvent[];
     readTracked(): TrackedJournalRow[];
     replayStatuses(): Map<string, TaskStatus>;
+    /**
+     * OBS-547: the task's latest dispatch IFF a `scope-authoring` event already closed it — the state a
+     * crash between that classification and the park that follows it leaves behind. replayResumeState()
+     * has already rewound that dispatch, so a resumed gate replay must neither take it back a second time
+     * (which erases an EARLIER chargeable attempt) nor attribute the park to the assignment the rewind
+     * restored. null ⇒ the latest dispatch is unclassified: today's accounting, unchanged.
+     */
+    classifiedDispatch(taskId: string): {
+        assignment?: Assignment;
+    } | null;
     replayResumeState(): Map<string, ResumeState>;
     replaySatisfiedGates(): Map<string, GateName>;
     replayCurrentAttemptGateResults(): Map<string, CurrentAttemptGateReplay>;

package/dist/run/journal.js

@@ -3,7 +3,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, tickmarkrDir } from "../graph/graph.js";
+import { stateDirName, taskContentDigest, tickmarkrDir } from "../graph/graph.js";
 import { GATE_NAMES, TIERS } from "../graph/schema.js";
 import { buildProfile, classify } from "../route/profile.js";
 import { DecisionEventSchema, trackJournalRows, } from "./protocol.js";
@@ -190,6 +190,91 @@ export function structuredFindings(gate, details, _scopeFiles = []) {
     }
     return rows;
 }
+const findingRows = (event, gate) => {
+    if (Array.isArray(event.data.findings)) {
+        const rows = event.data.findings.filter((finding) => {
+            if (finding === null || typeof finding !== "object")
+                return false;
+            const row = finding;
+            return typeof row.class === "string" && typeof row.path === "string"
+                && typeof row.symbol === "string" && typeof row.note === "string"
+                && typeof row.fingerprint === "string";
+        });
+        if (rows.length > 0)
+            return rows;
+    }
+    // Compatibility for hand-written/additive journals: the daemon always emits `findings`, but a
+    // digest-bound blocking row still has truthful evidence in details and must not vanish because its
+    // optional structured projection was lost. Missing DIGEST remains fail-closed below.
+    return typeof event.data.details === "string" ? structuredFindings(gate, event.data.details) : [];
+};
+/**
+ * Pure chronological fold over already-bounded journals. Its retirement set is deliberately closed:
+ * task completion or any ordinary approval retires prior findings; review-upheld retains them. A
+ * dispatch failure, a later run-start, a pass, or a merge is inert. Completion is digest-scoped, so
+ * proof for one version of a task cannot clear evidence for another version that reused the id.
+ */
+export function foldPriorEvidence(runs) {
+    const unresolved = new Map();
+    const merges = [];
+    const clearTask = (taskId, digest) => {
+        for (const [key, evidence] of unresolved) {
+            if (evidence.taskId === taskId && (digest === undefined || evidence.taskContentDigest === digest)) {
+                unresolved.delete(key);
+            }
+        }
+    };
+    for (const run of runs) {
+        // task-done immediately precedes merge in daemon journals. This per-run association lets the
+        // existing merge row stay byte-compatible while the stamped completion supplies its task identity.
+        const completedDigest = new Map();
+        for (const event of run.events) {
+            const taskId = event.taskId;
+            if (!taskId)
+                continue;
+            if (event.event === "task-approved") {
+                if (event.data.release !== REVIEW_UPHELD_RELEASE)
+                    clearTask(taskId);
+                continue;
+            }
+            if (event.event === "task-done") {
+                const digest = event.data.taskContentDigest;
+                if (typeof digest === "string") {
+                    clearTask(taskId, digest);
+                    completedDigest.set(taskId, digest);
+                }
+                else {
+                    completedDigest.delete(taskId);
+                }
+                continue;
+            }
+            if (event.event === "merge") {
+                const digest = completedDigest.get(taskId);
+                const commit = event.data.commit;
+                if (digest && typeof commit === "string" && /^[0-9a-f]{40}$/i.test(commit)) {
+                    merges.push({ runId: run.runId, taskId, commit, taskContentDigest: digest });
+                }
+                continue;
+            }
+            const gate = event.data.gate;
+            const digest = event.data.taskContentDigest;
+            if (event.event !== "gate-result" || event.data.pass !== false || event.data.skipped === true
+                || (gate !== "acceptance" && gate !== "review") || typeof digest !== "string")
+                continue;
+            for (const finding of findingRows(event, gate)) {
+                const evidence = {
+                    runId: run.runId, taskId, gate, taskContentDigest: digest, finding,
+                };
+                unresolved.set(`${taskId}\0${digest}\0${finding.fingerprint}`, evidence);
+            }
+        }
+    }
+    return { findings: [...unresolved.values()], merges };
+}
+/** One rendering shared verbatim by compile diagnostics and the fresh worker's feedback seam. */
+export function formatPriorFindingEvidence(evidence) {
+    return `Prior-run EVIDENCE (not a verdict) from ${evidence.runId} ${evidence.gate}: ${evidence.finding.note}`;
+}
 // v1.85 T3: volatile tokens carry no information about WHY a gate failed — ~663m across 5 runs went to
 // re-dispatching against failures that differed only in these. Every rule below erases a token PROVEN
 // to be a diagnostic location or a clock reading; nothing erases a value the failure asserts ABOUT.
@@ -418,13 +503,21 @@ const DispatchAssignmentSchema = z.object({
     channel: z.enum(["sub", "api"]),
     tier: z.enum(TIERS),
 });
+// OBS-547: "authoring" is a scope red every one of whose offenders the collateral map had already
+// named — a missing files[] line, not a worker quality failure. It is deliberately absent from the
+// routing profile's QUALITY_FAIL_PARKS (route/profile.ts): the channel did nothing wrong.
 export const PARK_KINDS = ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota",
-    "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch"];
+    "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch",
+    "authoring"];
 // v1.85 T3: "repair" is a third dispatch mode beside the v1.29 session pair — a fix-only attempt that
 // carries the failing findings and the diff CONTENT of the work already landed, instead of re-buying
 // ~20m of onboarding to rediscover them (62 of 68 measured re-dispatches were fresh).
 export const RETRY_MODES = ["resume", "fresh", "repair"];
-export const WORKER_RESULT_CAUSES = ["provider-death", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
+// OBS-548: "dead-channel" is the fourth conflation OBS-53 opened, named. The dead-channel fast-kill
+// concludes a worker while the rolling stall window still has most of its time left, so labelling it
+// stall-timeout points every downstream reader — the repair brief, the consult — at a mechanism that
+// cannot have fired.
+export const WORKER_RESULT_CAUSES = ["provider-death", "dead-channel", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
 // Status consumes the routing profile's existing quality split directly: verified park kinds classify
 // to 0, while availability/recovery noise classifies to null. Keep the synthetic row here at the
 // run↔route seam so presentation code never grows a second list of "bad" park kinds.
@@ -493,6 +586,10 @@ export function classifyWorkerResultCause(opts) {
     // v1.89 T7: a provider-outage signature is independent of trailer state and has its own remedy.
     if (PROVIDER_OUTAGE_RE.test(opts.output))
         return "provider-death";
+    // OBS-548: the fast-kill is its own mechanism and outranks every trailer-derived field below —
+    // those all bottom out in stall-timeout, which is the one thing this death is NOT.
+    if (opts.deadChannel)
+        return "dead-channel";
     // A stall kill is distinguished by its timeout signal, before any trailer-derived result fields.
     if (opts.timedOut)
         return "stall-timeout";
@@ -721,6 +818,30 @@ export function readAllTelemetry(repoRoot, lastK, opts = {}) {
 }
 // ponytail: fixed 50-run window; promote to a routing.learned.* config knob only if operators need to tune it.
 export const RUNS_WINDOW = 50;
+// OBS-543/OBS-549 use the same documented recency budget the routing profile already trusts. There is
+// one directory enumeration and one journal read per selected run; both compile history and fresh-run
+// feedback consume this function's folded result, so neither grows an unbounded or second reader.
+export const PRIOR_JOURNAL_RUN_WINDOW = RUNS_WINDOW;
+export function readPriorRunEvidence(repoRoot, tasks, opts = {}) {
+    const dir = runsDir(repoRoot);
+    if (!existsSync(dir))
+        return { findings: [], merges: [] };
+    const runIds = readdirSync(dir)
+        .filter((runId) => runId.startsWith("run-") && existsSync(join(dir, runId, "journal.jsonl")))
+        .sort()
+        .slice(-PRIOR_JOURNAL_RUN_WINDOW);
+    const folded = foldPriorEvidence(runIds.map((runId) => ({
+        runId,
+        events: readJsonl(join(dir, runId, "journal.jsonl")),
+    })));
+    const current = new Map(tasks.map((task) => [task.id, taskContentDigest(task)]));
+    return {
+        findings: folded.findings.filter((evidence) => evidence.runId !== opts.suppressRunId
+            && current.get(evidence.taskId) === evidence.taskContentDigest),
+        merges: folded.merges.filter((evidence) => evidence.runId !== opts.suppressRunId
+            && current.get(evidence.taskId) === evidence.taskContentDigest),
+    };
+}
 // VIS-03 reset cursor — one trimmed runId line at .tickmarkr/profile-since; absent/empty ⇒ undefined.
 // Opaque: used ONLY in the runId > comparison above, never a shell or path join beyond .tickmarkr/.
 export function readProfileCursor(repoRoot) {
@@ -907,9 +1028,37 @@ export class Journal {
     // logged attempt 0 two ms after run-resume). Count === max+1 on clean journals and is truthful on
     // corrupted ones. tried is the ordered dedup of channelKey(assignment) across dispatches (≡ the
     // pre-kill tried list). lastAssignment is the last well-formed dispatched assignment.
+    /**
+     * OBS-547: the task's latest dispatch IFF a `scope-authoring` event already closed it — the state a
+     * crash between that classification and the park that follows it leaves behind. replayResumeState()
+     * has already rewound that dispatch, so a resumed gate replay must neither take it back a second time
+     * (which erases an EARLIER chargeable attempt) nor attribute the park to the assignment the rewind
+     * restored. null ⇒ the latest dispatch is unclassified: today's accounting, unchanged.
+     */
+    classifiedDispatch(taskId) {
+        let outstanding = null;
+        let classified = null;
+        for (const e of this.read()) {
+            if (e.taskId !== taskId)
+                continue;
+            if (e.event === "task-dispatch") {
+                const parsed = DispatchAssignmentSchema.safeParse(e.data.assignment);
+                outstanding = parsed.success ? { assignment: parsed.data } : {}; // malformed: closable, unattributable
+                classified = null;
+            }
+            else if (e.event === "scope-authoring" && outstanding) {
+                classified = outstanding; // a duplicate classification closes nothing more (same rule as the replay)
+                outstanding = null;
+            }
+        }
+        return classified;
+    }
     replayResumeState() {
         const m = new Map();
         const pendingReroute = new Set(); // reroute verdicts not yet cleared by a later dispatch
+        // OBS-547: what the last dispatch ADDED, so a scope-authoring event can take it back. An
+        // unchargeable dispatch must replay as if it never happened — no attempt counted, no channel burned.
+        const lastDispatch = new Map();
         const lastReviewFail = new Map(); // OBS-189: newest failed review details per task
         for (const e of this.read()) {
             if (!e.taskId)
@@ -920,7 +1069,7 @@ export class Journal {
             }
             if (e.event === "task-dispatch") {
                 // A subsequent dispatch clears the pending reroute — the reroute was acted on pre-kill.
-                pendingReroute.delete(e.taskId);
+                const consumedReroute = pendingReroute.delete(e.taskId);
                 let st = m.get(e.taskId);
                 if (!st) {
                     st = { attempts: 0, tried: [] };
@@ -930,16 +1079,43 @@ export class Journal {
                 const parsed = DispatchAssignmentSchema.safeParse(e.data.assignment);
                 if (parsed.success) {
                     const key = channelKey(parsed.data);
-                    if (!st.tried.includes(key))
+                    const added = !st.tried.includes(key);
+                    if (added)
                         st.tried.push(key);
+                    lastDispatch.set(e.taskId, {
+                        ...(added ? { addedKey: key } : {}),
+                        prevAssignment: st.lastAssignment,
+                        consumedReroute,
+                    });
                     st.lastAssignment = parsed.data;
                 }
                 else {
+                    lastDispatch.set(e.taskId, { prevAssignment: st.lastAssignment, consumedReroute });
                     // fail closed: malformed assignment still COUNTS (above) but adds nothing to tried and
                     // poisons only lastAssignment (a malformed LAST dispatch must not be restored).
                     st.lastAssignment = undefined;
                 }
             }
+            else if (e.event === "scope-authoring") {
+                // OBS-547: the dispatch this event closes was an authoring defect — the spec is missing a
+                // files[] line and the worker was never at fault. Rewind its accounting so a resume neither
+                // charges the attempt nor treats its channel as burned.
+                // Idempotent: undo the OUTSTANDING dispatch or nothing. A crash between this append and the
+                // park that follows it makes a resume classify again and append a duplicate — the duplicate has
+                // no dispatch left to take back, and an unconditional decrement would erase an EARLIER
+                // chargeable attempt instead (the clamp at zero only hides that when there is no earlier one).
+                const st = m.get(e.taskId);
+                const undo = lastDispatch.get(e.taskId);
+                if (st && undo) {
+                    st.attempts = Math.max(0, st.attempts - 1);
+                    if (undo.addedKey)
+                        st.tried = st.tried.filter((k) => k !== undo.addedKey);
+                    st.lastAssignment = undo.prevAssignment;
+                    if (undo.consumedReroute)
+                        pendingReroute.add(e.taskId);
+                    lastDispatch.delete(e.taskId);
+                }
+            }
             else if (e.event === "consult-verdict" && e.data.action === "reroute") {
                 // A reroute bans the in-force channel; retry/decompose/human verdicts ban nothing (D-03).
                 pendingReroute.add(e.taskId);

package/dist/run/protocol.d.ts

@@ -267,6 +267,7 @@ export declare const DecisionEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strict>], "event">;
 export type DecisionEvent = z.infer<typeof DecisionEventSchema>;
 export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    taskId: z.ZodString;
     data: z.ZodObject<{
         attempt: z.ZodNumber;
         gate: z.ZodEnum<{
@@ -280,9 +281,9 @@ export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         }>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
-    taskId: z.ZodString;
     event: z.ZodLiteral<"gate-phase-start">;
 }, z.core.$strict>, z.ZodObject<{
+    taskId: z.ZodString;
     data: z.ZodObject<{
         attempt: z.ZodNumber;
         gate: z.ZodEnum<{
@@ -305,9 +306,9 @@ export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         }, z.core.$strict>]>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
-    taskId: z.ZodString;
     event: z.ZodLiteral<"gate-result">;
 }, z.core.$strict>, z.ZodObject<{
+    taskId: z.ZodString;
     data: z.ZodObject<{
         attempt: z.ZodNumber;
         role: z.ZodEnum<{
@@ -321,9 +322,9 @@ export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         vendor: z.ZodOptional<z.ZodString>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
-    taskId: z.ZodString;
     event: z.ZodLiteral<"role-invocation-start">;
 }, z.core.$strict>, z.ZodObject<{
+    taskId: z.ZodString;
     data: z.ZodObject<{
         attempt: z.ZodNumber;
         role: z.ZodEnum<{
@@ -351,7 +352,6 @@ export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         }, z.core.$strict>>;
         unmeteredReason: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
-    taskId: z.ZodString;
     event: z.ZodLiteral<"role-invocation-terminal">;
 }, z.core.$strict>, z.ZodObject<{
     data: z.ZodObject<{

package/dist/run/stall.d.ts

@@ -6,6 +6,36 @@ export interface StallProgressSample {
     seedSubmitted?: boolean;
     contextTokens?: number;
 }
+export declare function harvestCpuFlatWindowMs(resolutionMs: number): number;
+/** Test seam — pin the quantization-aware flat window without changing production policy. */
+export declare function setHarvestCpuFlatMsForTests(ms: number): void;
+export declare function resetHarvestCpuFlatMsForTests(): void;
+export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
+    ms: number;
+    resolutionMs: number;
+} | undefined>;
+export declare class WorkerTreeCpuAccountant {
+    private marker;
+    private cwd;
+    private active;
+    private loop;
+    private live;
+    private totalMs;
+    private gaps;
+    private consecutiveGaps;
+    private latest;
+    constructor(marker: string, cwd: string);
+    private sample;
+    start(): Promise<void>;
+    read(): {
+        cpu: {
+            ms: number;
+            resolutionMs: number;
+        } | undefined;
+        gaps: number;
+    };
+    stop(): Promise<void>;
+}
 export declare const NUDGEABLE_ADAPTERS: Set<string>;
 export declare const QUOTA_BANNER_TAIL_ROWS = 12;
 export declare function stallSnapshotTail(text: string, rows?: number): string;