tickmarkr 2.6.1 → 2.6.2

package/dist/run/git.d.ts

@@ -277,6 +277,14 @@ export type BaseContainment = {
  * future `git cherry` ever emitted a `-` line for a merge.
  */
 export declare function declaredBaseContainment(cwd: string, declaredRef: string, targetRef?: string): Promise<BaseContainment>;
+/**
+ * OBS-1107: does `dest` already hold everything `commit` changed? Replays the commit's OWN
+ * parent-to-commit change onto `dest` as a three-way merge; a clean merge whose tree IS `dest`'s tree
+ * brings nothing the destination lacks — a content-empty commit, or a patch already represented there
+ * under another hash. Content, never hash identity. Any git failure (a root commit, a git without
+ * `merge-tree --merge-base`) answers false: unproven work stays unaccounted.
+ */
+export declare function changeRepresented(cwd: string, commit: string, dest?: string): Promise<boolean>;
 export declare function removeWorktree(repo: string, dir: string): Promise<void>;
 export declare const REFS_PREFLIGHT_PREFIX = "refs/tickmarkr/preflight";
 export declare const REFS_PROBE_REMEDY = "run from the main repository or a full clone; a sandbox that denies writes under that path cannot host a run";

package/dist/run/git.js

@@ -863,6 +863,20 @@ export async function declaredBaseContainment(cwd, declaredRef, targetRef = "HEA
     }
     return missing.length > 0 ? { result: "drifted", missing } : { result: "contained", via: "patch-id" };
 }
+/**
+ * OBS-1107: does `dest` already hold everything `commit` changed? Replays the commit's OWN
+ * parent-to-commit change onto `dest` as a three-way merge; a clean merge whose tree IS `dest`'s tree
+ * brings nothing the destination lacks — a content-empty commit, or a patch already represented there
+ * under another hash. Content, never hash identity. Any git failure (a root commit, a git without
+ * `merge-tree --merge-base`) answers false: unproven work stays unaccounted.
+ */
+export async function changeRepresented(cwd, commit, dest = "HEAD") {
+    const merged = await shGit(`git merge-tree --write-tree --merge-base=${shq(`${commit}^`)} ${shq(dest)} ${shq(commit)}`, cwd);
+    if (merged.code !== 0)
+        return false;
+    const tree = await shGit(`git rev-parse ${shq(`${dest}^{tree}`)}`, cwd);
+    return tree.code === 0 && merged.stdout.split("\n")[0].trim() === tree.stdout.trim();
+}
 export async function removeWorktree(repo, dir) {
     await shGit(`git worktree remove --force ${shq(dir)}`, repo); // best-effort; stale dirs are re-added with -B
     await shGit(`rm -rf ${shq(dir)}`, repo);

package/dist/run/journal.d.ts

@@ -18,6 +18,8 @@ export interface ResumeState {
     tried: string[];
     lastAssignment?: Assignment;
     upheldFeedback?: string;
+    escalated?: Record<string, string>;
+    escalatedAdapters?: string[];
 }
 export interface CurrentAttemptGateReplay {
     commit: string;
@@ -29,12 +31,70 @@ export declare const ATTEMPT_CAP_RELEASE: "attempt-cap";
 export declare const GATE_SATISFIED_RELEASE: "gate-satisfied";
 export declare const REVIEW_UPHELD_RELEASE: "review-upheld";
 export declare const RECHECK_RELEASE: "recheck";
+export declare const APPROVAL_REFUSED: "approval-refused";
+/** OBS-1178: the journal row a decision answers — its physical 1-based line plus its timestamp. */
+export interface DecisionBinding {
+    line: number;
+    ts: string;
+}
+/** The token every surface prints and `approve --park` accepts: `<line>@<ts>`. */
+export declare const bindingToken: (binding: DecisionBinding) => string;
+export declare function parseBindingToken(token: string): DecisionBinding | undefined;
+/** The binding a task-approved row recorded under `park` or `failure`, when well formed. */
+export declare function recordedBinding(value: unknown): DecisionBinding | undefined;
+/** The newest failed gate before a park row — the gate a waive of that park would satisfy. */
+export declare function failedGateBeforePark(events: readonly JournalEvent[], taskId: string, parkIndex: number): GateName | undefined;
+/** The physical journal line of `events[i]` (see SOURCE_LINE). */
+export declare const physicalLine: (events: readonly JournalEvent[], i: number) => number;
+/** A row parsed outside this module (a cockpit capture) names its own physical line to the decision fold. */
+export declare const withPhysicalLine: <T extends JournalEvent>(row: T, line: number) => T;
+/** OBS-1178: an approval neither enacted nor refused yet, and — when it may not be enacted — why. */
+export interface OpenDecision {
+    taskId: string;
+    line: number;
+    stale?: string;
+}
+/**
+ * OBS-1178: THE decision fold. Every reader of task-approved rows — the replay folds, the daemon's
+ * startup, sweep and pending-action folds, scope-amendment replay and its audits, status and both
+ * cockpits — reads decisions through it, so no two surfaces can disagree on whether one happened.
+ *
+ * `effective` holds the PHYSICAL lines of the task-approved rows whose effects may apply: a row that
+ * was sound when an enactment row consumed it (bound by line and timestamp to the task's newest park,
+ * a waive also to that park's failed gate, or a recheck to the newest failure with no park after it;
+ * a legacy row carrying no binding only when no park or failure landed between it and that
+ * enactment), plus a row still open that is sound NOW. A refused row is never effective, and neither is an open row that no
+ * longer binds — a newer park or failure landed, or it names none — whatever unrelated rows landed
+ * around it. An enactment row also consumes the task's park and failure: a decision naming either
+ * after the task moved on is stale, while the decisions that enactment already consumed stay effective.
+ * `open` lists every unenacted, unrefused row with why it may not be enacted, and `refused` the lines
+ * an approval-refused row answered.
+ */
+export declare function foldDecisions(events: readonly JournalEvent[]): {
+    effective: Set<number>;
+    open: OpenDecision[];
+    refused: Set<number>;
+};
+/** The physical lines of the task-approved rows whose effects may apply (see foldDecisions). */
+export declare const effectiveDecisions: (events: readonly JournalEvent[]) => Set<number>;
+/**
+ * The journal as every decision reader must see it: task-approved rows that are not effective removed,
+ * every other row (and its physical line) kept. Order-only folds iterate this instead of skipping rows
+ * on their own.
+ */
+export declare function effectiveEvents(events: readonly JournalEvent[]): JournalEvent[];
+/** Per task, the open decisions that may not be enacted now — what the daemon refuses before enactment. */
+export interface StaleApprovals {
+    reason: string;
+    lines: number[];
+}
+export declare function staleApprovals(events: readonly JournalEvent[]): Map<string, StaleApprovals>;
 export interface PreservedRef {
     ref: string;
     diffCommand: string;
 }
 export declare function preservedRefsByTask(events: JournalEvent[]): Map<string, PreservedRef[]>;
-export declare function reviewRoundsSinceApproval(events: JournalEvent[], taskId: string): number;
+export declare function reviewRoundsSinceApproval(events: JournalEvent[], taskId: string, rounds?: (decided: JournalEvent[]) => JournalEvent[]): number;
 export declare function upheldFeedbackByTask(events: JournalEvent[]): Map<string, string>;
 export interface StructuredFinding {
     class: string;
@@ -177,6 +237,7 @@ export type PendingApprovalAction = {
  * enacts it.
  */
 export declare function pendingApprovalActions(events: JournalEvent[]): Map<string, PendingApprovalAction>;
+export declare function approvalAction(taskId: string, e: JournalEvent): PendingApprovalAction;
 /**
  * Why the last attempt failed, one row per journaled cause, in the daemon's own `source: details`
  * shape. The daemon builds that brief in a loop-local variable, which dies with the process: a resumed
@@ -192,10 +253,20 @@ export declare function pendingApprovalActions(events: JournalEvent[]): Map<stri
  * failures OR the delivery failure that preceded it. Of the approvals, only a WAIVE clears (the operator
  * retired the findings by fiat — the uphold case re-derives its own brief separately). OBS-1074: a
  * plain approve, a scope grant or a recheck re-funds an attempt that must still see why the last one
- * parked, plus the operator's stated reason — v2.5.7's T11 looped four times on one hygiene oracle
- * because every approval erased exactly the finding the fresh attempt was funded to fix.
+ * parked — v2.5.7's T11 looped four times on one hygiene oracle because every approval erased exactly
+ * the finding the fresh attempt was funded to fix. The operator's stated reasons ride after those rows
+ * as `standingRulings` (OBS-1150): no launch and no waive resets them.
  */
 export declare function journaledFailureBrief(events: JournalEvent[], taskId: string): string[];
+/**
+ * OBS-1150: an operator's approval reason is a ruling on the TASK, not on the attempt it released.
+ * The failure rows above are spent at the next worker-launch and the review context once bound only
+ * the newest reason, so ruling A vanished at the first launch after it and a later ruling B replaced
+ * it. Every effective reason therefore stands, oldest first, for the whole run; a repeat is carried
+ * once. A gate-satisfied release accepts a gate's verdict rather than ruling on the work, so its
+ * reason adds no standing ruling — and, being no ruling, it retires none either.
+ */
+export declare function standingRulings(events: JournalEvent[], taskId: string): string[];
 /** Never infer a cross-path alias from a symbol, sentence, or hash. */
 export declare function reviewFingerprintMatches(candidate: unknown, fingerprint: string): boolean;
 export declare function observedReviewFingerprints(finding: StructuredFinding): string[];
@@ -256,6 +327,32 @@ export type WorkerResultCause = (typeof WORKER_RESULT_CAUSES)[number];
 export declare function isQualityFailureParkKind(kind: ParkKind): boolean;
 export declare function classifyTaskFailure(taskEvents: JournalEvent[]): ParkKind;
 export declare function recordedTaskFailureKind(events: JournalEvent[], taskId: string): ParkKind | undefined;
+export declare const RESUME_HARVEST_SOURCE: "resume";
+export interface InterruptedAttempt {
+    attempt: number;
+    /** The producing dispatch's own assignment — the author the harvested work is gated under. */
+    assignment: Assignment;
+    /** Owned evidence still to read: nothing of this attempt's harvest is recorded yet. */
+    launch?: {
+        nonce: string;
+        dispatchScript: string;
+        slot: {
+            id: string;
+            name: string;
+            cwd: string;
+        };
+    };
+    /** A worker-result with no harvest row after it: finish that record. `reaped` only when a resume wrote
+     *  it — a resume records the result after its owned-process cleanup; a live daemon records it BEFORE
+     *  handling a failed reap, so its result alone never proves cleanup and `launch` must be reaped again. */
+    result?: {
+        finished: boolean;
+        summary: string;
+        reaped: boolean;
+    };
+}
+export declare function resumeHarvestAuthor(events: JournalEvent[], taskId: string): Assignment | undefined;
+export declare function interruptedAttempt(events: JournalEvent[], taskId: string): InterruptedAttempt | undefined;
 export declare function runHasEnded(events: JournalEvent[]): boolean;
 /** OBS-53: classify worker-result failures so retries and routing see the true signal, not one lumped bucket. */
 export declare function classifyWorkerResultCause(opts: {
@@ -392,6 +489,8 @@ export type EngagementCompare = {
 export declare function engagementComparable(events: JournalEvent[], loadedHash: string): EngagementCompare;
 export declare function newRunId(now?: Date): string;
 export declare function parseRunId(runId: string): string;
+/** The journal reader rule over bytes in hand: skip blanks, drop a torn line, keep each row's physical line. */
+export declare function parseJournalText(raw: string): JournalEvent[];
 export declare function readAllTelemetry(repoRoot: string, lastK: number, opts?: {
     after?: string;
 }): (TelemetryRow & {
@@ -402,6 +501,23 @@ 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 const REVIEW_NO_VERDICT_RUN_WINDOW = 10;
+export declare const REVIEW_NO_VERDICT_ADVISORY_AT = 2;
+export interface ReviewNoVerdictHistory {
+    /** completed runs measured, oldest first */
+    runs: string[];
+    /** window journals with a row that did not parse — their events are unknown, never zero */
+    unreadable: string[];
+    /** reviewer channel → review-no-verdict events; every channel seen reviewing is present, 0 included */
+    counts: Map<string, number>;
+}
+export declare function readReviewNoVerdictHistory(repoRoot: string, window?: number): ReviewNoVerdictHistory;
+/** One row per measured channel (plus one naming unreadable journals); doctor prints all, Fleet the warn rows. */
+export declare function reviewNoVerdictRows(history: ReviewNoVerdictHistory): {
+    channel: string;
+    verdict: "pass" | "warn";
+    value: string;
+}[];
 export declare function readProfileCursor(repoRoot: string): string | undefined;
 export declare function profileDiscountsPath(repoRoot: string): string;
 export declare function readProfileDiscounts(repoRoot: string): ProfileDiscount[];
@@ -424,6 +540,13 @@ export declare class Journal {
     append(event: string, taskId?: string, data?: Record<string, unknown>): void;
     phaseStart(taskId: string, phase: TaskPhase, data?: Record<string, unknown>): void;
     read(): JournalEvent[];
+    /** Parsed rows paired with their physical 1-based journal lines (OBS-1178 bindings name lines). */
+    readSourced(): {
+        events: JournalEvent[];
+        lines: number[];
+    };
+    /** OBS-1178: the binding of a task's newest park (or `task-failed`) row — what a decision on it names. */
+    newestBinding(taskId: string, event?: "task-human" | "task-failed"): DecisionBinding | undefined;
     readTracked(): TrackedJournalRow[];
     replayStatuses(): Map<string, TaskStatus>;
     /**