tickmarkr 2.5.6 → 2.5.8

package/dist/run/operator-summary.js

@@ -0,0 +1,77 @@
+/** Labels describe blockers, not journal park kinds or commands. */
+export const BLOCKER_KINDS = [
+    "human-decision", "retry", "cooldown", "dependency-wait", "stale-receipt",
+    "missing-capability", "unknown",
+];
+const SETTLED = new Set(["done", "completed", "merged"]);
+const emptyBlocker = (kind) => ({
+    kind, permittedActions: [], humanInterventionRequired: false,
+    decisionRequired: false, nextAction: null,
+});
+/** Pure projection in current-task order; no clock, host access, or retained state. */
+export function projectOperatorSummary(tasks, decisions) {
+    const statuses = new Map(tasks.map(task => [task.id, task.status]));
+    const parks = new Map(decisions.map(decision => [decision.taskId, decision]));
+    return tasks.map(task => {
+        let blocker = null;
+        const decision = task.status === "human" ? parks.get(task.id) : undefined;
+        const terminal = SETTLED.has(task.status) || task.status === "failed";
+        if (decision) {
+            const { park, verbs, diagnostic } = decision;
+            blocker = {
+                ...emptyBlocker(park.tombstone ? "unknown" : "human-decision"),
+                permittedActions: [...verbs],
+                humanInterventionRequired: !park.tombstone,
+                decisionRequired: verbs.length > 0,
+                ...(diagnostic !== undefined || park.reason !== undefined
+                    ? { diagnostic: diagnostic ?? park.reason } : {}),
+                nextAction: verbs.length > 0 ? `Choose a decision: ${verbs.join(", ")}` : null,
+            };
+            if (!park.tombstone && park.kind === "infra" && task.missingCapability) {
+                const { capability, diagnostic: capabilityDiagnostic } = task.missingCapability;
+                blocker.kind = "missing-capability";
+                blocker.capability = capability;
+                blocker.nextAction = `Diagnose host capability: ${capability}`;
+                if (diagnostic === undefined && capabilityDiagnostic !== undefined)
+                    blocker.diagnostic = capabilityDiagnostic;
+            }
+        }
+        else if (task.status === "human") {
+            // Missing decision evidence must not make a parked task look automatic.
+            blocker = { ...emptyBlocker("unknown"), humanInterventionRequired: true };
+        }
+        else if (!terminal) {
+            const unmet = task.status === "pending" ? task.deps.filter(id => !SETTLED.has(statuses.get(id))) : [];
+            if (unmet.length > 0) {
+                blocker = {
+                    ...emptyBlocker("dependency-wait"), prerequisites: unmet,
+                    nextAction: `Wait for prerequisites: ${unmet.join(", ")}`,
+                };
+            }
+            else if (task.staleReceipt) {
+                blocker = {
+                    ...emptyBlocker("stale-receipt"), diagnostic: task.staleReceipt.diagnostic,
+                    nextAction: "Inspect the stale receipt and refresh its evidence",
+                };
+            }
+            else if (task.wait) {
+                blocker = {
+                    ...emptyBlocker(task.wait.kind),
+                    ...(task.wait.diagnostic === undefined ? {} : { diagnostic: task.wait.diagnostic }),
+                    ...(task.wait.wakeAt === undefined ? {} : { wakeAt: task.wait.wakeAt }),
+                };
+            }
+            else if (task.status === "blocked" || task.status === "unknown") {
+                blocker = emptyBlocker("unknown");
+            }
+        }
+        const owner = task.responsible;
+        return {
+            taskId: task.id, phase: task.phase ?? null, lastEvidenceAt: task.lastEvidenceAt ?? null,
+            responsible: owner?.role !== undefined || owner?.agent !== undefined
+                ? { ...(owner.role === undefined ? {} : { role: owner.role }),
+                    ...(owner.agent === undefined ? {} : { agent: owner.agent }) } : null,
+            blocker,
+        };
+    });
+}

package/dist/run/protocol.d.ts

@@ -1,6 +1,77 @@
 import { z } from "zod";
 import { type GateName } from "../graph/schema.js";
 import { type GateOutcome } from "./outcome.js";
+/** Shared lifecycle vocabulary for shell evidence and later build-result emitters. */
+export declare const COMMAND_RECEIPT_OUTCOMES: readonly ["started", "completed", "spawn-failed", "timed-out", "cancelled", "reused-result", "skipped", "refused"];
+export declare const CommandReceiptAttributionSchema: z.ZodObject<{
+    runId: z.ZodString;
+    taskId: z.ZodString;
+    attempt: z.ZodNumber;
+    gateRound: z.ZodNumber;
+    invocation: z.ZodString;
+}, z.core.$strict>;
+export type CommandReceiptAttribution = z.infer<typeof CommandReceiptAttributionSchema>;
+export declare const ShellReceiptSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        skipped: "skipped";
+        started: "started";
+        completed: "completed";
+        "spawn-failed": "spawn-failed";
+        "timed-out": "timed-out";
+        cancelled: "cancelled";
+        "reused-result": "reused-result";
+        refused: "refused";
+    }>;
+    confirmedStart: z.ZodBoolean;
+    attribution: z.ZodOptional<z.ZodObject<{
+        runId: z.ZodString;
+        taskId: z.ZodString;
+        attempt: z.ZodNumber;
+        gateRound: z.ZodNumber;
+        invocation: z.ZodString;
+    }, z.core.$strict>>;
+    pid: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    signal: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    error: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ShellReceipt = z.infer<typeof ShellReceiptSchema>;
+/** A task-build row must carry the entire caller-owned correlation, even before spawn. */
+export declare const CommandReceiptSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        skipped: "skipped";
+        started: "started";
+        completed: "completed";
+        "spawn-failed": "spawn-failed";
+        "timed-out": "timed-out";
+        cancelled: "cancelled";
+        "reused-result": "reused-result";
+        refused: "refused";
+    }>;
+    confirmedStart: z.ZodBoolean;
+    pid: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    signal: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    error: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    attribution: z.ZodObject<{
+        runId: z.ZodString;
+        taskId: z.ZodString;
+        attempt: z.ZodNumber;
+        gateRound: z.ZodNumber;
+        invocation: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CommandReceipt = z.infer<typeof CommandReceiptSchema>;
+export declare function readCommandReceipt(raw: unknown): {
+    kind: "receipt";
+    receipt: CommandReceipt;
+} | {
+    kind: "protocol-issue";
+    issues: string[];
+    raw: unknown;
+};
 /** The T31 outcome vocabulary, made executable and strict at the persistence boundary. */
 export declare const GateOutcomeSchema: z.ZodType<GateOutcome>;
 export declare const ROLE_INVOCATION_ROLES: readonly ["worker", "judge", "review", "consult"];

package/dist/run/protocol.js

@@ -12,6 +12,38 @@ const TaskIdSchema = NonEmptyStringSchema;
 const TaskIdsSchema = z.array(TaskIdSchema);
 const AttemptSchema = z.number().int().nonnegative();
 const EvidenceSchema = z.record(z.string(), z.unknown());
+/** Shared lifecycle vocabulary for shell evidence and later build-result emitters. */
+export const COMMAND_RECEIPT_OUTCOMES = [
+    "started", "completed", "spawn-failed", "timed-out", "cancelled", "reused-result", "skipped", "refused",
+];
+export const CommandReceiptAttributionSchema = z.object({
+    runId: NonEmptyStringSchema,
+    taskId: TaskIdSchema,
+    attempt: AttemptSchema,
+    gateRound: z.number().int().nonnegative(),
+    invocation: NonEmptyStringSchema,
+}).strict();
+export const ShellReceiptSchema = z.object({
+    outcome: z.enum(COMMAND_RECEIPT_OUTCOMES),
+    confirmedStart: z.boolean(),
+    attribution: CommandReceiptAttributionSchema.optional(),
+    pid: z.number().int().positive().optional(),
+    exitCode: z.number().int().nullable().optional(),
+    signal: NonEmptyStringSchema.nullable().optional(),
+    error: z.string().optional(),
+    durationMs: z.number().nonnegative().optional(),
+}).strict();
+/** A task-build row must carry the entire caller-owned correlation, even before spawn. */
+export const CommandReceiptSchema = ShellReceiptSchema.extend({
+    attribution: CommandReceiptAttributionSchema,
+});
+export function readCommandReceipt(raw) {
+    const parsed = CommandReceiptSchema.safeParse(raw);
+    return parsed.success ? { kind: "receipt", receipt: parsed.data } : {
+        kind: "protocol-issue", raw,
+        issues: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`),
+    };
+}
 /** The T31 outcome vocabulary, made executable and strict at the persistence boundary. */
 export const GateOutcomeSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("passed") }).strict(),

package/dist/run/repair-disposition.d.ts

@@ -0,0 +1,41 @@
+import type { GateResult } from "../gates/types.js";
+/** Pure decision table of the scope-red disposition (OBS-1077, OBS-1074 residual): no filesystem,
+ * process, clock or journal. The caller supplies the inventory and performs every side effect. */
+export type RepairDispositionKind = "fund-repair" | "scope-request" | "authoring" | "none";
+export interface RepairDisposition {
+    kind: RepairDispositionKind;
+    /** validated inventory paths only — the sole paths a caller may put in an executable command */
+    paths: string[];
+    reason: string;
+    /** which evidence decided: a gate name, "worker" for a refusal, absent for the ordinary disposition */
+    source?: string;
+    /** an independent classification that kept priority over path prose */
+    blocker?: "infra" | "scope-collateral";
+    /** candidates that bound to nothing, or to more than one path; evidence, never approval advice */
+    diagnostics: ScopeHintDiagnostic[];
+}
+export interface ScopeHintDiagnostic {
+    candidate: string;
+    kind: "unresolved" | "ambiguous";
+    matches: string[];
+    reason: string;
+}
+export interface ScopeHintResolution {
+    resolved: string[];
+    diagnostics: ScopeHintDiagnostic[];
+}
+export interface RepairDispositionInput {
+    /** the failing gate results (passing rows are ignored) */
+    results: readonly GateResult[];
+    files: readonly string[];
+    /** the worker's refusal summary — present only when the worker reported ok:false */
+    refusalSummary?: string;
+    /** task tree plus diff, deleted tracked paths included */
+    inventory: Iterable<string>;
+}
+/** Lexing never starts in the middle of a word (same lexer as the daemon's scope-red disposition). */
+export declare const namedPaths: (text: string) => string[];
+/** Binds candidates to the SUPPLIED inventory and nothing else: an exact path, else a unique
+ * path-suffix. Anything unbound or bound twice comes back as a non-executable diagnostic. */
+export declare function resolveScopeHints(candidates: Iterable<string>, inventory: Iterable<string>): ScopeHintResolution;
+export declare function classifyRepairDisposition(input: RepairDispositionInput): RepairDisposition;

package/dist/run/repair-disposition.js

@@ -0,0 +1,77 @@
+import { filesGlob } from "../graph/files-glob.js";
+const failed = (g) => !(g.pass || g.meta?.skipped === true) || g.meta?.infra === true;
+const REFUSAL_RE = /outside|out.of.scope|allowlist|scope expansion|not (?:in|own)|unowned/i;
+/** Lexing never starts in the middle of a word (same lexer as the daemon's scope-red disposition). */
+export const namedPaths = (text) => [...text.matchAll(/(?:^|[\s`'"])((?:[A-Za-z0-9_@.()[\]-]+\/)+[A-Za-z0-9_@.[\]-]+|[A-Za-z0-9_@-]+(?:\.[A-Za-z0-9_-]+)+)(?=$|[\s`'"),:;.!?])/g)]
+    .map((match) => match[1].replace(/^\.\//, "").replace(/\.$/, ""))
+    .filter((path) => !path.split("/").includes(".."));
+/** Binds candidates to the SUPPLIED inventory and nothing else: an exact path, else a unique
+ * path-suffix. Anything unbound or bound twice comes back as a non-executable diagnostic. */
+export function resolveScopeHints(candidates, inventory) {
+    const known = new Set(inventory);
+    const resolved = new Set();
+    const diagnostics = [];
+    for (const candidate of new Set(candidates)) {
+        if (known.has(candidate)) {
+            resolved.add(candidate);
+            continue;
+        }
+        const matches = [...known].filter((path) => path.endsWith(`/${candidate}`)).sort();
+        if (matches.length === 1)
+            resolved.add(matches[0]);
+        else
+            diagnostics.push(matches.length === 0
+                ? { candidate, kind: "unresolved", matches, reason: `scope hint resolves to nothing in the task tree: ${candidate}` }
+                : { candidate, kind: "ambiguous", matches, reason: `scope hint ${candidate} matches ${matches.length} paths: ${matches.join(", ")}` });
+    }
+    return { resolved: [...resolved].sort(), diagnostics };
+}
+export function classifyRepairDisposition(input) {
+    const reds = input.results.filter(failed);
+    const none = (reason, extra = {}) => ({ kind: "none", paths: [], reason, diagnostics: [], ...extra });
+    // Independent classifications first: prose naming a path never erases them.
+    const infra = reds.find((g) => g.meta?.infra === true);
+    if (infra)
+        return none(`${infra.gate}: infra red keeps its own classification`, { source: infra.gate, blocker: "infra" });
+    const verdict = reds.find((g) => g.gate === "scope")?.meta?.collateral;
+    if (verdict) {
+        return verdict.authoring
+            ? { kind: "authoring", paths: [...verdict.predicted], reason: verdict.repair, source: "scope", blocker: "scope-collateral", diagnostics: [] }
+            : none("scope: collateral verdict has unpredicted offenders — ordinary chargeable disposition", { source: "scope", blocker: "scope-collateral" });
+    }
+    if (input.files.length === 0)
+        return none("task declares no files[]");
+    const allowed = filesGlob([...input.files]);
+    const inventory = [...input.inventory];
+    const unowned = (text) => {
+        const r = resolveScopeHints(namedPaths(text).filter((path) => !allowed(path)), inventory);
+        return { paths: r.resolved.filter((path) => !allowed(path)), diagnostics: r.diagnostics };
+    };
+    const owned = (text) => resolveScopeHints(namedPaths(text), inventory).resolved.some(allowed);
+    const refusal = input.refusalSummary !== undefined && REFUSAL_RE.test(input.refusalSummary)
+        ? unowned(input.refusalSummary) : { paths: [], diagnostics: [] };
+    // A test gate names where the ASSERTION lives — a detection site, not the code that needs fixing.
+    const sites = reds.filter((g) => g.gate === "test").map((g) => unowned(g.details));
+    const others = reds.filter((g) => g.gate !== "test");
+    const hints = others.map((g) => unowned(g.details));
+    const diagnostics = [refusal, ...sites, ...hints].flatMap((r) => r.diagnostics)
+        .filter((d, i, all) => all.findIndex((o) => o.candidate === d.candidate) === i);
+    const uniq = (rs) => [...new Set(rs.flatMap((r) => r.paths))].sort();
+    if (refusal.paths.length) {
+        return { kind: "scope-request", paths: refusal.paths, source: "worker", diagnostics,
+            reason: `worker refusal names unowned paths: ${refusal.paths.join(", ")}` };
+    }
+    const repair = uniq(hints);
+    if (repair.length && !others.some((g) => owned(g.details))) {
+        const review = others.some((g) => g.gate === "review");
+        return { kind: review ? "scope-request" : "authoring", paths: repair, source: others[0].gate, diagnostics,
+            reason: `files[] repair hint: ${repair.join(", ")}` };
+    }
+    const detection = uniq(sites);
+    if (detection.length) {
+        return { kind: "fund-repair", paths: detection, source: "test", diagnostics,
+            reason: `test gate names a detection site, not an out-of-scope repair: ${detection.join(", ")}` };
+    }
+    // Unknown attribution never blocks funding: the ordinary chargeable disposition applies.
+    return none("no attributable out-of-scope repair — ordinary chargeable disposition", { diagnostics });
+}

package/dist/tui/cockpit/board.d.ts

@@ -1,5 +1,6 @@
 import { type RunGraph } from "../../graph/schema.js";
 import type { OperatorSnapshot } from "../../run/operator-state.js";
+import type { AttemptHarvest, TaskRow } from "./derive.js";
 /** The prototype's palette (tasks-redesign.mjs:24-30): xterm-256 indices, stated once. */
 export declare const BOARD_PALETTE: {
     readonly chrome: 238;
@@ -49,6 +50,8 @@ export interface BoardInput {
     /** Footer key hints, joined the prototype's way; `false` leaves the footer to the caller (see boardFooter). */
     readonly keys?: readonly string[] | false;
     readonly colour?: boolean;
+    /** The cockpit's derived rows: the shared projection (blocker, next action, harvest) rides on each board row, unrendered. */
+    readonly rows?: readonly TaskRow[];
 }
 /** One task row, in the parts the Run view recomposes per width band. */
 export interface BoardRow {
@@ -63,6 +66,12 @@ export interface BoardRow {
     readonly note: string;
     /** The note's segments, so a band can wrap it across continuation rows without cutting one. */
     readonly noteParts: readonly string[];
+    /** From the shared projection (derive.ts TaskRow.summary), when the caller supplied rows. */
+    readonly blocker?: string;
+    readonly nextAction?: string;
+    readonly permittedActions?: readonly string[];
+    /** OBS-1048: the newest recorded attempt's harvest evidence, when the caller supplied rows. */
+    readonly harvest?: AttemptHarvest;
 }
 export interface BoardFrame {
     /** Header through the gate header rule, in the prototype's order. */

package/dist/tui/cockpit/board.js

@@ -89,6 +89,15 @@ export function areasFor(files) {
 const hm = (ms) => `${Math.floor(ms / 3.6e6)}h${String(Math.floor((ms % 3.6e6) / 6e4)).padStart(2, "0")}m`;
 const ago = (ms) => (ms < 6e4 ? "just now" : ms < 3.6e6 ? `${Math.round(ms / 6e4)}m ago` : `${Math.round(ms / 3.6e6)}h ago`);
 const isDone = (t) => t !== undefined && (t.merged || t.state === "completed");
+const projected = (row) => {
+    const blocker = row?.summary?.blocker;
+    const harvest = row?.harvests?.at(-1);
+    return {
+        ...(blocker ? { blocker: blocker.kind, permittedActions: blocker.permittedActions } : {}),
+        ...(blocker?.nextAction ? { nextAction: blocker.nextAction } : {}),
+        ...(harvest ? { harvest } : {}),
+    };
+};
 /** The prototype's frame, sectioned. `renderBoard` joins it row for row. */
 export function boardFrame(input, width) {
     const W = Math.max(1, Math.floor(width));
@@ -218,6 +227,7 @@ export function boardFrame(input, width) {
             tail: `  ${pad(mute(sliceCells(t?.channel ?? "—", CHAN - 2).head), CHAN)}${pad(mute(String(attempts)), 5)}`,
             note: note.join(mute(" · ")),
             noteParts: note,
+            ...projected(input.rows?.find((row) => row.taskId === g.id)),
         });
     }
     const bottom = [];

package/dist/tui/cockpit/derive.d.ts

@@ -1,4 +1,6 @@
 export { readOperatorState as deriveOperatorState } from "../../run/operator-state.js";
+import { type TaskActivityProjection } from "../../run/activity.js";
+import { type OperatorTaskSummary } from "../../run/operator-summary.js";
 import type { ComponentState, JournalRow, StatusStripItem } from "./components.js";
 import type { RunViewId } from "./views.js";
 export declare const SPARKLINE_BUCKET_WINDOW = 12;
@@ -60,8 +62,34 @@ export type CockpitGraph = {
         readonly id: string;
         readonly title?: string;
         readonly status?: string;
+        /** Prerequisites and declared gates: read only by the shared projection (blocker, readiness). */
+        readonly deps?: readonly string[];
+        readonly gates?: readonly string[];
     }[];
 };
+/** One recorded seat: a task attempt in a role. Keyed by all three, never by provider alone. */
+export type RecordedIdentity = {
+    readonly key: string;
+    readonly role: string;
+    readonly attempt: number;
+    /** The slot name the driver recorded, verbatim; absent when the row named none. */
+    readonly name?: string;
+};
+/**
+ * OBS-1048: what the journal recorded about one in-flight attempt's harvest. `trailerFirstSeenAt`
+ * is always absent — no producer journals it (daemon.ts samples the trailer without recording;
+ * OBS-1048 add.1, 2.5.8) — and is never synthesized from any other timestamp.
+ */
+export type AttemptHarvest = {
+    readonly attempt: number;
+    readonly lastWorkerStatus?: string;
+    readonly nudgeFailures: number;
+    readonly lastNudgeFailureAt?: string;
+    readonly pageCount: number;
+    readonly trailerFirstSeenAt?: undefined;
+    /** SUSPECTED: nudges failed and pages fired, and no worker-result of THIS attempt followed the launch. */
+    readonly suspectedStalledHarvest: boolean;
+};
 /** How an unrecorded field draws: the engagement said nothing, so the row says nothing. */
 export declare const ABSENT_FIELD = "-";
 /**
@@ -105,6 +133,13 @@ export type TaskRow = {
      * that earns one rather than having to read `done` as if it were the same.
      */
     readonly merged?: true;
+    /** Evidence-only activity projection (run/activity.ts), the one status renders. */
+    readonly activity?: TaskActivityProjection;
+    /** Operator summary (phase, blocker, next action) — the same projection status renders. */
+    readonly summary?: OperatorTaskSummary;
+    readonly identities?: readonly RecordedIdentity[];
+    /** Per recorded attempt, newest last (OBS-1048). */
+    readonly harvests?: readonly AttemptHarvest[];
 };
 /** One recorded gate result. `details` is the record's own text, verbatim. */
 export type GateRow = {

package/dist/tui/cockpit/derive.js

@@ -1,7 +1,13 @@
 // Consolidated C1/C6 readers use the incremental lifecycle contract; legacy captures keep their API.
 export { readOperatorState as deriveOperatorState } from "../../run/operator-state.js";
 import { channelKey } from "../../adapters/types.js";
+import { newestPark, permittedDecisionVerbs } from "../../cli/commands/approve.js";
+import { parseOwnedName } from "../../drivers/types.js";
+import { projectActivity } from "../../run/activity.js";
 import { isPidLive } from "../../run/lock.js";
+import { normalizeGateOutcome } from "../../run/outcome.js";
+import { projectOperatorSummary } from "../../run/operator-summary.js";
+import { trackJournalRows } from "../../run/protocol.js";
 export const SPARKLINE_BUCKET_WINDOW = 12;
 const MINUTE_MS = 60_000;
 const SPARKLINE_BUCKET_WIDTH_LADDER_MINUTES = [
@@ -470,7 +476,133 @@ function journalRows(events, tasks, defects, runStatus) {
  * graph's own `status` is never consulted, which is what keeps a recompiled
  * graph from repainting a parked task green.
  */
-function taskRows(events, tasks, graph) {
+const stringField = (data, key) => typeof data[key] === "string" ? data[key] : undefined;
+const attemptField = (data) => typeof data.attempt === "number" && Number.isInteger(data.attempt) && data.attempt >= 0 ? data.attempt : undefined;
+/** Recorded seats for one task: role and attempt from the row, or from an owned slot name it carries. */
+function recordedIdentities(events, taskId) {
+    const seen = new Map();
+    for (const event of events) {
+        if (event.taskId !== taskId)
+            continue;
+        const slot = recordValue(event.data.slot);
+        const name = stringField(event.data, "slotName") ?? (slot ? stringField(slot, "name") : stringField(event.data, "slot"));
+        const owned = name === undefined ? null : parseOwnedName(name);
+        const role = stringField(event.data, "role") ?? owned?.role ?? (event.event === "worker-launch" ? "worker" : undefined);
+        if (role === undefined)
+            continue;
+        const attempt = attemptField(event.data) ?? owned?.attempt;
+        if (attempt === undefined)
+            continue;
+        const key = `${taskId}:${attempt}:${role}`;
+        if (!seen.has(key))
+            seen.set(key, { key, role, attempt, ...(name === undefined ? {} : { name }) });
+    }
+    return [...seen.values()];
+}
+/**
+ * OBS-1048 fold, chronological: each worker-launch opens a fresh occurrence of its attempt label
+ * (labels reset on resume), and only a worker-result recorded AFTER that launch retires it — an
+ * unnumbered result binds to the newest launch so far, a numbered one to its own attempt's launch.
+ */
+function attemptHarvests(events, taskId) {
+    const byAttempt = new Map();
+    let newest;
+    for (const [order, event] of events.entries()) {
+        if (event.taskId !== taskId)
+            continue;
+        const attempt = attemptField(event.data) ?? (event.event === "worker-result" ? newest : undefined);
+        if (attempt === undefined)
+            continue;
+        const existing = byAttempt.get(attempt);
+        if (event.event === "worker-launch") {
+            // A launch resets its label's evidence: an earlier occurrence's status, nudges, pages and result are history.
+            byAttempt.set(attempt, { launched: true, returned: false, nudges: 0, pages: 0, order });
+            newest = attempt;
+            continue;
+        }
+        const h = existing ?? { launched: false, returned: false, nudges: 0, pages: 0, order };
+        if (!existing)
+            byAttempt.set(attempt, h);
+        switch (event.event) {
+            case "worker-status":
+                h.status = stringField(event.data, "status");
+                break;
+            case "worker-nudge-failed":
+                h.nudges += 1;
+                h.nudgeAt = event.ts;
+                break;
+            case "operator-page":
+                h.pages += 1;
+                break;
+            case "worker-result":
+                h.returned = true;
+                break;
+        }
+    }
+    // Attempt labels reset on resume, so numeric order is not chronology. The board reads the
+    // last harvest as newest; retain the order of each label's latest worker-launch occurrence.
+    return [...byAttempt].sort(([, a], [, b]) => a.order - b.order).map(([attempt, h]) => ({
+        attempt,
+        ...(h.status === undefined ? {} : { lastWorkerStatus: h.status }),
+        nudgeFailures: h.nudges,
+        ...(h.nudgeAt === undefined ? {} : { lastNudgeFailureAt: h.nudgeAt }),
+        pageCount: h.pages,
+        suspectedStalledHarvest: h.launched && !h.returned && h.nudges > 0 && h.pages > 0,
+    }));
+}
+/**
+ * The shared, evidence-only projection status renders (status.ts recordProjection), folded here
+ * so both surfaces read one fact. Phase/blocker/next-action come from run/activity.ts and
+ * run/operator-summary.ts; decisions from the production park oracle.
+ */
+function projectSummaries(events, runId, identities, graph, rowState) {
+    const journal = events.map((event) => ({
+        ts: event.ts, event: event.event, ...(event.taskId === undefined ? {} : { taskId: event.taskId }), data: event.data,
+    }));
+    const graphTask = (id) => graph?.tasks.find((task) => task.id === id);
+    const tasks = identities.map(({ id }) => ({
+        id, gates: graphTask(id)?.gates ?? [], deps: graphTask(id)?.deps ?? [], status: rowState(id) ?? graphTask(id)?.status ?? "unknown",
+    }));
+    const activity = projectActivity(runId, trackJournalRows(runId, journal.map((raw, sourceIndex) => ({ raw, sourceIndex }))), tasks);
+    const rehashAt = journal.reduce((at, event, index) => event.event === "graph-rehash" ? index : at, -1);
+    const summaryTasks = tasks.map((task) => {
+        const evidence = journal.filter((event) => event.taskId === task.id);
+        const last = evidence.at(-1);
+        const recorded = activity.get(task.id);
+        let phase = last ? recorded.state : undefined;
+        // A completed battery is evidence of readiness, never evidence that merge started (status.ts).
+        const boundary = journal.reduce((index, event, at) => ["run-start", "run-resume", "run-end"].includes(event.event)
+            || (event.taskId === task.id && (event.event === "task-dispatch"
+                || (event.event === "phase-start" && event.data.phase === "gates"))) ? at : index, -1);
+        const latest = new Map();
+        journal.forEach((event, index) => {
+            if (event.taskId === task.id && event.event === "gate-result" && typeof event.data.gate === "string")
+                latest.set(event.data.gate, index);
+        });
+        const priorGraph = rehashAt >= 0 && [...latest.values()].some((index) => index < rehashAt);
+        // Latest outcome including non-verdicts (status.ts): a held screen or skipped gate is not a pass.
+        const passedNow = (gate) => {
+            const latestResult = journal.slice(boundary + 1).filter((event) => event.taskId === task.id && event.event === "gate-result" && event.data.gate === gate).at(-1);
+            return latestResult !== undefined && normalizeGateOutcome(latestResult.data).kind === "passed";
+        };
+        if (recorded.state === "unconfirmed" && task.gates.length > 0 && !priorGraph && task.gates.every(passedNow)) {
+            phase = "awaiting merge phase";
+        }
+        const responsibility = [...evidence].reverse().find((event) => typeof event.data.role === "string" || typeof event.data.agent === "string");
+        return {
+            id: task.id, deps: task.deps, status: task.status, phase, lastEvidenceAt: last?.ts,
+            responsible: responsibility ? {
+                role: stringField(responsibility.data, "role"), agent: stringField(responsibility.data, "agent"),
+            } : undefined,
+        };
+    });
+    const decisions = summaryTasks.flatMap((task) => {
+        const park = task.status === "human" ? newestPark(journal, task.id) : undefined;
+        return park ? [{ taskId: task.id, park, verbs: permittedDecisionVerbs(park) }] : [];
+    });
+    return { activity, summaries: new Map(projectOperatorSummary(summaryTasks, decisions).map((task) => [task.taskId, task])) };
+}
+function taskRows(events, tasks, graph, runId) {
     const lastSeen = new Map();
     for (const event of events) {
         if (event.taskId !== undefined)
@@ -483,6 +615,15 @@ function taskRows(events, tasks, graph) {
             id,
             title: undefined,
         }));
+    // `task-done` records completion; only `merge` records landing. The fixed
+    // Tasks-view consumer maps `done` to a check, so the derived row must keep
+    // an unmerged completion in the neutral `completed` state and reserve
+    // `done` for a fact whose merge the journal actually carries.
+    const rowState = (id) => {
+        const fact = tasks.get(id);
+        return fact?.state === "done" && fact.merged !== true ? "completed" : fact?.state;
+    };
+    const projection = projectSummaries(events, runId, identities, graph, rowState);
     return identities.map(({ id, title }) => {
         const fact = tasks.get(id);
         const assignment = fact?.dispatches.at(-1)?.assignment;
@@ -491,13 +632,9 @@ function taskRows(events, tasks, graph) {
         // zero when a run resumes, so a task dispatched 0,1,0 was tried three times
         // and reporting its last label would say one.
         const attempts = fact?.dispatches.length ?? 0;
-        // `task-done` records completion; only `merge` records landing. The fixed
-        // Tasks-view consumer maps `done` to a check, so the derived row must keep
-        // an unmerged completion in the neutral `completed` state and reserve
-        // `done` for a fact whose merge the journal actually carries.
-        const state = fact?.state === "done" && fact.merged !== true
-            ? "completed"
-            : fact?.state;
+        const state = rowState(id);
+        const recorded = recordedIdentities(events, id);
+        const harvests = attemptHarvests(events, id);
         return {
             id: `task:${id}`,
             taskId: id,
@@ -513,6 +650,10 @@ function taskRows(events, tasks, graph) {
             // Landing is its own fact. `done` is work finished; only a recorded merge
             // is work landed, and only that earns a check-mark.
             ...(fact?.merged === true ? { merged: true } : {}),
+            activity: projection.activity.get(id),
+            summary: projection.summaries.get(id),
+            ...(recorded.length === 0 ? {} : { identities: recorded }),
+            ...(harvests.length === 0 ? {} : { harvests }),
         };
     });
 }
@@ -737,9 +878,10 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
                     : interrupted
                         ? "interrupted"
                         : "running";
+    const runId = source.fileName.replace(/(?:\.interrupted)?\.journal\.jsonl$/, "");
     return {
         binaryVersion,
-        runId: source.fileName.replace(/(?:\.interrupted)?\.journal\.jsonl$/, ""),
+        runId,
         branch: typeof start.data.branch === "string" ? start.data.branch : "unknown",
         status: runStatus,
         elapsed: elapsedReading(events[0].ts, events.at(-1).ts),
@@ -762,7 +904,7 @@ export function deriveRunCockpitData(source, binaryVersion, options = {}) {
             ? `${spotlight.id} · ${spotlight.phase} · attempt ${taskAttempt(spotlight)} · ${taskActor(spotlight)}`
             : "- · pending · attempt 1 · unassigned",
         journalRows: journalRows(events, tasks, defects, runStatus),
-        taskRows: taskRows(events, tasks, options.graph),
+        taskRows: taskRows(events, tasks, options.graph, runId),
         gateRows: gateRows(events),
         fleetRows: fleetRows(events),
         statusItems: [

package/dist/tui/cockpit/evidence-view.d.ts

@@ -1,6 +1,7 @@
 import { type ReactElement } from "react";
 import type { ChannelCost } from "../../report/cost.js";
 import { type OperatorRecordRow } from "../../report/operator-record.js";
+import { type OperatorPageGroup } from "../../run/operator-page-summary.js";
 import type { EvidenceIdentity } from "../../run/operator-state.js";
 import { type JournalEvent } from "../../run/journal.js";
 import { type ComponentState } from "./components.js";
@@ -49,6 +50,7 @@ export interface EvidenceViewInput {
     readonly learningPreview?: readonly string[];
 }
 export interface EvidenceViewModel {
+    readonly operatorPages: readonly OperatorPageGroup[];
     readonly journal: readonly EvidenceRow[];
     readonly channels: readonly OperatorRecordRow[];
     readonly reportLines: readonly string[];