tickmarkr 1.86.0 → 1.89.0

package/dist/run/daemon.d.ts

@@ -1,6 +1,7 @@
 import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
 import { type ExecutorDriver } from "../drivers/types.js";
+import type { GateResult } from "../gates/types.js";
 import { Journal, type JournalEvent } from "./journal.js";
 export interface RunOptions {
     runId?: string;
@@ -15,6 +16,7 @@ export interface RunOptions {
     mode?: RoutingMode;
     narrate?: (event: JournalEvent) => void;
     exit?: (code: number) => void;
+    supervise?: boolean;
 }
 export type ModeSource = "run flag" | "spec" | "repo config" | "global config" | "default";
 export interface ResolvedRunMode {
@@ -40,8 +42,45 @@ export interface RunSummary {
     blocked: string[];
     tipVerify?: "passed" | "failed";
     lastMergedTask?: string;
+    /** T14: did every approval this run accepted actually get enacted, or did the run end over one? */
+    approvalDisposition?: "complete" | "outstanding";
+    /** the accepted approvals that never reached a dispatch — named, never left to the park buckets */
+    outstandingApprovals?: string[];
 }
+/**
+ * T14: approvals the run accepted and never acted on. `approved` above is built ONCE at startup —
+ * deliberately, replay determinism depends on it — so an approval written while the daemon is live is
+ * inert for that run. Without this the run-end record stated only buckets and tipVerify, both
+ * accurate, over a milestone that was silently incomplete: run …230 ended tipVerify "passed" with two
+ * upheld approvals and zero subsequent dispatches. Scored per task on its NEWEST approval: a later
+ * approval is the live decision, and the events that answer it are the ones after it.
+ */
+export declare function outstandingApprovals(events: JournalEvent[]): string[];
 export declare function formatSummary(s: RunSummary): string;
+/**
+ * R3 (OBS-186): a gate that DECLINED to run is not a gate that failed. The review gate's skip branch
+ * no longer forges `pass: true` to buy passage, so the merge decision has to read the same predicate
+ * the run surfaces already read (src/run/activity.ts): pass, or an honest declared skip. Without this
+ * the honesty change would silently park every judge-only task at merge — an unrun gate blocking work
+ * it was never asked to review. `skipped` is set only by a gate that says so about ITSELF; a red
+ * verdict from a review that actually ran still fails here, exactly as before.
+ *
+ * ONE pair of predicates, every fold. `!g.pass` was correct only while the sole `pass:false` producer
+ * was a gate that actually failed; the moment a decline can be recorded red, every `!g.pass` in this
+ * file — the retry feedback brief, the review-fix eligibility test, the failing-battery list the
+ * ladder and the fingerprint cap are scored on, the structured findings attached to a blocking
+ * verdict — reads an unrun gate as a defect. `gateFailed` is the seam they now share, and the journal
+ * write below is the seam every OUT-of-file fold shares.
+ */
+/**
+ * T9: `meta.infra === true` overrides BOTH clauses above. A runner that died on the machine
+ * (spawn EAGAIN, OOM) without completing a suite answered nothing about the work, so the honest
+ * report of that fact must not double as authorization to merge — and it is the merge predicate,
+ * not the gate, that has to say so: classifying the failure into infra metadata while still
+ * reporting `pass: true` is exactly how a run that never verified anything gets merged. A declared
+ * skip stays satisfied; a gate that ran and passed stays satisfied.
+ */
+export declare const gateSatisfied: (g: GateResult) => boolean;
 /**
  * T4 (OBS-265): the journal with the review objections a round did NOT hinge on removed. Judge and
  * review are now launched together, so a round can journal a failed review that the serial walk would
@@ -97,4 +136,7 @@ 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;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;