tickmarkr 2.5.5 → 2.5.7

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

@@ -0,0 +1,69 @@
+/** Labels describe blockers, not journal park kinds or commands. */
+export declare const BLOCKER_KINDS: readonly ["human-decision", "retry", "cooldown", "dependency-wait", "stale-receipt", "missing-capability", "unknown"];
+export type BlockerKind = (typeof BLOCKER_KINDS)[number];
+/**
+ * Structural boundary: callers compute park with newestPark and verbs with
+ * permittedDecisionVerbs in cli/commands/approve. RunDecision also fits this
+ * shape. This module neither imports a surface nor repeats its decision table.
+ * Supply only current parks, from the same snapshot as the task statuses.
+ */
+export interface OperatorDecisionSnapshot {
+    readonly taskId: string;
+    readonly park: {
+        readonly kind: string | undefined;
+        readonly tombstone: boolean;
+        readonly reason?: string;
+    };
+    readonly verbs: readonly string[];
+    readonly diagnostic?: string;
+}
+export interface RecordedResponsibility {
+    readonly role?: string;
+    readonly agent?: string;
+}
+/**
+ * Current, already-reduced evidence supplied by the reader. Optional facts stay
+ * absent: a wait duration is not a wake timestamp, a channel is not an owner,
+ * and elapsed wall time alone cannot establish that a receipt is stale.
+ */
+export interface OperatorSummaryTask {
+    readonly id: string;
+    readonly status: string;
+    readonly deps: readonly string[];
+    readonly phase?: string;
+    readonly lastEvidenceAt?: string;
+    readonly responsible?: RecordedResponsibility;
+    readonly wait?: {
+        readonly kind: "retry" | "cooldown";
+        readonly wakeAt?: string;
+        readonly diagnostic?: string;
+    };
+    readonly staleReceipt?: {
+        readonly diagnostic: string;
+    };
+    readonly missingCapability?: {
+        readonly capability: string;
+        readonly diagnostic?: string;
+    };
+}
+export interface OperatorBlocker {
+    kind: BlockerKind;
+    permittedActions: string[];
+    humanInterventionRequired: boolean;
+    decisionRequired: boolean;
+    diagnostic?: string;
+    nextAction: string | null;
+    prerequisites?: string[];
+    wakeAt?: string;
+    capability?: string;
+}
+export interface OperatorTaskSummary {
+    taskId: string;
+    phase: string | null;
+    lastEvidenceAt: string | null;
+    /** null explicitly means unknown; never inferred from a park or wait. */
+    responsible: RecordedResponsibility | null;
+    blocker: OperatorBlocker | null;
+}
+/** Pure projection in current-task order; no clock, host access, or retained state. */
+export declare function projectOperatorSummary(tasks: readonly OperatorSummaryTask[], decisions: readonly OperatorDecisionSnapshot[]): OperatorTaskSummary[];

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/recovery.d.ts

@@ -0,0 +1,8 @@
+import type { GateResult } from "../gates/types.js";
+import type { JournalEvent } from "./journal.js";
+export type FailureDisposition = "infrastructure" | "behavioral" | "unknown";
+export type VerificationRetryCause = "infrastructure" | "host-starved";
+/** Structured verifier evidence wins; neither an exit code nor prose proves infrastructure. */
+export declare function failureDisposition(result: Pick<GateResult, "pass" | "meta">): FailureDisposition;
+/** Reserve before re-execution. Interrupted reservations and new subjects never refill the task cap. */
+export declare function reserveInfrastructureRetry(events: readonly JournalEvent[], taskId: string, subject: string, append: (event: string, taskId: string, data: Record<string, unknown>) => void, cause?: VerificationRetryCause): boolean;

package/dist/run/recovery.js

@@ -0,0 +1,25 @@
+/** Structured verifier evidence wins; neither an exit code nor prose proves infrastructure. */
+export function failureDisposition(result) {
+    if (result.pass)
+        return "unknown";
+    if (result.meta?.classification === "regression")
+        return "behavioral";
+    if (result.meta?.infra === true && result.meta?.classification === "infra")
+        return "infrastructure";
+    return "unknown";
+}
+/** Reserve before re-execution. Interrupted reservations and new subjects never refill the task cap. */
+export function reserveInfrastructureRetry(events, taskId, subject, append, cause = "infrastructure") {
+    const used = events.filter((e) => e.taskId === taskId && e.event === "infra-retry-reserved");
+    const malformed = used.some((e) => typeof e.data.subject !== "string" || !e.data.subject
+        || (e.data.cause !== "infrastructure" && e.data.cause !== "host-starved"));
+    const reason = !subject ? "unknown-subject" : malformed ? "invalid-accounting"
+        : used.some((e) => e.data.subject === subject) ? "subject-allowance-exhausted"
+            : used.length >= 2 ? "task-allowance-exhausted" : undefined;
+    if (reason) {
+        append("infra-retry-denied", taskId, { subject, cause, reason, consumed: used.length });
+        return false;
+    }
+    append("infra-retry-reserved", taskId, { subject, cause, consumed: used.length + 1 });
+    return true;
+}

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

@@ -0,0 +1,12 @@
+import type { JournalEvent } from "./journal.js";
+export interface RepairSelectionDecision {
+    selectTests: boolean;
+    requiredFiles: string[];
+    reason: "no-test-failure" | "known-failing-files" | "legacy-test-failure" | "unattributed-test-failure" | "full-suite-failure";
+}
+type SelectionEvent = Pick<JournalEvent, "event" | "taskId" | "data">;
+/** Diagnostic selection only: neither a narrow pass nor this decision can authorize integration.
+ * Distrust and known failing files survive later green results, approvals and resume. A historical
+ * ambiguous failure is never reinterpreted using a newly enabled policy. */
+export declare function repairSelectionDecision(events: readonly SelectionEvent[], taskId: string, enabled: boolean): RepairSelectionDecision;
+export {};

package/dist/run/repair-selection.js

@@ -0,0 +1,56 @@
+/** These are literal repository-relative identities. Existence and selection support are checked
+ * against the current worktree by the gate; this journal fold cannot establish either. */
+function fileIdentities(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.some((file) => typeof file !== "string" || !file || /[\\\x00-\x1f\x7f]/.test(file)
+        || /^[A-Za-z]:/.test(file) || file.split("/").some((part) => !part || part === "." || part === ".."))) {
+        return undefined;
+    }
+    return [...new Set(value)].sort();
+}
+/** Diagnostic selection only: neither a narrow pass nor this decision can authorize integration.
+ * Distrust and known failing files survive later green results, approvals and resume. A historical
+ * ambiguous failure is never reinterpreted using a newly enabled policy. */
+export function repairSelectionDecision(events, taskId, enabled) {
+    const required = new Set();
+    let distrust;
+    for (const event of events) {
+        if (event.taskId !== taskId || event.event !== "gate-result"
+            || event.data.gate !== "test" || event.data.pass !== false)
+            continue;
+        const data = event.data;
+        if (!enabled) {
+            distrust ??= "legacy-test-failure";
+            continue;
+        }
+        // Only the recorded closed disposition can exempt infrastructure. Contradictory structured
+        // failure evidence cannot turn a behavioral failure into a harmless infrastructure event.
+        if (data.disposition === "infrastructure" && data.classification !== "regression"
+            && (data.failingFiles === undefined || (Array.isArray(data.failingFiles) && data.failingFiles.length === 0)))
+            continue;
+        if (data.disposition !== "behavioral" || typeof data.commit !== "string"
+            || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(data.commit)) {
+            distrust ??= "unattributed-test-failure";
+            continue;
+        }
+        // A replacement full-suite failure follows a passing screen in the current pipeline. No
+        // ordinary full-suite failure establishes that a selector safely covers the failed behavior.
+        if (data.fullSuite === true) {
+            distrust ??= "full-suite-failure";
+            continue;
+        }
+        const selected = fileIdentities(data.selectedTests);
+        const failing = fileIdentities(data.failingFiles);
+        if (!selected || !failing || failing.some((file) => !selected.includes(file))
+            || (data.fullSuite !== undefined && data.fullSuite !== false)) {
+            distrust ??= "unattributed-test-failure";
+            continue;
+        }
+        for (const file of failing)
+            required.add(file);
+    }
+    return {
+        selectTests: distrust === undefined,
+        requiredFiles: [...required].sort(),
+        reason: distrust ?? (required.size ? "known-failing-files" : "no-test-failure"),
+    };
+}

package/dist/run/stall.d.ts

@@ -10,6 +10,10 @@ export declare function harvestCpuFlatWindowMs(resolutionMs: number): number;
 /** Test seam — pin the quantization-aware flat window without changing production policy. */
 export declare function setHarvestCpuFlatMsForTests(ms: number): void;
 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 workerTreeCpuMs(marker: string, cwd: string): Promise<{
     ms: number;
     resolutionMs: number;
@@ -17,6 +21,7 @@ export declare function workerTreeCpuMs(marker: string, cwd: string): Promise<{
 export declare class WorkerTreeCpuAccountant {
     private marker;
     private cwd;
+    private group?;
     private active;
     private loop;
     private live;
@@ -24,7 +29,7 @@ export declare class WorkerTreeCpuAccountant {
     private gaps;
     private consecutiveGaps;
     private latest;
-    constructor(marker: string, cwd: string);
+    constructor(marker: string, cwd: string, group?: (() => number | undefined) | undefined);
     private sample;
     start(): Promise<void>;
     read(): {

package/dist/run/stall.js

@@ -52,6 +52,51 @@ function parsePsCpu(raw) {
         + Math.round(Number(m[4]) * 1000);
     return { ms, frac: m[4].includes(".") };
 }
+/** The dispatch shell records its foreground group in an attempt-unique artifact. */
+export function readOwnedProcessGroup(path) {
+    try {
+        const raw = readFileSync(path, "utf8").trim();
+        const group = /^\d+$/.test(raw) ? Number(raw) : 0;
+        return Number.isSafeInteger(group) && group > 1 ? group : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Never infer ownership from a task name or scan another attempt's marker when reaping. */
+export async function reapOwnedProcessGroup(group, cwd) {
+    if (group === undefined)
+        return null;
+    const own = await shGit(`ps -o pgid= -p ${process.pid}`, cwd, 5_000);
+    // An in-process driver fixture (or a non-isolating host) can share the daemon's
+    // group. It is not an owned worker group: let the driver's close retire that slot.
+    if (own.code !== 0 || !/^\d+$/.test(own.stdout.trim()) || Number(own.stdout.trim()) === group)
+        return null;
+    try {
+        process.kill(-group, "SIGKILL");
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+    }
+    let survivors = [];
+    // SIGKILL delivery and process retirement are asynchronous. Bound the confirmation
+    // grace, retaining names if a process is still present after it.
+    for (let probe = 0; probe < 5; probe++) {
+        const snapshot = await shGit("ps -Awwo pid=,pgid=,stat=", cwd, 5_000);
+        if (snapshot.code !== 0)
+            return null;
+        survivors = snapshot.stdout.split("\n").flatMap((line) => {
+            const row = /^\s*(\d+)\s+(\d+)\s+(\S+)/.exec(line);
+            return row && Number(row[2]) === group && !row[3].startsWith("Z") ? [Number(row[1])] : [];
+        });
+        if (survivors.length === 0)
+            break;
+        if (probe < 4)
+            await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return survivors;
+}
 let linuxClockTickMs;
 function linuxProcessCpuMs(pid, cwd) {
     if (!existsSync("/proc/self/stat"))
@@ -81,7 +126,7 @@ function linuxProcessCpuMs(pid, cwd) {
 // Every non-seeded worker process descends from its attempt-unique dispatch script. One ps snapshot
 // finds that root and its descendants. An empty tree is measurable zero; a failed or unparseable
 // snapshot is undefined because missing evidence can never prove inactivity.
-async function workerTreeCpuSnapshot(marker, cwd) {
+async function workerTreeCpuSnapshot(marker, cwd, group) {
     const snapshot = await shGit("ps -Awwo pid=,ppid=,time=,command=", cwd, 15_000);
     if (snapshot.code !== 0)
         return undefined;
@@ -97,6 +142,16 @@ async function workerTreeCpuSnapshot(marker, cwd) {
     if (rows.length === 0)
         return undefined;
     const tree = new Set(rows.filter((p) => p.cmd.includes(marker)).map((p) => p.pid));
+    if (group !== undefined) {
+        const groups = await shGit("ps -Awwo pid=,pgid=", cwd, 15_000);
+        if (groups.code !== 0)
+            return undefined;
+        for (const line of groups.stdout.split("\n")) {
+            const row = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+            if (row && Number(row[2]) === group)
+                tree.add(row[1]);
+        }
+    }
     // ps output is not topologically ordered; relax the parent -> child closure until stable.
     for (let grew = true; grew;) {
         grew = false;
@@ -141,6 +196,7 @@ export async function workerTreeCpuMs(marker, cwd) {
 export class WorkerTreeCpuAccountant {
     marker;
     cwd;
+    group;
     active = false;
     loop;
     live = new Map();
@@ -148,12 +204,13 @@ export class WorkerTreeCpuAccountant {
     gaps = 0;
     consecutiveGaps = 0;
     latest;
-    constructor(marker, cwd) {
+    constructor(marker, cwd, group) {
         this.marker = marker;
         this.cwd = cwd;
+        this.group = group;
     }
     async sample() {
-        const snapshot = await workerTreeCpuSnapshot(this.marker, this.cwd);
+        const snapshot = await workerTreeCpuSnapshot(this.marker, this.cwd, this.group?.());
         if (snapshot === undefined) {
             this.gaps++;
             this.live.clear();

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 = {