@adhdev/mesh-shared 1.0.82-rc.4 → 1.0.82-rc.41

package/dist/launch-defaults.d.ts

@@ -0,0 +1,196 @@
+/** Daemon-local launch intent and command wire contract. P2P/local only;
+ * never include this document or its history in cloud status_report.
+ * Publication through mesh-shared's barrel is a later integration step. */
+export declare const LAUNCH_DEFAULT_ROLES: readonly ["assistant", "coordinator"];
+export type LaunchDefaultRole = typeof LAUNCH_DEFAULT_ROLES[number];
+export declare const LAUNCH_DEFAULT_SOURCES: readonly ["user", "stored_default", "project_default", "provider_default"];
+export type LaunchDefaultSource = typeof LAUNCH_DEFAULT_SOURCES[number];
+export declare const LAUNCH_DEFAULTS_NEXT_LAUNCH_NOTE = "Applies to the next launch; running sessions are unchanged.";
+export declare function isLaunchDefaultRole(value: unknown): value is LaunchDefaultRole;
+export declare function isLaunchDefaultSource(value: unknown): value is LaunchDefaultSource;
+export interface LaunchDefaultSelection {
+    provider: string;
+    /** Omission means pass no model/thinking argument, not inherit another provider. */
+    model?: string;
+    thinkingLevel?: string;
+}
+export type LaunchDefaultToolRestriction = 'enforced' | 'prompt_only';
+export type LaunchDefaultOrigin = 'owner' | 'human' | 'relay' | 'review' | 'review_tainted';
+export interface LaunchDefaultEntry extends LaunchDefaultSelection {
+    revision: number;
+    setBy: 'owner' | 'assistant';
+    setAt: number;
+    /** Ordered quota-failover alternatives (<= 3, distinct providers). Absent = none. */
+    fallback?: LaunchDefaultSelection[];
+}
+export interface LaunchDefaultChange {
+    at: number;
+    role: LaunchDefaultRole;
+    by: 'owner' | 'assistant';
+    origin: LaunchDefaultOrigin;
+    from: LaunchDefaultEntry | null;
+    to: LaunchDefaultEntry | null;
+}
+export interface LaunchDefaultsDocument {
+    version: 1;
+    /** Global document token, including clears; distinct from entry revisions. */
+    revision: number;
+    assistant?: LaunchDefaultEntry;
+    coordinator?: LaunchDefaultEntry;
+    history: LaunchDefaultChange[];
+}
+export interface LaunchDefaultRef {
+    role: LaunchDefaultRole;
+    scope: 'global' | 'project';
+    /** Entry revision for global defaults; host project token for project defaults. */
+    revision: number;
+    projectId?: string;
+}
+export type LaunchDefaultField = keyof LaunchDefaultSelection;
+export interface LaunchDefaultAxis {
+    value: string | null;
+    source: LaunchDefaultSource;
+    defaultRef?: LaunchDefaultRef;
+}
+export type LaunchDefaultWarning = 'catalog_unverified' | 'manual_mcp_setup_required';
+export type LaunchDefaultValidationReason = 'invalid_schema' | 'provider_unknown' | 'provider_not_cli' | 'provider_disabled' | 'provider_not_detected' | 'provider_not_eligible' | 'provider_quota_gated' | 'model_unsupported' | 'model_provider_mismatch' | 'model_not_offered' | 'thinking_unsupported' | 'thinking_not_offered' | 'catalog_unavailable';
+export type LaunchDefaultResolution = {
+    ok: true;
+    selection: LaunchDefaultSelection;
+    applied: Record<LaunchDefaultField, LaunchDefaultAxis>;
+    defaultRef?: LaunchDefaultRef;
+    documentRevision: number;
+    warnings: LaunchDefaultWarning[];
+    toolRestriction: LaunchDefaultToolRestriction;
+} | {
+    ok: false;
+    code: 'launch_default_required' | 'launch_default_unavailable' | 'launch_selection_invalid';
+    role: LaunchDefaultRole;
+    field: LaunchDefaultField;
+    reason: string;
+    source?: LaunchDefaultSource;
+    value?: string | null;
+    defaultRef?: LaunchDefaultRef;
+    candidates?: readonly string[];
+    hint: string;
+};
+export interface LaunchDefaultsRoleView {
+    stored: LaunchDefaultEntry | null;
+    /** The existing daemon resolver's result, including loud failures. */
+    effective: LaunchDefaultResolution;
+}
+type Target = {
+    role: 'assistant';
+    project?: never;
+} | {
+    role: 'coordinator';
+    project?: string;
+};
+export type LaunchDefaultsReadRequest = ({
+    action?: 'get';
+} & (Target | {
+    role?: never;
+    project?: never;
+})) | ({
+    action: 'check';
+} & Target & LaunchDefaultSelection);
+/** Mandatory CAS: global document token, or host project token for project writes.
+ * 0 is explicit first setup; clears advance the token and never restore fallback. */
+export type LaunchDefaultsSetRequest = Target & {
+    expectedRevision: number;
+} & (({
+    action: 'set';
+} & LaunchDefaultSelection) | {
+    action: 'clear';
+    provider?: never;
+    model?: never;
+    thinkingLevel?: never;
+});
+/** Existing assistant routing envelope; session identity never supplies origin. */
+export type AssistantLaunchDefaultsReadRequest = LaunchDefaultsReadRequest & {
+    assistantSessionId?: string;
+};
+export type AssistantLaunchDefaultsSetRequest = LaunchDefaultsSetRequest & {
+    assistantSessionId?: string;
+};
+export declare const LAUNCH_DEFAULT_ERROR_CODES: readonly ["invalid_args", "launch_default_required", "launch_default_unavailable", "launch_selection_invalid", "launch_default_invalid", "revision_conflict", "store_unavailable", "store_busy", "persistence_failed", "project_not_found", "project_ambiguous", "project_not_hosted", "project_storage_unavailable", "staging_unavailable", "staging_failed", "review_turn_tool_denied"];
+export type LaunchDefaultsErrorCode = typeof LAUNCH_DEFAULT_ERROR_CODES[number];
+export interface LaunchDefaultsError {
+    success: false;
+    code: LaunchDefaultsErrorCode;
+    error: string;
+    reason?: string;
+    role?: LaunchDefaultRole;
+    field?: LaunchDefaultField;
+    source?: LaunchDefaultSource;
+    value?: string | null;
+    defaultRef?: LaunchDefaultRef;
+    candidates?: readonly string[];
+    actualRevision?: number;
+    /** 0 for an absent global document; absent when it cannot be read. */
+    documentRevision?: number;
+    /** A persistence failure can replace intent without confirming durability.
+     * Re-read before retrying; never report applied on committed:true alone. */
+    committed?: boolean;
+}
+export interface LaunchDefaultsReadSuccess {
+    success: true;
+    result: 'get';
+    documentRevision: number;
+    roles: Partial<Record<LaunchDefaultRole, LaunchDefaultsRoleView>>;
+    project?: {
+        projectId: string;
+        revision: number;
+        entry: LaunchDefaultEntry | null;
+    };
+}
+export interface LaunchDefaultsCheckSuccess {
+    success: true;
+    result: 'check';
+    role: LaunchDefaultRole;
+    selection: LaunchDefaultSelection;
+    warnings: LaunchDefaultWarning[];
+    toolRestriction: LaunchDefaultToolRestriction;
+    lowersToolLock: boolean;
+}
+export interface LaunchDefaultsApplied {
+    success: true;
+    result: 'applied';
+    role: LaunchDefaultRole;
+    scope: 'global' | 'project';
+    projectId?: string;
+    entry: LaunchDefaultEntry | null;
+    previous: LaunchDefaultEntry | null;
+    /** CAS token returned by the authority that performed the write. */
+    revision: number;
+    warnings: LaunchDefaultWarning[];
+    durable: true;
+    note: string;
+}
+export interface LaunchDefaultsStaged {
+    success: true;
+    result: 'staged';
+    role: LaunchDefaultRole;
+    stagedId: string;
+    previous: LaunchDefaultEntry | null;
+    selection: LaunchDefaultSelection | null;
+    expectedRevision: number;
+    warnings: LaunchDefaultWarning[];
+    note: string;
+}
+/** Existing owner Inbox adapter stores this proposal; it is not another default.
+ * Applying it must revalidate on the host and CAS via the same set handler. */
+export interface LaunchDefaultsProposal {
+    kind: 'launch_defaults';
+    role: LaunchDefaultRole;
+    project?: string;
+    selection: LaunchDefaultSelection | null;
+    previous: LaunchDefaultEntry | null;
+    expectedRevision: number;
+    origin: LaunchDefaultOrigin;
+    callerSessionId?: string;
+}
+export type LaunchDefaultsReadResponse = LaunchDefaultsReadSuccess | LaunchDefaultsCheckSuccess | LaunchDefaultsError;
+export type LaunchDefaultsSetResponse = LaunchDefaultsApplied | LaunchDefaultsStaged | LaunchDefaultsError;
+export type LaunchDefaultsResponse = LaunchDefaultsReadResponse | LaunchDefaultsSetResponse;
+export {};

package/dist/mesh-tool-names.d.ts

@@ -18,10 +18,10 @@
  * Order mirrors mcp-server `ALL_MESH_TOOLS` for easy visual diffing, but the consistency
  * checks are set-based (order-insensitive).
  */
-export declare const CANONICAL_MESH_TOOL_NAMES: readonly ["mesh_status", "mesh_route_preview", "mesh_list_nodes", "mesh_enqueue_batch", "mesh_enqueue_task", "mesh_view_queue", "mesh_queue_cancel", "mesh_queue_requeue", "mesh_send_task", "mesh_read_chat", "mesh_read_debug", "mesh_read_terminal", "mesh_send_keys", "mesh_launch_session", "mesh_git_status", "mesh_read_node_logs", "mesh_fast_forward_node", "mesh_restart_daemon", "mesh_checkpoint", "mesh_approve", "mesh_answer_question", "mesh_list_pending_approvals", "mesh_create", "mesh_add_node", "mesh_clone_node", "mesh_remove_node", "mesh_cleanup_worktree_nodes", "mesh_refine_node", "mesh_refine_batch", "mesh_config", "mesh_init", "mesh_cleanup_sessions", "mesh_task_history", "mesh_ledger_query", "mesh_note", "mesh_reconcile_ledger", "mesh_mission_upsert", "mesh_mission_list", "mesh_review_inbox", "mesh_node_slots"];
+export declare const CANONICAL_MESH_TOOL_NAMES: readonly ["mesh_status", "mesh_route_preview", "mesh_list_nodes", "mesh_enqueue_batch", "mesh_enqueue_task", "mesh_view_queue", "mesh_queue_cancel", "mesh_direct_cancel", "mesh_queue_requeue", "mesh_queue_revise", "mesh_send_task", "mesh_read_chat", "mesh_read_debug", "mesh_read_terminal", "mesh_send_keys", "mesh_launch_session", "mesh_git_status", "mesh_read_node_logs", "mesh_fast_forward_node", "mesh_restart_daemon", "mesh_checkpoint", "mesh_approve", "mesh_answer_question", "mesh_list_pending_approvals", "mesh_create", "mesh_add_node", "mesh_reattach_source_parent", "mesh_attach_remote", "mesh_clone_node", "mesh_remove_node", "mesh_retry_node_bootstrap", "mesh_cleanup_worktree_nodes", "mesh_refine_node", "mesh_refine_batch", "mesh_config", "mesh_init", "mesh_cleanup_sessions", "mesh_task_history", "mesh_ledger_query", "mesh_note", "mesh_reconcile_ledger", "mesh_mission_upsert", "mesh_mission_list", "mesh_mission_git_eval", "mesh_release_upsert", "mesh_release_scope", "mesh_release_list", "mesh_release_record_deploy", "mesh_release_changelog_draft", "mesh_review_inbox", "mesh_node_slots", "driver_list", "driver_describe", "artifact_list", "artifact_read", "artifact_register"];
 export type CanonicalMeshToolName = typeof CANONICAL_MESH_TOOL_NAMES[number];
 /** The count the `NN tools` barrel doc comments and consistency test assert against. */
-export declare const CANONICAL_MESH_TOOL_COUNT: 40;
+export declare const CANONICAL_MESH_TOOL_COUNT: 56;
 /**
  * Tool names retired by the 2026-09-26 tool-surface consolidation (60 → 48).
  * Every capability behind them is still reachable: each retired name maps to the

package/dist/mesh-vocabulary.d.ts

@@ -15,9 +15,11 @@
  * ./brain-routing.ts and are re-exported here for one-stop discovery.
  */
 export { MESH_TASK_DIFFICULTIES, type MeshTaskDifficulty } from './brain-routing';
-export declare const MESH_TASK_STATUSES: readonly ["pending", "assigned", "completed", "failed", "cancelled"];
+/** `blocked` ends a worker attempt pending external follow-up; only completed satisfies dependencies.
+ * Branch convergence (including blocked_review) remains an independent axis. */
+export declare const MESH_TASK_STATUSES: readonly ["pending", "assigned", "completed", "blocked", "failed", "cancelled"];
 export type MeshTaskStatus = typeof MESH_TASK_STATUSES[number];
-export declare const MESH_TERMINAL_TASK_STATUSES: readonly ["completed", "failed", "cancelled"];
+export declare const MESH_TERMINAL_TASK_STATUSES: readonly ["completed", "blocked", "failed", "cancelled"];
 export type MeshTerminalTaskStatus = typeof MESH_TERMINAL_TASK_STATUSES[number];
 export declare const MESH_TASK_MODES: readonly ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
 export type MeshTaskMode = typeof MESH_TASK_MODES[number];
@@ -46,11 +48,18 @@ export type MeshSessionCleanupMode = typeof MESH_SESSION_CLEANUP_MODES[number];
 /** Outcome a delegated worker may report through `report_completion`. */
 export declare const WORKER_REPORT_OUTCOMES: readonly ["completed", "blocked", "failed"];
 export type WorkerReportOutcome = typeof WORKER_REPORT_OUTCOMES[number];
+/**
+ * Hard cap on a `report_completion` summary (characters, after trim). Over-limit
+ * summaries are REJECTED, never truncated. Declared once so the daemon validator
+ * and the mcp-server's pre-send check (which keeps an over-limit report out of the
+ * durable outbox) cannot drift apart.
+ */
+export declare const WORKER_REPORT_SUMMARY_MAX_CHARS = 8000;
 /** Final branch state a worker reports (see coordinator convergence rules). */
 export declare const WORKER_BRANCH_STATES: readonly ["merged_to_main", "pushed_feature_branch_needs_merge", "blocked_review", "cleanup_candidate", "not_mergeable"];
 export type WorkerBranchState = typeof WORKER_BRANCH_STATES[number];
-export declare const isMeshTaskStatus: (value: unknown) => value is "failed" | "pending" | "assigned" | "completed" | "cancelled";
-export declare const isMeshTerminalTaskStatus: (value: unknown) => value is "failed" | "completed" | "cancelled";
+export declare const isMeshTaskStatus: (value: unknown) => value is "pending" | "failed" | "blocked" | "assigned" | "completed" | "cancelled";
+export declare const isMeshTerminalTaskStatus: (value: unknown) => value is "failed" | "blocked" | "completed" | "cancelled";
 export declare const isMeshTaskMode: (value: unknown) => value is "code_change" | "validation" | "live_debug_readonly" | "launch_app" | "convergence";
 export declare const isMeshTaskPriority: (value: unknown) => value is "low" | "high" | "normal";
 export declare const isMeshDeliveryMode: (value: unknown) => value is "when_idle" | "interrupt";

package/dist/mission-git-state.d.ts

@@ -0,0 +1,83 @@
+/**
+ * mission-git-state — types and the pure aggregation for "did this mission's
+ * referenced commits/branches land on the default branch?"
+ * (docs/design/2026-11-01-mission-git-refs.md §3).
+ *
+ * The facts come from the daemon opening git objects itself (never from
+ * commit-message text, branch-name similarity or worker prose). `landed` means
+ * ONLY "the referenced changes are on the base"; it never implies live
+ * acceptance, mission completion or that remaining items are done, and it is
+ * never used to change a mission's status.
+ *
+ * Dependency-free leaf: plain data in, plain data out.
+ */
+/** Per-ref verdict. `unknown` is never folded into `not_contained` nor promoted to `contained_*`. */
+export declare const MISSION_REF_GIT_STATUSES: readonly ["contained_ancestor", "contained_patch_equivalent", "not_contained", "unknown"];
+export type MissionRefGitStatus = typeof MISSION_REF_GIT_STATUSES[number];
+/** How a contained verdict was reached. */
+export declare const MISSION_REF_GIT_METHODS: readonly ["ancestry", "cherry", "residual_patch"];
+export type MissionRefGitMethod = typeof MISSION_REF_GIT_METHODS[number];
+/** Mission-level projection. */
+export declare const MISSION_GIT_STATES: readonly ["no_refs", "landed", "partial", "not_landed", "unknown"];
+export type MissionGitStateValue = typeof MISSION_GIT_STATES[number];
+export declare function isMissionRefContained(status: MissionRefGitStatus): boolean;
+/** Why a ref is `unknown` (detail.unknownReason). Free-form strings are tolerated on read. */
+export type MissionRefUnknownReason = 'object_missing' | 'shallow' | 'undeterminable' | 'base_missing' | 'branch_not_found' | 'base_branch_ref' | 'gitlink_undeterminable' | 'merge_tree_failed' | 'node_offline' | 'no_repo' | 'budget' | 'not_a_git_ref';
+export interface MissionRefGitDetail {
+    reasonCode?: string;
+    unknownReason?: MissionRefUnknownReason | string;
+    /** `modified_since_landing_possible`: main later touched the same lines — shown as a hint, not a verdict. */
+    note?: string;
+    nodeId?: string;
+    residualPatchId?: string;
+    ahead?: number;
+    behind?: number;
+}
+/** One stored per-ref evaluation (a row of `mesh_mission_ref_evals`). */
+export interface MissionRefGitEval {
+    itemId: string;
+    /** `kind:repo:value` (normalized, lower-case SHA). */
+    refKey: string;
+    kind: 'commit' | 'branch';
+    value: string;
+    repo?: string;
+    /** Branch refs: the SHA the name resolved to at first evaluation (re-evaluation keeps using it). */
+    pinnedSha?: string;
+    baseRef: string;
+    baseSha?: string;
+    status: MissionRefGitStatus;
+    method?: MissionRefGitMethod;
+    detail?: MissionRefGitDetail;
+    evaluatedAt: string;
+}
+export interface MissionGitState {
+    missionId: string;
+    state: MissionGitStateValue;
+    /** `partial` only: some refs were `unknown` (not just `not_contained`). */
+    partialUnknown: boolean;
+    counts: {
+        total: number;
+        contained: number;
+        notContained: number;
+        unknown: number;
+    };
+    /** Base the newest evaluation compared against. */
+    baseRef?: string;
+    baseSha?: string;
+    /** Oldest `evaluatedAt` among the refs (the freshness floor). */
+    evaluatedAt?: string;
+    /** True when no row exists yet / the rows are older than the TTL — a refresh was (or can be) triggered. */
+    stale: boolean;
+    refs: MissionRefGitEval[];
+}
+/**
+ * Aggregate per-ref statuses (design §3.3):
+ *  - none → `no_refs`; all contained → `landed`; some contained → `partial`
+ *    (`partialUnknown` when any of the rest is `unknown`);
+ *  - none contained: all `not_contained` → `not_landed`, otherwise `unknown`.
+ */
+export declare function aggregateMissionGitState(statuses: readonly MissionRefGitStatus[]): {
+    state: MissionGitStateValue;
+    partialUnknown: boolean;
+    counts: MissionGitState['counts'];
+};

package/dist/mission-items.d.ts

@@ -0,0 +1,202 @@
+/**
+ * mission-items — structured mission records: the item kinds a mission carries
+ * (remaining work, live checks, owner decisions, evidence), their normalization
+ * and limits, dedupe-key derivation and the close outcome enum
+ * (docs/design/2026-10-28-structured-missions-and-owner-decisions.md §4, §5).
+ *
+ * Philosophy (owner 2026-10-28, design §0): NEVER reject for size or shape —
+ * over-long text is truncated, extra refs are dropped, unusable items are
+ * reported per-item. The only hard rule lives elsewhere (the daemon): a
+ * coordinator or worker can never ANSWER a decision, so `answer`/`delivery`
+ * are stripped from every caller-supplied `decision` here.
+ *
+ * Dependency-free leaf: pure functions over plain data, no storage.
+ */
+export declare const MISSION_ITEM_KINDS: readonly ["remaining", "live_check", "decision", "evidence"];
+export type MissionItemKind = typeof MISSION_ITEM_KINDS[number];
+export declare const MISSION_ITEM_STATES: readonly ["open", "done", "failed", "dropped", "moved", "answered", "expired", "withdrawn", "superseded"];
+export type MissionItemState = typeof MISSION_ITEM_STATES[number];
+/** States a coordinator/worker may SET through items_update, per kind. `answered`/`expired`/`failed` (owner live-check verdict) are daemon-owned. */
+export declare const COORDINATOR_SETTABLE_ITEM_STATES: Readonly<Record<MissionItemKind, readonly MissionItemState[]>>;
+export declare const MISSION_OUTCOMES: readonly ["merged", "verified_live", "superseded", "not_needed", "owner_abandoned", "unspecified"];
+export type MissionOutcome = typeof MISSION_OUTCOMES[number];
+export declare function isMissionOutcome(value: unknown): value is MissionOutcome;
+export declare const MISSION_REF_KINDS: readonly ["commit", "branch", "pr", "task", "artifact", "mission", "url"];
+export type MissionRefKind = typeof MISSION_REF_KINDS[number];
+export declare const MISSION_LIMITS: {
+    readonly summary: 300;
+    readonly outcomeReason: 500;
+    readonly itemText: 300;
+    readonly machine: 80;
+    readonly refs: 8;
+    readonly refValue: 300;
+    readonly refRepo: 120;
+    readonly refNote: 200;
+    readonly dedupeKey: 400;
+    readonly question: 300;
+    readonly context: 600;
+    readonly options: 5;
+    readonly optionLabel: 60;
+    readonly optionDetail: 200;
+    /** Open items per mission before the oldest `remaining` fold into a "N more" summary item. */
+    readonly openItemsPerMission: 200;
+    /** One event payload (serialized). */
+    readonly eventPayloadBytes: number;
+    /** items_add / items_update entries honoured per call (extra entries are reported, not applied). */
+    readonly itemsPerCall: 50;
+};
+export declare const MISSION_DECISION_OPTION_IDS: readonly ["a", "b", "c", "d", "e"];
+export declare const MISSION_DECISION_URGENCIES: readonly ["normal", "blocking"];
+export type MissionDecisionUrgency = typeof MISSION_DECISION_URGENCIES[number];
+export declare const MISSION_DECISION_ON_DUE: readonly ["remind", "apply_recommended"];
+export type MissionDecisionOnDue = typeof MISSION_DECISION_ON_DUE[number];
+export interface MissionItemRef {
+    kind: MissionRefKind;
+    repo?: string;
+    value: string;
+    note?: string;
+}
+export interface MissionDecisionOption {
+    id: string;
+    label: string;
+    detail?: string;
+}
+/** Who/where an answer came from. Written only by the daemon's (owner-side) answer path — never from tool input. */
+export interface MissionDecisionAnswer {
+    optionId?: string;
+    text?: string;
+    by: 'owner' | 'auto_recommended';
+    via: 'dashboard' | 'assistant' | 'push' | 'cli' | 'auto';
+    interpretedFrom?: string;
+    at: string;
+    ingress?: string;
+}
+export interface MissionDecisionDelivery {
+    messageId: string;
+    /**
+     * `queued`: the coordinator's input queue accepted it but has not typed it yet — the daemon
+     * confirms it against the send receipt (a daemon restart drops that queue). Daemon-written.
+     */
+    state: 'pending' | 'queued' | 'sent' | 'acked';
+    lastAttemptAt?: string;
+    /** Coordinator session + funnel messageId of a `queued` delivery (receipt lookup). Daemon-written. */
+    sessionId?: string;
+    wireMessageId?: string;
+    /** Failed send attempts of this revision (retry backoff). Daemon-written. */
+    attempts?: number;
+    /** What the coordinator is told: a first answer, a changed answer, or an undone one. Daemon-written. */
+    kind?: 'answered' | 'changed' | 'undone';
+}
+export interface MissionDecision {
+    question: string;
+    context?: string;
+    options: MissionDecisionOption[];
+    recommended?: string;
+    allowFreeText: boolean;
+    dueAt?: string;
+    onDue: MissionDecisionOnDue;
+    urgency: MissionDecisionUrgency;
+    answer?: MissionDecisionAnswer;
+    delivery?: MissionDecisionDelivery;
+    /**
+     * Coordinator-prompt watermark (bundle B): ISO time the coordinator last "saw" this item's
+     * answer. An answered decision is shown in the coordinator prompt while this is absent or
+     * older than `answer.at` (a changed answer re-surfaces). Written only by the daemon.
+     */
+    promptAckedAt?: string;
+    /** Counts answer writes (answer / change / undo); delivery messageIds are `decision:<itemId>:r<n>`. Daemon-written. */
+    answerRevision?: number;
+    /** ISO time an `onDue: remind` crossing was recorded (once per dueAt). Daemon-written. */
+    remindedAt?: string;
+}
+export interface NormalizedMissionItem {
+    kind: MissionItemKind;
+    text: string;
+    machine?: string;
+    refs: MissionItemRef[];
+    decision?: MissionDecision;
+    dedupeKey: string;
+    /** Fields that were truncated/dropped — informational, never an error. */
+    truncated: string[];
+}
+export declare function truncateMissionText(value: string, max: number): string;
+export declare function normalizeMissionSummary(value: unknown): {
+    value: string;
+    truncated: boolean;
+} | null;
+export declare function normalizeOutcomeReason(value: unknown): {
+    value: string;
+    truncated: boolean;
+} | null;
+/** Refs: ≤8, `{kind, repo?, value, note?}`. Unusable entries are dropped; the 9th and later are dropped. */
+export declare function normalizeMissionRefs(value: unknown): {
+    refs: MissionItemRef[];
+    truncated: boolean;
+};
+/**
+ * Caller-supplied decision → stored shape. `answer`/`delivery` (and any other
+ * unknown key) are DROPPED: a coordinator/worker cannot pre-answer its own
+ * question. `recommended` must name one of the options, else it is dropped.
+ */
+export declare function normalizeDecisionInput(raw: Record<string, unknown>, truncated: string[]): MissionDecision | null;
+/** Normalized text for dedupe: lower-case, whitespace-collapsed, trailing punctuation trimmed. */
+export declare function normalizeForDedupe(text: string): string;
+export declare function deriveItemDedupeKey(kind: MissionItemKind, parts: {
+    text?: string;
+    machine?: string;
+    refs?: readonly MissionItemRef[];
+    question?: string;
+    explicit?: string;
+}): string;
+/**
+ * Normalize one caller-supplied `items_add[]` entry. Returns `null` + `error`
+ * only when nothing usable remains (no text/question) — everything else is
+ * clamped, never rejected.
+ */
+export declare function normalizeMissionItemInput(raw: unknown): {
+    item: NormalizedMissionItem;
+} | {
+    error: string;
+};
+export interface MissionItemUpdateInput {
+    id: string;
+    state?: MissionItemState;
+    text?: string;
+    machine?: string | null;
+    refs?: MissionItemRef[];
+}
+/** Normalize one `items_update[]` entry (id required). The kind-specific state rule is applied by the daemon, which knows the stored kind. */
+export declare function normalizeMissionItemUpdate(raw: unknown): {
+    update: MissionItemUpdateInput;
+    truncated: string[];
+} | {
+    error: string;
+};
+/** Cap a serialized event payload at {@link MISSION_LIMITS.eventPayloadBytes}; over-size payloads become a stub that says so. */
+export declare function boundEventPayload(payload: Record<string, unknown>): string;
+/** The carry-over mission's fixed title (design §5.1). */
+export declare const CARRY_OVER_MISSION_TITLE = "Carry-over \u2014 open items from closed missions";
+/** The title earlier builds stored; existing DBs still hold it, so it keeps matching (no rename). */
+export declare const LEGACY_CARRY_OVER_MISSION_TITLE = "\uC774\uC6D4 \u2014 \uB2EB\uD78C \uBBF8\uC158\uC5D0\uC11C \uB118\uC5B4\uC628 \uD56D\uBAA9";
+/** Canonical goal text of a newly created carry-over mission. */
+export declare const CARRY_OVER_MISSION_GOAL = "Open items carried over from closed missions, and decisions requested without a mission. Managed automatically \u2014 do not close.";
+/**
+ * THE one predicate for "is this the auto carry-over mission". The daemon's `is_carry_over`
+ * column (`isCarryOver`) is the source of truth; wire views that cannot carry the flag (older
+ * strict decoders reject unknown keys) fall back to the fixed title. Use this everywhere.
+ */
+export declare function isCarryOverMissionRecord(m: {
+    isCarryOver?: boolean;
+    title?: unknown;
+} | null | undefined): boolean;
+/** The carry-over mission's title is fixed (the daemon ignores renames), so a title match identifies it on wire views that carry no flag. */
+export declare function isCarryOverMissionTitle(title: unknown): boolean;
+/** Prefix of the owner-confirmation decision a coordinator's `owner_abandoned` close creates. */
+export declare const OWNER_ABANDON_CONFIRM_KEY_PREFIX = "owner-abandon-confirm:";
+export declare const OWNER_ABANDON_CONFIRM_QUESTION = "The coordinator closed this as 'owner abandoned' \u2014 correct?";
+export declare const OWNER_ABANDON_CONFIRM_OPTIONS: readonly ["Correct", "Reopen"];
+/** worker `report_completion.decisions_needed` cap. */
+export declare const WORKER_DECISIONS_NEEDED_MAX = 3;
+/** worker `report_completion.commits` cap and shape. */
+export declare const WORKER_COMMITS_MAX = 20;
+export declare function normalizeReportCommits(value: unknown): string[] | null;

package/dist/node-facts.d.ts

@@ -94,6 +94,20 @@ export interface MeshNodeFactsProviderQuota {
          * rather than presenting them as a freshly measured value.
          */
         lastGoodWindows?: boolean;
+        /**
+         * Unix ms the reporting node's NEXT scheduled retry of this transient
+         * failure is due (HTTP Retry-After wins when later). Re-stamped to the
+         * real backoff time on every failure — see daemon-core
+         * `updateFailureRetry`. Absent on persistent failures and on daemons
+         * predating the stamp.
+         */
+        retryAtMs?: number;
+        /**
+         * True once the node has spent its bounded transient-retry budget and
+         * stopped retrying; the next look is the hourly backfill. Readers must
+         * stop calling retained numbers "refreshing" (`assessQuotaFreshness`).
+         */
+        retryExhausted?: boolean;
         /**
          * Unix ms when the reporting node last ATTEMPTED a refresh of this
          * provider — deliberately distinct from `updatedAt`, which dates the
@@ -109,6 +123,41 @@ export interface MeshNodeFactsProviderQuota {
          * predating the field.
          */
         fetchedAt?: number;
+        /**
+         * Provenance of the RETAINED reading when `lastGoodWindows` is true —
+         * the source/plan/measurement time of the snapshot that produced the
+         * carried numbers, as opposed to the top-level `source`/`planType`,
+         * which describe the fresh failed attempt. See daemon-core
+         * `QuotaMetadata.lastGood`.
+         */
+        lastGood?: {
+            measuredAt: number;
+            source?: string;
+            planType?: string | null;
+            collectorScope?: string;
+        };
+        /**
+         * `'background-collector'` when the snapshot came from a daemon-spawned
+         * probe rather than an executing CLI session; a failure with this scope
+         * is not evidence about a running session's sign-in.
+         */
+        collectorScope?: string;
+        /**
+         * DISPLAY-ONLY copy of the last numbers this node measured when it can
+         * no longer prove they belong to the CURRENT account (lineage unknown,
+         * or the failure left no confirmed match). Never read by routing, gates
+         * or ranking: those keep treating the entry as unknown. Dashboards show
+         * it marked "account unconfirmed" with its age. Never set across a
+         * CONFIRMED account switch (both accounts known and different).
+         */
+        unconfirmedReading?: {
+            /** Unix ms the numbers were measured. */
+            measuredAt: number;
+            session?: MeshNodeFactsQuotaWindow | null;
+            weekly?: MeshNodeFactsQuotaWindow | null;
+            monthly?: MeshNodeFactsQuotaWindow | null;
+            buckets?: MeshNodeFactsProviderQuota['buckets'];
+        };
         [extra: string]: unknown;
     };
     [extra: string]: unknown;
@@ -132,6 +181,13 @@ export interface MeshNodeFactsProviderEnablement {
 }
 export interface MeshNodeFacts {
     schemaVersion: number;
+    /** Cached CLI detection only; no paths or account data. */
+    providerInventory?: {
+        observedAt: number;
+        providers: Record<string, {
+            installed: boolean;
+        }>;
+    };
     reportedAt: number;
     daemonBuild?: MeshNodeFactsDaemonBuild;
     providerVersions?: Record<string, string>;
@@ -194,6 +250,24 @@ export interface MeshNodeFacts {
      * Booleans keyed by provider type only — no free text, no credentials.
      */
     providerEnablement?: Record<string, MeshNodeFactsProviderEnablement>;
+    /**
+     * The reporting machine's stored quota RESERVE (daemon-core
+     * `ADHDevConfig.quotaReserve`, sparse, ≤ 2 KB, migration audit trail
+     * stripped): the "how much quota to leave for the person" bar that the
+     * coordinator's launch gate applies to THIS machine's snapshots.
+     * ★ABSENT means "this node did not tell us" (older daemon) and resolves to
+     * the code defaults — the same fail-open direction as before the field
+     * existed. Percentages, durations and hashed account keys only; no free
+     * text, no emails. Resolve with daemon-core `resolveQuotaReserve`; never
+     * read its fields directly.
+     */
+    quotaReserve?: {
+        version: 1;
+        defaults?: Record<string, number>;
+        pools?: Record<string, Record<string, number>>;
+        accounts?: Record<string, Record<string, Record<string, number>>>;
+        updatedAt?: string;
+    };
     /** Future fields ride through opaquely — do not enumerate them in relays. */
     [extra: string]: unknown;
 }
@@ -238,7 +312,7 @@ export declare function normalizeMeshNodeFacts(raw: unknown): MeshNodeFacts | un
  * the host `agy` itself uses; the unprefixed `cloudcode-pa` host 429s Google
  * AI Pro Antigravity accounts), and its credential lives in the OS keyring,
  * not the stale on-disk token file — see the provenance note in daemon-core
- * `quota/fetchers/antigravity.ts`. Supported on macOS and Windows; other
+ * `quota/fetchers/antigravity.ts`. Supported on macOS, Windows, and Linux; other
  * platforms report `unsupported` rather than guess at a keyring backend
  * nobody has verified.
  *