tickmarkr 2.6.2 → 2.6.4

package/dist/run/interactive-seed.d.ts

@@ -1,4 +1,5 @@
 import { type Assignment, type WorkerAdapter } from "../adapters/types.js";
+import { DeliveryReadinessError } from "../drivers/herdr.js";
 import type { ExecutorDriver, Slot } from "../drivers/types.js";
 export interface InteractiveSeedResult {
     output: string;
@@ -8,6 +9,9 @@ export interface InteractiveSeedResult {
     trustAnswered: boolean;
 }
 type SeedDriver = Pick<ExecutorDriver, "run" | "waitOutput" | "read" | "sendKey">;
+export declare class SeedReadinessError extends DeliveryReadinessError {
+    constructor(waitedMs: number, transcript: string, readinessMatch: string);
+}
 export declare function runInteractiveSeed(opts: {
     driver: SeedDriver;
     slot: Slot;

package/dist/run/interactive-seed.js

@@ -1,4 +1,5 @@
 import { matchesTrustDialog } from "../adapters/types.js";
+import { DeliveryReadinessError } from "../drivers/herdr.js";
 // The workspace-trust prompt is a STARTUP gate: it renders before the readiness banner and blocks
 // it, so this wait is the only window in which anything can answer it. Observation therefore runs
 // for the WHOLE readiness budget. Review round 7 (material): a 60-second cutoff here was a window
@@ -9,6 +10,18 @@ import { matchesTrustDialog } from "../adapters/types.js";
 // blocked anyway, and it ends at the first of readiness, a modal, or the deadline.
 const TRUST_POLL_MS = 1_000;
 const TRUST_PANE_ROWS = 80;
+// OBS-1205 add.1: a launch whose readiness never appeared never received the brief, so its deadline is
+// the delivery-readiness class (OBS-142: the interface never became interactive), not a launched
+// worker. Thrown as that class, the daemon's existing catch journals `delivery-readiness-failed`,
+// closes the slot and walks the escalation ladder to a failover — with no `worker-launch` row, which is
+// where a funded repair's findings expire, so the repair the seed never delivered stays owed.
+export class SeedReadinessError extends DeliveryReadinessError {
+    constructor(waitedMs, transcript, readinessMatch) {
+        super(waitedMs, transcript);
+        this.name = "SeedReadinessError";
+        this.message = `seed readiness pattern not seen after ${waitedMs}ms: ${readinessMatch}`;
+    }
+}
 // v1.89 T19 / OBS-406: wait for readiness, answering a fingerprint-matched trust modal at most ONCE
 // on the way. The daemon's own trust loop runs only after runInteractiveSeed returns, and this wait
 // is exactly the window the modal blocks in — a declaration consulted only there is unreachable
@@ -17,23 +30,34 @@ async function awaitReadiness(opts) {
     const { driver, slot, readinessMatch, deadline } = opts;
     const dialog = opts.adapter.trustDialog;
     const left = () => Math.max(0, deadline - Date.now());
+    // Every wait below is awaited, and the budget can run out inside any of them (OrcaDriver.waitOutput
+    // checks its sweep before its clock). Readiness a wait returns after the deadline is expired — it may
+    // be what a key pressed at the edge produced — and a launch whose deadline passed has already
+    // failed, so neither a key nor a seed follows it. Both branches apply it.
+    const expired = () => Date.now() >= deadline;
+    const readyInTime = async (ms) => (await driver.waitOutput(slot, readinessMatch, ms)) && !expired();
     // Nothing this launch could answer (no declaration, an honest {kind:"none"}, or a driver with no
-    // keystroke surface): the single long wait, byte-identical to pre-T19 behaviour.
+    // keystroke surface): the single long wait, pre-T19 behaviour plus the post-await deadline check.
     if (!dialog || dialog.kind === "none" || !driver.sendKey) {
-        return { ready: await driver.waitOutput(slot, readinessMatch, left()), trustAnswered: false };
+        return { ready: await readyInTime(left()), trustAnswered: false };
     }
     let trustAnswered = false;
-    while (!trustAnswered && left() > 0) {
-        if (await driver.waitOutput(slot, readinessMatch, Math.min(TRUST_POLL_MS, left()))) {
+    while (!trustAnswered && !expired()) {
+        if (await readyInTime(Math.min(TRUST_POLL_MS, left()))) {
             return { ready: true, trustAnswered };
         }
         let paneText;
         try {
-            paneText = await driver.read(slot, TRUST_PANE_ROWS);
+            // OBS-1205: a cursor-drawn modal has text only on the RENDERED frame, so the slot's screen read
+            // is preferred when its driver has one. An unreadable or foreign frame is a failed read, never
+            // a cue to match the stream instead; drivers without a screen keep polling `read`.
+            paneText = await (slot.readScreen ? slot.readScreen() : driver.read(slot, TRUST_PANE_ROWS));
         }
         catch {
             continue; // a failed read is not a matched modal — keep observing, spend nothing
         }
+        if (expired())
+            break; // the wait or the read outlived the budget: no key after the deadline
         if (!matchesTrustDialog(paneText, dialog))
             continue;
         // Review round 7 (material): the latch is spent BEFORE the awaited send, not after it. A send
@@ -54,7 +78,8 @@ async function awaitReadiness(opts) {
             /* dispatched-then-rejected: never retried here, and never re-tried by the daemon either */
         }
     }
-    return { ready: await driver.waitOutput(slot, readinessMatch, left()), trustAnswered };
+    // An expired budget gets no closing sweep: a zero-length wait still reads the terminal once.
+    return { ready: !expired() && await readyInTime(left()), trustAnswered };
 }
 // v1.69 T6: launch-then-seed handoff for adapters whose real TUI cannot be argv-seeded.
 // Both the launch command and the seed line are delivered through the driver's existing `run`
@@ -65,6 +90,8 @@ export async function runInteractiveSeed(opts) {
     await opts.driver.run(opts.slot, seed.launch(opts.assignment.model));
     // `trustAnswered` rides EVERY return below, including both early ones: the daemon initializes its
     // per-slot latch from it, and an omission there reads as "no key was sent" — the second-Enter defect.
+    // The readiness deadline throws instead; `onTrustAnswered` already carried the latch out.
+    const launchedAt = Date.now();
     const { ready, trustAnswered } = await awaitReadiness({
         driver: opts.driver,
         slot: opts.slot,
@@ -74,9 +101,8 @@ export async function runInteractiveSeed(opts) {
         ...(opts.onTrustAnswered ? { onTrustAnswered: opts.onTrustAnswered } : {}),
     });
     const banner = await opts.driver.read(opts.slot, 1000);
-    if (!ready) {
-        return { output: banner, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}`, trustAnswered };
-    }
+    if (!ready)
+        throw new SeedReadinessError(Date.now() - launchedAt, banner, seed.readinessMatch);
     let sessionId;
     if (seed.confirmBanner) {
         const confirm = seed.confirmBanner(banner, opts.assignment.model);

package/dist/run/journal.d.ts

@@ -107,6 +107,8 @@ export interface StructuredFinding {
     observedFingerprints?: string[];
     /** Prior id validated against the reviewer's reraised list by the review gate. */
     reraisedFrom?: string;
+    /** OBS-1195: an anchor's explicitly named parent chain; it retires when that chain is resolved. */
+    boundTo?: string;
     /** Resolved definition AND defect identity; bare symbol spelling is never lineage. */
     codeIdentity?: {
         definition: string;
@@ -185,7 +187,10 @@ export declare function formatPriorFindingEvidence(evidence: PriorFindingEvidenc
 /** 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;
+/** The invocation a gate row's receipt names — the identity of the execution that observed it. */
+export declare const receiptOrigin: (data: Record<string, unknown>) => string | undefined;
 export declare function identicalGateFailures(events: JournalEvent[], taskId: string, gate: string, normalized: string): number;
+export declare const readableExcerpt: (text: string) => string;
 /** What each funded repair's next battery actually reached. A repair spends its budget only
  * when that battery reaches one of the gates it was funded to fix; an earlier red is evidence that
  * this repair never got its funded turn, not a charge against the repair ladder. */
@@ -309,7 +314,28 @@ export declare function carryReviewFindings(priors: readonly StructuredFinding[]
  * after round re-seats ONE fingerprint, and a revised rationale replaces the prior rationale on that
  * row. N rounds of the same concern therefore carry the newest accepted explanation once, not N rows.
  */
+/** OBS-1151: this task's journaled judgments, newest first — subjects to compare a fresh ruling against,
+ * never verdicts to reuse. A row without a well-formed judgment (legacy, park, unparseable) is skipped. */
+export declare function priorJudgments(events: readonly JournalEvent[], taskId: string): Array<{
+    commit: string;
+    judge?: string;
+    criteria: Array<{
+        id: string;
+        key: string;
+        met: boolean;
+        paths: string[];
+    }>;
+}>;
 export declare function outstandingReviewFindings(events: JournalEvent[], taskId: string): StructuredFinding[];
+/**
+ * OBS-1019 add.2: each outstanding material chain with the number of valid review verdicts that
+ * re-raised it since the last review pass or review-gate waive. Only a chain's own observed spellings
+ * count, so an unrelated finding sharing a path never lengthens it.
+ */
+export declare function reraisedReviewChains(events: JournalEvent[], taskId: string): Array<{
+    finding: StructuredFinding;
+    reraises: number;
+}>;
 /** The findings a funded repair must carry into the next dispatch, or undefined if none is pending. */
 export declare function pendingRepairFindings(events: JournalEvent[], taskId: string): string | undefined;
 /**
@@ -409,8 +435,8 @@ export declare const TelemetryRowSchema: z.ZodObject<{
     quotaFailover: z.ZodOptional<z.ZodLiteral<true>>;
     overrun: z.ZodOptional<z.ZodLiteral<true>>;
     retryMode: z.ZodOptional<z.ZodEnum<{
-        repair: "repair";
         resume: "resume";
+        repair: "repair";
         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>]>>;
@@ -567,4 +593,100 @@ export declare class Journal {
     readTelemetry(): TelemetryRow[];
     readJudgeTelemetry(): TelemetryRow[];
 }
+export declare const OWED_CHECK_VERSION: 1;
+export declare const OWED_DISCHARGE_EVENT: "owed-check-discharged";
+export interface OwedCheck {
+    version: typeof OWED_CHECK_VERSION;
+    id: string;
+    runId: string;
+    taskId: string;
+    gate: GateName;
+    /** The immutable range the waived gate measured, and its canonical subject (daemon gateCommitSubject). */
+    base: string;
+    head: string;
+    subject: string;
+    /** Verbatim (whitespace-sensitive) patch identity of the whole range and of each commit, in order — the integration mapping key. */
+    patch: string;
+    patches: string[];
+    criteria: string;
+    /** The task's file scope at waive time: a discharge gates exactly this allowlist, never a wider one. */
+    files: string[];
+    authors: string[];
+    /** The channels this repository's adapters declared under its config at waive time (key → vendor):
+     *  the only seats a review discharge's reviewer and author channels may resolve to. */
+    declared: ChannelFact[];
+    cause: string;
+    evidence: string;
+    disposition: "accepted-risk";
+    known: boolean;
+    unknownReason?: string;
+}
+export interface OwedFold {
+    known: boolean;
+    debt: number | "unknown";
+    outstanding: OwedCheck[];
+    acceptedRisk: OwedCheck[];
+    discharged: string[];
+    unknown: Array<{
+        taskId?: string;
+        gate?: string;
+        reason: string;
+    }>;
+}
+export declare const owedCriteria: (acceptance: unknown) => string;
+/** The daemon's canonical gate subject for base..head (daemon.ts gateCommitSubject), byte for byte. */
+export declare const owedSubject: (cwd: string, base: string, head: string) => string;
+/** Ordered verbatim patch ids of the commits in base..head; an empty commit authored no patch. */
+export declare const rangePatches: (cwd: string, base: string, head: string) => string[];
+/** Verbatim patch identity of the whole change base..head introduces. */
+export declare const rangePatch: (cwd: string, base: string, head: string) => string;
+/**
+ * `head` is the task's own recorded integration merge of the obligation's range — exactly. Its first
+ * parent is `mergeBase`; its second parent replays the waived history source tree for source tree from
+ * a base with the waived base's tree (a carry may mint new commit objects, never new content — and
+ * patch ids alone ignore where a hunk lands); its tree is git's own clean merge of the two (no
+ * resolution, no amend); and it introduced the same ordered verbatim patch series and total patch.
+ * Squashed, reordered, relocated, re-indented, reverted or conflict-resolved history fails one of
+ * these and is refused as ambiguous; containment never counts.
+ * Both verify (before discharging) and the fold (re-reading every discharge) decide through here.
+ */
+export declare function integrationMapped(cwd: string, events: readonly JournalEvent[], o: OwedCheck, mergeBase: unknown, head: unknown): boolean;
+/**
+ * Lifetime patch authors of base..head, read from the run: the daemon's subjectAuthors fold
+ * (daemon.ts, not exported and not this task's to edit) restated synchronously so the waive row is
+ * written without yielding. Recreation rows name SOURCE hashes, so ownership joins by stable patch
+ * identity across changed commit objects; a gate-only restore (resume-restore's seat, a recreation
+ * after work started) never becomes an author. Unreadable history names an unknown author.
+ */
+export declare function owedAuthors(events: readonly JournalEvent[], taskId: string, cwd: string, base: string, head: string): string[];
+/**
+ * The obligation a waive of `gate` leaves on the task branch's current range. Synchronous on purpose:
+ * approve writes it into the waive row under the approval serialization without yielding, so a live
+ * daemon's boundary sees the same single append it always did. Anything not bound exactly — the
+ * waived row measured another subject, unreadable refs, unresolved authors, unreadable criteria — is
+ * recorded, never guessed, as known: false.
+ */
+export declare function captureOwedCheck(input: {
+    cwd: string;
+    runId: string;
+    taskId: string;
+    gate: GateName;
+    cause: string;
+    acceptance: unknown;
+    files: unknown;
+    declared: readonly ChannelFact[] | undefined;
+    taskRef: string;
+    integrationRef: string;
+    events: readonly JournalEvent[];
+}): OwedCheck;
+export type ChannelFact = {
+    key: string;
+    vendor: string;
+};
+/**
+ * The CURRENT owed-check fold: accepted-risk history, outstanding debt, and whether it is known.
+ * `cwd` is any checkout of the run's repository (integration discharges are re-proved from git).
+ * It never throws: a fold that cannot be computed is unknown debt, not a crash and never zero.
+ */
+export declare function foldOwedChecks(events: readonly JournalEvent[], cwd: string): OwedFold;
 export {};