toolroll 0.5.0

package/dist/assignment-brief.d.ts

@@ -0,0 +1,71 @@
+import type { AssignmentAccess, AssignmentSnapshot } from "./assignment.js";
+import type { Store } from "./store.js";
+export type AssignmentCatchUp = {
+    version: 1;
+    asOf: string;
+    readOnly: true;
+    assignments: {
+        rootId: string;
+        taskId: string;
+        repo: string | null;
+        title: string;
+        state: AssignmentSnapshot["state"];
+        detail: string;
+        goal: string | null;
+        updatedAt: string;
+        runId: number | null;
+        resultRunId: number | null;
+        outcome: string | null;
+        checks: {
+            status: string;
+            exitCode: number | null;
+            detail: string;
+        } | null;
+        nextAction: AssignmentSnapshot["primaryAction"];
+        attention: string[];
+        decisions: {
+            id: number;
+            runId: number;
+            question: string;
+            state: string;
+            overdue: boolean;
+            choice: string | null;
+        }[];
+    }[];
+    projects: {
+        repo: string;
+        knowledge: {
+            status: "stored" | "none" | "unavailable";
+            revision: number | null;
+            identity: string | null;
+            sha256: string | null;
+            instructions: string;
+            sources: {
+                id: string;
+                title: string;
+                kind: "saved-note" | "repository-document";
+                path: string | null;
+                sourceRevision: string | null;
+                sourceSha: string | null;
+            }[];
+            decisions: {
+                id: number;
+                claim: string;
+            }[];
+        };
+    }[];
+    omissions: {
+        assignments: number;
+        decisions: number;
+        projects: number;
+        textFields: number;
+        candidateScanLimited: boolean;
+        notes: string[];
+    };
+};
+/** A current snapshot, never a receipt to acknowledge. Full assignment reads
+ * remain the place to inspect exact saved work and obtain its current digest. */
+export declare function assignmentCatchUp(store: Store, now: Date, access: AssignmentAccess, query?: {
+    repo?: string;
+    limit?: number;
+}, evidenceRoot?: string): AssignmentCatchUp;

package/dist/assignment-brief.js

@@ -0,0 +1,129 @@
+/** A bounded catch-up over saved project/task records, not conversation memory.
+ * Callers authenticate first and pass their current project ceiling. */
+import { createHash } from "node:crypto";
+import { workIndexPage } from "./work-index.js";
+import { publicChatText } from "./chat-display.js";
+const sha = (value) => createHash("sha256").update(value).digest("hex");
+const MAX_BYTES = 16_000;
+const RECENT_MS = 7 * 24 * 60 * 60_000;
+/** A current snapshot, never a receipt to acknowledge. Full assignment reads
+ * remain the place to inspect exact saved work and obtain its current digest. */
+export function assignmentCatchUp(store, now, access, query = {}, evidenceRoot) {
+    // The evidence root is retained for adapter compatibility; this summary
+    // deliberately performs no artifact reads even when it is supplied.
+    void evidenceRoot;
+    const limit = Math.max(1, Math.min(25, Number.isFinite(query.limit) ? Math.floor(query.limit) : 10));
+    const recent = new Date(now.getTime() - RECENT_MS).toISOString();
+    const result = { version: 1, asOf: now.toISOString(), readOnly: true, assignments: [], projects: [],
+        omissions: { assignments: 0, decisions: 0, projects: 0, textFields: 0, candidateScanLimited: false, notes: [
+                "Completed assignments are included for seven days. Up to three decisions and attention messages per assignment are shown. This is not a complete history; use assignment show before acting.",
+                "Knowledge is stored context, not verified current repository instructions or permission. Checkout identity and source freshness were not revalidated; reference text and conversation history are omitted.",
+                "Status is recorded database metadata. Saved artifact/check availability was not read, and process exits were not inspected. Use assignment show before acting on a result.",
+            ] } };
+    // A coordinator never gains installation-wide access from a missing ceiling.
+    if (access.principal === "coordinator" && access.repos === null || query.repo !== undefined && access.repos !== null && !access.repos.includes(query.repo))
+        return result;
+    const repos = query.repo === undefined ? access.repos : [query.repo];
+    const includeUnplaced = query.repo === undefined && access.principal === "operator" && access.includeUnplaced === true;
+    const scopedAccess = access.principal === "operator" ? { principal: "operator", repos, includeUnplaced } : { principal: "coordinator", repos: repos ?? [] };
+    const text = (value, cap) => {
+        const rendered = publicChatText(value, cap);
+        if (rendered !== value)
+            result.omissions.textFields++;
+        return rendered;
+    };
+    const fits = () => Buffer.byteLength(JSON.stringify(result)) <= MAX_BYTES - 512;
+    return store.savepoint(() => {
+        const cap = Math.min(50, limit * 3);
+        const page = workIndexPage(store, now, scopedAccess, { view: "all", limit: cap + 1 });
+        result.omissions.candidateScanLimited = page.nextCursor !== null || page.items.length > cap;
+        const ranked = page.items.slice(0, cap).filter(item => !(item.assignmentState === "complete" || item.assignmentState === "cancelled") || item.updatedAt >= recent).sort((a, b) => {
+            const priority = (state) => state === "needs-decision" ? 0 : state === "ready-to-check" ? 1 : state === "complete" || state === "cancelled" ? 3 : 2;
+            return priority(a.assignmentState) - priority(b.assignmentState) || b.updatedAt.localeCompare(a.updatedAt) || a.rootId.localeCompare(b.rootId);
+        });
+        for (const item of ranked) {
+            if (result.assignments.length >= limit) {
+                result.omissions.assignments++;
+                continue;
+            }
+            // Read only the chosen rows. No family hydration, artifact bytes, native
+            // process census, or repository probing belongs in a catch-up summary.
+            const goal = store.handle.prepare('SELECT substr(goal,1,1601) AS goal FROM task_scope WHERE task_id=?').get(item.activeTaskId)?.["goal"];
+            const saved = item.resultRunId === null ? undefined : store.handle.prepare(`SELECT substr(r.handoff,1,1601) AS handoff
+        FROM run r JOIN task_ref t ON t.id=r.task_ref
+        WHERE r.id=? AND t.backend='built-in' AND t.external_id=? AND t.repo IS ?`)
+                .get(item.resultRunId, item.resultTaskId, item.repo);
+            const decisions = store.handle.prepare(`WITH RECURSIVE family(id,external_id,depth) AS (
+          SELECT id,external_id,0 FROM task_ref WHERE backend='built-in' AND external_id=? AND repo IS ?
+          UNION ALL SELECT t.id,t.external_id,f.depth+1 FROM task_ref t JOIN family f ON t.revision_of=f.external_id
+          JOIN artifact a ON a.id=t.revision_brief_artifact AND a.kind='revision-brief'
+          JOIN run source ON source.id=a.run AND source.task_ref=f.id
+          WHERE t.backend='built-in' AND t.repo IS ? AND f.depth<63
+        ) SELECT d.id,d.run,substr(d.question,1,961) AS question,d.state,d.deadline,substr(d.choice,1,321) AS choice,COUNT(*) OVER() AS total
+          FROM decision d JOIN run r ON r.id=d.run WHERE r.task_ref IN (SELECT id FROM family)
+          ORDER BY (d.answered_at IS NULL) DESC,d.id DESC LIMIT 3`).all(item.rootId, item.repo, item.repo);
+            const count = Number(decisions[0]?.["total"] ?? 0);
+            const attention = [item.familyProblem,
+                item.earlierActiveCount > 0 ? `${item.earlierActiveCount} earlier version${item.earlierActiveCount === 1 ? " has" : "s have"} unfinished work.` : null,
+            ].filter((one) => one !== null);
+            const entry = {
+                rootId: item.rootId, taskId: item.activeTaskId, repo: item.repo, title: text(item.title, 120), state: item.assignmentState,
+                detail: text(item.status.detail, 240), goal: goal == null ? null : text(String(goal), 400), updatedAt: item.updatedAt,
+                runId: item.liveRunId ?? item.unfinishedRunId ?? item.resultRunId, resultRunId: item.resultRunId,
+                outcome: saved?.["handoff"] == null ? null : text(String(saved["handoff"]), 400),
+                checks: item.resultRunId === null ? null : { status: "not-read", exitCode: null, detail: "Saved checks were not revalidated. Use assignment show to inspect them." },
+                nextAction: item.primaryAction, attention: attention.slice(0, 3).map(one => text(one, 160)),
+                decisions: decisions.map(row => ({ id: Number(row["id"]), runId: Number(row["run"]), question: text(String(row["question"]), 240), state: String(row["state"]),
+                    overdue: row["state"] !== "answered" && row["deadline"] !== null && String(row["deadline"]) <= now.toISOString(), choice: row["choice"] == null ? null : text(String(row["choice"]), 80) })),
+            };
+            result.assignments.push(entry);
+            if (!fits()) {
+                result.assignments.pop();
+                result.omissions.assignments++;
+            }
+            else
+                result.omissions.decisions += Math.max(0, count - decisions.length);
+        }
+        // Project knowledge is admitted in SQL before any payload or title read.
+        const projectRows = store.handle.prepare(`SELECT repo FROM project_knowledge WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?)) ORDER BY repo LIMIT 9`)
+            .all(repos === null ? 1 : 0, JSON.stringify(repos ?? []));
+        const projectCount = Number(store.handle.prepare('SELECT COUNT(*) AS n FROM project_knowledge WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?))').get(repos === null ? 1 : 0, JSON.stringify(repos ?? []))?.["n"] ?? 0);
+        result.omissions.projects = Math.max(0, projectCount - 8);
+        for (const project of projectRows.slice(0, 8)) {
+            const repo = String(project["repo"]);
+            const knowledge = { status: "unavailable", revision: null, identity: null, sha256: null, instructions: "", sources: [], decisions: [] };
+            const row = store.handle.prepare('SELECT * FROM project_knowledge WHERE repo=?').get(repo);
+            try {
+                const payload = String(row["payload"]), revision = Number(row["revision"]), identity = String(row["identity"]);
+                const history = store.handle.prepare('SELECT sha FROM knowledge_change WHERE repo=? AND identity=? AND revision=?').get(repo, identity, revision);
+                if (Buffer.byteLength(payload) > 160_000 || !Number.isSafeInteger(revision) || revision < 1 || sha(payload) !== row["sha"] || history?.["sha"] !== row["sha"])
+                    throw Error("invalid stored context");
+                const saved = JSON.parse(payload);
+                if (typeof saved.instructions !== "string" || !Array.isArray(saved.references) || saved.references.length > 12)
+                    throw Error("invalid stored context");
+                const sources = saved.references.map((one) => {
+                    if (typeof one.id !== "string" || typeof one.title !== "string" || typeof one.content !== "string")
+                        throw Error("invalid stored source");
+                    const id = text(one.id, 80), path = typeof one.path === "string" ? text(one.path, 160) : null;
+                    return { id, title: text(one.title, 120), kind: path === null ? "saved-note" : "repository-document", path,
+                        sourceRevision: typeof one.sourceRevision === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceRevision) ? one.sourceRevision : null,
+                        sourceSha: typeof one.sourceSha === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceSha) ? one.sourceSha : null };
+                });
+                Object.assign(knowledge, { status: "stored", revision, identity: /^[a-f0-9]{64}$/.test(identity) ? identity : null, sha256: String(row["sha"]), instructions: text(saved.instructions, 600), sources });
+            }
+            catch { /* Integrity failures are explicit; never replay an older version as current. */ }
+            try {
+                knowledge.decisions = store.handle.prepare("SELECT id,claim FROM project_decision WHERE repo=? AND status='active' ORDER BY id DESC LIMIT 8").all(repo).map(row => ({ id: Number(row["id"]), claim: text(String(row["claim"]), 160) }));
+            }
+            catch { /* memory absent on an older database reads as no decisions */ }
+            result.projects.push({ repo, knowledge });
+            if (!fits()) {
+                result.projects.pop();
+                result.omissions.projects++;
+            }
+        }
+        if (result.omissions.candidateScanLimited)
+            result.omissions.notes.push("Candidate scanning was limited; omitted assignment counts are lower bounds, not a complete project total. Filter by project or read the task list for older work.");
+        return result;
+    });
+}

package/dist/assignment-delivery.d.ts

@@ -0,0 +1,56 @@
+import type { Store } from "./store.js";
+import type { AssignmentOwner } from "./assignment.js";
+import { type AssignmentStatusEvent } from "./assignment-status.js";
+type SavedDeliveryEvent = {
+    id: number;
+    createdAt: string;
+    rootId: string;
+    project: string;
+    kind: "assignment-status";
+    digest: string;
+    assignment: AssignmentStatusEvent["assignment"];
+};
+export type AssignmentDeliveryEvent = SavedDeliveryEvent | {
+    id: number;
+    unavailable: true;
+};
+export type AssignmentDeliveryBatch = {
+    version: 1;
+    id: string | null;
+    consumer: string;
+    after: number;
+    nextCursor: number;
+    hasMore: boolean;
+    events: AssignmentDeliveryEvent[];
+};
+type Failure = {
+    ok: false;
+    reason: "invalid-input" | "unavailable" | "stale-batch" | "event-too-large";
+    message: string;
+};
+export type AssignmentInboxResult = {
+    ok: true;
+    batch: AssignmentDeliveryBatch;
+    replayed: boolean;
+} | Failure;
+export type AssignmentDeliveryAckResult = {
+    ok: true;
+    alreadyAcknowledged: boolean;
+    cursor: number;
+} | Failure;
+/** A read stages one immutable page. Until ACK, any process using this owner
+ * and consumer receives that exact page, regardless of new status events or
+ * a changed requested page size. Lost access replaces content with an opaque
+ * tombstone; it does not prevent acknowledgment of that already issued page.
+ * Consumer names identify independent inboxes. */
+export declare function assignmentInbox(store: Store, owner: AssignmentOwner, query: {
+    consumer: string;
+    limit?: number;
+}, now: Date): AssignmentInboxResult;
+/** ACK advances only the exact issued page, atomically. Replaying any prior
+ * ACK is harmless, including while a newer page awaits acknowledgment. */
+export declare function acknowledgeAssignmentDelivery(store: Store, owner: AssignmentOwner, query: {
+    consumer: string;
+    batchId: string;
+}, now: Date): AssignmentDeliveryAckResult;
+export {};

package/dist/assignment-delivery.js

@@ -0,0 +1,160 @@
+/** Durable, explicitly acknowledged delivery of assignment status events.
+ * Callers authenticate the raw coordinator credential inside the same Store
+ * transaction. Delivery receipts never complete tasks or grant authority. */
+import { createHash, randomBytes } from "node:crypto";
+import { ASSIGNMENT_STATUS_ACTION, parseAssignmentStatusEvent } from "./assignment-status.js";
+const MAX_PAGE_BYTES = 64 * 1024;
+const fail = (reason, message) => ({ ok: false, reason, message });
+const actor = (owner) => `coordinator:${owner.id}`;
+const keyFor = (owner, consumer) => createHash("sha256").update(JSON.stringify([owner.id, consumer])).digest("hex");
+const validConsumer = (value) => typeof value === "string" && /^[a-z0-9][a-z0-9-]{0,63}$/.test(value);
+const ownerSql = `COALESCE((SELECT 'lead:'||o.lead FROM team_task_owner o WHERE o.task_ref=t.id),(SELECT a.actor FROM action_ledger a WHERE a.task_id = t.external_id
+  AND a.action = 'assignment claimed' AND a.source = 'work' ORDER BY a.id DESC LIMIT 1),
+  'coordinator:' || t.coordinator_cid)`;
+function admittedRepos(store, owner) {
+    if (owner.kind !== "coordinator" || typeof owner.id !== "string" || owner.id.length === 0)
+        return null;
+    const row = store.handle.prepare("SELECT repos,revoked_at FROM coordinator_credential WHERE cid = ?").get(owner.id);
+    if (!row || row["revoked_at"] !== null)
+        return null;
+    try {
+        const repos = JSON.parse(String(row["repos"]));
+        return Array.isArray(repos) && repos.every(repo => typeof repo === "string") ? repos : null;
+    }
+    catch {
+        return null;
+    }
+}
+function exposedBatch(store, owner, repos, batch) {
+    return { ...batch, events: batch.events.map(event => {
+            const admitted = repos.includes(event.project) && store.handle.prepare(`SELECT 1 FROM task_ref t
+      WHERE t.backend = 'built-in' AND t.external_id = ? AND t.repo = ? AND t.revision_of IS NULL AND ${ownerSql} = ?`)
+                .get(event.rootId, event.project, actor(owner)) !== undefined;
+            return admitted ? event : { id: event.id, unavailable: true };
+        }) };
+}
+function eventFromRow(row, owner) {
+    const parsed = parseAssignmentStatusEvent(String(row["outcome"]));
+    if (parsed === null || parsed.assignment.rootId !== row["task_id"] || parsed.assignment.owner?.id !== owner.id)
+        return null;
+    return { id: Number(row["id"]), createdAt: String(row["at"]), rootId: String(row["task_id"]),
+        project: String(row["repo"]), kind: "assignment-status", digest: parsed.digest, assignment: parsed.assignment };
+}
+function pendingBatch(store, owner, key) {
+    const id = store.serviceCursor(`assignment-inbox:${key}:pending`);
+    if (id === 0)
+        return null;
+    const invalid = () => fail("unavailable", "The saved delivery page is invalid; its cursor has not advanced.");
+    const row = store.handle.prepare("SELECT outcome FROM action_ledger WHERE id = ? AND actor = ? AND action = ? AND source = 'work'")
+        .get(id, actor(owner), `assignment delivery batch:${key}`);
+    if (!row || Buffer.byteLength(String(row["outcome"])) > MAX_PAGE_BYTES)
+        return invalid();
+    let parsed;
+    try {
+        parsed = JSON.parse(String(row["outcome"]));
+    }
+    catch {
+        return invalid();
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return invalid();
+    const batch = parsed;
+    if (Object.keys(batch).sort().join(",") !== "after,consumer,events,hasMore,id,nextCursor,version" || batch.version !== 1 ||
+        typeof batch.id !== "string" || !/^[a-f0-9]{32}$/.test(batch.id) || !validConsumer(batch.consumer) ||
+        !Number.isSafeInteger(batch.after) || batch.after < 0 || !Number.isSafeInteger(batch.nextCursor) || batch.nextCursor <= batch.after ||
+        typeof batch.hasMore !== "boolean" || !Array.isArray(batch.events) || batch.events.length < 1 || batch.events.length > 100)
+        return invalid();
+    let previous = batch.after;
+    for (const event of batch.events) {
+        if (!event || !Number.isSafeInteger(event.id) || event.id <= previous)
+            return invalid();
+        const source = store.handle.prepare("SELECT id,at,task_id,repo,outcome FROM action_ledger WHERE id = ? AND actor = ? AND action = ? AND source = 'work'")
+            .get(event.id, actor(owner), ASSIGNMENT_STATUS_ACTION);
+        const original = source === undefined ? null : eventFromRow(source, owner);
+        if (original === null || JSON.stringify(original) !== JSON.stringify(event))
+            return invalid();
+        previous = event.id;
+    }
+    return previous === batch.nextCursor ? batch : invalid();
+}
+/** A read stages one immutable page. Until ACK, any process using this owner
+ * and consumer receives that exact page, regardless of new status events or
+ * a changed requested page size. Lost access replaces content with an opaque
+ * tombstone; it does not prevent acknowledgment of that already issued page.
+ * Consumer names identify independent inboxes. */
+export function assignmentInbox(store, owner, query, now) {
+    if (!validConsumer(query.consumer) || (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 100)))
+        return fail("invalid-input", "Use a consumer name of 1–64 characters and a page size of 1–100.");
+    return store.transact(() => store.savepoint(() => {
+        const repos = admittedRepos(store, owner);
+        if (repos === null)
+            return fail("unavailable", "The coordinator is no longer active.");
+        const key = keyFor(owner, query.consumer), cursorKey = `assignment-inbox:${key}:acked`;
+        const after = store.serviceCursor(cursorKey), pending = pendingBatch(store, owner, key);
+        if (pending !== null) {
+            if ("ok" in pending)
+                return pending;
+            if (pending.consumer !== query.consumer || pending.after !== after)
+                return fail("unavailable", "The saved delivery page does not match its cursor.");
+            return { ok: true, batch: exposedBatch(store, owner, repos, pending), replayed: true };
+        }
+        const limit = query.limit ?? 10;
+        const rows = store.handle.prepare(`SELECT n.id,n.at,n.task_id,n.repo,n.outcome
+      FROM action_ledger n JOIN task_ref t ON t.backend = 'built-in'
+        AND t.external_id = n.task_id AND t.repo = n.repo AND t.revision_of IS NULL
+      WHERE n.id > ? AND n.action = ? AND n.source = 'work' AND n.actor = ?
+        AND n.repo IN (SELECT value FROM json_each(?)) AND ${ownerSql} = ?
+      ORDER BY n.id LIMIT ?`).all(after, ASSIGNMENT_STATUS_ACTION, actor(owner), JSON.stringify(repos), actor(owner), limit + 1);
+        const batch = { version: 1, id: null, consumer: query.consumer, after, nextCursor: after, hasMore: rows.length > limit, events: [] };
+        for (const row of rows.slice(0, limit)) {
+            const event = eventFromRow(row, owner);
+            if (event === null)
+                return fail("unavailable", "The next saved assignment event is invalid; no event was skipped.");
+            batch.events.push(event);
+            if (Buffer.byteLength(JSON.stringify(batch)) > MAX_PAGE_BYTES - 128) {
+                batch.events.pop();
+                if (batch.events.length === 0)
+                    return fail("event-too-large", "The next assignment event exceeds the delivery limit; no event was skipped.");
+                batch.hasMore = true;
+                break;
+            }
+            batch.nextCursor = event.id;
+        }
+        if (batch.events.length === 0)
+            return { ok: true, batch, replayed: false };
+        batch.id = randomBytes(16).toString("hex");
+        const id = store.recordAction({ at: now.toISOString(), actor: actor(owner), repo: null, taskId: null, runId: null,
+            action: `assignment delivery batch:${key}`, outcome: JSON.stringify(batch), source: "work" });
+        store.setServiceCursor(`assignment-inbox:${key}:pending`, id, now);
+        return { ok: true, batch, replayed: false };
+    }));
+}
+/** ACK advances only the exact issued page, atomically. Replaying any prior
+ * ACK is harmless, including while a newer page awaits acknowledgment. */
+export function acknowledgeAssignmentDelivery(store, owner, query, now) {
+    if (!validConsumer(query.consumer) || typeof query.batchId !== "string" || !/^[a-f0-9]{32}$/.test(query.batchId))
+        return fail("invalid-input", "Use the exact consumer and batch ID returned by the inbox.");
+    return store.transact(() => store.savepoint(() => {
+        const repos = admittedRepos(store, owner);
+        if (repos === null)
+            return fail("unavailable", "The coordinator is no longer active.");
+        const key = keyFor(owner, query.consumer), cursorKey = `assignment-inbox:${key}:acked`;
+        const cursor = store.serviceCursor(cursorKey), action = `assignment delivery acknowledged:${key}`;
+        const acknowledged = store.handle.prepare(`SELECT 1 FROM action_ledger WHERE actor = ? AND action = ? AND source = 'work'
+      AND json_extract(outcome, '$.batchId') = ? LIMIT 1`).get(actor(owner), action, query.batchId);
+        if (acknowledged)
+            return { ok: true, alreadyAcknowledged: true, cursor };
+        const pending = pendingBatch(store, owner, key);
+        if (pending !== null && "ok" in pending)
+            return pending;
+        if (pending === null || pending.id !== query.batchId || pending.consumer !== query.consumer || pending.after !== cursor)
+            return fail("stale-batch", "This batch was not issued to this inbox; its cursor has not advanced.");
+        // Access loss redacts replayed events; the exact issued page remains
+        // acknowledgeable so its inaccessible entries cannot wedge this inbox.
+        store.recordAction({ at: now.toISOString(), actor: actor(owner), repo: null, taskId: null, runId: null,
+            action, outcome: JSON.stringify({ batchId: pending.id, after: pending.after, cursor: pending.nextCursor }), source: "work" });
+        store.setServiceCursor(cursorKey, pending.nextCursor, now);
+        store.setServiceCursor(`assignment-inbox:${key}:pending`, 0, now);
+        return { ok: true, alreadyAcknowledged: false, cursor: pending.nextCursor };
+    }));
+}

package/dist/assignment-presentation.d.ts

@@ -0,0 +1,26 @@
+/** Current assignment presentation shared by summaries and result views.
+ * Saved assessments remain history; this projection never changes receipts,
+ * checks, approvals, ownership, or the exact completion identity. */
+import type { AssignmentSnapshot } from './assignment.js';
+import { type DisplayStatus, type WorkStatus } from './workspace-ui.js';
+export type AssignmentWorkStatus = DisplayStatus & Partial<Pick<WorkStatus, 'views' | 'rank'>>;
+export type AssignmentAttention = {
+    id: string;
+    detail: string;
+    tone: 'problem' | 'attention';
+};
+/** Only the retired assessment requirement is history-only. Specific missing
+ * material, defects and failed checks remain visible, including reviewer findings. */
+export declare function historicalAssessmentReason(reason: string): boolean;
+/** Known storage-cap notices do not mean the retained bytes are damaged. */
+export declare function shortenedMaterialReason(detail: string): boolean;
+export declare function assignmentPresentationOf(assignment: AssignmentSnapshot, options?: {
+    workStatus?: AssignmentWorkStatus;
+    diagnostics?: WorkStatus['diagnostics'];
+    additionalAttention?: readonly string[];
+}): {
+    status: WorkStatus;
+    primaryAction: import("./work-summary.js").WorkAction | null;
+    attention: AssignmentAttention[];
+    diagnostics: Pick<DisplayStatus, "detail" | "label" | "token" | "tone">[];
+};

package/dist/assignment-presentation.js

@@ -0,0 +1,80 @@
+import { GOAL_ASSESSMENT_PENDING } from './proof.js';
+import { failedCheckExit } from './workspace-ui.js';
+const LABELS = {
+    working: 'Working', checking: 'Checking', 'needs-decision': 'Needs your decision',
+    'ready-to-check': 'Ready', complete: 'Complete', cancelled: 'Cancelled',
+};
+/** Only the retired assessment requirement is history-only. Specific missing
+ * material, defects and failed checks remain visible, including reviewer findings. */
+export function historicalAssessmentReason(reason) {
+    return reason === GOAL_ASSESSMENT_PENDING || reason === 'no proof was written' || reason === 'No builder proof artifact is recorded.' || /^criterion "[^"]+" awaits independent goal assessment\.?$/.test(reason) ||
+        /^semantic coverage: .* — (?:required .*|independent review is optional .*)$/.test(reason);
+}
+/** Known storage-cap notices do not mean the retained bytes are damaged. */
+export function shortenedMaterialReason(detail) {
+    return detail === 'The check output was shortened when it was stored; its download holds only the stored part.' ||
+        detail === 'The sealed diff was shortened when it was stored; its download holds only the stored part, not the full change.' ||
+        detail === 'The report was shortened when it was stored; its download holds only the stored part.' ||
+        detail === 'The check log was shortened when stored; only the retained output is available.' ||
+        detail === 'The changed-file list was cut short; the counts are complete.' ||
+        /^Saved (?:terminal-diff|report) #\d+ is incomplete\.$/.test(detail);
+}
+export function assignmentPresentationOf(assignment, options = {}) {
+    const { state } = assignment, work = options.workStatus;
+    const status = state === 'working'
+        ? { ...(work ?? { label: LABELS[state], tone: 'muted' }), token: `assignment-${state}`,
+            detail: assignment.detail, action: null, views: work?.views?.filter(view => view !== 'completed') ?? ['all'], rank: work?.rank ?? 2 }
+        : { token: `assignment-${state}`, label: state === 'checking' ? work?.label ?? LABELS[state] : LABELS[state], detail: assignment.detail,
+            action: null, tone: state === 'needs-decision' ? 'attention' : state === 'checking' ? work?.tone ?? 'live' : state === 'ready-to-check' ? 'ready' : state === 'complete' ? 'done' : 'muted',
+            views: state === 'ready-to-check' || state === 'needs-decision' ? ['all', 'needs-you'] : state === 'complete' ? ['all', 'completed']
+                : state === 'checking' && work?.views?.includes('running') ? ['all', 'running'] : ['all'],
+            rank: state === 'needs-decision' || state === 'ready-to-check' ? 0 : state === 'checking' ? 1 : state === 'complete' ? 3 : 4 };
+    const ready = state === 'ready-to-check' || state === 'complete';
+    const checks = assignment.receipt?.checks;
+    const checkReason = (detail) => detail === checks?.detail || /^Checks (?:failed|passed|did not finish)/.test(detail) ||
+        failedCheckExit([detail]) !== null;
+    const materialReason = (detail) => {
+        const saved = /^Saved (check-log|terminal-diff|report) #(\d+)/.exec(detail);
+        if (saved) {
+            const current = assignment.receipt?.artifacts.filter(one => one.kind === saved[1]) ?? [];
+            // An older attempt's missing file is a distinct limitation. Only the
+            // one exact current file can share its detailed reader's explanation.
+            return current.length === 1 && current[0].id === Number(saved[2]) ? saved[1] === 'terminal-diff' ? 'diff' : saved[1] : `artifact:${saved[2]}`;
+        }
+        if (/^The (?:retained verification log|check log|check output) /.test(detail))
+            return 'check-log';
+        if (/^The sealed diff /.test(detail))
+            return 'diff';
+        if (/^The report (?:was |is |cannot |no longer )/.test(detail))
+            return 'report';
+        return null;
+    };
+    const attention = new Map();
+    for (const detail of [...assignment.attention, ...(options.additionalAttention ?? [])]) {
+        if (historicalAssessmentReason(detail) || detail === assignment.detail)
+            continue;
+        const material = materialReason(detail);
+        const id = checks !== undefined && checkReason(detail) ? 'checks' : material === null ? `detail:${detail}` : `material:${material}`;
+        // A read of the exact machine record owns the check outcome. A legacy
+        // assessment cannot claim failure after the actual check passed.
+        if (id === 'checks' && (checks?.status === 'passed' || assignment.detail.includes(checks.detail)))
+            continue;
+        if ([...attention.values()].some(one => one.detail.includes(detail)))
+            continue;
+        const previous = attention.get(id);
+        // Damage to the retained bytes outranks their earlier storage limit.
+        if (previous !== undefined && shortenedMaterialReason(detail) && !shortenedMaterialReason(previous.detail))
+            continue;
+        attention.set(id, { id, detail: id === 'checks' ? checks.detail : detail, tone: 'problem' });
+    }
+    const diagnostics = (options.diagnostics ?? []).filter(one => {
+        if (historicalAssessmentReason(one.detail) || one.detail === assignment.detail || attention.has(`detail:${one.detail}`))
+            return false;
+        if (ready && (one.token === 'verification-needed' || one.token.startsWith('review-')))
+            return false;
+        if (checks !== undefined && (one.token === 'checks-failed' || checkReason(one.detail)))
+            return false;
+        return true;
+    });
+    return { status, primaryAction: assignment.primaryAction, attention: [...attention.values()], diagnostics };
+}

package/dist/assignment-status.d.ts

@@ -0,0 +1,62 @@
+import type { Store } from "./store.js";
+import { type AssignmentSnapshot } from "./assignment.js";
+export declare const ASSIGNMENT_STATUS_ACTION = "assignment status observed";
+export declare const ASSIGNMENT_STATUS_SOURCE: "work";
+/** No saved artifact contents, credential bytes, or polling timestamps. Exact
+ * IDs and digests identify the full read; display text is deliberately bounded. */
+export declare function assignmentStatusBrief(assignment: AssignmentSnapshot): {
+    rootId: string;
+    activeTaskId: string;
+    title: string;
+    state: "cancelled" | "checking" | "complete" | "needs-decision" | "ready-to-check" | "working";
+    detail: string;
+    owner: {
+        kind: "coordinator" | "lead";
+        id: string;
+        label: string;
+    } | null;
+    runId: number | null;
+    primaryAction: {
+        code: "inspect-decisions" | "inspect-run" | "inspect-stop" | "inspect-task" | "open-pr" | "reconcile-run" | import("./dispatch.js").DispatchAction;
+        label: string;
+        target: import("./work-summary.js").WorkTarget;
+    } | null;
+    attention: string[];
+    result: {
+        digest: string;
+        runId: number;
+        checks: {
+            status: "failed" | "not-run" | "passed" | "unavailable";
+            exitCode: number | null;
+            logArtifactId: number | null;
+        };
+        checksDigest: string;
+    } | null;
+    completion: {
+        actor: string;
+        digest: string;
+    } | null;
+    publication: {
+        state: string;
+        prUrl: string | null;
+        remoteState: string | null;
+    } | null;
+};
+export type AssignmentStatusEvent = {
+    version: 1;
+    digest: string;
+    stateDigest: string;
+    assignment: ReturnType<typeof assignmentStatusBrief> & {
+        owner: NonNullable<ReturnType<typeof assignmentStatusBrief>["owner"]>;
+    };
+};
+/** An unreadable ledger event is an explicit consumer error, not a cursor that
+ * may silently skip the row. This validates the bounded data, not authority. */
+export declare function parseAssignmentStatusEvent(value: string): AssignmentStatusEvent | null;
+/** Call inside the mutation's transaction when possible; independently atomic
+ * for worker reconciliation. The latest event, not a permanent digest set,
+ * deduplicates retries so Working → Needs decision → Working is retained. */
+export declare function noteAssignmentStatus(store: Store, snapshot: AssignmentSnapshot, now: Date): number | null;
+/** At most fifty roots per pass; the cursor survives process restarts. A full
+ * pass cycles back, so changes below the cursor are eventually observed too. */
+export declare function syncAssignmentStatuses(store: Store, now: Date, repos: readonly string[], root?: string): void;