tickmarkr 2.6.0 → 2.6.2

package/dist/run/merge.d.ts

@@ -1,5 +1,5 @@
 import type { TickmarkrConfig } from "../config/config.js";
-import { type Baseline, type GateEvidenceOptions, type FailureClassification } from "../gates/baseline.js";
+import { type Baseline, type BaselineProvenance, type GateEvidenceOptions, type FailureClassification } from "../gates/baseline.js";
 import type { GateEvidenceReceipt } from "./protocol.js";
 export interface TipVerifyResult {
     evidenceReceipt?: GateEvidenceReceipt;
@@ -21,6 +21,8 @@ export interface TipVerifyResult {
     spawnedCommand?: string;
     /** Q121s: nonzero exit whose failures are ALL baseline-recorded — forgiven exactly as the battery forgives. */
     forgiven?: boolean;
+    /** OBS-1123: the capture that recorded the forgiven fingerprints; absent for a legacy baseline that never said. */
+    baselineProvenance?: BaselineProvenance;
     /** D-131: carried from a persisted per-gate verdict — this cycle did NOT execute the command. */
     reused?: true;
     /**

package/dist/run/merge.js

@@ -225,6 +225,7 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline, ev
                 exitCode: hit.exitCode ?? 0,
                 fingerprints: hit.meta?.fingerprints ?? [],
                 ...(hit.meta?.forgiven ? { forgiven: true } : {}),
+                ...(hit.meta?.forgiven && hit.meta.baselineProvenance ? { baselineProvenance: hit.meta.baselineProvenance } : {}),
                 details: formatReusedDetails(hit.details, id),
                 ...(hit.meta?.reportPath ? { reportPath: hit.meta.reportPath } : {}),
                 ...(hit.meta?.spawnedCommand ? { spawnedCommand: hit.meta.spawnedCommand } : {}),
@@ -382,7 +383,7 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline, ev
                                 + `${describeCapacity(entry?.capacity)} and this verification ran under ${describeCapacity(r.capacity)} `
                                 + `— forgiveness across a changed capacity is not evidence`
                             : `exit ${r.code}`)),
-            ...(forgiven && !deficit ? { forgiven: true } : {}),
+            ...(forgiven && !deficit ? { forgiven: true, ...(baseline?.provenance ? { baselineProvenance: baseline.provenance } : {}) } : {}),
             ...(cause ? { cause } : {}),
             ...(pass ? {} : { artifact }),
         };
@@ -401,7 +402,7 @@ export async function verifyIntegrationTip(intWt, commands, runDir, baseline, ev
         const id = pending.get(result.gate);
         if (id && id.tree === completedTree && !isInfraResult(result)) {
             store.set(id, { ...result, meta: {
-                    fingerprints: result.fingerprints, forgiven: result.forgiven,
+                    fingerprints: result.fingerprints, forgiven: result.forgiven, baselineProvenance: result.baselineProvenance,
                     reportPath: result.reportPath, spawnedCommand: result.spawnedCommand,
                     artifact: result.artifact,
                     evidenceReceipt: result.evidenceReceipt, evidenceReceipts: result.evidenceReceipts,

package/dist/run/operator-state.d.ts

@@ -11,11 +11,18 @@ export interface OperatorRecord extends EvidenceIdentity {
     event: JournalEvent;
 }
 export type OperatorTaskState = "unknown" | "pending" | "running" | "completed" | "merged" | "failed" | "human" | "blocked";
-export type OperatorGateState = "unknown" | "not-run" | "disabled" | "running" | "passed" | "failed";
+export type OperatorGateState = "unknown" | "not-run" | "disabled" | "queued" | "running" | "passed" | "failed";
 export interface OperatorGate {
     state: OperatorGateState;
     evidence?: EvidenceIdentity;
 }
+export interface GateActivity {
+    state: "queued" | "running";
+    gate?: string;
+    reason?: "suite-wait" | "host-degraded";
+    count?: number;
+    evidence: EvidenceIdentity;
+}
 export interface OperatorTask {
     id: string;
     title?: string;
@@ -30,10 +37,14 @@ export interface OperatorTask {
     evidence?: EvidenceIdentity;
     mergeEvidence?: EvidenceIdentity;
     gates: Record<string, OperatorGate>;
+    gateActivity?: GateActivity;
     /** BD-1: the board's per-task counters — latest dispatch channel, review verdicts drawn, human parks. */
     channel?: string;
     reviewRounds: number;
     parks: number;
+    /** Distinct producing channels of the merged subject from task-done; "unknown" names unattributed preserved work.
+     * Kept apart from `channel`: the last-dispatched seat may have authored nothing. */
+    authors?: readonly string[];
 }
 export interface OperatorSnapshot {
     sequence: number;
@@ -47,6 +58,10 @@ export interface OperatorSnapshot {
     label: string;
     green: boolean;
     currentTip: "passed" | "not required" | "pending" | "failed" | "unknown";
+    graphAvailability?: {
+        status: "readable" | "absent" | "unreadable";
+        error?: string;
+    };
     comparable: boolean;
     comparison: "matching graph" | "not comparable";
     merged: number;
@@ -60,6 +75,12 @@ export interface OperatorSnapshot {
     latestRunEnd?: EvidenceIdentity;
     approvedResumeRequired: boolean;
 }
+/** Author channels recorded on a task-done row. A row written before authors were recorded carries none and
+ * projects nothing (never the dispatch); unattributed preserved work arrives as an explicit "unknown" entry. */
+export declare const doneAuthors: (data: Record<string, unknown>) => string[] | undefined;
+/** The note a status row or board row shows beside the last-dispatched channel when the merged
+ * authors are not exactly that channel (a carry-only seat, a mixed subject, or legacy unknown). */
+export declare const authorsNote: (authors: readonly string[] | undefined, channel: string | undefined) => string | undefined;
 /** Incremental pure lifecycle fold. Retains facts per task/gate, never verdict bodies or event history. */
 export declare class OperatorStateFold {
     private tasks;
@@ -78,11 +99,12 @@ export declare class OperatorStateFold {
     private total;
     apply(record: OperatorRecord): void;
     private task;
-    snapshot({ graph, sequence, observedAt, readable }?: {
+    snapshot({ graph, sequence, observedAt, readable, graphAvailability }?: {
         graph?: RunGraph;
         sequence?: number;
         observedAt?: number;
         readable?: boolean;
+        graphAvailability?: OperatorSnapshot["graphAvailability"];
     }): OperatorSnapshot;
     private comparableTo;
 }

package/dist/run/operator-state.js

@@ -5,6 +5,12 @@ const bucketNames = ["failed", "human", "blocked", "pending"];
 const strings = (value) => Array.isArray(value) && value.every(v => typeof v === "string") ? [...value] : undefined;
 const identity = ({ source, line, id, generation }) => ({ source, line, id, generation });
 const emptyGates = () => Object.fromEntries(GATE_NAMES.map(g => [g, { state: "not-run" }]));
+/** Author channels recorded on a task-done row. A row written before authors were recorded carries none and
+ * projects nothing (never the dispatch); unattributed preserved work arrives as an explicit "unknown" entry. */
+export const doneAuthors = (data) => strings(data.authors);
+/** The note a status row or board row shows beside the last-dispatched channel when the merged
+ * authors are not exactly that channel (a carry-only seat, a mixed subject, or legacy unknown). */
+export const authorsNote = (authors, channel) => authors === undefined || (authors.length === 1 && authors[0] === channel) ? undefined : `authors ${authors.join("+")}`;
 /** Incremental pure lifecycle fold. Retains facts per task/gate, never verdict bodies or event history. */
 export class OperatorStateFold {
     tasks = new Map();
@@ -75,6 +81,7 @@ export class OperatorStateFold {
             t.dispatches++;
             t.parkKind = undefined;
             t.gates = emptyGates();
+            t.gateActivity = undefined;
             t.attempt = typeof e.data.attempt === "number" ? e.data.attempt : undefined;
             // These are recorded values only: no guessed directory or universal silence threshold.
             t.path = typeof e.data.worktree === "string" ? e.data.worktree : typeof e.data.cwd === "string" ? e.data.cwd : undefined;
@@ -84,8 +91,10 @@ export class OperatorStateFold {
             if (a && typeof a.adapter === "string" && typeof a.model === "string")
                 t.channel = `${a.adapter}:${a.model}`;
         }
-        if (e.event === "task-done")
+        if (e.event === "task-done") {
             t.state = "completed";
+            t.authors = doneAuthors(e.data);
+        }
         if (e.event === "merge") {
             t.state = "merged";
             t.merged = true;
@@ -104,12 +113,39 @@ export class OperatorStateFold {
         if (e.event === "task-approved") {
             t.state = "pending";
             t.parkKind = undefined;
+            t.gateActivity = undefined;
             this.approved = !this.active;
+            if (e.data.release === "recheck")
+                t.gates = emptyGates();
+        }
+        if (e.event === "phase-start" && e.data.phase === "gates")
+            t.gateActivity = undefined;
+        if (e.event === "suite-wait" || e.event === "host-degraded") {
+            // Only this row's attribution is authority. Legacy task-only waits must not borrow a red gate.
+            const gate = typeof e.data.gate === "string" && GATE_NAMES.includes(e.data.gate) ? e.data.gate : undefined;
+            t.gateActivity = { state: "queued", gate, reason: e.event, evidence: ref,
+                ...(typeof e.data.count === "number" ? { count: e.data.count } : {}) };
+            if (gate)
+                t.gates[gate] = { state: "queued", evidence: ref };
+        }
+        if (e.event === "suite-admitted")
+            t.gateActivity = undefined;
+        if (["task-done", "merge", "task-failed", "task-human", "task-blocked"].includes(e.event))
+            t.gateActivity = undefined;
+        const phaseGate = e.event === "phase-start" && typeof e.data.phase === "string"
+            ? e.data.phase.startsWith("gate:") ? e.data.phase.slice(5) : e.data.phase === "judge" ? "acceptance" : e.data.phase === "review" ? "review" : undefined
+            : undefined;
+        const gate = e.data.gate ?? phaseGate;
+        if ((e.event === "phase-start" && (phaseGate !== undefined || e.data.gate !== undefined)) || e.event === "gate-start" || e.event === "gate-phase-start") {
+            t.gateActivity = { state: "running", evidence: ref };
         }
-        const gate = e.data.gate;
         if (typeof gate === "string" && GATE_NAMES.includes(gate)) {
-            if (e.event === "gate-start")
+            if (e.event === "gate-start" || e.event === "gate-phase-start" || e.event === "phase-start") {
                 t.gates[gate] = { state: "running", evidence: ref };
+                t.gateActivity = { state: "running", gate, evidence: ref };
+            }
+            if (e.event === "gate-result" && t.gateActivity?.gate === gate)
+                t.gateActivity = undefined;
             if (e.event === "gate-result" && gate === "review")
                 t.reviewRounds++;
             if (e.event === "gate-result")
@@ -126,7 +162,7 @@ export class OperatorStateFold {
         }
         return t;
     }
-    snapshot({ graph, sequence = 0, observedAt = Date.now(), readable = true } = {}) {
+    snapshot({ graph, sequence = 0, observedAt = Date.now(), readable = true, graphAvailability } = {}) {
         const hash = graph && graphDefinitionHash(graph);
         const comparable = this.comparableTo(hash);
         const ids = comparable ? [...graph.tasks.map(t => t.id), ...[...this.tasks.keys()].filter(id => !graph.tasks.some(t => t.id === id))] : [...this.tasks.keys()];
@@ -150,7 +186,7 @@ export class OperatorStateFold {
         return {
             sequence, observedAt, lastEventAt: this.lastEventAt, firstEventAt: this.firstEventAt, resumes: this.resumes, escalations: this.escalations, lifecycle,
             label: this.approved ? "approved; resume required" : lifecycle,
-            green, currentTip, comparable, comparison: comparable ? "matching graph" : "not comparable",
+            green, currentTip, graphAvailability, comparable, comparison: comparable ? "matching graph" : "not comparable",
             merged,
             planned, tasks, buckets,
             gatesRan: { passed: this.passed, total: this.total }, latestRunEnd: this.end?.evidence,

package/dist/run/operator-summary.d.ts

@@ -13,6 +13,9 @@ export interface OperatorDecisionSnapshot {
         readonly kind: string | undefined;
         readonly tombstone: boolean;
         readonly reason?: string;
+        /** OBS-1178: the park row's physical line and timestamp — the token a decision binds to. */
+        readonly line?: number;
+        readonly ts?: string;
     };
     readonly verbs: readonly string[];
     readonly diagnostic?: string;

package/dist/run/operator-summary.js

@@ -25,7 +25,9 @@ export function projectOperatorSummary(tasks, decisions) {
                 decisionRequired: verbs.length > 0,
                 ...(diagnostic !== undefined || park.reason !== undefined
                     ? { diagnostic: diagnostic ?? park.reason } : {}),
-                nextAction: verbs.length > 0 ? `Choose a decision: ${verbs.join(", ")}` : null,
+                nextAction: verbs.length > 0
+                    ? `Choose a decision: ${verbs.join(", ")}${park.line !== undefined && park.ts !== undefined ? ` (--park ${park.line}@${park.ts})` : ""}`
+                    : null,
             };
             if (!park.tombstone && park.kind === "infra" && task.missingCapability) {
                 const { capability, diagnostic: capabilityDiagnostic } = task.missingCapability;

package/dist/run/protocol.d.ts

@@ -66,10 +66,10 @@ export declare const GateEvidenceReceiptSchema: z.ZodObject<{
     termination: z.ZodObject<{
         kind: z.ZodEnum<{
             unknown: "unknown";
+            timeout: "timeout";
             signal: "signal";
             "not-started": "not-started";
             exit: "exit";
-            timeout: "timeout";
         }>;
         exitCode: z.ZodNullable<z.ZodNumber>;
         signal: z.ZodNullable<z.ZodString>;
@@ -222,6 +222,11 @@ export declare const RoleInvocationStartEventSchema: z.ZodObject<{
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -240,6 +245,11 @@ export declare const RoleInvocationTerminalEventSchema: z.ZodObject<{
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         outcome: z.ZodEnum<{
             failed: "failed";
@@ -352,6 +362,11 @@ export declare const DecisionEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
@@ -369,6 +384,11 @@ export declare const DecisionEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         outcome: z.ZodEnum<{
             failed: "failed";
@@ -473,6 +493,11 @@ export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>;
     event: z.ZodLiteral<"role-invocation-start">;
@@ -489,6 +514,11 @@ export declare const DecisionEventWriteSchema: z.ZodDiscriminatedUnion<[z.ZodObj
         adapter: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         vendor: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
         evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         outcome: z.ZodEnum<{
             failed: "failed";

package/dist/run/protocol.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { GATE_NAMES } from "../graph/schema.js";
+import { EFFORTS, GATE_NAMES } from "../graph/schema.js";
 import { normalizeGateOutcome } from "./outcome.js";
 // T32 (F2): the decision protocol is deliberately smaller than the journal. Existing journals contain
 // many observational event types and must remain readable; only the five event names below assert a
@@ -133,6 +133,8 @@ const RoleInvocationIdentityDataSchema = z.object({
     adapter: NonEmptyStringSchema.optional(),
     model: NonEmptyStringSchema.optional(),
     vendor: NonEmptyStringSchema.optional(),
+    // OBS-1182: the effort the seat actually launched at; absent = the CLI's own default, never a level.
+    effort: z.enum(EFFORTS).optional(),
     evidence: EvidenceSchema.optional(),
 });
 const RoleInvocationStartDataSchema = RoleInvocationIdentityDataSchema.strict();

package/dist/run/stall.d.ts

@@ -13,7 +13,42 @@ export declare function resetHarvestCpuFlatMsForTests(): void;
 /** The dispatch shell records its foreground group in an attempt-unique artifact. */
 export declare function readOwnedProcessGroup(path: string): number | undefined;
 /** Never infer ownership from a task name or scan another attempt's marker when reaping. */
-export declare function reapOwnedProcessGroup(group: number | undefined, cwd: string): Promise<number[] | null>;
+export declare function reapOwnedProcessGroup(group: number | undefined, cwd: string, ownership?: WorkerReapOwnership): Promise<number[] | null>;
+export interface ReapProcess {
+    pid: number;
+    ppid: number;
+    group: number;
+    session: string;
+    identity: string;
+    command: string;
+    startedAt?: string;
+}
+export interface WorkerReapOwnership {
+    marker: string;
+    /** Session recorded by the dispatch shell before its children can detach. */
+    session?: string;
+    parent?: {
+        pid: number;
+        startedAt: string;
+    };
+    identities?: Map<number, string>;
+    /** Descendants observed while the dispatch root was still alive. */
+    descendants?: Map<number, string>;
+    excludedGroups: number[];
+    excludedWorktrees: string[];
+    /** Discovery evidence is distinct from the final survivor census. */
+    strays: number[];
+}
+/** Bounded host boundary, also used to inject unreadability and pid reuse in regressions. */
+export declare const workerReapHost: {
+    snapshot(): Promise<ReapProcess[] | undefined>;
+    inspect(pid: number): Promise<{
+        cwd: string;
+        suiteParent?: number;
+    } | undefined>;
+    identity: (pid: number) => Promise<string | null | undefined>;
+    kill(pid: number): void;
+};
 export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
     ms: number;
     resolutionMs: number;
@@ -22,6 +57,7 @@ export declare class WorkerTreeCpuAccountant {
     private marker;
     private cwd;
     private group?;
+    private identities?;
     private active;
     private loop;
     private live;
@@ -29,7 +65,7 @@ export declare class WorkerTreeCpuAccountant {
     private gaps;
     private consecutiveGaps;
     private latest;
-    constructor(marker: string, cwd: string, group?: (() => number | undefined) | undefined);
+    constructor(marker: string, cwd: string, group?: (() => number | undefined) | undefined, identities?: Map<number, string> | undefined);
     private sample;
     start(): Promise<void>;
     read(): {