@dispatch-foo/protocol 0.0.0-stage → 0.2.0

package/dist/untrusted-DJNiucEX-tUd9XZzz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"untrusted-DJNiucEX-tUd9XZzz.d.ts","names":["E","Assignee","F","TaskKind","J","StatusRoles","K","StatusDefinition","M","TaskCycle","N","TaskDoc","R","TaskRisk","g","TaskKindInput","j","TaskAttachment","k","Priority","q","StatusModel","TaskComment","AddCommentInput","CommentPatch","CommentStorePort","commentInputError","compareComments","commentThreadIds","Set","TeamParseError","Error","TeamMember","MAX_HANDLE_BYTES","DroppedEntry","describeDroppedEntry","handleFromEmail","parseTeam","parseTeamReport","serializeTeam","upsertMember","Person","UNRESOLVED_LINEAR_ASSIGNEE","UNRESOLVED_LINEAR_PERSON","personError","resolvePeople","canonicalAssignee","personFor","fanoutHolder","LabelDefinition","isLabelColor","labelRef","labelDefinitionError","labelColorIndex","Map","withLabelColor","ATTACHMENTS_DIR","ATTACHMENT_MAX_BYTES","sanitizeAttachmentName","attachmentRelativePath","PolicyGate","POLICY_GATES","PolicyRungDef","POLICY_RUNGS","MIN_POLICY_RUNG","MAX_POLICY_RUNG","GATE_RUNGS","Record","RISK_RUNG_CAPS","PolicyGateMode","POLICY_GATE_MODES","PolicyConfig","Partial","DEFAULT_POLICY","PolicyRuling","effectiveRung","consultPolicy","FloorCheck","FloorCheckDef","IRREVERSIBILITY_FLOOR","FLOOR_CHECKS","isFloorCheck","FloorRuling","consultFloor","describeFloorHold","describePolicyAuthorization","Extract","ScoreFactorKey","QueueWeights","DEFAULT_QUEUE_WEIGHTS","ReadinessLevel","UNBLOCKING_HALF_VALUE","AGE_HORIZON_DAYS","isQueueWeight","ScoreFactor","ScoredTask","RankOptions","QueueFactorInfo","QUEUE_FACTORS","QUEUE_FACTOR_KEYS","rankTasks","OrchestratorConfig","MAX_CONCURRENCY_HARD_CAP","RepoDigestConfig","DEFAULT_REPO_DIGEST","PreviewConfig","DEFAULT_PREVIEW","previewSettings","DispatchConfig","ReceiptsConfig","DEFAULT_RECEIPTS","DEFAULT_RECEIPTS_BRANCH","SyncConfig","DEFAULT_SYNC","VerifyStep","StatusEntryInput","ModelConfig","EffortConfig","ExecutorConfig","RemoteConfig","LinearConfig","FixLoopConfig","VerifyConfig","CartoConfig","NotificationsConfig","MessagingConfig","MemoryConfig","A2AConfig","QueueConfig","projectPolicy","QueueWeightsResult","queueWeights","CartoMode","CARTO_MODES","DEFAULT_CARTO","EscalationStep","FIX_STRATEGIES","FIX_MODEL_TIERS","DEFAULT_FIX_LOOP","NotificationKind","notificationKindForMessage","NOTIFICATION_KINDS","SECRET_URL_MASK_SUFFIX","isMaskedSecretUrl","DEFAULT_NOTIFICATIONS","DEFAULT_MESSAGING","DEFAULT_MEMORY","A2A_SKILLS","A2ASkill","DEFAULT_A2A","LINEAR_DIRECTIONS","DEFAULT_LINEAR","DEFAULT_MODELS","EFFORT_LEVELS","EffortLevel","isEffortLevel","EFFORT_ROLES","MODEL_ROLES","ExecutorModels","ExecutorPricing","ExecutorCommand","EXECUTOR_PRICING_FIELDS","EXECUTOR_MODEL_ROLES","DEFAULT_EXECUTOR_NAME","executorModels","Pick","ConfigPatch","LinearWorkflowState","LinearLabel","LinearUser","LinearRelation","LinearAttachment","LinearTruncatedField","LinearIssue","LinearComment","LinearProjectStatus","LinearProject","LinearProjectMilestone","LinearInitiative","LinearIssueInput","LinearProjectInput","LinearMilestoneInput","LinearInitiativeInput","LINEAR_EXTERNAL_PREFIX","externalId","parseExternal","LinearEntity","LinearRef","linearExternal","parseLinearExternal","priorityToLinear","priorityFromLinear","DEFAULT_STATUS_MAP","resolveWorkflowState","resolveConflict","SubagentStatus","SubagentEvent","SubagentSourceEntry","SubagentNode","SubagentSummary","nextSubagentStatus","foldSubagents","summarizeSubagents","Iterable","SubagentTreeNode","nestSubagents","flattenSubagentTree","DocScope","DocNamespace","DocStatus","DOC_STATUSES","RevisionCause","LinkRel","LINK_RELS","LinkTargetType","LINK_TARGET_TYPES","LinkTarget","DocHead","DocRecord","DocRevisionInfo","DocLink","DocOutlineEntry","DocOp","DocSaveStatus","DocSaveResult","ProposalState","DocProposal","DocProposalView","DocConflict","DocRead","DocSummary","DocHit","DocLinking","DocsHealth","DOCS_LIMITS","RESERVED_DOC_SLUGS","normalizeDocText","jsonEscapedBytes","docTitleProblem","docSlugProblem","docBodyProblem","docSlug","DocFileMeta","renderDocFile","parseDocFile","ASSET_NAME","RegExp","assetNames","rewriteAssetLinks","RunStepEntry","RunStep","runStepFromEntry","FindingSeverity","FindingVerdict","FindingRecommendation","Finding","AddFindingInput","FindingUpdatePatch","FindingListFilter","FINDING_SEVERITIES","FINDING_VERDICTS","FINDING_RECOMMENDATIONS","LedgerKind","LedgerEntry","AddLedgerInput","LedgerListFilter","LEDGER_KINDS","CommandEvidence","MutationEvidence","tasksConflict","claimConflictsWithWrites","schedulableBatch","ActorKind","ActorRef","ActorRefError","UNASSIGNED","parseActorRef","formatActorRef","isValidAssignee","slugify","describeValue","isOutstanding","SqlValue","Uint8Array","SqliteStatement","SqliteDatabase","SqliteDriver","sqliteDriver","DISPATCH_DB_VERSION","dispatchDbPath","attachDispatchDb","openSqliteDb","openDispatchDb","queryAll","Row","queryOne","dbVersion","SqliteRowError","generateCommentId","FileCommentStore","SqliteCommentStore","SqliteFindingStore","ListSafeError","SqliteLedgerStore","SqliteEvidenceStore","TaskStoreBackend","SqliteRecordStores","ProjectStores","TaskStorePort","OpenStoresOptions","openProjectStores","initProjectStores","TaskParseError","parseTaskFile","serializeTaskFile","splitSections","getSection","setSection","appendActivity","removeSection","Amendment","appendAmendment","DISPATCH_DIR","attachmentsDir","CreateInput","UpdatePatch","ListFilter","ListSafeResult","Omit","newTaskDoc","applyUpdatePatch","ensureProjectConfig","ensureProjectGitignore","TaskStore","untrustedInline","untrustedBlock","untrustedFenced","untrustedVerbatim","$","$i","$n","$r","$t","A","Aa","Ai","An","Ar","At","B","Bi","Bn","Br","Bt","C","Ca","Ci","Cn","Cr","Ct","D","Da","Di","Dn","Dr","Dt","Ea","Ei","En","Er","Et","Fi","Fn","Fr","Ft","G","Gi","Gn","Gr","Gt","H","Hi","Hn","Hr","Ht","I","Ii","In","Ir","It","Ji","Jn","Jr","Jt","Ki","Kn","Kr","Kt","L","Li","Ln","Lr","Lt","Ma","Mi","Mn","Mr","Mt","Na","Ni","Nn","Nr","Nt","O","Oa","Oi","On","Or","Ot","P","Pa","Pi","Pn","Pr","Pt","Q","Qi","Qn","Qr","Qt","Ri","Rn","Rr","Rt","S","Sa","Si","Sn","Sr","St","T","Ta","Ti","Tn","Tr","Tt","U","Ui","Un","Ur","Ut","V","Vi","Vn","Vr","Vt","W","Wi","Wn","Wr","Wt","X","Xi","Xn","Xr","Xt","Y","Yi","Yn","Yr","Yt","Z","Zi","Zn","Zr","Zt","_","_a","_i","_n","_r","_t","a","aa","ai","an","ar","at","b","ba","bi","bn","br","bt","c","ca","ci","cn","cr","ct","d","da","di","dn","dr","dt","ea","ei","en","er","et","f","fa","fi","fn","fr","ft","ga","gi","gn","gr","gt","h","ha","hi","hn","hr","ht","i","ia","ii","in","ir","it","ja","ji","jn","jr","jt","ka","ki","kn","kr","kt","l","la","li","ln","lr","lt","m","ma","mi","mn","mr","mt","n","na","ni","nn","nr","nt","o","oa","oi","on","or","ot","p","pa","pi","pn","pr","pt","qi","qn","qr","qt","r","ra","ri","rn","rr","rt","s","sa","si","sn","sr","st","t","ta","ti","tn","tr","tt","u","ua","ui","un","ur","ut","v","va","vi","vn","vr","vt","w","wa","wi","wn","wr","wt","x","xa","xi","xn","xr","xt","y","ya","yi","yn","yr","yt","z","zi","zn","zr","zt"],"sources":["../src/address.ts","../src/envelope.ts","../src/store.ts","../../core/dist/untrusted-DJNiucEX.d.ts"],"sourcesContent":["import { E as Assignee, F as TaskKind, J as StatusRoles, K as StatusDefinition, M as TaskCycle, N as TaskDoc, R as TaskRisk, g as TaskKindInput, j as TaskAttachment, k as Priority, q as StatusModel } from \"./graph-WUr-nk9j.js\";\n\n//#region src/comments.d.ts\ninterface TaskComment {\n  id: string;\n  taskId: string;\n  /** A serialized ActorRef (see actor.ts). */\n  author: Assignee;\n  /** Markdown. */\n  body: string;\n  created: string;\n  updated: string;\n  /** The comment this one replies to, for threads; null at the top level. */\n  parentId: string | null;\n  /** The id in an external tracker (`linear:<uuid>`), or null. */\n  external: string | null;\n}\ninterface AddCommentInput {\n  taskId: string;\n  author: Assignee;\n  body: string;\n  parentId?: string | null;\n  external?: string | null;\n  /** Kept verbatim when importing (a synced comment's own timestamp). */\n  created?: string;\n}\ninterface CommentPatch {\n  body?: string;\n  external?: string | null;\n}\n/** The comment surface both backends answer. */\ninterface CommentStorePort {\n  /** One task's comments, oldest first. */\n  list(taskId: string): TaskComment[];\n  get(taskId: string, id: string): TaskComment | null;\n  add(input: AddCommentInput, now?: string): TaskComment;\n  /** Throws when the comment does not exist. */\n  update(taskId: string, id: string, patch: CommentPatch, now?: string): TaskComment;\n  /** Removes the comment and its replies; the removed ids ([] if absent). */\n  remove(taskId: string, id: string): string[];\n}\n/** Why a comment input is invalid, or null when it is fine. */\ndeclare function commentInputError(body: unknown): string | null;\n/** Oldest first, ties broken by id, the order every backend returns. */\ndeclare function compareComments(a: TaskComment, b: TaskComment): number;\n/** `id` plus every reply beneath it, for a cascading delete. */\ndeclare function commentThreadIds(comments: readonly TaskComment[], id: string): Set<string>;\n//#endregion\n//#region src/team.d.ts\ndeclare class TeamParseError extends Error {}\ninterface TeamMember {\n  handle: string;\n  email: string;\n  displayName: string;\n  /** Prior addresses, so a changed git email keeps its handle. */\n  emails: string[];\n}\n/** The longest handle an address may carry. Handles are ASCII, so length is bytes. */\ndeclare const MAX_HANDLE_BYTES = 64;\n/** A roster entry parseTeamReport skipped, and what the owner must fix. */\ninterface DroppedEntry {\n  /** The entry's email, or null when it has none. */\n  email: string | null;\n  /** `too-long` when the handle's length is all that is wrong; `malformed` otherwise. */\n  problem: 'too-long' | 'malformed';\n}\n/**\n * Names an entry parseTeamReport dropped, for a log line or an error. The\n * email is quoted and escaped so a hand-edited one cannot forge extra lines.\n */\ndeclare function describeDroppedEntry(entry: DroppedEntry): string;\n/** Derives a stable handle from an email's local part, suffixing on collision. */\ndeclare function handleFromEmail(email: string, taken: Set<string>): string;\ndeclare function parseTeam(yaml: string): TeamMember[];\n/**\n * Parses a roster and reports each entry it drops, so the caller can refuse to\n * rewrite the file and tell the owner what to fix.\n */\ndeclare function parseTeamReport(yaml: string): {\n  members: TeamMember[];\n  dropped: DroppedEntry[];\n};\ndeclare function serializeTeam(members: TeamMember[]): string;\n/**\n * Records the local developer in the roster. `knownHandle` is the caller's own\n * record of who it is, which is the only reliable way to survive an email\n * change — never guess identity from a display name, since two people share one.\n */\ndeclare function upsertMember(members: TeamMember[], email: string, displayName: string, knownHandle?: string): {\n  members: TeamMember[];\n  member: TeamMember;\n  changed: boolean;\n};\n//#endregion\n//#region src/people.d.ts\ninterface Person {\n  /** A serialized human ActorRef, `human:<handle>`. */\n  ref: string;\n  name: string;\n  email?: string | null;\n  avatarUrl?: string | null;\n  /** The id in an external tracker (`linear:<user-uuid>`), or null. */\n  external?: string | null;\n  /** A stand-in for someone the registry cannot name yet: shown where a task\n   *  holds it, never offered as a choice (see UNRESOLVED_LINEAR_PERSON). */\n  placeholder?: boolean;\n}\n/**\n * The assignee a Linear pull writes for an issue whose Linear user the\n * registry cannot name yet: still somebody, so a fan-out never takes the issue\n * for unassigned. Never pushed; pulled again once the registry names them.\n */\ndeclare const UNRESOLVED_LINEAR_ASSIGNEE = \"human:linear-user\";\n/** How GET /api/people lists that placeholder while a task holds it. */\ndeclare const UNRESOLVED_LINEAR_PERSON: Person;\n/** Why `value` is not a valid `people:` entry, or null when it is. */\ndeclare function personError(value: unknown): string | null;\n/**\n * Everyone a picker should offer: the team roster (`team.yml`, whose members\n * are `human:<handle>`) merged with configured `people`, which win field by\n * field on a shared ref. Roster order first, then configured-only people.\n */\ndeclare function resolvePeople(configured: readonly Person[], members: readonly TeamMember[]): Person[];\n/**\n * An assignee as a person-level ref: the legacy bare `human` is the local\n * user (`localHumanRef`); every other value passes through.\n */\ndeclare function canonicalAssignee(raw: string, localHumanRef: string): string;\n/** The person behind `ref` (after the legacy alias), if registered. */\ndeclare function personFor(ref: string, people: readonly Person[], localHumanRef: string): Person | undefined;\n/**\n * Who holds a task against a fan-out working for `dispatcher` (a `human:`\n * ref): the other person it belongs to (assigned to them, or to an agent they\n * run), else null and the fan-out may start it: unassigned, an unowned agent,\n * or the dispatcher's own. An unreadable assignee is somebody's. Bare `human`\n * means `localHumanRef`.\n */\ndeclare function fanoutHolder(assignee: string | null | undefined, dispatcher: string, localHumanRef: string): string | null;\n//#endregion\n//#region src/labels.d.ts\ninterface LabelDefinition {\n  /** The label's own name; inside a group, the part after `Group/`. */\n  name: string;\n  /** `#rgb` or `#rrggbb`, or null to let the UI pick one. */\n  color: string | null;\n  /** The group label's name, for a label nested in a group. */\n  group?: string | null;\n  /** The id in an external tracker (`linear:<label-uuid>`), or null. */\n  external?: string | null;\n}\n/** Whether `value` is a color the registry stores (hex, so it is safe in CSS). */\ndeclare function isLabelColor(value: unknown): value is string;\n/** A label as a task spells it: `Group/Name` inside a group, else the name. */\ndeclare function labelRef(label: {\n  name: string;\n  group?: string | null;\n}): string;\n/** Why `value` is not a valid `labels:` entry, or null when it is. */\ndeclare function labelDefinitionError(value: unknown): string | null;\n/** Lowercased label ref -> color, for the labels that have one. */\ndeclare function labelColorIndex(labels: readonly LabelDefinition[]): Map<string, string>;\n/**\n * The registry with `ref`'s color set: an existing entry (matched\n * case-insensitively) is recolored, a new one is appended. Clearing the color\n * of an entry no tracker links drops the entry, since it says nothing else.\n */\ndeclare function withLabelColor(labels: readonly LabelDefinition[], ref: string, color: string | null): LabelDefinition[];\n//#endregion\n//#region src/attachments.d.ts\ndeclare const ATTACHMENTS_DIR = \".dispatch/attachments\";\ndeclare const ATTACHMENT_MAX_BYTES: number;\ndeclare function sanitizeAttachmentName(name: string): string | null;\ndeclare function attachmentRelativePath(taskId: string, name: string): string;\n//#endregion\n//#region src/policy.d.ts\n/** A human gate the policy engine can demote from blocking to recording. */\ntype PolicyGate = 'scope' | 'approval' | 'verify-retry' | 'merge' | 'wake' | 'memory' | 'doc';\n/** Runtime counterpart of PolicyGate — see the note on FINDING_SEVERITIES. */\ndeclare const POLICY_GATES: readonly PolicyGate[];\n/**\n * One stop of the autonomy ladder. Rungs are ordered: a project at rung N has\n * every demotion of the rungs at or below N. Rung 1 is today's strictest\n * behavior — every gate blocks.\n */\ninterface PolicyRungDef {\n  rung: number;\n  name: string;\n  /** What the stop means, phrased for the slider UI. */\n  label: string;\n}\n/** The ladder's stops, per docs/design/autonomy-ladder.md. */\ndeclare const POLICY_RUNGS: readonly PolicyRungDef[];\ndeclare const MIN_POLICY_RUNG = 1;\ndeclare const MAX_POLICY_RUNG = 4;\n/**\n * The rung at which each gate stops blocking and starts recording. THE\n * assignment table: the settled design adjusts autonomy by editing these\n * numbers, and every call site picks the change up through consultPolicy.\n *\n * - scope: an agent's request to edit outside its declared writes.\n * - approval: a tool-call escalation the SDK classifier referred to a human.\n * - verify-retry: igniting the review→fix loop and re-running a red verify.\n * - merge: handing a green run to the merge queue.\n * - wake: rousing a sleeping agent to deliver it a message.\n * - memory: an agent's lesson joining project or team memory.\n * - doc: an agent's edit to an accepted team doc (every run that links the doc\n *   reads it).\n */\ndeclare const GATE_RUNGS: Record<PolicyGate, number>;\n/**\n * The highest rung a task's declared risk allows, whatever the project says.\n * `effectiveRung = min(project rung, cap)`: a human always merges elevated\n * work, and a critical task (a publish, a release) never auto-decides at all.\n * A per-gate `auto` pin does not beat the cap — the cap is the task saying\n * \"watch this one\", and a project-wide pin cannot know which task it is on.\n */\ndeclare const RISK_RUNG_CAPS: Record<TaskRisk, number>;\n/** A per-gate override pin: `block` re-promotes a gate the rung would demote,\n *  `auto` demotes one gate without raising the whole rung. */\ntype PolicyGateMode = 'block' | 'auto';\ndeclare const POLICY_GATE_MODES: readonly PolicyGateMode[];\ninterface PolicyConfig {\n  /** The project's ladder stop. Defaults to 1: nothing auto-decides until a\n   *  human raises the rung. */\n  rung: number;\n  /** Per-gate pins that win over the rung, in either direction. */\n  gates: Partial<Record<PolicyGate, PolicyGateMode>>;\n}\ndeclare const DEFAULT_POLICY: PolicyConfig;\n/**\n * What a gate call site should do, and — when it may auto-decide — the\n * authorization it must write into the ledger entry recording the decision.\n */\ntype PolicyRuling = {\n  mode: 'block';\n} | {\n  mode: 'auto';\n  gate: PolicyGate;\n  /** The rung in force when the gate consulted policy: the project rung,\n   *  lowered to the task's risk cap when that is lower. */\n  rung: number;\n  /** Whether the rung itself or a per-gate pin authorized the demotion. */\n  authorizedBy: 'rung' | 'override';\n};\n/** The rung a task actually runs at: the project rung, capped by the task's\n *  risk. Absent risk reads as routine, the cap that changes nothing. */\ndeclare function effectiveRung(policy: PolicyConfig, risk?: TaskRisk): number;\n/**\n * The single decision function every gate call site consults. A gate below\n * the effective rung (and not pinned `auto`) blocks exactly as today; at or\n * above it, the caller auto-decides and records the returned authorization.\n * `risk` is the task's declared risk, which caps the rung — see RISK_RUNG_CAPS.\n */\ndeclare function consultPolicy(policy: PolicyConfig, gate: PolicyGate, risk?: TaskRisk): PolicyRuling;\n/**\n * The irreversibility floor: actions that always block for a human, at every\n * policy rung, in both lenses. Deliberately a DIFFERENT type from PolicyGate —\n * consultPolicy cannot be asked about a floor check, GATE_RUNGS has no entry\n * to lower, and PolicyConfig.gates cannot pin one — so the policy engine\n * cannot demote the floor by construction, not by convention.\n *\n * Membership is the six members docs/design/autonomy-ladder.md settles\n * (t-df1163, \"The irreversibility floor\"). Amending the floor is an edit to\n * this table, and only this table: the server's detectors (server/floor.ts)\n * and both lenses key off it.\n */\ntype FloorCheck = 'force-push' | 'delete-outside-writes' | 'budget-cap' | 'publish' | 'repo-settings' | 'finding-ruling';\n/** One floor member, with the copy both lenses render: the builder slider's\n *  always-on footer and the engineer gate table's pinned rows show the same\n *  label and summary. */\ninterface FloorCheckDef {\n  check: FloorCheck;\n  label: string;\n  summary: string;\n}\ndeclare const IRREVERSIBILITY_FLOOR: readonly FloorCheckDef[];\n/** Runtime counterpart of FloorCheck, same pattern as POLICY_GATES. */\ndeclare const FLOOR_CHECKS: readonly FloorCheck[];\n/** Membership test against unvalidated input (config keys, API payloads). */\ndeclare function isFloorCheck(value: string): value is FloorCheck;\n/**\n * The floor's whole decision function: it takes no PolicyConfig on purpose.\n * There is no rung, pin, or lens that changes the answer — the return type\n * cannot even express 'auto'.\n */\ninterface FloorRuling {\n  mode: 'block';\n  check: FloorCheck;\n  /** Marks the ruling as a floor hold, so surfaces can render the padlock. */\n  floor: true;\n}\ndeclare function consultFloor(check: FloorCheck): FloorRuling;\n/** The one-line receipt a floor hold carries, mirroring\n *  describePolicyAuthorization so ledger entries phrase both directions of the\n *  policy engine identically. */\ndeclare function describeFloorHold(check: FloorCheck): string;\n/**\n * The one-line provenance a recorded auto-decision carries in the ledger, so\n * every gate phrases its authorization identically and the receipt names the\n * exact rung and the gate it decided.\n */\ndeclare function describePolicyAuthorization(ruling: Extract<PolicyRuling, {\n  mode: 'auto';\n}>): string;\n//#endregion\n//#region src/scoring.d.ts\n/**\n * The factors this version scores. The full scoring service adds project rank,\n * initiative rank, and due-date proximity once the planning hierarchy exists;\n * those arrive as new rows in the factor table below, not as a rewrite here.\n */\ntype ScoreFactorKey = 'urgency' | 'unblocking' | 'age' | 'readiness';\n/** How much each factor counts, keyed by factor. 0 turns a factor off. */\ntype QueueWeights = Record<ScoreFactorKey, number>;\n/**\n * Urgency leads because a person set it deliberately; unblocking is worth\n * roughly two thirds of that because freeing other work is real but indirect;\n * age is a small counterweight that eventually rescues a starved task rather\n * than a driver of ordering on its own. Readiness sits between: a judged\n * title-only spec should lose to a well-specified peer but not to age alone.\n */\ndeclare const DEFAULT_QUEUE_WEIGHTS: QueueWeights;\n/** The daemon's readiness reading for one task, as the ranking consumes it\n *  (see packages/server's judgments/readiness.ts for the full reading). */\ninterface ReadinessLevel {\n  /** 0 (title only) .. 3 (criteria and surface both named). */\n  level: number;\n}\n/**\n * The dependent count at which the unblocking factor reaches 0.5. The curve is\n * `count / (count + this)`, so value rises fast over the first few dependents\n * and flattens after — a task freeing 12 others is not twice as valuable as one\n * freeing 6, and normalizing against the batch instead would make every score\n * depend on whatever else happened to be ready at the time.\n */\ndeclare const UNBLOCKING_HALF_VALUE = 3;\n/** Days of waiting at which the age factor saturates at 1. */\ndeclare const AGE_HORIZON_DAYS = 30;\n/**\n * Whether a value can serve as a factor weight: a finite number, zero or above.\n * Zero is valid and meaningful — it is how a factor is turned off. Negative is\n * not: it would invert the factor's meaning rather than disable it.\n *\n * Shared so config validation (which rejects a bad weight loudly) and\n * `rankTasks` (which must not let one bad weight NaN out every score) agree on\n * exactly what \"usable\" means.\n */\ndeclare function isQueueWeight(value: unknown): value is number;\n/** One factor's contribution to a single task's score. */\ninterface ScoreFactor {\n  /** Join against QUEUE_FACTORS on this to get the label and description —\n   *  repeating them per task would just be the same strings N times. */\n  key: ScoreFactorKey;\n  /** The factor's own reading of the task, normalized to 0..1. */\n  value: number;\n  /** The configured weight, echoed so a UI can show the knob beside the value. */\n  weight: number;\n  /** `value * weight`, rescaled so a task's contributions sum to its score. */\n  contribution: number;\n  /** Why this task got this value, in words. */\n  detail: string;\n}\ninterface ScoredTask {\n  task: TaskDoc;\n  /** Weighted mean of every factor value, 0..1. */\n  score: number;\n  factors: ScoreFactor[];\n}\ninterface RankOptions {\n  weights: QueueWeights;\n  /** Injected rather than read from the clock so scoring stays pure. */\n  now: string;\n  /** Keep only the top N. Applied after ranking. */\n  limit?: number;\n  /** Readiness readings by task id. Omitted — no judgment client, or none\n   *  judged yet — the readiness factor drops out of the weighted mean\n   *  entirely, so the ranking is byte-for-byte what it was without it. */\n  readiness?: Record<string, ReadinessLevel>;\n  /** The project's status model; the built-in one when omitted. */\n  statuses?: StatusModel;\n}\n/** What a factor is, without the function that computes it: the shape config\n *  validation and the Settings UI need to name and explain a weight. */\ninterface QueueFactorInfo {\n  key: ScoreFactorKey;\n  /** Display name for the queue's breakdown column and the weight setting. */\n  label: string;\n  /** What a value of 1 means, so a weight control can explain itself. */\n  describes: string;\n}\n/** The factor table without its compute functions — what a config validator or\n *  a Settings screen needs to name, explain, and check a set of weights. */\ndeclare const QUEUE_FACTORS: readonly QueueFactorInfo[];\n/** Every valid weight key, in breakdown order. */\ndeclare const QUEUE_FACTOR_KEYS: readonly ScoreFactorKey[];\n/**\n * Ranks the tasks that can be started now, highest weighted score first, with\n * the per-factor breakdown that makes the ordering explainable.\n *\n * Candidates come from `dispatchableTasks`, not `readyTasks`: this queue exists\n * to be pulled from, so it must show exactly what the orchestrator would agree\n * to start. The two differ on a blocker sitting in review — dispatchable, not\n * yet done — and using `readyTasks` would hide startable work from the one\n * surface whose whole job is to surface it.\n *\n * Takes the whole task set, not just the candidates: the unblocking factor\n * needs the full blockedBy graph — including blocked and in-progress tasks —\n * to see what a candidate would free.\n *\n * The score is the weighted *mean* of the factor values rather than their raw\n * weighted sum, so it always reads as 0..1 no matter how a project scales its\n * weights, and each factor's `contribution` sums back to it.\n */\ndeclare function rankTasks(tasks: TaskDoc[], options: RankOptions): ScoredTask[];\n//#endregion\n//#region src/configTypes.d.ts\n/** Per-run caps and defaults for the orchestrator's executors. `maxBudgetUsd`\n *  has no default — omitting it means \"no budget cap\". */\ninterface OrchestratorConfig {\n  maxTurns?: number;\n  /** Ceiling on one `verifyCommand` run. The merge queue is serial, so a verify\n   *  that never returns holds up every entry behind it. */\n  verifyTimeoutSec: number;\n  maxBudgetUsd?: number;\n  permissionMode: string;\n  epicConcurrency: number;\n  /** Hard ceiling on concurrent runs any one epic session may hold, capped at\n   *  `MAX_CONCURRENCY_HARD_CAP`. `epicConcurrency` must not exceed it. */\n  maxConcurrency: number;\n  /** What the spend gate charges for a run still in flight, before its real\n   *  cost is known. */\n  runCostEstimateUsd: number;\n  /** The executor a dispatch runs on when the caller names none. */\n  executor: string;\n}\n/** The largest `maxConcurrency` the loader accepts. Browser-safe so the\n *  dispatch dialog can clamp its own input against it. */\ndeclare const MAX_CONCURRENCY_HARD_CAP = 32;\ninterface RepoDigestConfig {\n  /** False stops all generation; the cache still serves what is on disk. */\n  enabled: boolean;\n  /** Minimum age of a cached digest before a stale one is regenerated. */\n  cooldownHours: number;\n}\ndeclare const DEFAULT_REPO_DIGEST: RepoDigestConfig;\n/**\n * Per-run dev-server previews: what turns a finished run from a diff you read\n * into an app you look at. The daemon starts the command inside the run's own\n * worktree, so a preview shows that run's work and nothing else.\n */\ninterface PreviewConfig {\n  /** False stops the daemon starting any preview at all. */\n  enabled: boolean;\n  /** Shell command to start this project's dev server, run inside the run's\n   *  worktree. Absent means autodetect from the worktree's package.json — see\n   *  `detectPreviewCommand`. A repo with neither simply has no preview, which\n   *  is an ordinary state, not an error. */\n  command?: string;\n  /** Command that installs dependencies, run once before `command` when the\n   *  worktree has no `node_modules`. A run's worktree is a fresh checkout, so\n   *  without this most dev servers fail to boot at all. */\n  installCommand?: string;\n  /** How long the dev server has to answer on its port before the daemon\n   *  gives up and reports the preview as failed. Generous by default: a cold\n   *  worktree may install first. */\n  readyTimeoutSec: number;\n  /** How long a preview may sit with no request before the daemon sweeps it. Dev\n   *  servers are expensive and a reviewer looks at one for a minute, so an\n   *  idle preview is pure cost. */\n  idleTimeoutSec: number;\n}\ndeclare const DEFAULT_PREVIEW: PreviewConfig;\n/** The preview settings a config implies. The single reader of the optional\n *  `preview` block, so no caller has to remember that a hand-built config\n *  (test fixtures, mostly) may not carry one. Returns a fresh object every\n *  call — DEFAULT_PREVIEW is a shared module constant, and handing it out by\n *  reference would let one caller's mutation change every later read. */\ndeclare function previewSettings(config: DispatchConfig): PreviewConfig;\n/**\n * The git-versioned audit trail the daemon exports outside the project repo.\n *\n * On by default, because the receipt log is what keeps the project's history\n * auditable once the database — not git — is the sync layer. Turning it off\n * stops the export; it never deletes a log already written.\n */\ninterface ReceiptsConfig {\n  enabled: boolean;\n  /**\n   * Where the log lives. Absent means the default under DISPATCH_HOME, keyed\n   * by a hash of the project path the same way runs and worktrees are. A\n   * relative path is resolved against the project root.\n   */\n  dir?: string;\n  /**\n   * Where to push the log after each export, so it survives the machine:\n   * one of the project's own remotes, by name (`origin`). Absent, with no\n   * `repo` either, keeps the log local, as it always was.\n   */\n  remote?: string;\n  /**\n   * Or a repository of its own: a git URL, or a path (relative to the\n   * project root). Mutually exclusive with `remote`.\n   */\n  repo?: string;\n  /** The branch the log is pushed to. */\n  branch?: string;\n}\ndeclare const DEFAULT_RECEIPTS: ReceiptsConfig;\n/** The branch receipts go to when `receipts.remote` names no other. */\ndeclare const DEFAULT_RECEIPTS_BRANCH = \"dispatch-receipts\";\n/**\n * Two-way board sync between teammates' daemons over git\n * (packages/server/src/sync). Off unless turned on: each daemon keeps its own\n * database, and this is what lets several of them converge on one board.\n */\ninterface SyncConfig {\n  enabled: boolean;\n  /** Which of the project's own remotes carries the sync branch, by name.\n   *  Ignored when `repo` is set. */\n  remote: string;\n  /**\n   * A repository of its own for the board instead: a git URL, or a path\n   * (relative to the project root). Set only when the config names one;\n   * mutually exclusive with `remote`.\n   */\n  repo?: string;\n  /** The branch the changes travel on. Nothing but sync writes to it. */\n  branch: string;\n  /** How often to sync when nothing local has changed. */\n  intervalSec: number;\n}\ndeclare const DEFAULT_SYNC: SyncConfig;\n/** One named gate in the verify pipeline. */\ninterface VerifyStep {\n  name: string;\n  command: string;\n}\n/** A `statuses:` entry as written: a bare name, or a name with a type/color. */\ntype StatusEntryInput = string | {\n  name: string;\n  type?: StatusDefinition['type'];\n  color?: string | null;\n};\ninterface DispatchConfig {\n  /** Status names in board order (always populated). */\n  statuses: string[];\n  /** Typed statuses, parallel to `statuses`. Set by loadConfig when any\n   *  entry is typed; read through `statusModelOf`, which fills defaults. */\n  statusDefinitions?: StatusDefinition[];\n  /** Which status each lifecycle event writes. Absent means the defaults;\n   *  read through `statusModelOf`. */\n  statusRoles?: StatusRoles;\n  /** The people registry beyond team.yml (see people.ts); absent when none. */\n  people?: Person[];\n  /** The label registry (see labels.ts): colors and links; absent when none. */\n  labels?: LabelDefinition[];\n  autoCommit: boolean;\n  verifyCommand?: string;\n  /** Verify as named steps rather than one opaque command, so a failure names\n   *  the check that broke. Takes precedence over `verifyCommand`. */\n  verifySteps?: VerifyStep[];\n  orchestrator: OrchestratorConfig;\n  models: ModelConfig;\n  /** Per-role reasoning effort. `loadConfig` always populates it (empty when\n   *  the block is absent); optional so hand-built fixtures stay valid. */\n  effort?: EffortConfig;\n  /** Per-executor overrides of the execute-side model roles (see\n   *  `executorModels`). `loadConfig` always populates it; optional only so\n   *  hand-built config literals (test fixtures) stay valid. */\n  executors?: Record<string, ExecutorConfig>;\n  /** Machines reachable over ssh — see RemoteConfig. Absent means none. */\n  remotes?: Record<string, RemoteConfig>;\n  linear: LinearConfig;\n  fixLoop: FixLoopConfig;\n  /** How to run this project for a `verify` run to exercise it. Absent means\n   *  the verify stage has nothing to dispatch, so a task simply skips it. */\n  verify?: VerifyConfig;\n  carto: CartoConfig;\n  repoDigest: RepoDigestConfig;\n  notifications: NotificationsConfig;\n  messaging: MessagingConfig;\n  /** Optional only so hand-built fixtures stay valid; `loadConfig` always\n   *  sets it. */\n  memory?: MemoryConfig;\n  /** The A2A bridge's policy; `loadConfig` always sets it, optional for hand-built fixtures. */\n  a2a?: A2AConfig;\n  /** One line per `a2a:` key that fell back to its default. */\n  a2aWarnings?: string[];\n  /**\n   * The git receipt log. `loadConfig` always populates this, so a config it\n   * returns can be read without a fallback; it is optional only so callers\n   * that build a DispatchConfig literal by hand — test fixtures, mostly — do\n   * not all have to be updated at once. Absent means DEFAULT_RECEIPTS.\n   */\n  receipts?: ReceiptsConfig;\n  /** Board sync. Optional for the same reason `receipts` is; absent means\n   *  DEFAULT_SYNC. Read it through `syncSettings()`. */\n  sync?: SyncConfig;\n  /** Optional in the type, but `loadConfig` always populates it — the marker\n   *  is for hand-built config objects (test fixtures) written before the block\n   *  existed. Read it through `queueWeights()`, never directly: that is what\n   *  forces a caller to handle a rejected block instead of silently ranking\n   *  against defaults. */\n  queue?: QueueConfig;\n  /** Parent directory for PR review worktrees (Task 7); each PR gets a\n   *  `pr-<n>` child inside it. Absent means the default sibling of `rootDir`. */\n  prWorktreeDir?: string;\n  /** The autonomy policy: which gates auto-decide instead of blocking.\n   *  `loadConfig` always populates it; optional only so hand-built config\n   *  literals (test fixtures) predating the block stay valid. Read it through\n   *  `projectPolicy()`, never directly, so the default rung applies. */\n  policy?: PolicyConfig;\n  /** Per-run dev-server previews. `loadConfig` always populates it; optional\n   *  only so hand-built config literals predating the block stay valid. Read\n   *  it through `previewSettings()`, never directly, so a partial block still\n   *  carries the default timeouts. */\n  preview?: PreviewConfig;\n}\n/** The policy a config implies. The single reader of the optional `policy`\n *  block, so no gate call site has to remember that a hand-built config may\n *  not carry one. Returns a fresh object every call — DEFAULT_POLICY is a\n *  shared module constant, and handing it out by reference would let one\n *  caller's mutation change every later gate consult process-wide. */\ndeclare function projectPolicy(config: DispatchConfig): PolicyConfig;\n/** Settings for the planning queue's ranking. Nested under `queue:` rather\n *  than sitting at the top level so the pull actions and dispatch policy that\n *  come later have somewhere obvious to land. */\ninterface QueueConfig {\n  /** Per-factor weights for the scoring function (see scoring.ts). Every\n   *  factor key is always present — a partial `queue.weights:` block layers\n   *  over the defaults rather than replacing them. Holds the defaults when\n   *  `error` is set, so a Settings screen still has something to render. */\n  weights: QueueWeights;\n  /** Why the `queue:` block on disk was rejected, when it was.\n   *\n   *  Carried rather than thrown from `loadConfig`, because throwing there\n   *  turns one mistyped weight into a 422 on every config-reading endpoint in\n   *  the daemon. The blast radius belongs to the queue: consumers whose answer\n   *  must be correct go through `queueWeights()`, which refuses. */\n  error?: string;\n}\n/** Either the weights to rank with, or the reason the configured block cannot\n *  be used. A result rather than a plain value so a caller cannot accidentally\n *  rank against defaults while the user's real config is broken. */\ntype QueueWeightsResult = {\n  ok: true;\n  weights: QueueWeights;\n} | {\n  ok: false;\n  error: string;\n};\n/** The scoring weights a config implies. The single reader of the optional\n *  `queue` block, so no caller has to remember that a hand-built config may\n *  not carry one — or that the one on disk may not have parsed.\n *\n *  Returns a fresh object every call: DEFAULT_QUEUE_WEIGHTS is a module-level\n *  constant read live by every loadConfig, so handing it out by reference\n *  would let one caller's mutation corrupt every later ranking process-wide. */\ndeclare function queueWeights(config: DispatchConfig): QueueWeightsResult;\n/** Whether Dispatch uses carto for the dependency graph, and whether it may\n *  build the container itself. `on` is a build policy, never a requirement —\n *  an absent binary always degrades to the built-in scanner. */\ntype CartoMode = 'on' | 'detect' | 'off';\ninterface CartoConfig {\n  enabled: CartoMode;\n}\ndeclare const CARTO_MODES: readonly CartoMode[];\ndeclare const DEFAULT_CARTO: CartoConfig;\n/** The run recipe a `verify` run exercises the project with — none of these\n *  are required, since a project may need only one of them explained. */\ninterface VerifyConfig {\n  command?: string;\n  url?: string;\n  notes?: string;\n}\n/** One rung of the fix-loop escalation ladder: how round `round`, and every\n *  later round up to the next rung, is dispatched. */\ninterface EscalationStep {\n  round: number;\n  strategy: 'resume' | 'fresh';\n  modelTier: 'standard' | 'high';\n}\n/** Bounds on the review -> fix -> re-review loop. `cap` is the last round that\n *  may dispatch; reaching it demands an explicit ruling on every finding.\n *  `auto` opens the loop on its own when a task's implementer finishes —\n *  the default lifecycle; individual tasks opt out via `fix-loop: false`. */\ninterface FixLoopConfig {\n  auto: boolean;\n  cap: number;\n  escalation: EscalationStep[];\n}\ndeclare const FIX_STRATEGIES: readonly string[];\ndeclare const FIX_MODEL_TIERS: readonly string[];\ndeclare const DEFAULT_FIX_LOOP: FixLoopConfig;\n/**\n * The kinds of thing that can wait on a human — the decision feed's own\n * vocabulary, owned here so the notification toggles and the feed cannot\n * drift apart. The server's DecisionFeed aliases its item kind to this type.\n *\n * - `approval`        a run is parked on a permission gate.\n * - `scope-request`   an agent asked to edit outside its declared writes.\n * - `memory`          an agent proposes a lesson for shared memory.\n * - `doc`             an agent proposes an edit to an accepted doc.\n * - `question`        an agent sent a blocking question (msg_send) and waits\n *                     on the answer.\n * - `fix-loop-capped` a review/fix loop exhausted its rounds and wants a ruling.\n * - `run-stalled`     a run failed or dead-ended and nobody has dealt with it.\n */\ntype NotificationKind = 'approval' | 'scope-request' | 'memory' | 'doc' | 'question' | 'fix-loop-capped' | 'run-stalled';\n/** The toggle a message notifies under; null when no human is being asked. */\ndeclare function notificationKindForMessage(message: {\n  kind: string;\n  blocking: boolean;\n  data?: unknown;\n}): NotificationKind | null;\n/** Every kind, in the order the Settings UI renders them. */\ndeclare const NOTIFICATION_KINDS: readonly NotificationKind[];\n/**\n * Delivery beyond the app for things awaiting a human. `kinds` gates both\n * channels — the desktop's OS notifications and the webhook — so a noisy\n * kind (a stalled run, a capped fix loop) can be quieted without also muting\n * an agent's question. The in-app record (the inbox, the decision feed) is\n * never gated: these toggles tune what interrupts you, not what is kept.\n */\ninterface NotificationsConfig {\n  kinds: Record<NotificationKind, boolean>;\n  /** An http(s) URL every newly-blocking feed item is POSTed to as JSON — the\n   *  seam for Slack or anything else; no per-service integrations. Absent\n   *  means no webhook. */\n  webhook?: string;\n}\n/** What the daemon hands out in place of a webhook URL's path, since the URL\n *  is the credential: `https://hooks.slack.com/services/T0/B0/x` becomes\n *  `https://hooks.slack.com/…`. Shared so the server's masking and the\n *  desktop's \"is this value masked?\" check cannot drift apart. */\ndeclare const SECRET_URL_MASK_SUFFIX = \"/\\u2026\";\n/** True when `value` is a masked webhook the daemon handed out, never a URL a\n *  user typed. Such a value must not be written back as the webhook. */\ndeclare function isMaskedSecretUrl(value: string): boolean;\ndeclare const DEFAULT_NOTIFICATIONS: NotificationsConfig;\n/** Rate and timeout limits for the messaging system. */\ninterface MessagingConfig {\n  urgentPerHour: number;\n  agentTurnsPerThreadPerHour: number;\n  agentBlockingTimeoutSec: number;\n  /** Mail ops applied per clock hour from any one teammate's machine (federation). */\n  remoteMailPerReplicaPerHour: number;\n}\ndeclare const DEFAULT_MESSAGING: MessagingConfig;\n/** Memory's prompt budget, write limits and decay clock. */\ninterface MemoryConfig {\n  indexTokens: number;\n  personalWritesPerHour: number;\n  proposalsPerHour: number;\n  maxOpenProposals: number;\n  proposalTtlDays: number;\n  staleAfterDays: number;\n  retireAfterDays: number;\n  claudeAutoMemory: 'export' | 'off';\n}\ndeclare const DEFAULT_MEMORY: MemoryConfig;\n/** The skills an A2A agent card may offer. */\ndeclare const A2A_SKILLS: readonly [\"ask\", \"handoff\", \"status\"];\ntype A2ASkill = (typeof A2A_SKILLS)[number];\n/** Project policy for the A2A bridge. Holds no listener setting: those are machine-local. */\ninterface A2AConfig {\n  /** The card's name; null means the basename of the project root. */\n  name: string | null;\n  /** The card's description; null means the default description. */\n  description: string | null;\n  /** The skills the card offers; null means every skill built. */\n  skills: A2ASkill[] | null;\n  /** How long a blocking send waits for its answer, 1 to 600 seconds. */\n  blockingWaitSec: number;\n  requestsPerMinute: number;\n  sendsPerHour: number;\n  handoffsPerDay: number;\n  openTasksPerClient: number;\n  streamsPerClient: number;\n  outboundPerHour: number;\n  /** Refuse bearer tokens from a client whose agent ever presented the\n   *  signature extension, so a paired Dispatch peer must sign (OD-11). */\n  requireSignedDispatchPeers: boolean;\n}\ndeclare const DEFAULT_A2A: A2AConfig;\n/** Linear sync settings. Holds no secret — the API key lives in `~/.dispatch/credentials.json`. */\ninterface LinearConfig {\n  enabled: boolean;\n  /** The primary linked team: `teamIds[0]`, or null when none is linked.\n   *  Read from a legacy `teamId:` when `teamIds:` is absent. */\n  teamId: string | null;\n  /** Every linked team, primary first. Issues follow a move between them\n   *  and unlink only when they leave all of them. */\n  teamIds: string[];\n  /** Pre-mirroring map (status -> state name or type). Once a team is linked\n   *  the statuses ARE its workflow states; this only guides that first move. */\n  statusMap: Record<string, string>;\n  /** Seconds between polls when no webhook delivers changes. */\n  intervalSec: number;\n  direction: 'both' | 'pull' | 'push';\n  /** Whether a task's Acceptance Criteria travels in the Linear description. */\n  includeAcceptanceCriteria: boolean;\n}\ndeclare const LINEAR_DIRECTIONS: readonly [\"both\", \"pull\", \"push\"];\ndeclare const DEFAULT_LINEAR: LinearConfig;\n/** Per-role model ids. Each role is a distinct kind of agent work, so cheap\n *  roles can run on a cheap model without downgrading coding runs. */\ninterface ModelConfig {\n  /** Coding runs — the agent that edits the repo. */\n  execute: string;\n  /** The overseer chat: a full agent session in the checkout that also holds\n   *  the daemon's own controls (dispatch, approve, cancel). */\n  overseer: string;\n  /** Multi-turn planning conversations. */\n  plan: string;\n  /** One-shot natural-language task drafting. */\n  draft: string;\n  /** Filling in description / acceptance criteria for a task or inbox item. */\n  enrich: string;\n  /** Grouping inbox captures into suggested epics. */\n  cluster: string;\n  /** Short mechanical text: titles, summaries, commit messages. */\n  summarize: string;\n  /** TypeSafe System One judgments — inbox triage, readiness, the landing\n   *  checklist, run model tier. A Jev model id, not a Claude one. */\n  judge: string;\n}\ndeclare const DEFAULT_MODELS: ModelConfig;\n/** Reasoning effort levels a Claude agent session accepts, lowest first. */\ndeclare const EFFORT_LEVELS: readonly [\"low\", \"medium\", \"high\", \"xhigh\", \"max\"];\ntype EffortLevel = (typeof EFFORT_LEVELS)[number];\ndeclare function isEffortLevel(value: unknown): value is EffortLevel;\n/** Per-role effort for the Claude agent sessions. An unset role sends no\n *  effort, so the model's own default applies (Opus 5.5: medium). */\ninterface EffortConfig {\n  execute?: EffortLevel;\n  overseer?: EffortLevel;\n  plan?: EffortLevel;\n}\ndeclare const EFFORT_ROLES: readonly (keyof EffortConfig)[];\n/** Every valid key of `ModelConfig`, in the order the Settings UI renders them. */\ndeclare const MODEL_ROLES: readonly (keyof ModelConfig)[];\n/** The two model roles a run's executor decides: the coding model and the\n *  lighter tier judged/reviewed routine work drops to. Either may be unset,\n *  meaning \"whatever that executor runs by default\". */\ninterface ExecutorModels {\n  execute?: string;\n  plan?: string;\n}\n/** USD per million tokens, for an executor that reports usage but no cost. */\ninterface ExecutorPricing {\n  input: number;\n  /** Defaults to `input` when unset. */\n  cachedInput?: number;\n  output: number;\n}\n/**\n * How to run an agent that is just a command-line program.\n *\n * Dispatch speaks two agents' protocols natively (Claude's SDK, Codex's app\n * server). Everything else — and there are dozens — is a CLI that takes a\n * prompt and prints to stdout, which is enough to run inside a worktree and\n * review afterwards. Declaring one here is what makes it dispatchable without\n * a code change.\n *\n * `run` is the argv, with two placeholders substituted before spawn:\n * `{prompt}` and `{model}`. An entry containing a placeholder is replaced\n * wholesale, so `--model={model}` and a bare `{model}` both work. When `run`\n * has no `{prompt}`, the prompt is written to the process's stdin instead,\n * which is what the agents that read a prompt from a pipe expect.\n */\ninterface ExecutorCommand {\n  run: string[];\n  /** Extra environment for the child, merged over the daemon's own. */\n  env?: Record<string, string>;\n}\n/**\n * A machine Dispatch can reach over ssh.\n *\n * Only what ssh itself needs, plus the checkout to work in. Everything else —\n * keys, jump hosts, multiplexing — belongs in the user's own `~/.ssh/config`,\n * which ssh already reads and which is where anyone maintaining a fleet\n * already keeps it. Re-declaring that here would be a second place to keep in\n * step with the first.\n */\ninterface RemoteConfig {\n  /** Hostname or an alias from the user's ssh config. */\n  host: string;\n  user?: string;\n  port?: number;\n  /** The checkout on that machine; commands run here. */\n  path?: string;\n  /** Passed as `ssh -i`. Prefer an ssh-config `IdentityFile` where possible. */\n  identityFile?: string;\n}\ninterface ExecutorConfig {\n  models: ExecutorModels;\n  pricing?: ExecutorPricing;\n  /** Present only for CLI-backed agents; the built-in executors ignore it. */\n  command?: ExecutorCommand;\n}\ndeclare const EXECUTOR_PRICING_FIELDS: readonly (keyof ExecutorPricing)[];\ndeclare const EXECUTOR_MODEL_ROLES: readonly (keyof ExecutorModels)[];\n/** The executor `orchestrator.executor` names when the config is silent. */\ndeclare const DEFAULT_EXECUTOR_NAME = \"claude\";\ndeclare function executorModels(config: Pick<DispatchConfig, 'models' | 'executors'>, name: string): ExecutorModels;\n/** The subset of config the Settings screen can change. Everything else — statuses chief\n *  among them — is structural, and editing it from a form would invalidate existing tasks. */\ninterface ConfigPatch {\n  verifyCommand?: string | null;\n  autoCommit?: boolean;\n  epicConcurrency?: number;\n  verifyTimeoutSec?: number;\n  maxConcurrency?: number;\n  runCostEstimateUsd?: number;\n  /** `null` clears the key, restoring \"no cap\" — both are optional in OrchestratorConfig. */\n  maxTurns?: number | null;\n  maxBudgetUsd?: number | null;\n  permissionMode?: OrchestratorConfig['permissionMode'];\n  models?: Partial<ModelConfig>;\n  /** Per-role effort; `null` removes the role so the model default applies. */\n  effort?: Partial<Record<keyof EffortConfig, EffortLevel | null>>;\n  /** Writes `orchestrator.executor`. */\n  executor?: string;\n  /** Written key-by-key under `executors.<name>.models`. `command` declares\n   *  or changes a CLI agent (null makes it a plain executor again); a whole\n   *  entry of `null` removes that agent. */\n  executors?: Record<string, {\n    models?: Partial<ExecutorModels>;\n    pricing?: ExecutorPricing;\n    command?: ExecutorCommand | null;\n  } | null>;\n  linear?: Partial<LinearConfig>;\n  fixLoop?: Partial<FixLoopConfig>;\n  verify?: Partial<VerifyConfig>;\n  /** `webhook: null` clears the URL. `kinds` merges over what is on disk. */\n  notifications?: {\n    kinds?: Partial<Record<NotificationKind, boolean>>;\n    webhook?: string | null;\n  };\n  /** Weights only — the factor table itself is code, not configuration. */\n  queue?: {\n    weights?: Partial<QueueWeights>;\n  };\n  /** `gates` is written key-by-key; a `null` pin clears the override so the\n   *  rung decides again. */\n  policy?: {\n    rung?: number;\n    gates?: Partial<Record<PolicyGate, PolicyGateMode | null>>;\n  };\n  /** The board's statuses, in order, replacing the list. */\n  statuses?: StatusEntryInput[];\n  /** Replaces `statusRoles`; null removes it (defaults apply again). */\n  statusRoles?: StatusRoles | null;\n  /** Replaces `people`; null or empty removes it. */\n  people?: Person[] | null;\n  /** Replaces `labels`; null or empty removes it. */\n  labels?: LabelDefinition[] | null;\n  /** Named verify gates, replacing the list; null or empty removes it. */\n  verifySteps?: VerifyStep[] | null;\n  /** Per remote name: a config sets it, null removes it. */\n  remotes?: Record<string, RemoteConfig | null>;\n  carto?: {\n    enabled?: CartoMode;\n  };\n  repoDigest?: {\n    enabled?: boolean;\n    cooldownHours?: number | null;\n  };\n  receipts?: {\n    enabled?: boolean;\n    dir?: string | null;\n    remote?: string | null;\n    repo?: string | null;\n    branch?: string | null;\n  };\n  sync?: {\n    enabled?: boolean;\n    remote?: string | null;\n    repo?: string | null;\n    branch?: string | null;\n    intervalSec?: number | null;\n  };\n  prWorktreeDir?: string | null;\n  preview?: {\n    enabled?: boolean;\n    command?: string | null;\n    installCommand?: string | null;\n    readyTimeoutSec?: number | null;\n    idleTimeoutSec?: number | null;\n  };\n  /** A value sets the key, `null` removes it (its default applies again). */\n  memory?: { [K in keyof MemoryConfig]?: MemoryConfig[K] | null };\n}\n//#endregion\n//#region src/linearMap.d.ts\n/** One Linear workflow state. `type` is the fixed semantic bucket; `name` is per-team config. */\ninterface LinearWorkflowState {\n  id: string;\n  name: string;\n  type: string;\n  /** `#rrggbb`; absent on callers that only need the name and type. */\n  color?: string;\n  /** Board order within the team. */\n  position?: number;\n}\ninterface LinearLabel {\n  id: string;\n  name: string;\n  color?: string;\n  /** The group label's name, for a label nested in a group. */\n  group?: string | null;\n  /** The owning team, or null for a workspace label. */\n  teamId?: string | null;\n}\n/** A workspace member. `displayName` is Linear's short handle. */\ninterface LinearUser {\n  id: string;\n  name: string;\n  displayName: string;\n  email: string | null;\n  avatarUrl: string | null;\n  active: boolean;\n}\n/** One relation, normalized so `issueId` is always the source side\n *  (`issueId` blocks / duplicates / relates to `relatedIssueId`). */\ninterface LinearRelation {\n  id: string;\n  type: string;\n  issueId: string;\n  relatedIssueId: string;\n}\n/** A link attached to an issue. `url` is unique per issue. */\ninterface LinearAttachment {\n  id: string;\n  title: string;\n  url: string;\n  subtitle: string | null;\n  sourceType: string | null;\n}\n/** A nested list the fetch cut short; that field is not trusted this pass. */\ntype LinearTruncatedField = 'labels' | 'relations' | 'attachments' | 'children';\n/** The Issue fields this sync reads. `id` is the stable UUID; `identifier` is display-only. */\ninterface LinearIssue {\n  id: string;\n  identifier: string;\n  title: string;\n  description: string | null;\n  priority: number;\n  estimate: number | null;\n  url: string;\n  createdAt: string;\n  updatedAt: string;\n  archivedAt: string | null;\n  /** ISO date (TimelessDate). */\n  dueDate: string | null;\n  state: LinearWorkflowState | null;\n  labels: LinearLabel[];\n  team: {\n    id: string;\n    key: string;\n  } | null;\n  assigneeId: string | null;\n  creatorId: string | null;\n  cycle: TaskCycle | null;\n  projectId: string | null;\n  projectMilestoneId: string | null;\n  parentId: string | null;\n  childIds: string[];\n  /** Outgoing and inverse relations together, one entry per relation id. */\n  relations: LinearRelation[];\n  attachments: LinearAttachment[];\n  truncated: LinearTruncatedField[];\n}\n/** A comment on an issue; `parentId` threads a reply under its parent. */\ninterface LinearComment {\n  id: string;\n  issueId: string;\n  body: string;\n  userId: string | null;\n  parentId: string | null;\n  createdAt: string;\n  updatedAt: string;\n  archivedAt: string | null;\n}\n/** A project status: one of the workspace's, bucketed by `type`\n *  (backlog | planned | started | paused | completed | canceled). */\ninterface LinearProjectStatus {\n  id: string;\n  name: string;\n  type: string;\n  color?: string;\n  position?: number;\n}\n/** A Linear project. `summary` is the short description; `content` the long markdown. */\ninterface LinearProject {\n  id: string;\n  name: string;\n  summary: string;\n  content: string | null;\n  icon: string | null;\n  color: string | null;\n  startDate: string | null;\n  targetDate: string | null;\n  leadId: string | null;\n  status: LinearProjectStatus | null;\n  priority: number;\n  url: string;\n  createdAt: string;\n  updatedAt: string;\n  archivedAt: string | null;\n  teamIds: string[];\n  /** Membership rows (the join entity's id and the initiative), in Linear's order. */\n  initiatives: {\n    id: string;\n    initiativeId: string;\n  }[];\n}\ninterface LinearProjectMilestone {\n  id: string;\n  name: string;\n  description: string | null;\n  targetDate: string | null;\n  sortOrder: number;\n  projectId: string;\n  createdAt: string;\n  updatedAt: string;\n  archivedAt: string | null;\n}\n/** An initiative. `status` is Linear's PascalCase enum (Planned, Active, …). */\ninterface LinearInitiative {\n  id: string;\n  name: string;\n  description: string | null;\n  content: string | null;\n  ownerId: string | null;\n  creatorId: string | null;\n  status: string;\n  targetDate: string | null;\n  color: string | null;\n  icon: string | null;\n  url: string;\n  createdAt: string;\n  updatedAt: string;\n  archivedAt: string | null;\n}\n/** Issue mutation input. `null` clears a field; an absent key leaves it alone. */\ninterface LinearIssueInput {\n  teamId?: string;\n  title?: string;\n  description?: string;\n  priority?: number;\n  estimate?: number | null;\n  stateId?: string;\n  assigneeId?: string | null;\n  labelIds?: string[];\n  dueDate?: string | null;\n  cycleId?: string | null;\n  projectId?: string | null;\n  projectMilestoneId?: string | null;\n  parentId?: string | null;\n}\ninterface LinearProjectInput {\n  name?: string;\n  content?: string;\n  leadId?: string | null;\n  statusId?: string;\n  startDate?: string | null;\n  targetDate?: string | null;\n  color?: string;\n  icon?: string | null;\n  priority?: number;\n  teamIds?: string[];\n}\ninterface LinearMilestoneInput {\n  name?: string;\n  description?: string;\n  targetDate?: string | null;\n  projectId?: string;\n  sortOrder?: number;\n}\ninterface LinearInitiativeInput {\n  name?: string;\n  content?: string;\n  ownerId?: string | null;\n  status?: string;\n  targetDate?: string | null;\n  color?: string;\n  icon?: string | null;\n}\ndeclare const LINEAR_EXTERNAL_PREFIX = \"linear:\";\n/** The value stored in `TaskMeta.external` for a Linear issue — always keyed by the UUID. */\ndeclare function externalId(issue: {\n  id: string;\n}): string;\n/** The Linear issue UUID inside an `external` value, or null when it names another system. */\ndeclare function parseExternal(value: string | null | undefined): string | null;\n/** The Linear record kinds a task can mirror. */\ntype LinearEntity = 'issue' | 'project' | 'milestone' | 'initiative';\n/** A task's link to one Linear record. */\ninterface LinearRef {\n  entity: LinearEntity;\n  id: string;\n}\n/** The `TaskMeta.external` value for a Linear record of any kind. */\ndeclare function linearExternal(ref: LinearRef): string;\n/** The Linear record an `external` value names, of any kind, or null. */\ndeclare function parseLinearExternal(value: string | null | undefined): LinearRef | null;\ndeclare function priorityToLinear(priority: Priority): number;\ndeclare function priorityFromLinear(value: number): Priority;\n/** Default dispatch-status -> Linear-state mapping, matching Linear's out-of-the-box state names. */\ndeclare const DEFAULT_STATUS_MAP: Record<string, string>;\n/** The Linear state a dispatch status maps to, matched by state name then by `type`.\n *  Null when nothing matches, which callers treat as \"leave the state alone\". */\ndeclare function resolveWorkflowState(status: string, statusMap: Record<string, string>, states: LinearWorkflowState[]): LinearWorkflowState | null;\n/** Which side of a link has the newer edit. Ties and unparseable timestamps resolve to\n *  `'none'`, so an ambiguous comparison never triggers a write in either direction. */\ndeclare function resolveConflict(localUpdated: string, remoteUpdated: string): 'local' | 'remote' | 'none';\n//#endregion\n//#region src/subagents.d.ts\n/** Where a sub-agent is in its life. `stopped` is a sub-agent a person or the\n * parent agent killed, as opposed to one that failed on its own. */\ntype SubagentStatus = 'running' | 'done' | 'failed' | 'stopped';\n/**\n * What one `kind: 'agent'` transcript entry says. `id` is the spawning\n * tool_use id, the one handle every event about the same sub-agent shares —\n * the executor correlates the SDK's own task ids back to it so readers never\n * have to. `phase` says which lifecycle edge this is; `status` is the\n * sub-agent's status as of this event.\n */\ninterface SubagentEvent {\n  id: string;\n  phase: 'started' | 'progress' | 'finished';\n  status: SubagentStatus;\n  /** The task description the parent gave it. */\n  label?: string;\n  /** The `subagent_type` it was spawned as (`Explore`, `general-purpose`, …). */\n  type?: string;\n  /** Running totals the SDK reports on progress/finish. */\n  toolUses?: number;\n  tokens?: number;\n  durationMs?: number;\n  /** The tool the sub-agent most recently called, from a progress event. */\n  lastTool?: string;\n  /** A progress event's present-tense summary, or the final report's gist. */\n  summary?: string;\n}\n/**\n * The slice of a transcript entry the fold reads. Structural on purpose so\n * the server's NormalizedEntry and the client's mirror of it both qualify\n * without either importing the other.\n */\ninterface SubagentSourceEntry {\n  ts: string;\n  kind: string;\n  /** Set on entries emitted from inside a sub-agent: the spawning tool_use id. */\n  parentToolUseId?: string;\n  agent?: SubagentEvent;\n}\n/** One sub-agent, folded from every event about it. */\ninterface SubagentNode {\n  id: string;\n  /** The sub-agent that spawned this one, or `null` for the run's own agent. */\n  parentId: string | null;\n  label: string;\n  type?: string;\n  status: SubagentStatus;\n  startedAt: string;\n  finishedAt?: string;\n  /** Tool calls seen from this sub-agent, or the SDK's own count if larger. */\n  toolUses: number;\n  tokens?: number;\n  durationMs?: number;\n  lastTool?: string;\n  summary?: string;\n}\n/** The per-run counts RunMeta carries so lists can show fan-out without the transcript. */\ninterface SubagentSummary {\n  total: number;\n  running: number;\n  done: number;\n  failed: number;\n  stopped: number;\n}\n/**\n * Applies one event's status on top of the status already known for that\n * sub-agent. A terminal status is final: a progress event that arrives after\n * the finish (the two come from different SDK streams and can cross) must not\n * flip a finished sub-agent back to running.\n */\ndeclare function nextSubagentStatus(current: SubagentStatus | undefined, event: Pick<SubagentEvent, 'status'>): SubagentStatus;\n/**\n * Folds a run's entries into its sub-agents, in the order they were spawned.\n * Tool entries carrying `parentToolUseId` count toward that sub-agent's tool\n * calls, so a live tree ticks with every call even before the SDK reports a\n * total. Events about a sub-agent whose start was never recorded still create\n * a node (labelled by its id), so a transcript that begins mid-stream is\n * shown rather than dropped.\n */\ndeclare function foldSubagents(entries: readonly SubagentSourceEntry[]): SubagentNode[];\n/** Counts a folded list (or any status list) into the RunMeta summary. */\ndeclare function summarizeSubagents(statuses: Iterable<{\n  status: SubagentStatus;\n}>): SubagentSummary;\n/** A folded node with its children attached, for rendering as a tree. */\ninterface SubagentTreeNode extends SubagentNode {\n  depth: number;\n  children: SubagentTreeNode[];\n}\n/**\n * Nests a folded list by `parentId`, keeping spawn order within each level.\n * A node whose parent is missing (never recorded) is treated as a root rather\n * than lost.\n */\ndeclare function nestSubagents(nodes: readonly SubagentNode[]): SubagentTreeNode[];\n/** Depth-first flattening of `nestSubagents`' output — one row per sub-agent, indented. */\ndeclare function flattenSubagentTree(roots: readonly SubagentTreeNode[]): SubagentTreeNode[];\n//#endregion\n//#region src/docs.d.ts\ntype DocScope = 'personal' | 'team';\ntype DocNamespace = 'team' | `p:${string}`;\ntype DocStatus = 'draft' | 'accepted' | 'archived';\ndeclare const DOC_STATUSES: readonly DocStatus[];\ntype RevisionCause = 'create' | 'save' | 'edit' | 'merge' | 'revert' | 'import' | 'restore' | 'proposal' | 'approve' | 'reject' | 'sync';\ntype LinkRel = 'spec' | 'plan' | 'context';\ndeclare const LINK_RELS: readonly LinkRel[];\ntype LinkTargetType = 'task' | 'run' | 'thread' | 'memory' | 'doc';\ndeclare const LINK_TARGET_TYPES: readonly LinkTargetType[];\ninterface LinkTarget {\n  type: LinkTargetType;\n  id: string;\n}\ninterface DocHead {\n  id: string;\n  n: number;\n  hash: string;\n  bytes: number;\n  sealed: boolean;\n}\ninterface DocRecord {\n  id: string;\n  ns: DocNamespace;\n  slug: string;\n  handle: string;\n  title: string;\n  scope: DocScope;\n  owner: {\n    human: string;\n    identity: string;\n  } | null;\n  status: DocStatus;\n  archivedFrom: 'draft' | 'accepted' | null;\n  restored: {\n    status: DocStatus;\n    at: string;\n  } | null;\n  head: DocHead;\n  reviewedRev: string | null;\n  unreviewed: boolean;\n  conflicted: boolean;\n  origin: string | null;\n  published: {\n    path: string;\n    rev: string;\n    n: number | null;\n    task: string;\n    commit: string | null;\n  } | null;\n  lastPublishPath: string | null;\n  problem?: string;\n  createdBy: string;\n  createdAt: string;\n  updatedBy: string;\n  updatedAt: string;\n}\ninterface DocRevisionInfo {\n  id: string;\n  doc: string;\n  n: number | null;\n  parents: string[];\n  title: string;\n  author: string;\n  cause: RevisionCause;\n  summary: string;\n  approval: {\n    by: string;\n    policy?: {\n      rung: number;\n    };\n  } | null;\n  hash: string;\n  bytes: number;\n  conflicted: boolean;\n  sealed: boolean;\n  unreviewed: boolean;\n  provisional: boolean;\n  via: string | null;\n  createdAt: string;\n  updatedAt: string;\n}\ninterface DocLink {\n  doc: string;\n  target: LinkTarget;\n  rel: LinkRel;\n  source: 'manual' | 'mention';\n  createdBy: string;\n  createdAt: string;\n}\ninterface DocOutlineEntry {\n  ord: number;\n  level: number;\n  heading: string;\n  anchor: string;\n  bytes: number;\n  line: number;\n}\ntype DocOp = {\n  op: 'replace_section';\n  section: string;\n  text: string;\n} | {\n  op: 'replace';\n  find: string;\n  text: string;\n} | {\n  op: 'insert';\n  before: string;\n  text: string;\n} | {\n  op: 'append';\n  text: string;\n  section?: string;\n} | {\n  op: 'set_title';\n  title: string;\n};\ntype DocSaveStatus = 'saved' | 'amended' | 'merged' | 'proposed' | 'unchanged';\ninterface DocSaveResult {\n  doc: DocRecord;\n  handle: string;\n  rev: {\n    id: string;\n    n: number | null;\n    hash: string;\n  };\n  status: DocSaveStatus;\n  rebased?: {\n    since: {\n      n: number;\n      author: string;\n      summary: string;\n    }[];\n  };\n  proposal?: string;\n  gate?: string;\n  mine?: {\n    id: string;\n    n: number | null;\n    hash: string;\n  };\n}\ntype ProposalState = 'open' | 'approved' | 'rejected' | 'expired' | 'withdrawn' | 'failed';\ninterface DocProposal {\n  rev: string;\n  doc: string;\n  base: string;\n  author: string;\n  operator: string | null;\n  runId: string | null;\n  taskId: string | null;\n  origin: string;\n  gate: string | null;\n  state: ProposalState;\n  decidedBy: string | null;\n  decidedByPolicy: {\n    rung: number;\n    authorizedBy: 'rung' | 'override';\n  } | null;\n  reason: string | null;\n  result: string | null;\n  createdAt: string;\n  decidedAt: string | null;\n}\ninterface DocProposalView {\n  proposal: DocProposal;\n  title: string;\n  body: string;\n  chunks: {\n    equal: boolean;\n    a: string[];\n    b: string[];\n  }[];\n  mergeable: {\n    clean: boolean;\n    headN: number;\n    headRev: string;\n    headHash: string;\n  };\n  marked: string | null;\n}\ninterface DocConflict {\n  code: 'conflict';\n  reason: 'merge-conflict' | 'base-changed';\n  head: {\n    id: string;\n    n: number;\n    hash: string;\n    body: string;\n    author: string;\n  };\n  base: {\n    id: string;\n    n: number;\n  } | null;\n  hunks: {\n    line: number;\n    base: string[];\n    head: string[];\n    mine: string[];\n  }[];\n  marked: string;\n}\ninterface DocRead {\n  doc: DocRecord;\n  rev: DocRevisionInfo;\n  links: DocLink[];\n  outline: DocOutlineEntry[];\n  section: {\n    anchor: string;\n    heading: string;\n  } | null;\n  text: string;\n  offset: number;\n  nextOffset: number | null;\n  total: number;\n  proposal: string | null;\n}\ninterface DocSummary extends DocRecord {\n  rel: LinkRel | null;\n  fromParent: boolean;\n}\ninterface DocHit {\n  doc: string;\n  handle: string;\n  title: string;\n  scope: DocScope;\n  anchor: string;\n  heading: string;\n  snippet: string;\n  score: number;\n}\ninterface DocLinking {\n  doc: DocRecord;\n  rel: LinkRel;\n  source: 'manual' | 'mention';\n  fromParent: boolean;\n}\ninterface DocsHealth {\n  available: boolean;\n  reason: string | null;\n  search: 'fts5' | 'like';\n  bytes: number;\n  warnings: string[];\n  lastSweep: string | null;\n  restore?: unknown;\n  orphans?: string[];\n}\ndeclare const DOCS_LIMITS: {\n  readonly titleBytes: 200;\n  readonly slugChars: 64;\n  readonly bodyBytes: number;\n  readonly escapedBodyBytes: number;\n  readonly linksPerDoc: 200;\n  readonly opsPerCall: 50;\n  readonly findMaxBytes: number;\n  readonly queryBytes: 500;\n  readonly readPageBytes: number;\n  readonly requestBytes: number;\n  readonly importContentBytes: number;\n  readonly importSessionBytes: number;\n  readonly imageBytes: number;\n  readonly summaryBytes: 200;\n  readonly receiptFileBytes: number;\n  readonly revisionParents: 8;\n};\ndeclare const RESERVED_DOC_SLUGS: readonly string[];\ndeclare function normalizeDocText(text: string): string;\ndeclare function jsonEscapedBytes(text: string): number;\ndeclare function docTitleProblem(title: unknown): string | null;\ndeclare function docSlugProblem(slug: unknown): string | null;\ndeclare function docBodyProblem(body: unknown): string | null;\ndeclare function docSlug(title: string): string;\ninterface DocFileMeta {\n  id: string;\n  slug: string;\n  title: string;\n  status: DocStatus;\n  rev: string;\n  n: number;\n  parents: string[];\n  author: string;\n  cause: RevisionCause;\n  createdAt: string;\n  hash: string;\n  links: {\n    target: string;\n    rel: LinkRel;\n  }[];\n  authors: string[];\n  updatedAt: string;\n  scope?: DocScope;\n}\ndeclare function renderDocFile(meta: DocFileMeta, body: string): string;\ndeclare function parseDocFile(text: string): {\n  meta: DocFileMeta;\n  body: string;\n} | {\n  error: string;\n};\n/** A stored image's name: the hex sha256 of its bytes and its sniffed extension. */\ndeclare const ASSET_NAME: RegExp;\n/** Each asset name the body's `![…](asset:…)` images reference, once, in order. */\ndeclare function assetNames(body: string): string[];\n/** `body` with each `asset:` image link pointed at `to(name)`. */\ndeclare function rewriteAssetLinks(body: string, to: (name: string) => string): string;\n//#endregion\n//#region src/runStep.d.ts\n/** The slice of a transcript entry a step is read from. */\ninterface RunStepEntry {\n  kind: string;\n  toolName?: string;\n  toolInput?: unknown;\n  /** Set on a sub-agent's own entries, which never name the run's step. */\n  parentToolUseId?: string;\n  agent?: {\n    phase: string;\n    label?: string;\n  };\n}\n/** The step a live run last announced, and when (the entry's `ts`). */\ninterface RunStep {\n  text: string;\n  at: string;\n}\n/**\n * The step one log entry announces, or null when it says nothing new about\n * what the run is doing (prose, usage ticks, a sub-agent's own tool calls).\n */\ndeclare function runStepFromEntry(entry: RunStepEntry, runId: string): string | null;\n//#endregion\n//#region src/findings.d.ts\ntype FindingSeverity = 'critical' | 'important' | 'minor';\ntype FindingVerdict = 'open' | 'addressed' | 'parked' | 'blocked';\n/** The reviewer's call on whether work may ship with this outstanding. */\ntype FindingRecommendation = 'blocks' | 'park';\ninterface Finding {\n  id: string;\n  taskId: string;\n  runId: string | null;\n  severity: FindingSeverity;\n  verdict: FindingVerdict;\n  title: string;\n  detail: string;\n  file: string | null;\n  line: number | null;\n  /** Other paths this finding covers, when one check fires across many files\n   *  at once. Absent on findings about a single location. */\n  files?: string[];\n  /** Set when parked or blocked — why, in the controller's words. */\n  ruling: string | null;\n  recommendation?: FindingRecommendation;\n  round: number;\n  createdAt: string;\n  updatedAt: string;\n  /** Serialized ActorRef of whoever raised it; empty for pre-team records. */\n  raisedBy: string;\n}\ninterface AddFindingInput {\n  taskId: string;\n  runId: string | null;\n  severity: FindingSeverity;\n  title: string;\n  detail: string;\n  file?: string | null;\n  line?: number | null;\n  /** Paths this finding covers when one check fired across many files. */\n  files?: string[];\n  round?: number;\n  recommendation?: FindingRecommendation;\n  /** Serialized ActorRef of whoever raised it. */\n  raisedBy: string;\n}\ninterface FindingUpdatePatch {\n  verdict?: FindingVerdict;\n  ruling?: string | null;\n}\ninterface FindingListFilter {\n  taskId?: string;\n  verdict?: FindingVerdict;\n  severity?: FindingSeverity;\n}\ndeclare const FINDING_SEVERITIES: readonly FindingSeverity[];\ndeclare const FINDING_VERDICTS: readonly FindingVerdict[];\ndeclare const FINDING_RECOMMENDATIONS: readonly FindingRecommendation[];\n//#endregion\n//#region src/ledger.d.ts\ntype LedgerKind = 'constraint' | 'hazard' | 'decision' | 'handoff';\ninterface LedgerEntry {\n  id: string;\n  epicId: string | null;\n  sourceTaskId: string | null;\n  kind: LedgerKind;\n  title: string;\n  detail: string;\n  /** Task ids this applies to; empty means every task under the epic. */\n  appliesTo: string[];\n  createdAt: string;\n  /** Serialized ActorRef of whoever wrote it; empty for pre-team records. */\n  authoredBy: string;\n}\ninterface AddLedgerInput {\n  epicId?: string | null;\n  sourceTaskId?: string | null;\n  kind: LedgerKind;\n  title: string;\n  detail: string;\n  appliesTo?: string[];\n  /** Serialized ActorRef of whoever wrote it. */\n  authoredBy: string;\n}\ninterface LedgerListFilter {\n  epicId?: string | null;\n}\ndeclare const LEDGER_KINDS: readonly LedgerKind[];\n//#endregion\n//#region src/evidence.d.ts\ninterface CommandEvidence {\n  command: string;\n  exitCode: number;\n  durationMs: number;\n  summary: string;\n  at: string;\n}\ninterface MutationEvidence {\n  guard: string;\n  file: string;\n  testsFailed: number;\n  at: string;\n}\n//#endregion\n//#region src/conflicts.d.ts\n/** Two tasks conflict when their write-sets intersect; empty means unknown. */\ndeclare function tasksConflict(a: string[], b: string[]): boolean;\ndeclare function claimConflictsWithWrites(claim: string[], writes: string[]): boolean;\ndeclare function schedulableBatch(ready: {\n  id: string;\n  writes: string[];\n}[], limit: number): string[];\n//#endregion\n//#region src/actor.d.ts\ntype ActorKind = 'human' | 'agent';\ninterface ActorRef {\n  kind: ActorKind;\n  /** Stable handle within the project; null means \"any actor of this kind\". */\n  handle: string | null;\n  /** For agents, the handle of the human who owns it; null otherwise. */\n  operator: string | null;\n}\ndeclare class ActorRefError extends Error {}\n/** The unassigned wire value, kept distinct from a malformed one. */\ndeclare const UNASSIGNED = \"none\";\n/**\n * Parses a task's `assignee` wire value. Returns null for `none`; the bare\n * `human`/`agent` legacy values parse as that kind with no handle, so existing\n * task files stay valid without migration.\n */\ndeclare function parseActorRef(raw: string): ActorRef | null;\ndeclare function formatActorRef(ref: ActorRef | null): string;\n/** Validation gate for `assignee`, used where a throw would be the wrong shape. */\ndeclare function isValidAssignee(raw: string): boolean;\n//#endregion\n//#region src/slug.d.ts\ndeclare function slugify(title: string): string;\n//#endregion\n//#region src/describe.d.ts\ndeclare function describeValue(value: unknown): string;\n//#endregion\n//#region src/timeline.d.ts\n/**\n * Whether a task's content has moved past the version a consumer last\n * accounted for. False when it moved backwards — a branch checkout holding an\n * older revision must never be pushed as if it were new work (see 53190d6).\n * Unparseable timestamps are treated as not-outstanding: when in doubt, hold.\n */\ndeclare function isOutstanding(updated: string, lastAccounted: string | undefined): boolean;\n//#endregion\n//#region src/sqliteDb.d.ts\n/**\n * The slice of a synchronous SQLite driver everything above this module uses.\n *\n * It is declared here rather than imported from either driver so that no other\n * file names `node:sqlite` or `bun:sqlite` — sqliteTaskStore, sqliteRecords and\n * storeBackend all type their handle as `SqliteDatabase` and stay driver-blind.\n */\ntype SqlValue = null | number | bigint | string | Uint8Array;\ninterface SqliteStatement {\n  all(...params: SqlValue[]): unknown[];\n  /** The matched row, or `undefined` when the query matched none. */\n  get(...params: SqlValue[]): unknown;\n  run(...params: SqlValue[]): {\n    changes: number | bigint;\n    lastInsertRowid: number | bigint;\n  };\n}\ninterface SqliteDatabase {\n  /**\n   * Which driver module this handle was actually built from.\n   *\n   * It earns its place twice. A test can assert what `openDispatchDb` LOADED\n   * rather than what `sqliteDriver()` would answer, and those are different\n   * claims: the selector returning 'bun:sqlite' proves nothing about the\n   * module the loader reached for. And it brands the interface, so a raw\n   * `bun:sqlite` Database — which is otherwise structurally identical, but\n   * whose `get()` answers a miss with null — can no longer be passed to\n   * anything typed `SqliteDatabase`.\n   */\n  readonly driver: SqliteDriver;\n  prepare(sql: string): SqliteStatement;\n  exec(sql: string): void;\n  close(): void;\n}\n/** The module `openDispatchDb` loads its driver from on the current runtime. */\ntype SqliteDriver = 'bun:sqlite' | 'node:sqlite';\n/**\n * Picks a driver by runtime: Bun gets `bun:sqlite`, everything else\n * `node:sqlite`.\n *\n * Bun is not a runtime that happens to also have `node:sqlite` — it only\n * gained that module in 1.4.0, and the shipped `dispatch` CLI, the dispatchd\n * sidecar and the MCP server are single-file binaries compiled with the Bun\n * pinned in `.prototools`. Loading `node:sqlite` under Bun therefore worked on\n * a developer machine with a newer Bun on PATH and threw \"No such built-in\n * module: node:sqlite\" in every released binary, taking `dispatch migrate` and\n * every database-backed project with it. Keying off `process.versions.bun`\n * rather than off a probe means the choice does not silently drift back the\n * day the pinned Bun is bumped.\n */\ndeclare function sqliteDriver(): SqliteDriver;\n/**\n * Bumped whenever the DDL below changes in a way an existing database has to\n * be migrated through. Stored in SQLite's own `user_version` pragma, so the\n * schema carries its version without a table of its own.\n */\ndeclare const DISPATCH_DB_VERSION = 4;\n/**\n * Where a project's database lives by default.\n *\n * Note this is inside the project repo, which is the convenient default for\n * a single-project daemon but not the end state: the storage-spine plan moves\n * the database (and the git receipt log beside it) out to\n * `~/.dispatch/projects/<id>/` so orchestration state stops churning project\n * diffs. Every caller passes an explicit path, so moving it is a one-line\n * change at the call site rather than a change here.\n */\ndeclare function dispatchDbPath(rootDir: string): string;\n/**\n * Opens (creating if needed) a dispatch database and brings its schema up to\n * date. Callers hold the returned handle for the life of the process; the\n * store classes below each take one rather than opening their own, so all of\n * them see the same transaction and the same WAL.\n *\n * A database stamped with a version this build does not understand is\n * rejected rather than opened; see the check below.\n *\n * There are deliberately no foreign keys between findings/ledger rows and\n * tasks: today's JSONL sidecars keep a finding after its task file is deleted,\n * and a schema that silently cascaded those away would lose review history the\n * file-backed store still has.\n */\n/**\n * Opens a dispatch database only if one is already there, returning null when\n * it is not. This is the read-side counterpart of openDispatchDb: attaching to\n * a project must not bring a database (plus its -wal and -shm files) into\n * existence, the same way constructing a `TaskStore` does not create\n * `.dispatch/tasks`. Without it, listing tasks in a directory that never opted\n * in would litter the repo and make every project look initialized.\n */\ndeclare function attachDispatchDb(dbPath: string): SqliteDatabase | null;\ndeclare function openSqliteDb(dbPath: string): SqliteDatabase;\ndeclare function openDispatchDb(dbPath: string): SqliteDatabase;\ndeclare function queryAll<Row>(db: SqliteDatabase, sql: string, params?: SqlValue[]): Row[];\ndeclare function queryOne<Row>(db: SqliteDatabase, sql: string, params?: SqlValue[]): Row | undefined;\n/** The schema version an already-open database was last written with. */\ndeclare function dbVersion(db: SqliteDatabase): number;\n/**\n * A row this build cannot read: a JSON column that will not parse, an enum\n * column holding a value outside its set. Distinct from \"no such row\" so a\n * caller can tell a missing task from a damaged one.\n *\n * Damaged rows are surfaced, never coerced. A `blocked_by` that read as `[]`\n * would silently un-block a task; a `writes` that read as `[]` would erase a\n * task's declared write scope; an `applies_to` that read as `[]` would\n * broadcast a ledger entry aimed at one task to every task under its epic.\n * The file backend throws a TaskParseError in exactly these situations, and\n * listSafe() is the seam that turns one bad record into a skip rather than a\n * failed scan.\n */\ndeclare class SqliteRowError extends Error {\n  readonly table: string;\n  readonly rowId: string;\n  readonly column: string;\n  constructor(table: string, rowId: string, column: string, detail: string);\n}\n//#endregion\n//#region src/commentStore.d.ts\n/** A fresh comment id: `c-` plus 8 hex characters. */\ndeclare function generateCommentId(): string;\n/**\n * The file backend's comments: `.dispatch/comments/<taskId>.jsonl`, one\n * comment per line, oldest first. A task's file is rewritten whole on each\n * write, so it stays small, diffable and committable like the task files.\n */\ndeclare class FileCommentStore implements CommentStorePort {\n  readonly rootDir: string;\n  readonly dir: string;\n  constructor(rootDir: string);\n  private file;\n  list(taskId: string): TaskComment[];\n  private write;\n  get(taskId: string, id: string): TaskComment | null;\n  add(input: AddCommentInput, now?: string): TaskComment;\n  update(taskId: string, id: string, patch: CommentPatch, now?: string): TaskComment;\n  remove(taskId: string, id: string): string[];\n}\n/** The database backend's comments: the `comments` table. */\ndeclare class SqliteCommentStore implements CommentStorePort {\n  private readonly db;\n  constructor(db: SqliteDatabase);\n  list(taskId: string): TaskComment[];\n  get(taskId: string, id: string): TaskComment | null;\n  add(input: AddCommentInput, now?: string): TaskComment;\n  update(taskId: string, id: string, patch: CommentPatch, now?: string): TaskComment;\n  remove(taskId: string, id: string): string[];\n}\n//#endregion\n//#region src/sqliteRecords.d.ts\ndeclare class SqliteFindingStore {\n  private readonly db;\n  private readonly generateId;\n  constructor(db: SqliteDatabase, generateId?: (now: string) => string);\n  get(id: string): Finding | null;\n  list(filter?: FindingListFilter): Finding[];\n  private rows;\n  /**\n   * The same scan as list(), but a row this build cannot read is collected as\n   * an error instead of aborting the scan — the seam SqliteTaskStore.listSafe\n   * already has, for the same reason: one damaged row must not make every\n   * read of this table fail.\n   *\n   * Deliberately NOT the default. `list()`, `get()` and `openFor()` still\n   * throw, because their callers include the merge gate: `openFor` answers\n   * \"what is still blocking this task\", and a read that quietly returned\n   * FEWER blockers than the table holds would let work merge past a finding\n   * that was supposed to stop it. Failing loudly is the safe direction there.\n   * This variant is for the read-only surfaces — listing findings in the UI,\n   * and reporting damage in `dispatch doctor` — where the alternative to a\n   * partial answer is no answer at all.\n   */\n  listSafe(filter?: FindingListFilter): {\n    records: Finding[];\n    errors: ListSafeError[];\n  };\n  /** The findings still blocking a task's fix loop. */\n  openFor(taskId: string): Finding[];\n  add(input: AddFindingInput, now?: string): Finding;\n  /**\n   * Imports an already-formed finding verbatim, keeping the id and stamps it\n   * arrived with instead of minting new ones the way add() does. Used by the\n   * one-time import of `.dispatch/findings.jsonl`, where a finding's id is\n   * already referenced by task activity and by fix-loop state.\n   *\n   * Returns false when a row already holds that id, which is what makes the\n   * import re-runnable: a second pass adds nothing rather than replacing a\n   * record the daemon has since ruled on.\n   */\n  put(record: Finding): boolean;\n  update(id: string, patch: FindingUpdatePatch, now?: string): Finding;\n}\ndeclare class SqliteLedgerStore {\n  private readonly db;\n  private readonly generateId;\n  constructor(db: SqliteDatabase, generateId?: (now: string) => string);\n  add(input: AddLedgerInput, now?: string): LedgerEntry;\n  /**\n   * Imports an already-formed ledger entry verbatim — the ledger half of\n   * SqliteFindingStore.put(), and there for the same reason: `.dispatch/\n   * ledger.jsonl` entries carry ids and timestamps that later tasks quote, so\n   * an import has to keep them rather than mint fresh ones.\n   */\n  put(record: LedgerEntry): boolean;\n  get(id: string): LedgerEntry | null;\n  list(filter?: LedgerListFilter): LedgerEntry[];\n  /**\n   * The skip-and-report counterpart of list() — see the note on\n   * SqliteFindingStore.listSafe for why this is a separate method rather than\n   * the default. `entriesFor()` in particular keeps throwing: it feeds the\n   * constraints and hazards injected into a dispatched task's prompt, and an\n   * agent silently briefed with fewer constraints than the ledger holds is\n   * worse than one whose dispatch fails.\n   */\n  listSafe(filter?: LedgerListFilter): {\n    records: LedgerEntry[];\n    errors: ListSafeError[];\n  };\n  private rows;\n  /**\n   * What a dispatched task should see: entries aimed at it directly, plus\n   * untargeted entries scoped to its epic or project-wide (epicId null).\n   *\n   * `appliesTo` is a JSON array column, so the membership half is filtered in\n   * TypeScript; the volumes involved are a project's ledger, not a log.\n   */\n  entriesFor(taskId: string, epicId: string | null): LedgerEntry[];\n}\ndeclare class SqliteEvidenceStore {\n  private readonly db;\n  constructor(db: SqliteDatabase);\n  addCommand(runId: string, evidence: CommandEvidence): CommandEvidence;\n  addMutation(runId: string, mutation: MutationEvidence): MutationEvidence;\n  /**\n   * Every run this database holds evidence for, commands and mutations\n   * together, oldest first.\n   *\n   * The receipt exporter needs this because it writes one file per run and has\n   * no other way to learn which runs exist — nothing in this database owns\n   * runs, so `run_id` is only ever an opaque key arriving from the\n   * orchestrator. Ordered by each run's earliest stamp rather than by id so\n   * the exported file list reads chronologically.\n   */\n  runIds(): string[];\n  commandsFor(runId: string): CommandEvidence[];\n  mutationsFor(runId: string): MutationEvidence[];\n}\n//#endregion\n//#region src/storeBackend.d.ts\ntype TaskStoreBackend = 'files' | 'sqlite';\n/**\n * The record stores that only exist on the database backend. On `files` these\n * are still the daemon's own JSONL sidecars (packages/server's FindingStore\n * and LedgerStore) plus each run's transcript, which core has no handle on —\n * hence `records: null` there rather than a second set of classes here.\n *\n * Also null on `sqlite` when the project has no database yet: there is nothing\n * to read and nowhere to write until something initializes one.\n */\ninterface SqliteRecordStores {\n  db: SqliteDatabase;\n  findings: SqliteFindingStore;\n  ledger: SqliteLedgerStore;\n  evidence: SqliteEvidenceStore;\n  comments: SqliteCommentStore;\n}\ninterface ProjectStores {\n  backend: TaskStoreBackend;\n  tasks: TaskStorePort;\n  records: SqliteRecordStores | null;\n  /** Releases the database handle; a no-op on the file backend. */\n  close(): void;\n}\ninterface OpenStoresOptions {\n  rootDir: string;\n  /** Defaults to `files`, which is what every caller does today. */\n  backend?: TaskStoreBackend;\n  /** Ignored unless `backend` is `sqlite`; defaults to `dispatchDbPath()`. */\n  dbPath?: string;\n  /** How new task ids are minted, on `sqlite`. A synced board passes\n   *  generateSyncedTaskId for longer ids (see ids.ts); absent is the default\n   *  six-character generator. */\n  generateTaskId?: (kind: TaskKind, title: string, now: string) => string;\n}\n/**\n * Attaches to a project's existing state without creating anything.\n *\n * This holds on both backends, and it has to: `new TaskStore(rootDir)` does\n * not create `.dispatch/tasks`, so attaching to a database must not bring\n * `dispatch.db` (plus its `-wal` and `-shm` companions) into a repo either.\n * A project with nothing there reads as uninitialized — `isInitialized()` is\n * false, lists come back empty, and writes refuse — rather than as an empty\n * project that quietly answers every question with a default.\n */\ndeclare function openProjectStores(options: OpenStoresOptions): ProjectStores;\n/** Creates a project's state if it is missing, then attaches to it. */\ndeclare function initProjectStores(options: OpenStoresOptions): ProjectStores;\n//#endregion\n//#region src/taskfile.d.ts\ndeclare class TaskParseError extends Error {\n  readonly file?: string | undefined;\n  constructor(message: string, file?: string | undefined);\n}\ndeclare function parseTaskFile(content: string, file?: string): TaskDoc;\ndeclare function serializeTaskFile(doc: TaskDoc): string;\ndeclare function splitSections(body: string): {\n  preamble: string;\n  sections: {\n    heading: string;\n    content: string;\n  }[];\n};\n/**\n * Reads the text under a `## <heading>` section, trimmed. The read counterpart\n * of `setSection`; `''` when the heading is absent or has nothing under it.\n */\ndeclare function getSection(body: string, heading: string): string;\n/**\n * Replaces a `## <heading>` section's text, preserving the other sections and\n * their order; inserts a missing heading before `## Activity` (or appends it).\n */\ndeclare function setSection(body: string, heading: string, content: string): string;\n/**\n * Appends an activity bullet. Assumes `## Activity` is the LAST section of the\n * body (the store's create template guarantees this).\n */\ndeclare function appendActivity(body: string, line: string, actor?: string): string;\n/**\n * Removes a `## <heading>` section entirely, heading included — unlike\n * `setSection(body, heading, '')`, which leaves an empty heading in place.\n */\ndeclare function removeSection(body: string, heading: string): string;\ninterface Amendment {\n  date: string;\n  reason: string;\n  overrides: string;\n  source: string | null;\n}\n/**\n * Appends a new amendment to the `## Amendments` section, keeping every prior\n * one — corrections accumulate rather than overwrite a task's history.\n */\ndeclare function appendAmendment(body: string, amendment: Amendment): string;\n//#endregion\n//#region src/store.d.ts\ndeclare const DISPATCH_DIR = \".dispatch\";\ndeclare function attachmentsDir(rootDir: string, taskId: string): string;\ninterface CreateInput {\n  title: string;\n  kind?: TaskKindInput;\n  status?: string;\n  description?: string;\n  parent?: string | null;\n  milestone?: string | null;\n  blockedBy?: string[];\n  labels?: string[];\n  priority?: Priority;\n  assignee?: Assignee;\n  selfReview?: boolean;\n  fixLoop?: boolean;\n  writes?: string[];\n  risk?: TaskRisk;\n  model?: string | null;\n  derivedFrom?: string;\n  estimate?: number | null;\n  dueDate?: string | null;\n  startDate?: string | null;\n  cycle?: TaskCycle | null;\n  relatedTo?: string[];\n  duplicateOf?: string | null;\n  initiatives?: string[];\n  color?: string | null;\n  icon?: string | null;\n  sortOrder?: number | null;\n  /** Who is creating it, as an actor ref. */\n  creator?: Assignee | null;\n  /** The id in an external tracker (`linear:<uuid>`), linked from the start. */\n  external?: string | null;\n  /** When it was really created, for an import; defaults to `now`. */\n  created?: string;\n}\ninterface UpdatePatch {\n  title?: string;\n  status?: string;\n  parent?: string | null;\n  milestone?: string | null;\n  blockedBy?: string[];\n  labels?: string[];\n  priority?: Priority;\n  assignee?: Assignee;\n  selfReview?: boolean;\n  fixLoop?: boolean;\n  writes?: string[];\n  risk?: TaskRisk;\n  model?: string | null;\n  external?: string | null;\n  kind?: TaskKind;\n  estimate?: number | null;\n  dueDate?: string | null;\n  startDate?: string | null;\n  cycle?: TaskCycle | null;\n  relatedTo?: string[];\n  duplicateOf?: string | null;\n  initiatives?: string[];\n  color?: string | null;\n  icon?: string | null;\n  sortOrder?: number | null;\n  /** Who created it; a tracker sync backfills it from the remote record. */\n  creator?: Assignee | null;\n  archivedAt?: string | null;\n  exercised?: boolean;\n  attachments?: TaskAttachment[];\n  appendActivity?: string;\n  activityActor?: string;\n  description?: string;\n  acceptanceCriteria?: string;\n  body?: string;\n}\ninterface ListFilter {\n  status?: string;\n  kind?: TaskKindInput;\n  parent?: string;\n}\ninterface ListSafeError {\n  file: string;\n  message: string;\n}\ninterface ListSafeResult {\n  docs: TaskDoc[];\n  errors: ListSafeError[];\n}\n/**\n * The backend-neutral task surface, extracted so a second backend can sit\n * behind it: `TaskStore` (markdown files under `.dispatch/tasks`) and\n * `SqliteTaskStore` (a single daemon-owned database) both satisfy it, and\n * picking between them is a construction-time choice — see\n * `openProjectStores` in storeBackend.ts.\n *\n * Filesystem-only members are deliberately left off: `tasksDir` and\n * `taskFilePath` have no answer in a database-backed project, so a caller\n * that needs a path on disk has to hold a concrete `TaskStore`, not a port.\n */\ninterface TaskStorePort {\n  readonly rootDir: string;\n  isInitialized(): boolean;\n  create(input: CreateInput, now?: string): TaskDoc;\n  get(id: string): TaskDoc | null;\n  list(filter?: ListFilter): TaskDoc[];\n  listSafe(filter?: ListFilter): ListSafeResult;\n  update(id: string, patch: UpdatePatch, now?: string): TaskDoc;\n  amend(id: string, input: Omit<Amendment, 'date'>, now?: string): TaskDoc;\n  remove(id: string): boolean;\n}\n/**\n * The TaskDoc a freshly created task starts as — every default in one place.\n *\n * Shared by both backends rather than written out twice. The defaults here\n * (`status: 'todo'`, `priority: 'none'`, `selfReview: false`, the absent-vs-\n * false handling of `fixLoop`, the body template) ARE the contract for what a\n * new task looks like, so a copy per backend is a copy that can drift — and a\n * task created against one backend would quietly differ from the same task\n * created against the other.\n *\n * Pure: the caller supplies the id, since minting one is the part the two\n * backends genuinely do differently (a filename probe versus an insert that\n * may lose a race).\n */\ndeclare function newTaskDoc(id: string, kind: TaskKind, input: CreateInput, now: string): TaskDoc;\n/**\n * Applies an `UpdatePatch` to an existing doc, producing the next one.\n *\n * The other half of the create/update contract both backends have to agree\n * on: which patch keys target the markdown body rather than the frontmatter,\n * that `undefined` means \"leave alone\" while `null` on `archivedAt` means\n * \"clear\", and that a whole-body replacement is the base later section edits\n * apply to. Shared for the same reason as `newTaskDoc` — this is behaviour,\n * not plumbing, and two copies of it can disagree.\n *\n * Pure: persisting the result is the caller's job.\n */\ndeclare function applyUpdatePatch(doc: TaskDoc, patch: UpdatePatch, now: string): TaskDoc;\ndeclare function ensureProjectConfig(rootDir: string): void;\n/**\n * Writes (or tops up) `.dispatch/.gitignore` so a project never commits the\n * state the daemon owns.\n *\n * Additive, never a rewrite: an existing file keeps everything in it and only\n * gains the rules it is missing. A user who pinned an extra path here, or\n * deliberately un-ignored one of ours by deleting the line, would otherwise\n * have that undone on the next `dispatch init` — and silently, since nothing\n * about running init suggests it edits files you already have.\n *\n * A group is appended only when one of its RULES is missing, never because its\n * comment is: a project that moves to the database has the machine-local rules\n * already, and re-appending their explanation every time would grow a comment\n * block on every init.\n */\ndeclare function ensureProjectGitignore(rootDir: string, backend: TaskStoreBackend): void;\ndeclare class TaskStore implements TaskStorePort {\n  readonly rootDir: string;\n  readonly tasksDir: string;\n  private fileIndex;\n  constructor(rootDir: string);\n  static init(rootDir: string): TaskStore;\n  isInitialized(): boolean;\n  create(input: CreateInput, now?: string): TaskDoc;\n  private idTaken;\n  private scan;\n  get(id: string): TaskDoc | null;\n  list(filter?: ListFilter): TaskDoc[];\n  listSafe(filter?: ListFilter): ListSafeResult;\n  private filterAndSort;\n  update(id: string, patch: UpdatePatch, now?: string): TaskDoc;\n  amend(id: string, input: Omit<Amendment, 'date'>, now?: string): TaskDoc;\n  remove(id: string): boolean;\n  taskFilePath(id: string): string | null;\n}\n//#endregion\n//#region src/untrusted.d.ts\ndeclare function untrustedInline(text: string): string;\ndeclare function untrustedBlock(text: string): string;\ndeclare function untrustedFenced(label: string, text: string): string;\ndeclare function untrustedVerbatim(label: string, text: string): string;\n//#endregion\nexport { sqliteDriver as $, isFloorCheck as $i, parseExternal as $n, QueueConfig as $r, DocStatus as $t, SqliteRecordStores as A, CommentStorePort as Aa, DEFAULT_POLICY as Ai, summarizeSubagents as An, EXECUTOR_PRICING_FIELDS as Ar, RunStep as At, DISPATCH_DB_VERSION as B, POLICY_GATE_MODES as Bi, LinearLabel as Bn, FixLoopConfig as Br, DocLink as Bt, parseTaskFile as C, handleFromEmail as Ca, ReadinessLevel as Ci, SubagentStatus as Cn, DEFAULT_RECEIPTS_BRANCH as Cr, FINDING_VERDICTS as Ct, splitSections as D, upsertMember as Da, UNBLOCKING_HALF_VALUE as Di, foldSubagents as Dn, EFFORT_LEVELS as Dr, FindingSeverity as Dt, setSection as E, serializeTeam as Ea, ScoredTask as Ei, flattenSubagentTree as En, DispatchConfig as Er, FindingRecommendation as Et, SqliteFindingStore as F, GATE_RUNGS as Fi, LinearEntity as Fn, ExecutorConfig as Fr, DOC_STATUSES as Ft, SqliteStatement as G, PolicyRuling as Gi, LinearProjectStatus as Gn, MemoryConfig as Gr, DocProposal as Gt, SqliteDatabase as H, PolicyConfig as Hi, LinearProject as Hn, LinearConfig as Hr, DocNamespace as Ht, SqliteLedgerStore as I, IRREVERSIBILITY_FLOOR as Ii, LinearInitiative as In, ExecutorModels as Ir, DocConflict as It, dispatchDbPath as J, consultFloor as Ji, LinearTruncatedField as Jn, NOTIFICATION_KINDS as Jr, DocRecord as Jt, attachDispatchDb as K, PolicyRungDef as Ki, LinearRef as Kn, MessagingConfig as Kr, DocProposalView as Kt, FileCommentStore as L, MAX_POLICY_RUNG as Li, LinearInitiativeInput as Ln, ExecutorPricing as Lr, DocFileMeta as Lt, initProjectStores as M, commentInputError as Ma, FloorCheck as Mi, LINEAR_EXTERNAL_PREFIX as Mn, EffortLevel as Mr, runStepFromEntry as Mt, openProjectStores as N, commentThreadIds as Na, FloorCheckDef as Ni, LinearAttachment as Nn, EscalationStep as Nr, ASSET_NAME as Nt, OpenStoresOptions as O, AddCommentInput as Oa, isQueueWeight as Oi, nestSubagents as On, EFFORT_ROLES as Or, FindingUpdatePatch as Ot, SqliteEvidenceStore as P, compareComments as Pa, FloorRuling as Pi, LinearComment as Pn, ExecutorCommand as Pr, DOCS_LIMITS as Pt, queryOne as Q, effectiveRung as Qi, linearExternal as Qn, PreviewConfig as Qr, DocScope as Qt, SqliteCommentStore as R, MIN_POLICY_RUNG as Ri, LinearIssue as Rn, FIX_MODEL_TIERS as Rr, DocHead as Rt, getSection as S, describeDroppedEntry as Sa, RankOptions as Si, SubagentSourceEntry as Sn, DEFAULT_RECEIPTS as Sr, FINDING_SEVERITIES as St, serializeTaskFile as T, parseTeamReport as Ta, ScoreFactorKey as Ti, SubagentTreeNode as Tn, DEFAULT_SYNC as Tr, FindingListFilter as Tt, SqliteDriver as U, PolicyGate as Ui, LinearProjectInput as Un, MAX_CONCURRENCY_HARD_CAP as Ur, DocOp as Ut, SqlValue as V, POLICY_RUNGS as Vi, LinearMilestoneInput as Vn, LINEAR_DIRECTIONS as Vr, DocLinking as Vt, SqliteRowError as W, PolicyGateMode as Wi, LinearProjectMilestone as Wn, MODEL_ROLES as Wr, DocOutlineEntry as Wt, openSqliteDb as X, describeFloorHold as Xi, LinearWorkflowState as Xn, NotificationsConfig as Xr, DocSaveResult as Xt, openDispatchDb as Y, consultPolicy as Yi, LinearUser as Yn, NotificationKind as Yr, DocRevisionInfo as Yt, queryAll as Z, describePolicyAuthorization as Zi, externalId as Zn, OrchestratorConfig as Zr, DocSaveStatus as Zt, newTaskDoc as _, resolvePeople as _a, DEFAULT_QUEUE_WEIGHTS as _i, parseDocFile as _n, DEFAULT_MEMORY as _r, LedgerEntry as _t, CreateInput as a, isLabelColor as aa, StatusEntryInput as ai, LinkTarget as an, A2AConfig as ar, ActorRefError as at, appendActivity as b, TeamMember as ba, QueueFactorInfo as bi, SubagentEvent as bn, DEFAULT_NOTIFICATIONS as br, AddFindingInput as bt, ListSafeError as c, labelRef as ca, VerifyStep as ci, RESERVED_DOC_SLUGS as cn, CARTO_MODES as cr, isValidAssignee as ct, TaskStorePort as d, UNRESOLVED_LINEAR_ASSIGNEE as da, isMaskedSecretUrl as di, docBodyProblem as dn, ConfigPatch as dr, schedulableBatch as dt, ATTACHMENTS_DIR as ea, QueueWeightsResult as ei, DocSummary as en, parseLinearExternal as er, isOutstanding as et, UpdatePatch as f, UNRESOLVED_LINEAR_PERSON as fa, notificationKindForMessage as fi, docSlug as fn, DEFAULT_A2A as fr, tasksConflict as ft, ensureProjectGitignore as g, personFor as ga, AGE_HORIZON_DAYS as gi, normalizeDocText as gn, DEFAULT_LINEAR as gr, LEDGER_KINDS as gt, ensureProjectConfig as h, personError as ha, queueWeights as hi, jsonEscapedBytes as hn, DEFAULT_FIX_LOOP as hr, AddLedgerInput as ht, untrustedVerbatim as i, LabelDefinition as ia, SECRET_URL_MASK_SUFFIX as ii, LinkRel as in, resolveWorkflowState as ir, ActorRef as it, TaskStoreBackend as j, TaskComment as ja, FLOOR_CHECKS as ji, DEFAULT_STATUS_MAP as jn, EffortConfig as jr, RunStepEntry as jt, ProjectStores as k, CommentPatch as ka, rankTasks as ki, nextSubagentStatus as kn, EXECUTOR_MODEL_ROLES as kr, FindingVerdict as kt, ListSafeResult as l, withLabelColor as la, executorModels as li, RevisionCause as ln, CartoConfig as lr, parseActorRef as lt, attachmentsDir as m, fanoutHolder as ma, projectPolicy as mi, docTitleProblem as mn, DEFAULT_EXECUTOR_NAME as mr, MutationEvidence as mt, untrustedFenced as n, attachmentRelativePath as na, RemoteConfig as ni, LINK_RELS as nn, priorityToLinear as nr, slugify as nt, DISPATCH_DIR as o, labelColorIndex as oa, SyncConfig as oi, LinkTargetType as on, A2ASkill as or, UNASSIGNED as ot, applyUpdatePatch as p, canonicalAssignee as pa, previewSettings as pi, docSlugProblem as pn, DEFAULT_CARTO as pr, CommandEvidence as pt, dbVersion as q, RISK_RUNG_CAPS as qi, LinearRelation as qn, ModelConfig as qr, DocRead as qt, untrustedInline as r, sanitizeAttachmentName as ra, RepoDigestConfig as ri, LINK_TARGET_TYPES as rn, resolveConflict as rr, ActorKind as rt, ListFilter as s, labelDefinitionError as sa, VerifyConfig as si, ProposalState as sn, A2A_SKILLS as sr, formatActorRef as st, untrustedBlock as t, ATTACHMENT_MAX_BYTES as ta, ReceiptsConfig as ti, DocsHealth as tn, priorityFromLinear as tr, describeValue as tt, TaskStore as u, Person as ua, isEffortLevel as ui, assetNames as un, CartoMode as ur, claimConflictsWithWrites as ut, Amendment as v, DroppedEntry as va, QUEUE_FACTORS as vi, renderDocFile as vn, DEFAULT_MESSAGING as vr, LedgerKind as vt, removeSection as w, parseTeam as wa, ScoreFactor as wi, SubagentSummary as wn, DEFAULT_REPO_DIGEST as wr, Finding as wt, appendAmendment as x, TeamParseError as xa, QueueWeights as xi, SubagentNode as xn, DEFAULT_PREVIEW as xr, FINDING_RECOMMENDATIONS as xt, TaskParseError as y, MAX_HANDLE_BYTES as ya, QUEUE_FACTOR_KEYS as yi, rewriteAssetLinks as yn, DEFAULT_MODELS as yr, LedgerListFilter as yt, generateCommentId as z, POLICY_GATES as zi, LinearIssueInput as zn, FIX_STRATEGIES as zr, DocHit as zt };\n//# sourceMappingURL=untrusted-DJNiucEX.d.ts.map"],"mappings":"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"}