toolroll 0.5.0

package/dist/assignment-status.js

@@ -0,0 +1,152 @@
+/** Private lead catch-up, separate from human notification delivery. These are
+ * observed assignment transitions, not a promise to capture every intermediate
+ * state between scans. Recording or reading them never dispatches agent work. */
+import { createHash } from "node:crypto";
+import { assignmentOf } from "./assignment.js";
+import { publicChatText } from "./chat-display.js";
+export const ASSIGNMENT_STATUS_ACTION = "assignment status observed";
+export const ASSIGNMENT_STATUS_SOURCE = "work";
+const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const text = publicChatText;
+/** No saved artifact contents, credential bytes, or polling timestamps. Exact
+ * IDs and digests identify the full read; display text is deliberately bounded. */
+export function assignmentStatusBrief(assignment) {
+    const receipt = assignment.receipt;
+    const action = assignment.primaryAction;
+    return {
+        rootId: assignment.rootId, activeTaskId: assignment.activeTaskId,
+        title: text(assignment.title, 200), state: assignment.state, detail: text(assignment.detail, 1_000),
+        owner: assignment.owner === null ? null : { kind: assignment.owner.kind, id: assignment.owner.id, label: text(assignment.owner.label, 100) },
+        runId: assignment.attempts.find(one => one.taskId === assignment.activeTaskId)?.runId ?? receipt?.runId ?? null,
+        // The same state can be read by an operator or a coordinator. Permission
+        // hints are caller-specific, not a transition or a grant to this consumer.
+        primaryAction: action === null ? null : { code: action.code, label: text(action.label, 160), target: action.target },
+        attention: assignment.attention.slice(0, 8).map(one => text(one, 500)),
+        result: receipt === null ? null : { digest: receipt.digest, runId: receipt.runId,
+            checks: { status: receipt.checks.status, exitCode: receipt.checks.exitCode, logArtifactId: receipt.checks.logArtifactId }, checksDigest: hash(receipt.checks) },
+        completion: assignment.completion === null ? null : { actor: assignment.completion.actor, digest: assignment.completion.digest },
+        publication: assignment.publication === null ? null : { state: text(assignment.publication.state, 80),
+            prUrl: /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+$/.test(assignment.publication.prUrl ?? "") && assignment.publication.prUrl.length <= 2_000 ? assignment.publication.prUrl : null,
+            remoteState: assignment.publication.remoteState === null ? null : text(assignment.publication.remoteState, 80) },
+    };
+}
+/** 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 function parseAssignmentStatusEvent(value) {
+    if (Buffer.byteLength(value) > 32_768)
+        return null;
+    const object = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+    const string = (v, n) => typeof v === "string" && v.length <= n;
+    const sha = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
+    const id = (v) => v === null || Number.isSafeInteger(v) && Number(v) > 0;
+    const keys = (v, names) => Object.keys(v).length === names.length && names.every(name => Object.hasOwn(v, name));
+    try {
+        const event = JSON.parse(value);
+        if (!object(event) || !keys(event, ["version", "digest", "stateDigest", "assignment"]) || event["version"] !== 1 || !sha(event["digest"]) || !sha(event["stateDigest"]))
+            return null;
+        const a = event["assignment"];
+        if (!object(a) || !keys(a, ["rootId", "activeTaskId", "title", "state", "detail", "owner", "runId", "primaryAction", "attention", "result", "completion", "publication"]) ||
+            !string(a["rootId"], 64) || !string(a["activeTaskId"], 64) || !string(a["title"], 200) || !string(a["detail"], 1_000) || !id(a["runId"]) ||
+            !["working", "checking", "needs-decision", "ready-to-check", "complete", "cancelled"].includes(String(a["state"])) ||
+            !Array.isArray(a["attention"]) || a["attention"].length > 8 || !a["attention"].every(one => string(one, 500)))
+            return null;
+        const owner = a["owner"], action = a["primaryAction"], result = a["result"], completion = a["completion"], publication = a["publication"];
+        if (!object(owner) || !keys(owner, ["kind", "id", "label"]) || !["coordinator", "lead"].includes(String(owner["kind"])) || !string(owner["id"], 128) || !string(owner["label"], 100))
+            return null;
+        if (action !== null && (!object(action) || !keys(action, ["code", "label", "target"]) || !string(action["code"], 80) || !string(action["label"], 160) ||
+            !object(action["target"]) || !keys(action["target"], ["taskId", "runId", "decisionId"]) || !string(action["target"]["taskId"], 64) || !id(action["target"]["runId"]) || !id(action["target"]["decisionId"])))
+            return null;
+        if (result !== null && (!object(result) || !keys(result, ["digest", "runId", "checks", "checksDigest"]) || !sha(result["digest"]) || !id(result["runId"]) || result["runId"] === null || !sha(result["checksDigest"]) ||
+            !object(result["checks"]) || !keys(result["checks"], ["status", "exitCode", "logArtifactId"]) ||
+            !["passed", "failed", "not-run", "unavailable"].includes(String(result["checks"]["status"])) ||
+            !(result["checks"]["exitCode"] === null || Number.isInteger(result["checks"]["exitCode"]) && Number(result["checks"]["exitCode"]) >= 0 && Number(result["checks"]["exitCode"]) <= 255) || !id(result["checks"]["logArtifactId"])))
+            return null;
+        if (completion !== null && (!object(completion) || !keys(completion, ["actor", "digest"]) || !string(completion["actor"], 160) || !sha(completion["digest"])))
+            return null;
+        if (publication !== null && (!object(publication) || !keys(publication, ["state", "prUrl", "remoteState"]) || !string(publication["state"], 80) ||
+            !(publication["prUrl"] === null || string(publication["prUrl"], 2_000)) || !(publication["remoteState"] === null || string(publication["remoteState"], 80))))
+            return null;
+        return hash(a) === event["stateDigest"] ? event : null;
+    }
+    catch {
+        return 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 function noteAssignmentStatus(store, snapshot, now) {
+    if (!snapshot.owner?.active || snapshot.repo === null)
+        return null;
+    return store.transact(() => {
+        const owner = snapshot.owner;
+        const ref = store.lookupRef(snapshot.rootId);
+        if (!ref || ref.repo !== snapshot.repo || ref.revisionOf !== null)
+            return null;
+        if (owner.kind === "lead") {
+            const held = store.handle.prepare("SELECT o.lead,l.status FROM team_task_owner o JOIN team_lead l ON l.id=o.lead WHERE o.task_ref=?").get(ref.id);
+            if (held?.["lead"] !== owner.id || held["status"] !== "active")
+                return null;
+        }
+        else {
+            const claimed = store.handle.prepare("SELECT actor FROM action_ledger WHERE task_id=? AND action='assignment claimed' AND source='work' ORDER BY id DESC LIMIT 1").get(snapshot.rootId);
+            if ((claimed === undefined ? ref.coordinatorCid : String(claimed["actor"]).replace(/^coordinator:/, "")) !== owner.id)
+                return null;
+            const credential = store.handle.prepare("SELECT repos FROM coordinator_credential WHERE cid=? AND revoked_at IS NULL").get(owner.id);
+            let repos;
+            try {
+                repos = JSON.parse(String(credential?.["repos"] ?? "null"));
+            }
+            catch {
+                return null;
+            }
+            if (!Array.isArray(repos) || !repos.includes(snapshot.repo))
+                return null;
+        }
+        const assignment = assignmentStatusBrief(snapshot);
+        if (assignment.owner === null)
+            return null;
+        const stateDigest = hash(assignment);
+        const previous = store.handle.prepare("SELECT id,outcome FROM action_ledger WHERE task_id=? AND action=? AND source=? ORDER BY id DESC LIMIT 1")
+            .get(snapshot.rootId, ASSIGNMENT_STATUS_ACTION, ASSIGNMENT_STATUS_SOURCE);
+        if (previous !== undefined) {
+            try {
+                if (JSON.parse(String(previous["outcome"]))?.stateDigest === stateDigest)
+                    return null;
+            }
+            catch { /* Preserve an unreadable older event; append the current observation. */ }
+        }
+        const digest = hash({ rootRef: ref.id, owner: owner.id, previous: previous === undefined ? null : Number(previous["id"]), stateDigest });
+        const event = { version: 1, digest, stateDigest, assignment: { ...assignment, owner: assignment.owner } };
+        return store.recordAction({ at: now.toISOString(), actor: `${owner.kind}:${owner.id}`, repo: snapshot.repo,
+            taskId: snapshot.rootId, runId: assignment.runId, action: ASSIGNMENT_STATUS_ACTION,
+            outcome: JSON.stringify(event), source: ASSIGNMENT_STATUS_SOURCE });
+    });
+}
+/** 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 function syncAssignmentStatuses(store, now, repos, root) {
+    if (repos.length === 0)
+        return;
+    const allowed = [...new Set(repos)].sort();
+    const key = `assignment-status:${hash(allowed)}`;
+    const rows = store.handle.prepare(`SELECT t.id,t.external_id FROM task_ref t
+    WHERE t.backend='built-in' AND t.revision_of IS NULL
+    AND t.repo IN (SELECT value FROM json_each(?)) AND t.id>?
+    AND (t.coordinator_cid IS NOT NULL OR EXISTS(SELECT 1 FROM team_task_owner o WHERE o.task_ref=t.id) OR EXISTS
+      (SELECT 1 FROM action_ledger a WHERE a.task_id=t.external_id AND a.action='assignment claimed' AND a.source='work'))
+    ORDER BY t.id LIMIT 50`).all(JSON.stringify(allowed), store.serviceCursor(key));
+    // Release the writer between families. Each observation and its durable
+    // position still commit together; an interrupted sweep resumes after the
+    // last committed family instead of holding every heartbeat behind a batch.
+    if (rows.length === 0)
+        store.setServiceCursor(key, 0, now);
+    for (const [index, row] of rows.entries()) {
+        store.transact(() => {
+            const snapshot = assignmentOf(store, String(row['external_id']), now, { principal: 'coordinator', repos: allowed }, root);
+            if (snapshot !== null)
+                noteAssignmentStatus(store, snapshot, now);
+            store.setServiceCursor(key, index === rows.length - 1 && rows.length < 50 ? 0 : Number(row['id']), now);
+        });
+    }
+}

package/dist/assignment-ui.d.ts

@@ -0,0 +1,71 @@
+/** Presentation only. Assignment state and retry authority belong to their
+ * existing projections and signed operating-mode terms, never this renderer. */
+import type { AssignmentSnapshot } from './assignment.js';
+import type { DisplayStatus, StatusTone, WorkStatus } from './workspace-ui.js';
+import { type AssignmentWorkStatus } from './assignment-presentation.js';
+/** The existing verified receipt reader may discover damage after a verdict
+ * was saved. Keep the limitation visible without inventing another work stage. */
+export declare function assignmentWithEvidence(assignment: AssignmentSnapshot, resultStatus: DisplayStatus | null, resultRunId?: number | null): AssignmentSnapshot;
+export declare function assignmentStatusOf(assignment: AssignmentSnapshot, workStatus?: AssignmentWorkStatus): WorkStatus;
+/** Navigation only. A control action still opens its existing exact ceremony. */
+export declare function assignmentActionHref(assignment: AssignmentSnapshot): string | null;
+export type AssignmentAttemptRow = {
+    taskId: string;
+    label: string;
+    href: string;
+    runId: number | null;
+    detail: string | null;
+};
+/** Every version of the assignment, oldest first, as the card lists them. */
+export declare function assignmentAttemptsOf(assignment: AssignmentSnapshot): AssignmentAttemptRow[];
+export declare function assignmentAttemptsHtml(assignment: AssignmentSnapshot): string;
+type AssignmentCardOptions = {
+    hideAction?: boolean;
+    problem?: boolean;
+    diagnostics?: WorkStatus['diagnostics'];
+    workStatus?: AssignmentWorkStatus;
+    resultHref?: string;
+};
+/** The status card's content: one projection for the server HTML and the
+ * rebuilt task page, so the two never word the same state differently. */
+export type AssignmentCard = {
+    token: string;
+    tone: StatusTone;
+    label: string;
+    action: {
+        label: string;
+        href: string;
+        openResult: boolean;
+    } | null;
+    /** Ready with passing checks: a verdict chip replaces the detail sentence. */
+    passed: {
+        by: string | null;
+    } | null;
+    detail: {
+        text: string;
+        problem: boolean;
+    };
+    problems: string[];
+    diagnostics: {
+        token: string;
+        label: string;
+        detail: string;
+        problem: boolean;
+    }[];
+    notices: {
+        summary: string;
+        lines: string[];
+    } | null;
+    attempts: AssignmentAttemptRow[];
+    lead: {
+        label: string;
+        active: boolean;
+    } | null;
+};
+export declare function assignmentCardOf(assignment: AssignmentSnapshot, options?: AssignmentCardOptions): AssignmentCard;
+export declare function assignmentSummaryHtml(assignment: AssignmentSnapshot, options?: AssignmentCardOptions & {
+    compact?: boolean;
+}): string;
+/** Shared assignment layout; actions remain comfortable on touch screens. */
+export declare const ASSIGNMENT_CSS = ".assignment-summary{min-width:0;overflow-wrap:anywhere}.assignment-summary .assignment-state{font-weight:600;margin:0}.assignment-summary h2.assignment-state{font-size:1.125rem;color:var(--foreground)}.assignment-summary>.assignment-attempts,.assignment-summary>.assignment-notices{border:0;box-shadow:none;padding:0;margin:.25rem 0 0;background:transparent}.assignment-summary>.button-link{margin-top:.7rem;min-height:44px}.assignment-summary>.work-action{display:inline-flex;margin-inline-start:.6rem;min-height:44px;align-items:center}.assignment-detail{margin:.55rem 0}.assignment-attempts summary,.assignment-notices summary{min-height:44px;display:list-item;align-content:center;cursor:pointer}.assignment-notices summary{font-size:.8125rem;color:var(--foreground)}.assignment-notices p{margin:.25rem 0 .5rem}.assignment-attempts ol{padding-left:1.4rem}.assignment-attempts li{margin:.4rem 0}.assignment-attempts li a{display:inline-flex;align-items:center;min-height:44px;margin-right:.7rem}.assignment-attempts li p{margin:0 0 .4rem}";
+export {};

package/dist/assignment-ui.js

@@ -0,0 +1,103 @@
+import { assignmentPresentationOf, shortenedMaterialReason } from './assignment-presentation.js';
+const escape = (value) => value.replace(/[&<>"']/g, char => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[char]);
+/** The existing verified receipt reader may discover damage after a verdict
+ * was saved. Keep the limitation visible without inventing another work stage. */
+export function assignmentWithEvidence(assignment, resultStatus, resultRunId = assignment.receipt?.runId ?? null) {
+    if (resultStatus?.token !== 'evidence-damaged')
+        return assignment;
+    return { ...assignment,
+        attempts: assignment.attempts.map(attempt => attempt.taskId === assignment.activeTaskId && resultRunId !== null && attempt.runId === resultRunId ? { ...attempt, detail: resultStatus.detail } : attempt),
+        attention: [...new Set([...assignment.attention, resultStatus.detail])],
+    };
+}
+export function assignmentStatusOf(assignment, workStatus) {
+    return assignmentPresentationOf(assignment, workStatus === undefined ? {} : { workStatus }).status;
+}
+const taskHref = (assignment, taskId) => `/t/${encodeURIComponent(assignment.rootId)}?version=${encodeURIComponent(taskId)}`;
+/** Navigation only. A control action still opens its existing exact ceremony. */
+export function assignmentActionHref(assignment) {
+    const action = assignment.primaryAction;
+    if (action === null)
+        return null;
+    const { taskId, runId, decisionId } = action.target;
+    if (decisionId !== null)
+        return `/d/${decisionId}`;
+    if (action.code === 'inspect-decisions')
+        return '/';
+    if (action.code === 'open-pr' && /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+$/.test(assignment.publication?.prUrl ?? ''))
+        return assignment.publication.prUrl;
+    if (runId !== null && (action.code === 'open-result' || action.code === 'open-pr' || action.code === 'retry-review')) {
+        return `/review?result=${encodeURIComponent(taskId)}&run=${runId}${assignment.repo === null ? '' : '&project=' + encodeURIComponent(assignment.repo)}`;
+    }
+    if (runId !== null && (action.code === 'inspect-run' || action.code === 'reconcile-run'))
+        return `/r/${runId}`;
+    const anchor = action.code === 'approve-scope' ? '#approve'
+        : action.code === 'inspect-stop' || action.code === 'resume-run' ? '#task-control'
+            : action.code === 'unhold' || action.code === 'retry-task' ? '#task-actions'
+                : action.code === 'write-scope' || action.code === 'select-agent' ? '#scope'
+                    : action.code === 'inspect-hold' ? '#holds'
+                        : action.code === 'start-worker' || action.code === 'repair-dependency' ? '#run-status' : '';
+    return taskHref(assignment, taskId) + anchor;
+}
+/** Every version of the assignment, oldest first, as the card lists them. */
+export function assignmentAttemptsOf(assignment) {
+    return assignment.attempts.map((attempt, index) => ({
+        taskId: attempt.taskId, label: `${index === 0 ? 'Original' : `Correction ${index}`} · ${attempt.label}`,
+        href: taskHref(assignment, attempt.taskId), runId: attempt.runId,
+        detail: (assignment.state === 'checking' && attempt.taskId === assignment.activeTaskId) || attempt.detail === assignment.detail ? null : attempt.detail,
+    }));
+}
+export function assignmentAttemptsHtml(assignment) {
+    if (assignment.attempts.length === 0)
+        return '';
+    return `<details class="assignment-attempts"><summary>Attempts <span class="meta">${assignment.attempts.length}</span></summary><ol>` + assignmentAttemptsOf(assignment).map(attempt => `<li data-attempt-task="${escape(attempt.taskId)}" data-history-version="${escape(attempt.taskId)}"><a href="${escape(attempt.href)}">${escape(attempt.label)}</a>${attempt.runId === null ? '' : ` <a href="/r/${attempt.runId}">Run #${attempt.runId}</a>`}${attempt.detail === null ? '' : `<p class="meta">${escape(attempt.detail)}</p>`}</li>`).join('') + `</ol>${assignment.owner === null ? '' : `<p class="meta">Lead: ${escape(assignment.owner.label)}${assignment.owner.active ? '' : ' · access ended'}</p>`}<p class="work-meta work-id">Task <span class="mono">${escape(assignment.rootId)}</span></p></details>`;
+}
+/** Only recognized storage limits and explicitly identified older records are
+ * secondary. Unknown findings and damaged current material stay in view. */
+function savedMaterialNotice(detail, assignment) {
+    if (shortenedMaterialReason(detail))
+        return 'partial';
+    const earlier = /^Saved [\w-]+ #(\d+) \(run (\d+)\) is unavailable or changed\.$/.exec(detail);
+    return earlier !== null && assignment.receipt !== null && Number(earlier[2]) < assignment.receipt.runId &&
+        !assignment.receipt.artifacts.some(one => one.id === Number(earlier[1])) ? 'history' : null;
+}
+export function assignmentCardOf(assignment, options = {}) {
+    const presentation = assignmentPresentationOf(assignment, options);
+    const { status, diagnostics } = presentation;
+    const href = assignment.primaryAction?.code === 'open-result' && options.resultHref !== undefined ? options.resultHref : assignmentActionHref(assignment);
+    const attention = presentation.attention.map(one => one.detail);
+    const notices = [...attention, ...diagnostics.map(one => one.detail)].filter(one => savedMaterialNotice(one, assignment) !== null);
+    const partial = notices.some(one => savedMaterialNotice(one, assignment) === 'partial');
+    const history = notices.some(one => savedMaterialNotice(one, assignment) === 'history');
+    const ready = assignment.state === "ready-to-check" || assignment.state === "complete";
+    const checkProblem = ready && assignment.receipt !== null && assignment.receipt.completionKind !== 'research-report' && assignment.receipt.checks.status !== 'passed';
+    return {
+        token: status.token, tone: status.tone, label: status.label,
+        action: options.hideAction || href === null ? null : { label: assignment.primaryAction.label, href, openResult: options.resultHref !== undefined },
+        // A good outcome at a glance; the same words stay in the result.
+        passed: ready && !checkProblem && assignment.receipt !== null && assignment.receipt.checks.status === 'passed'
+            ? { by: assignment.completion === null ? null : assignment.completion.actor.replace(/^(?:operator|coordinator|lead):/, '') } : null,
+        detail: { text: assignment.detail, problem: checkProblem || options.problem === true && !ready },
+        problems: attention.filter(one => savedMaterialNotice(one, assignment) === null),
+        diagnostics: diagnostics.filter(one => savedMaterialNotice(one.detail, assignment) === null)
+            .map(one => ({ token: one.token, label: one.label, detail: one.detail, problem: one.tone === 'problem' || one.tone === 'attention' })),
+        notices: notices.length === 0 ? null : { summary: [partial ? 'Saved output is partial' : '', history ? 'Earlier material unavailable' : ''].filter(Boolean).join(' · '), lines: [...new Set(notices)] },
+        attempts: assignmentAttemptsOf(assignment),
+        lead: assignment.owner === null ? null : { label: assignment.owner.label, active: assignment.owner.active },
+    };
+}
+export function assignmentSummaryHtml(assignment, options = {}) {
+    const card = assignmentCardOf(assignment, options);
+    return `<section class="${options.compact ? 'assignment-summary' : 'card assignment-summary'}" aria-label="assignment progress" data-assignment="${escape(assignment.rootId)}" data-work-status="${card.token}" data-tone="${card.tone}"${options.compact ? '' : ' data-task-status'}>` +
+        (options.compact ? `<span class="status-line" data-work-status="${card.token}" data-tone="${card.tone}"><i class="status-dot" aria-hidden="true"></i><span class="status-label">${card.label}</span></span>` : `<h2 class="assignment-state">${card.label}</h2>`) +
+        (card.action === null ? '' : `<a class="${options.compact ? 'work-action' : 'button-link'}" href="${escape(card.action.href)}"${card.action.openResult ? ' data-open-result' : ''}${options.compact ? '' : ' data-primary-action'}>${escape(card.action.label)}${options.compact ? ' →' : ''}</a>`) +
+        (!options.compact && card.passed !== null
+            ? `<p class="meta assignment-detail assignment-verdict"><span class="verdict-chip verdict-chip--success">Checks passed</span>${card.passed.by === null ? '' : ` Completed by ${escape(card.passed.by)}`}</p>`
+            : `<p class="${card.detail.problem ? 'problem' : 'meta'} assignment-detail">${escape(card.detail.text)}</p>`) +
+        card.problems.map(one => `<p class="problem">${escape(one)}</p>`).join('') +
+        card.diagnostics.map(one => `<p class="${one.problem ? 'problem' : 'meta'}" data-work-diagnostic="${escape(one.token)}">${escape(one.label)} · ${escape(one.detail)}</p>`).join('') +
+        (card.notices === null ? '' : `<details class="assignment-notices"><summary>${card.notices.summary}</summary>${card.notices.lines.map(one => `<p class="meta">${escape(one)}</p>`).join('')}</details>`) +
+        assignmentAttemptsHtml(assignment) + `</section>`;
+}
+/** Shared assignment layout; actions remain comfortable on touch screens. */
+export const ASSIGNMENT_CSS = `.assignment-summary{min-width:0;overflow-wrap:anywhere}.assignment-summary .assignment-state{font-weight:600;margin:0}.assignment-summary h2.assignment-state{font-size:1.125rem;color:var(--foreground)}.assignment-summary>.assignment-attempts,.assignment-summary>.assignment-notices{border:0;box-shadow:none;padding:0;margin:.25rem 0 0;background:transparent}.assignment-summary>.button-link{margin-top:.7rem;min-height:44px}.assignment-summary>.work-action{display:inline-flex;margin-inline-start:.6rem;min-height:44px;align-items:center}.assignment-detail{margin:.55rem 0}.assignment-attempts summary,.assignment-notices summary{min-height:44px;display:list-item;align-content:center;cursor:pointer}.assignment-notices summary{font-size:.8125rem;color:var(--foreground)}.assignment-notices p{margin:.25rem 0 .5rem}.assignment-attempts ol{padding-left:1.4rem}.assignment-attempts li{margin:.4rem 0}.assignment-attempts li a{display:inline-flex;align-items:center;min-height:44px;margin-right:.7rem}.assignment-attempts li p{margin:0 0 .4rem}`;

package/dist/assignment.d.ts

@@ -0,0 +1,222 @@
+import { type Store, type ProofVerdictRow, type ProofAcceptanceRow } from "./store.js";
+import { type WorkAction, type WorkSummaryAccess } from "./work-summary.js";
+import { type VerifiedApprover } from "./principal.js";
+export type AssignmentAccess = WorkSummaryAccess;
+export type AssignmentOwner = {
+    kind: "coordinator" | "lead";
+    id: string;
+    label: string;
+};
+export type AssignmentChecks = {
+    status: "passed" | "failed" | "not-run" | "unavailable";
+    exitCode: number | null;
+    command: string | null;
+    logArtifactId: number | null;
+    detail: string;
+};
+export type AssignmentReceipt = {
+    digest: string;
+    rootId: string;
+    taskId: string;
+    runId: number;
+    base: string | null;
+    head: string | null;
+    scopeDigest: string | null;
+    proof: ProofVerdictRow | null;
+    completionKind: "verified-build" | "checked-build" | "finished-build" | "research-report" | "accepted-exception" | null;
+    proofAcceptance: ProofAcceptanceRow | null;
+    checks: AssignmentChecks;
+    artifacts: {
+        id: number;
+        kind: string;
+        sha256: string;
+        bytes: number;
+        complete: boolean;
+    }[];
+    caveats: string[];
+    agentReport: string | null;
+    evidence: "recorded";
+};
+export type AssignmentSnapshot = {
+    version: 1;
+    rootId: string;
+    activeTaskId: string;
+    repo: string | null;
+    title: string;
+    state: "working" | "checking" | "needs-decision" | "ready-to-check" | "complete" | "cancelled";
+    detail: string;
+    primaryAction: WorkAction | null;
+    attention: string[];
+    attempts: {
+        taskId: string;
+        runId: number | null;
+        label: string;
+        detail: string;
+    }[];
+    owner: (AssignmentOwner & {
+        active: boolean;
+    }) | null;
+    receipt: AssignmentReceipt | null;
+    savedContext?: {
+        goal: string | null;
+        outOfScope: string | null;
+        excerpts: {
+            artifactId: number;
+            runId: number;
+            kind: string;
+            sha256: string;
+            text: string | null;
+            shortened: boolean;
+            problem: string | null;
+        }[];
+    };
+    completion: {
+        actor: string;
+        at: string;
+        digest: string;
+    } | null;
+    handoff: {
+        kind: "result" | "decision" | "attention";
+        digest: string;
+        acknowledged: boolean;
+    } | null;
+    publication: {
+        state: string;
+        prUrl: string | null;
+        remoteState: string | null;
+    } | null;
+    deployment: {
+        status: "not-recorded";
+    };
+};
+/** Status-first handoff for routine reads. Fetch get_assignment only when
+ * inspecting its exact evidence; do not repeat a full proof in every poll. */
+export declare function assignmentBrief(assignment: AssignmentSnapshot | null): {
+    version: 1;
+    rootId: string;
+    activeTaskId: string;
+    state: "cancelled" | "checking" | "complete" | "needs-decision" | "ready-to-check" | "working";
+    detail: string;
+    owner: (AssignmentOwner & {
+        active: boolean;
+    }) | null;
+    primaryAction: WorkAction | null;
+    attention: string[];
+    attempts: number;
+    handoff: {
+        kind: "result" | "decision" | "attention";
+        digest: string;
+        acknowledged: boolean;
+    } | null;
+    completion: {
+        actor: string;
+        at: string;
+        digest: string;
+    } | null;
+    result: {
+        digest: string;
+        taskId: string;
+        runId: number;
+        base: string | null;
+        head: string | null;
+        completionKind: "accepted-exception" | "checked-build" | "finished-build" | "research-report" | "verified-build" | null;
+        checks: AssignmentChecks;
+        proofAcceptance: ProofAcceptanceRow | null;
+        verdict: "attested" | "refuted" | "short" | "verified" | null;
+        criteria: {
+            passed: number;
+            total: number;
+        };
+        evidence: "recorded";
+    } | null;
+    publication: {
+        state: string;
+        prUrl: string | null;
+        remoteState: string | null;
+    } | null;
+    deployment: {
+        status: "not-recorded";
+    };
+} | null;
+export declare function assignmentOf(store: Store, taskId: string, now: Date, access: AssignmentAccess, root?: string): AssignmentSnapshot | null;
+type MutationResult = {
+    ok: true;
+    assignment: AssignmentSnapshot;
+} | {
+    ok: false;
+    reason: string;
+    message: string;
+};
+export declare function claimAssignment(store: Store, taskId: string, owner: AssignmentOwner, now: Date, root?: string): MutationResult;
+/** Diagnostic only: artifact availability does not authorize or block a human
+ * handoff. Deployment independently validates its actual native check. */
+export declare function assignmentEvidenceIntact(store: Store, root: string, receipt: AssignmentReceipt): boolean;
+export declare function checkAssignment(store: Store, taskId: string, receiptDigest: string, owner: AssignmentOwner, now: Date, root?: string): MutationResult;
+/** The signed-in user can mark the same exact receipt handled without taking
+ * lead ownership. This records review, never check success or new authority. */
+export declare function checkAssignmentAsOperator(store: Store, taskId: string, receiptDigest: string, who: VerifiedApprover, now: Date, root?: string): MutationResult;
+/** The ordinary worker reconciles at most 50 owned roots per pass. A lost
+ * wakeup is recovered after restart; immutable notification keys dedupe it. */
+export declare function syncAssignmentHandoffs(store: Store, now: Date, repos: readonly string[], root?: string): void;
+export declare function assignmentUpdates(store: Store, now: Date, access: AssignmentAccess, query: {
+    after: number;
+    limit: number;
+}, root?: string): {
+    events: {
+        id: number;
+        createdAt: string;
+        rootId: string;
+        digest: string;
+        superseded: boolean;
+        assignment: {
+            version: 1;
+            rootId: string;
+            activeTaskId: string;
+            state: "cancelled" | "checking" | "complete" | "needs-decision" | "ready-to-check" | "working";
+            detail: string;
+            owner: (AssignmentOwner & {
+                active: boolean;
+            }) | null;
+            primaryAction: WorkAction | null;
+            attention: string[];
+            attempts: number;
+            handoff: {
+                kind: "result" | "decision" | "attention";
+                digest: string;
+                acknowledged: boolean;
+            } | null;
+            completion: {
+                actor: string;
+                at: string;
+                digest: string;
+            } | null;
+            result: {
+                digest: string;
+                taskId: string;
+                runId: number;
+                base: string | null;
+                head: string | null;
+                completionKind: "accepted-exception" | "checked-build" | "finished-build" | "research-report" | "verified-build" | null;
+                checks: AssignmentChecks;
+                proofAcceptance: ProofAcceptanceRow | null;
+                verdict: "attested" | "refuted" | "short" | "verified" | null;
+                criteria: {
+                    passed: number;
+                    total: number;
+                };
+                evidence: "recorded";
+            } | null;
+            publication: {
+                state: string;
+                prUrl: string | null;
+                remoteState: string | null;
+            } | null;
+            deployment: {
+                status: "not-recorded";
+            };
+        };
+    }[];
+    nextCursor: number;
+    hasMore: boolean;
+};
+export {};