toolroll 0.9.103 → 0.9.105

package/dist/approval-authority.d.ts

@@ -1,51 +0,0 @@
-/** SQL over a `task_scope` alias and a repo expression: whether that row's approval authority stands at `now` (an SQL
- * expression, used exactly four times: the mode and grant clauses, the release's expiry and a fast start's window). It never asks whether the row is approved.
- * COALESCE: a NULL basis would make the OR chain NULL, and NOT NULL reads as "not dead"; NULL stands on nothing. */
-export declare function authorityStandsSql(scope: string, repo: string, now: string): string;
-/**
- * SQL, conjunctive with every alternative above (plain-toolroll.md P2.4): narrow only. A fast start's seal dispatches only
- * inside its start window, and only as what it claims to be: a person's own ceremony yes to these exact bytes, proved at
- * the seal's instant (`password`), or (one-step-chat.md C1) their own yes on a chat Start card (`chat`), which stands only
- * on ONE complete chat proof row at the seal's instant carrying the fast marker (chatFastProofSql). Losing the marker
- * leaves an ordinary person approval; nothing here grants anything.
- */
-export declare function fastStartStandsSql(scope: string, now: string): string;
-/**
- * SQL: a chat seal's fast-start proof — ONE `approval proved` row that matches all of: this task, the seal's approver,
- * the seal's instant, outcome `chat`, and a detail that is valid JSON (checked before any json_extract, which would fail
- * on anything else) whose `$.fastStart.rule` is the rule this build writes (fast-start.ts FAST_START_RULE), `$.at` the
- * seal's instant and `$.digest` the approved digest. Facts split across rows never add up to one.
- */
-export declare const chatFastProofSql: (scope: string) => string;
-/**
- * SQL, conjunctive with every alternative above (results routing slice 3): a task whose sealed route tries a cheaper
- * model (its build leg's selection is a trial) stands only on a PERSON's own yes to these exact bytes — the ceremony
- * (`password`) or their paired-chat tap (`chat`), with that person's proof at the seal's instant, and no machine's.
- * A mode, a grant, a schedule, a carry, an automatic seal or the lead never stand for one, whatever else allows them.
- * The route is matched as text, so a route that can't be read as JSON is held to it too (fail closed).
- */
-export declare function trialSealStandsSql(scope: string): string;
-/**
- * SQL, conjunctive with every alternative above (easy-start plan C5): a seal a local owner gave (its proof row at the
- * seal's instant says `local-owner`) stands only while local mode is on, for that owner, at the local generation its
- * proof names (approvalProofDetail's " · local <generation> <transport> · "), and while its project's checks aren't
- * stored as unsandboxed. Turning local mode off, or moving its generation, stops every such seal dispatching.
- */
-export declare const localSealStandsSql: (scope: string, repo: string) => string;
-/** SQL: a `carried` seal stands only on its own carry row — this task, this approved digest, this candidate, and the
- * reference `<authority>:<carry>` the carry transaction wrote (release-once.md). */
-export declare const carrySealSql: (scope: string) => string;
-/**
- * SQL: a task that belongs to a release authority (its anchor, or a carried commit) dispatches only as the current
- * generation's tip while the release is open and unexpired, with the anchor's approver still an active approver who
- * can reach the project and the anchor's approval on its exact sealed digest. A task that belongs to no release passes.
- * The claim and build belts read the whole predicate (scope.ts liveReleaseOf) besides. "Open and unexpired" here is
- * release-authority.ts releaseStateAt(a, now) === "open", written in SQL.
- */
-export declare const releaseStandsSql: (scope: string, now: string) => string;
-/** SQL: a machine made this seal — any proof at the seal's instant that isn't a person's (whatever its detail says,
- * parsed or not: fail closed), or the lead's own approval act then. */
-export declare const machineSealSql: (scope: string) => string;
-/** SQL: a person's proof at the seal's instant for these exact bytes, its detail parsed (the versioned JSON record,
- * whitespace and all, or the legacy text). */
-export declare const personSealSql: (scope: string) => string;

package/dist/approval-password.d.ts

@@ -1,31 +0,0 @@
-import type { Scope } from "./scope.js";
-import type { Store } from "./store.js";
-export type ApprovalPasswordField = {
-    field: "none";
-    why: "passwordless" | "local-owner";
-} | {
-    field: "remembered";
-    since: string;
-} | {
-    field: "required";
-} | {
-    field: "local-refused";
-    message: string;
-    href: string;
-    action: string;
-};
-export type ApprovalPasswordFacts = {
-    /** The approver. */
-    name: string;
-    taskId: string;
-    scope: Scope;
-    /** Passwordless is on for this browser session (html.ts passwordlessRendering). */
-    passwordless: boolean;
-    /** The request is this laptop's local owner (easy-start C5). */
-    localOwner: boolean;
-    /** When a password was last typed on this session, if it may still stand (scope.ts freshnessFor), else null. */
-    freshAt: number | null;
-    /** Where a refused local owner goes back to. */
-    returnTo: string;
-};
-export declare function approvalPasswordField(store: Store, facts: ApprovalPasswordFacts): ApprovalPasswordField;

package/dist/approval-policy.d.ts

@@ -1,69 +0,0 @@
-/**
- * Separation of duties (v102): a project's approval rules. Two can be on at
- * once, and neither changes a thing until a project turns it on.
- *
- * - The person who filed a task can't approve it ("not the requester").
- * - Protected work (the whole project, or tasks that touch protected paths)
- *   needs two different people to approve the same exact scope, and an AI
- *   subagent or an operating mode can never decide it.
- *
- * The store enforces these at the one place every approval is sealed
- * (`Store.sealScopeApproval`); this module holds the pure parts.
- */
-/** Who filed a task, as far as anyone can tell: a person (browser, chat, a
- * revision), a coordinator acting for the person who made it, an AI
- * subagent, or automation that names no person (a schedule, the CLI, a flow
- * with no owner). The requester rule binds only a named person. */
-export type FilerKind = "person" | "coordinator" | "subagent" | "automation";
-export type Filer = {
-    name: string | null;
-    kind: FilerKind;
-};
-/** A filer from a name as the ledger writes it: a subagent's ends " (AI)"; a coordinator's starts "coordinator:"; none is automation. */
-export declare function filerFor(name: string | null | undefined): Filer;
-export type ApprovalRules = {
-    notRequester: boolean;
-    protectProject: boolean;
-    protectedPaths: string[];
-};
-export declare const NO_RULES: ApprovalRules;
-/** Who is sealing: a person at a ceremony, an operating mode, a subagent, or automation. */
-export type ApproverKind = "person" | "mode" | "ai" | "automation";
-export type ApprovalGate = {
-    verdict: "seal";
-    protectedWork: boolean;
-} | {
-    verdict: "vote";
-    have: number;
-    need: 2;
-    already: boolean;
-} | {
-    verdict: "refuse";
-    reason: "requester" | "person-required";
-};
-/** Whether a task that says it touches `touch` may touch something under
- * `protectedGlob`, or a changed file is protected. A plain path covers
- * itself and everything under it; a pattern with no slash matches at any
- * depth (as in .gitignore); two patterns that could reach the same files
- * count as overlapping; a path that climbs out of the checkout is
- * protected. Every doubt errs toward protecting. */
-export declare function touchesProtected(touch: string, protectedGlob: string): boolean;
-/** The changed files (from a build's diff) that the rules protect. */
-export declare function protectedChanges(rules: ApprovalRules, changed: readonly string[]): string[];
-/** Whether a task's declared paths reach protected work. A task that
- * declares no paths can't show it stays clear, so it counts as protected. */
-export declare function isProtectedWork(rules: ApprovalRules, touches: string[]): boolean;
-/** Protected paths as a person types them: one per line or comma separated, trimmed, deduplicated, at most 50. */
-export declare function parseProtectedPaths(raw: string): {
-    ok: true;
-    paths: string[];
-} | {
-    ok: false;
-    problem: string;
-};
-/** The rules in a line, for the ledger's before → after. */
-export declare function rulesWords(rules: ApprovalRules): string;
-/** What a person reads when the rules stop an approval. */
-export declare function gateWords(gate: Exclude<ApprovalGate, {
-    verdict: "seal";
-}>): string;

package/dist/approval-rules-ui.d.ts

@@ -1,40 +0,0 @@
-/**
- * Settings → Approval rules (v102): a project's separation of duties. An
- * instance operator sets them (with their password, or a fresh sign-in with
- * the identity provider); everyone else reads them. Every change is in the
- * ledger, before → after.
- */
-import { type Html } from "./html.js";
-import type { ApprovalRules } from "./approval-policy.js";
-/** The rules' style, and the same for the Releases section under its own class (so a page holds one `.approval-rules`
- * form, not two). */
-export declare const APPROVAL_RULES_CSS: string;
-export type ApprovalRulesView = {
-    repo: string;
-    name: string;
-    rules: ApprovalRules & {
-        updatedBy: string | null;
-        updatedAt: string | null;
-    };
-    canChange: boolean;
-    /** People who can approve on this project (two approvers need two). */
-    approvers: number;
-};
-/** The rules in plain words, for anyone who can see the project. */
-export declare function rulesSummary(rules: ApprovalRules): string;
-/** Settings → Approval rules → Releases (docs/plans/auto-approve-green.md): who approves this project's releases. */
-export type ReleaseApprovalView = {
-    repo: string;
-    auto: boolean;
-    setBy: string | null;
-    at: string | null;
-    canChange: boolean;
-};
-export declare function releaseApprovalHtml(view: ReleaseApprovalView, notice?: {
-    said?: string | null;
-    problem?: string | null;
-}): Html;
-export declare function approvalRulesHtml(view: ApprovalRulesView, notice: {
-    said?: string | null;
-    problem?: string | null;
-}): Html;

package/dist/assignment-adapters.d.ts

@@ -1,152 +0,0 @@
-import { type AssignmentSnapshot } from "./assignment.js";
-import type { Store } from "./store.js";
-import { type AssignmentInput, type AssignmentOperation } from "./contracts/gateway-tools.js";
-export declare const ASSIGNMENT_ACTIONS: AssignmentOperation[];
-export type { AssignmentOperation };
-type Args = Record<string, unknown>;
-type Failure = {
-    ok: false;
-    reason: string;
-    message: string;
-};
-/** The gateway's assignment tools: names and words. Each one's input is ASSIGNMENT_INPUTS[operation]
- * (src/contracts/gateway-tools.ts), which `toolroll assignment` reads its flags with too. */
-export declare const ASSIGNMENT_TOOLS: readonly [{
-    readonly name: "get_assignment";
-    readonly operation: "show";
-    readonly description: "Read one assignment's root, current execution, owner, exact result and handoff receipt. Approval, proof and deployment remain separate facts.";
-}, {
-    readonly name: "list_assignment_updates";
-    readonly operation: "updates";
-    readonly description: "Read the history of assignment handoffs sent to people in your projects, after a cursor. History only: it delivers and acknowledges nothing. To receive your updates, use get_assignment_inbox.";
-}, {
-    readonly name: "claim_assignment";
-    readonly operation: "claim";
-    readonly description: "Record yourself as this assignment's lead. Repeating your claim is safe; another active owner cannot be replaced. This grants no approval or execution authority.";
-}, {
-    readonly name: "acknowledge_assignment";
-    readonly operation: "check";
-    readonly description: "Acknowledge the exact ready-to-check receipt as its lead, using the current receipt digest. This does not accept failed proof, answer decisions, approve work, publish or deploy.";
-}, {
-    readonly name: "get_assignment_brief";
-    readonly operation: "brief";
-    readonly description: "Catch up from the local database: current work, decisions, saved results and project knowledge. Bounded read only; no model call or task mutation.";
-}, {
-    readonly name: "get_assignment_inbox";
-    readonly operation: "inbox";
-    readonly description: "Receive a durable batch of your assignments' status changes. Use a stable consumer name. Until acknowledged, the same batch survives reconnects and restarts. Receiving never completes or reruns work.";
-}, {
-    readonly name: "acknowledge_assignment_delivery";
-    readonly operation: "ack";
-    readonly description: "Acknowledge receipt of an inbox batch after handling its updates. This advances only your delivery cursor; it never marks work complete, answers a decision or starts a revision.";
-}];
-/** The CLI and MCP read an assignment call with the same schema; MCP reads it before dispatch too, and this protects
- * direct adapter callers. A refusal is its path-named lines; a ref or project path with control characters, which
- * JSON Schema can't say, is refused after parsing. */
-export declare function readAssignmentArgs<O extends AssignmentOperation>(operation: O, args: Args): {
-    ok: true;
-    value: AssignmentInput<O>;
-} | Failure;
-/** Every read and mutation authenticates inside the same transaction as its
- * projection. A cached name/allowlist cannot keep a revoked identity alive. */
-export declare function assignmentForCoordinator(store: Store, token: string, operation: AssignmentOperation, args: Args, now: Date, evidenceRoot?: string): Failure | {
-    ok: true;
-    body: import("./assignment-brief.js").AssignmentCatchUp;
-} | {
-    ok: true;
-    body: {
-        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: (import("./assignment.js").AssignmentOwner & {
-                    active: boolean;
-                }) | null;
-                primaryAction: import("./work-summary.js").WorkAction | null;
-                attention: string[];
-                attempts: number;
-                handoff: {
-                    kind: "result" | "decision" | "attention";
-                    digest: string;
-                    acknowledged: boolean;
-                } | null;
-                completion: {
-                    actor: string;
-                    at: string;
-                    digest: string;
-                    lead?: true;
-                    landed?: 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: import("./assignment.js").AssignmentChecks;
-                    proofAcceptance: import("./store.js").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;
-                review: import("./review-switch.js").BuildReviewView | null;
-                deployment: {
-                    status: "not-recorded";
-                };
-                readiness: {
-                    verdict: import("./proof.js").ProofVerdict | null;
-                    checksOff: boolean;
-                    blockers: import("./task-status.js").CompletionBlocker[];
-                } | null;
-            };
-        }[];
-        nextCursor: number;
-        hasMore: boolean;
-    };
-} | {
-    ok: true;
-    body: AssignmentSnapshot;
-} | {
-    ok: true;
-    body: {
-        ok: true;
-        batch: import("./assignment-delivery.js").AssignmentDeliveryBatch;
-        replayed: boolean;
-    } | {
-        ok: true;
-        alreadyAcknowledged: boolean;
-        cursor: number;
-    };
-};
-export type AssignmentCliContext = {
-    commandName?: string;
-    store: Store;
-    write: (line: string) => void;
-    json: boolean;
-    now: Date;
-    evidenceRoot?: string;
-    env?: NodeJS.ProcessEnv;
-};
-/** Explicit secret source only. Never print secret values or discover default
- * files. A bad explicit credential must not fall back to a local read. */
-export declare function coordinatorToken(flags: Map<string, string | true>, env: NodeJS.ProcessEnv): {
-    token: string | null;
-} | Failure;
-export declare function runAssignmentCommand(positional: readonly string[], flags: Map<string, string | true>, context: AssignmentCliContext): number;

package/dist/assignment-brief.d.ts

@@ -1,83 +0,0 @@
-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[];
-        /** Where the next action leads in the console (navigation only). */
-        nextHref?: string | null;
-        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;
-                why: string;
-            }[];
-        };
-    }[];
-    omissions: {
-        assignments: number;
-        decisions: number;
-        projects: number;
-        textFields: number;
-        candidateScanLimited: boolean;
-        notes: string[];
-    };
-};
-/** A reason's first sentence, or its first line. */
-export declare function firstSentenceOf(text: string): string;
-/** A project's active decisions, newest first: each one's title and its reason in one line (first sentence or
- * line). Memory absent on an older database reads as no decisions. */
-export declare function activeDecisionsOf(store: Store, repo: string, text?: (value: string, cap: number) => string): {
-    id: number;
-    claim: string;
-    why: 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-delivery.d.ts

@@ -1,86 +0,0 @@
-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;
-/**
- * What the lead's follow inbox would hand over next, without issuing anything (lead sweeps, docs/plans/lead-fan-out.md):
- * whether a page is already issued (it always replays at once — never held), and the unread events' tasks.
- */
-export declare function leadFollowUnread(store: Store, grant: {
-    id: number;
-    repos: readonly string[];
-}, consumer: string): {
-    issued: boolean;
-    events: {
-        task: string;
-        state: string;
-    }[];
-};
-/** The built-in lead's inbox: the same page, replay and acknowledgment as a coordinator's, over its follow grant. */
-export declare function leadFollowInbox(store: Store, grant: {
-    id: number;
-    repos: readonly string[];
-}, 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;
-/** The built-in lead acknowledges its own page the same way, once it has handled it. */
-export declare function acknowledgeLeadFollowDelivery(store: Store, grant: {
-    id: number;
-    repos: readonly string[];
-}, query: {
-    consumer: string;
-    batchId: string;
-}, now: Date): AssignmentDeliveryAckResult;
-export {};

package/dist/assignment-presentation.d.ts

@@ -1,37 +0,0 @@
-/** 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';
-import { type PullRequestFact, type StatusAction, type TaskStatus, type TaskStatusFacts } from './task-status.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 type AssignmentStatusOptions = {
-    workStatus?: AssignmentWorkStatus;
-    diagnostics?: WorkStatus['diagnostics'];
-    additionalAttention?: readonly string[];
-    /** A live planner rather than a builder holds the work. */
-    planning?: boolean;
-    pullRequest?: PullRequestFact | null;
-    action?: StatusAction | null;
-    links?: TaskStatusFacts['links'];
-    evidence?: TaskStatusFacts['evidence'];
-};
-/** The one shared status (task-status.ts) for this assignment. */
-export declare function assignmentTaskStatusOf(assignment: AssignmentSnapshot, options?: AssignmentStatusOptions): TaskStatus;
-export declare function assignmentPresentationOf(assignment: AssignmentSnapshot, options?: AssignmentStatusOptions): {
-    status: WorkStatus;
-    taskStatus: TaskStatus;
-    primaryAction: import("./work-summary.js").WorkAction | null;
-    attention: AssignmentAttention[];
-    diagnostics: Pick<DisplayStatus, "detail" | "label" | "token" | "tone">[];
-};

package/dist/assignment-status.d.ts

@@ -1,71 +0,0 @@
-import type { Store } from "./store.js";
-import { type AssignmentSnapshot } from "./assignment.js";
-export declare const ASSIGNMENT_STATUS_ACTION = "assignment status observed";
-/** A reader's first sight of a task that is not news: the state later events are compared to, never delivered. */
-export declare const ASSIGNMENT_STATUS_BASELINE = "assignment status baseline";
-export declare const ASSIGNMENT_STATUS_SOURCE: "work";
-/** The states that wake a lead: a result to check, a question, completion, or cancellation. */
-export declare const LEAD_WAKE_STATES: readonly AssignmentSnapshot["state"][];
-/** The built-in lead's events, one stream per follow grant. */
-export declare const followActor: (grant: number) => string;
-/** 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: "answer-agent" | "inspect-decisions" | "inspect-findings" | "inspect-run" | "inspect-stop" | "inspect-task" | "open-pr" | "recheck-stopped" | "reconcile-run" | "sign-in" | 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;
-};
-/** An owner's events always name it; the built-in lead's follow events name whatever owner the task has, or none. */
-export type AssignmentStatusEvent = {
-    version: 1;
-    digest: string;
-    stateDigest: string;
-    assignment: ReturnType<typeof assignmentStatusBrief>;
-};
-/** 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;
-/** The built-in lead's crew update (lead-follow.ts): the same event, under its follow grant. The
- * caller has already proved the grant and its projects; the root must still be a placed task. */
-export declare function noteFollowStatus(store: Store, grant: number, snapshot: AssignmentSnapshot, now: Date, action?: typeof ASSIGNMENT_STATUS_ACTION | typeof ASSIGNMENT_STATUS_BASELINE): 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.
- * A pass is skipped when nothing moved since the cycle began (sweep-gate.ts). */
-export declare function syncAssignmentStatuses(store: Store, now: Date, repos: readonly string[], root?: string): void;