@ordewell/core 0.10.12 → 0.11.1

package/dist/{Task-CfBM0wkV.d.ts → Task-BL4Idm9r.d.ts}

@@ -1,3 +1,254 @@
+/** Advice to the reader of how much a finding matters; it never reaches the verdict. */
+type FindingSeverity = 'blocker' | 'major' | 'minor' | 'info';
+/** A severity as a surface labels it, so both task views word it the same. */
+declare const SEVERITY_LABEL: Record<FindingSeverity, string>;
+declare function severityLabel(severity: FindingSeverity): string;
+/** The worst severity among `findings`, or null for none: what a compact row says at a glance. */
+declare function worstSeverity(findings: readonly Pick<HandoffFinding, 'severity'>[]): FindingSeverity | null;
+/**
+ * A typed reference a reader can check rather than trust. A `task` names the
+ * task by id once the call is accepted, and `finding` one of its findings.
+ * `resolved` is read-time metadata: the author cannot vouch for resolution,
+ * so the completion schema strips it and the saved handoff carries no check.
+ */
+type HandoffEvidence = {
+    kind: 'file';
+    path: string;
+    line?: number;
+    resolved?: boolean;
+} | {
+    kind: 'commit';
+    sha: string;
+    repo?: string;
+    resolved?: boolean;
+} | {
+    kind: 'task';
+    task: string;
+    finding?: string;
+} | {
+    kind: 'url';
+    url: string;
+};
+/**
+ * What a saved patch does not carry as the task's worktree held it
+ * (ADR-0050): `excluded`, a symbolic link or a submodule, never carried;
+ * `dropped`, a file whose part of the patch was over the size cap;
+ * `normalized`, a file git converts on the way in (its text, eol, filter or
+ * encoding attributes), whose bytes in the patch differ from the file the
+ * task left. `paths` names the first few; `count` is all of them.
+ */
+interface PatchFlag {
+    kind: 'excluded' | 'dropped' | 'normalized';
+    count: number;
+    paths: string[];
+}
+/**
+ * A read-only task's prototype, saved with `save_patch` (ADR-0050): the patch
+ * Ordewell keeps beside the attempt's log, and what is in it. Only Ordewell
+ * adds one, never the author: the completion call's artifacts are the other
+ * four kinds.
+ */
+interface HandoffPatch {
+    kind: 'patch';
+    /** The patch file, relative to the workspace root. */
+    path: string;
+    /** The attempt that saved it, beside whose log it is kept. */
+    attempt: number;
+    /** The commit it was taken against, where it applies as it is. */
+    base: string;
+    files: number;
+    /** Lines added and removed, binary files counting none. */
+    added: number;
+    removed: number;
+    /** Of {@link files}, those whose change is binary. */
+    binary: number;
+    bytes: number;
+    /** The SHA-256 of the patch file's bytes, hex: what `apply_patch` checks the file against before it applies it. */
+    sha256: string;
+    flags?: PatchFlag[];
+}
+/** What a task produced: the four kinds of evidence, or a patch Ordewell saved for it. */
+type HandoffArtifact = HandoffEvidence | HandoffPatch;
+interface HandoffFinding {
+    /** `F1` … `Fn`, assigned by Ordewell in the order the author gave them. */
+    id: string;
+    severity: FindingSeverity;
+    title: string;
+    detail?: string;
+    evidence?: HandoffEvidence[];
+}
+/**
+ * A change task's commit message, as its author wrote it for a human
+ * reviewer: what changed and why. The summary is for the next agent.
+ */
+interface HandoffCommit {
+    subject: string;
+    body?: string;
+}
+/** What the plan keeps on a task: enough for a surface or a dependent's prompt without reading a log. */
+interface HandoffDigest {
+    commit?: HandoffCommit;
+    summary: string;
+    /** The first {@link DIGEST_FINDINGS} findings; the rest are in the attempt's log. */
+    findings: HandoffFinding[];
+    findingCount: number;
+    artifacts?: HandoffArtifact[];
+}
+/** The whole handoff, as the attempt's log keeps it. */
+interface StoredHandoff extends HandoffDigest {
+    report?: string;
+}
+/** A handoff as its author sends it, before Ordewell numbers the findings. */
+interface Handoff {
+    /** How the attempt ended, as the call said: a commit counts only with `done`. */
+    status?: 'done' | 'blocked' | 'failed';
+    commit?: HandoffCommit;
+    summary: string;
+    findings?: Omit<HandoffFinding, 'id'>[];
+    artifacts?: HandoffArtifact[];
+    report?: string;
+}
+/** The most a report keeps: whole findings fit, and a runaway one does not bloat the files that hold it. */
+declare const REPORT_MAX_CHARS = 20000;
+/**
+ * What a `task_complete` call may hand over. A call past one is refused, not
+ * cut: an author who is told learns, one cut silently does not.
+ */
+declare const HANDOFF_LIMITS: {
+    readonly summary: 1500;
+    readonly commitSubject: 100;
+    readonly commitBody: 500;
+    readonly findings: 50;
+    readonly title: 200;
+    readonly detail: 2000;
+    readonly reference: 2000;
+    readonly evidence: 10;
+    readonly artifacts: 20;
+    readonly report: 20000;
+};
+/** Findings the plan's digest keeps of a handoff. */
+declare const DIGEST_FINDINGS = 25;
+/** The handoff a call stated, its findings numbered in the author's order; undefined when it stated nothing. */
+declare function storedHandoff(handoff: Handoff): StoredHandoff | undefined;
+/**
+ * A handoff that also names the patch its attempt saved (ADR-0050).
+ * Ordewell adds it, past the author's own artifacts and their limit, and an
+ * attempt that ended without a completion call still hands it on.
+ */
+declare function withPatch(handoff: StoredHandoff | undefined, patch: HandoffPatch): StoredHandoff;
+/** The patch a handoff names, if its attempt saved one (ADR-0050). */
+declare function savedPatchOf(handoff: HandoffDigest | undefined): HandoffPatch | undefined;
+/** What the plan keeps of a handoff: no report, and at most {@link DIGEST_FINDINGS} findings. */
+declare function handoffDigest(handoff: StoredHandoff): HandoffDigest;
+/** How a task is named in a handoff's text: the plan's reference for its id, or the id where the plan has none. */
+type HandoffTaskName = (taskId: string) => string | undefined;
+/** A handoff with the tasks it cites named by their references in `plan`, as a reader names them. */
+declare function namedHandoff<H extends HandoffDigest>(plan: readonly Task[], handoff: H): H;
+/** A typed reference as a reader says it: `src/a.ts:42`, `commit abc`, `task #2 F1`, a URL, a saved patch. */
+declare function handoffReferenceText(ref: HandoffArtifact, taskName?: HandoffTaskName): string;
+/** A size as a reader takes it in: bytes, KB or MB. */
+declare function byteSize(bytes: number): string;
+/** One flag of a saved patch as text: what it is, how many, and the paths it names. */
+declare function patchFlagText(flag: PatchFlag): string;
+/** What a saved patch changes, once: files, binary files, lines and size (ADR-0050). */
+declare function patchChangesText(patch: HandoffPatch): string;
+/** The same without the size, for a row that already names the patch and has little room (ADR-0050). */
+declare function patchLinesText(patch: HandoffPatch): string;
+/** A saved patch as one line: where, how big, from which commit, and its flags (ADR-0050). */
+declare function patchText(patch: HandoffPatch): string;
+/**
+ * A saved patch as a preview block (ADR-0050): what it changes and the commit
+ * it applies to, the file to open, and every path it left out. The compact
+ * surfaces say it in one line with `patchText`; this is for a task's handoff,
+ * where there is room for the flags.
+ */
+declare function patchLines(patch: HandoffPatch): string[];
+/**
+ * A saved patch as every surface shows it (ADR-0050): what was saved, the
+ * files and lines it changes, where the file is, and what it left out. Each
+ * surface paints these words and offers its own way to open the file; none of
+ * them works out a count, a size or a flag for itself.
+ */
+interface PatchView {
+    /** The patch file, relative to the workspace root: what a surface opens. */
+    path: string;
+    /** "attempt 1". */
+    attempt: string;
+    /** "3 files, 1 binary, +42 -7, 1.5 KB". */
+    changes: string;
+    /** "from commit abc123def456". */
+    base: string;
+    /** "saved as <path> (attempt 1)": the fact it was saved, and the file to open. */
+    saved: string;
+    /** One line per flag: what it left out, how many and which paths; empty when it left out nothing. */
+    flags: string[];
+    /** The compact row's part: "patch: 3 files, 1 binary, +42 -7". */
+    peek: string;
+}
+/** One saved patch, worded once for every surface. */
+declare function patchView(patch: HandoffPatch): PatchView;
+/** Every patch a handoff names, in the order Ordewell added them. */
+declare function savedPatchViews(handoff: HandoffDigest | undefined): PatchView[];
+/** The patch a handoff names, as a surface shows it; null when it names none. */
+declare function savedPatchView(handoff: HandoffDigest | undefined): PatchView | null;
+/** One finding as text: its id, severity and title, then its detail and evidence under it. */
+declare function findingLines(f: HandoffFinding, taskName?: HandoffTaskName): string[];
+/** A handoff's artifacts as one line, or none when it lists none. */
+declare function artifactLines(handoff: HandoffDigest, taskName?: HandoffTaskName): string[];
+/** A handoff's opening as text: its commit, subject then body, then the summary. */
+declare function openingLines(handoff: HandoffDigest): string[];
+/** Each pushed handoff's text ceiling, excluding artifacts (ADR-0047). */
+declare const HANDOFF_PUSH_CHARS = 4000;
+/** Shared push rendering: reserve the closing pointer before accepting each whole finding. */
+declare function boundedHandoffLines(handoff: HandoffDigest, omission: (more: number) => string, taskName?: HandoffTaskName, footer?: string): string[];
+interface HandoffPreviewOptions {
+    /** How many findings to list; the rest are counted. Default: every finding the digest holds. */
+    maxFindings?: number;
+    /** How to name a task a reference cites; the plan's reference when given. */
+    taskName?: HandoffTaskName;
+}
+/**
+ * A handoff as a compact surface prints it (ADR-0047): the commit, the summary, each
+ * finding's title line (`F1 [blocker] Title`), how many the digest left out,
+ * and the artifacts. The detail and evidence stay in the attempt's log.
+ */
+declare function handoffPreviewLines(handoff: HandoffDigest, options?: HandoffPreviewOptions): string[];
+/**
+ * A handoff as a wake-up carries it (ADR-0029, ADR-0037): the commit and
+ * summary, its findings whole within the shared ceiling, how many are left
+ * out, and the artifacts. The report is never pushed; it waits in the attempt's log.
+ */
+declare function handoffWakeLines(handoff: HandoffDigest, taskName?: HandoffTaskName): string[];
+/**
+ * A handoff as text, for a reader with no structure to render it from: the
+ * commit and summary, every finding it holds with its id, severity, detail
+ * and evidence, how many the digest left out, the artifacts, and the report
+ * when it has one.
+ */
+declare function handoffLines(handoff: HandoffDigest | StoredHandoff, taskName?: HandoffTaskName): string[];
+/**
+ * The tasks whose handoffs `taskId` may cite and read (ADR-0047): itself, its
+ * transitive dependencies, and its loop's other end — a check its body tasks,
+ * a body task its check (ADR-0045). The plan's own graph scopes the reach.
+ */
+declare function readableTaskIds(plan: readonly Task[], taskId: string): Set<string>;
+type HandoffCheck<H> = {
+    ok: true;
+    handoff: H;
+} | {
+    ok: false;
+    refusal: string;
+};
+/**
+ * Check the references a handoff makes, at the call (ADR-0047): a `task`
+ * must be one the producer may read and a finding of it one that exists, and
+ * a `url` must be http or https, so no surface renders a `javascript:` link.
+ * A `file` or `commit` is a claim about a tree Ordewell may not see, so it is
+ * taken as given. An accepted handoff names each task by its id, which a
+ * later edit of the plan does not renumber.
+ */
+declare function checkHandoff<H extends Handoff>(handoff: H, producerId: string, plan: readonly Task[]): HandoffCheck<H>;
+
 interface TaskDiffRead {
     repo?: string;
     path?: string;
@@ -34,6 +285,63 @@ type IsolationAvailability = {
     reason: IsolationInactiveReason;
     repos?: string[];
 };
+/**
+ * What a repository's HEAD is. `unborn` is a repository with no commit yet,
+ * on `branch`; `unknown` is one git could not be asked about.
+ */
+type RepoHead = {
+    kind: 'branch';
+    branch: string;
+    commit: string;
+} | {
+    kind: 'detached';
+    commit: string;
+} | {
+    kind: 'unborn';
+    branch?: string;
+} | {
+    kind: 'unknown';
+};
+/** One repository of the group, as it is right now. */
+interface PreviewRepo {
+    /** Relative to the workspace, as everywhere else: `.` for a workspace that is in one repository. */
+    path: string;
+    head: RepoHead;
+    /** Whether tracked files differ from HEAD; absent when not inspected (isolation is off or git is missing). */
+    dirty?: boolean;
+    /** Only for the lone repository: the workspace-relative path of its top level when the workspace is below it, such as `..`. */
+    top?: string;
+}
+/**
+ * What a current look at a workspace says about isolation, for a surface that
+ * shows it before any run (ADR-0013, ADR-0014). Every status but `failed`
+ * answers as `isActive` would for the same workspace, so the two cannot
+ * disagree; only `isActive` at run start is authoritative, and the base
+ * branch a run forks from is read again then.
+ *
+ * - `ready`: code tasks get isolated worktrees from `repos`. A repo with no
+ *   commit yet is listed with an `unborn` head and shared instead.
+ * - `dirty`: as `ready` once the start-time decision (stash, or run without
+ *   isolation) is made; `repos` marks the ones with `dirty`.
+ * - `disabled`, `git-missing`, `no-commits`: code tasks run in the workspace.
+ * - `no-repo`: nothing in the workspace is a repository (`repos` is empty).
+ * - `failed`: git could not be read; says nothing about whether there is a
+ *   repository. `error` is the reason.
+ *
+ * Ops and script tasks use the user's checkout whatever the status.
+ */
+interface IsolationPreview {
+    status: 'ready' | 'dirty' | 'disabled' | 'git-missing' | 'no-repo' | 'no-commits' | 'failed';
+    repos: PreviewRepo[];
+    /** What every task would share live, as `IsolationAvailability.shared` names it; empty unless `ready` or `dirty`. */
+    shared: string[];
+    error?: string;
+}
+/** The read-only look at a workspace's isolation: starts no run and changes nothing in any repository. */
+interface IIsolationPreview {
+    /** Never rejects: a failed inspection is a `failed` preview. */
+    preview(workspaceRoot: string): Promise<IsolationPreview>;
+}
 /**
  * Where a run's tasks work, as the planner is told it: the repos of the group
  * and the paths shared live between tasks. A lone repository is `['.']` with
@@ -105,6 +413,13 @@ interface IsolationTaskRecord {
      * so a stale reason cannot outlive the failure it explains.
      */
     landingError?: string;
+    /**
+     * The commit the task's done handoff stated, kept from the landing that
+     * first brought it: what Ordewell's own commits for the task are written
+     * from (ADR-0013), a repair's merge and every later landing included,
+     * though a repair's handoff states none.
+     */
+    commit?: HandoffCommit;
     /** Repo-relative paths, in `conflictRepo`, that conflicted; set only while `status` is `conflict` or `repairing`. */
     conflictFiles?: string[];
     /**
@@ -123,6 +438,12 @@ interface IsolationTaskRecord {
      * names it in a group of one, prefixed with its repo's path in a group.
      */
     repairedFiles?: string[];
+    /**
+     * A read-only task's (ADR-0046): never integrated, and removed whole
+     * whenever it is released, whatever its worktrees hold, with nothing kept
+     * on a branch and no git run inside them.
+     */
+    readOnly?: true;
     /**
      * Set once the task's landed work is in the checked-out HEAD of every repo
      * it changed — merged into the user's branch, by Merge all or by hand — or
@@ -273,7 +594,7 @@ type IsolationMergeBlockReason = 'merge-in-progress' | 'conflict' | 'uncommitted
 interface IsolationMergeBlock {
     repo: string;
     reason: IsolationMergeBlockReason;
-    /** The files that would conflict, or the user's uncommitted ones the merge also changes; empty for the other reasons. */
+    /** The files that would conflict, or the user's uncommitted ones the merge would change or stand in the way of; empty for the other reasons. */
     files: string[];
     /** `wrong-branch` only: the branch the run started on. */
     expected?: string;
@@ -292,6 +613,9 @@ interface IsolationMergeBlock {
  *   which cannot preflight, or for a reason no preflight could foresee. That
  *   merge was aborted, leaving `repo` as it was; `landed` names the repos
  *   merged before it, which stay merged, and is absent when there are none.
+ *   A `failed` merge git itself refused carries the first line it said as
+ *   `error`; one that never started, for a merge of the user's already in
+ *   progress, carries none.
  *
  * A group of one is blocked only by a partial landing or by being on the wrong
  * branch; otherwise its one merge lands or is aborted whole, so it reports as
@@ -307,6 +631,7 @@ type IsolationMergeResult = {
     repo: string;
     files?: string[];
     landed?: string[];
+    error?: string;
 };
 /**
  * What `discard` does with each repo's integration branch: `keep` it for review
@@ -437,8 +762,13 @@ interface IWorktreeIsolation {
      * the Runner into. Fresh attempts start clean from the tips. A `restore`
      * puts the previous attempt's preserved work on top of them, falling back
      * to the tips in every repo when any restoration conflicts (ADR-0018).
+     * `readOnly` marks the record as a read-only task's (ADR-0046). A failure
+     * after the last attempt was replaced throws `PrepareFailedError`, naming
+     * the work that was kept on branches as that attempt's record went.
      */
-    prepare(task: Task, run: IsolationRun, intent?: PrepareIntent): Promise<PreparedTask>;
+    prepare(task: Task, run: IsolationRun, intent?: PrepareIntent, opts?: {
+        readOnly?: boolean;
+    }): Promise<PreparedTask>;
     /**
      * Hand a conflicted task's kept workspace to a conflict repair (ADR-0015)
      * as it is — nothing is re-cut — and return the same cwd. Records each
@@ -463,13 +793,19 @@ interface IWorktreeIsolation {
      * tasks waiting at once the lowest plan order goes first. On anything but
      * `merged` the worktrees and refs stay, and nothing is resolved here: a
      * conflict is repaired, if at all, by a new attempt of the task in its own
-     * worktree (ADR-0015), never inside this queue.
+     * worktree (ADR-0015), never inside this queue. A read-only task's record
+     * is never merged: it is `failed` (ADR-0046).
      *
      * `persist` is called once `run.landing` is set and before the first
      * merge; the caller saves the run there, synchronously, which is what
      * lets `pruneOrphans` finish a landing a crash interrupted.
+     *
+     * `commit`, the one the task's done handoff stated, is kept on the record,
+     * and what Ordewell commits and merges for the task is written from it;
+     * without one, the record's earlier commit, else the task title. A commit
+     * the runner made is never rewritten.
      */
-    integrate(task: Task, run: IsolationRun, persist?: () => void): Promise<IsolationOutcome>;
+    integrate(task: Task, run: IsolationRun, persist?: () => void, commit?: HandoffCommit): Promise<IsolationOutcome>;
     /**
      * `keep: false` removes the task's worktree, branch and record (retry, task
      * removal), keeping whatever had not landed on a branch first; a record
@@ -477,9 +813,10 @@ interface IWorktreeIsolation {
      * worktree and branch exactly as they are
      * for inspection — a failed verdict, a stop, a cancel — and only moves the task off `active`,
      * so a crash-recovery prune does not sweep it away; a repair it ends leaves
-     * the task `conflict`, as it was before the repair. Takes the run rather than
-     * a bare task id: ids are only unique within one plan, and one daemon serves
-     * many (ADR-0025 D2).
+     * the task `conflict`, as it was before the repair. A read-only task's
+     * record goes whole either way, with nothing kept (ADR-0046). Takes the run
+     * rather than a bare task id: ids are only unique within one plan, and one
+     * daemon serves many (ADR-0025 D2).
      */
     release(run: IsolationRun, taskId: string, opts: {
         keep: boolean;
@@ -677,6 +1014,18 @@ declare function isMeasured(totals: UsageTotals): boolean;
 interface ContextFill {
     usedTokens: number;
     windowTokens?: number;
+    /**
+     * Why an API planner's automatic compaction (ADR-0002) is not running for
+     * its model, as it stood when the meter was sent: the settings file turns it
+     * off, or no catalog states the model's window. Absent while it runs, and on
+     * a harness planner, whose agent compacts its own context.
+     */
+    autoCompaction?: {
+        off: 'settings';
+    } | {
+        off: 'unknown_window';
+        model: string;
+    };
 }
 /** What the usage line draws of a ledger — live from its broadcast, or reloaded from the saved one. */
 interface UsageLine {
@@ -768,9 +1117,9 @@ declare function taskUsageSummary(task: Pick<UsageTask, 'attemptUsage'>): TaskUs
 declare function formatTokenCount(n: number): string;
 /** Two decimals from 1 up and up to four below it: a call can cost a fraction of a cent, a session several dollars. */
 declare function formatCost(currency: string, amount: number): string;
-/** `ctx 61k (6%)`, `ctx 61k` while the window is unknown, nothing before a call was measured. */
+/** `ctx 61k (6%)`, `ctx 61k` while the window is unknown, nothing before a call was measured; `· no auto-compact` when automatic compaction is not running. */
 declare function contextMeterText(fill: ContextFill | undefined): string | null;
-/** Exact counts for the meter's hover. */
+/** Exact counts for the meter's hover, and why automatic compaction is not running, where it is not. */
 declare function contextMeterTitle(fill: ContextFill): string;
 /** The cost per currency as reported, joined by ` · `; null when none was reported. */
 declare function costText(totals: UsageTotals): string | null;
@@ -818,7 +1167,30 @@ type ExecutionActor = {
  | {
     kind: 'autorun';
 };
-type ExecutionCommandName = 'run_plan' | 'run_task' | 'stop_task' | 'stop_run' | 'retry_task' | 'message_task' | 'answer_approval' | 'merge_all' | 'skip_task' | 'force_start' | 'mark_complete' | 'mark_not_done' | 'interrupt_task' | 'force_send_queued' | 'remove_queued' | 'cancel_resume' | 'answer_checkpoint' | 'approve_review';
+type ExecutionCommandName = 'run_plan' | 'run_task' | 'stop_task' | 'stop_run' | 'retry_task' | 'message_task' | 'answer_approval' | 'merge_all' | 'skip_task' | 'force_start' | 'mark_complete' | 'mark_not_done' | 'interrupt_task' | 'force_send_queued' | 'remove_queued' | 'cancel_resume' | 'answer_checkpoint' | 'approve_review' | 'run_script';
+/**
+ * How the user consented to the script a `run_script` call ran (ADR-0035):
+ * on the approval card, by an effect allowlist rule (by name), by autorun in
+ * Full, or by choosing Act for the supervisor.
+ */
+type ScriptConsent = {
+    by: 'card';
+} | {
+    by: 'allowlist';
+    rule: string;
+} | {
+    by: 'autorun';
+} | {
+    by: 'act';
+};
+/**
+ * Where a `run_script` call's task stood as the call answered, or as it ended
+ * later: `passed` and `failed` are its verdict, `changed-files` a pass that left
+ * a tracked change waiting on the user, `stopped` an attempt ended with no
+ * verdict, `running` one still under way after a minute, and `gated` one
+ * waiting at its merge gate.
+ */
+type ScriptResult = 'passed' | 'failed' | 'changed-files' | 'stopped' | 'running' | 'gated';
 /**
  * One call at the command seam as the timeline keeps it: what was asked, by
  * whom, about which task, and how it ended — done, refused by the seam, or
@@ -838,10 +1210,16 @@ interface ExecutionRecord {
     outcome: 'done' | 'refused' | 'declined';
     /** The refusal, the message sent, or the note a denial carried. */
     detail?: string;
+    /** `run_script`: how the script was consented to, once it was. */
+    consent?: ScriptConsent;
+    /** `run_script`: where its task stood; one that answered before its end gets a record of that end too. */
+    result?: ScriptResult;
+    /** `run_script`: the record of that end, kept once the task ended after the call answered. */
+    ended?: true;
     at: string;
 }
 
-declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec", "improve-codebase-architecture", "tdd"];
+declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec", "improve-codebase-architecture", "tdd", "diagnose", "explore"];
 interface SkillMetadata {
     name: string;
     description: string;
@@ -904,6 +1282,12 @@ declare class SkillsService {
     /** A seed the user never edited: safe to replace with a newer built-in. */
     private isUntouchedSeed;
     private seed;
+    /**
+     * A built-in read where it ships, for a home that cannot hold the seed. It is
+     * reported as `global` because that is the precedence a built-in has — it
+     * still shadows a workspace copy of the same name.
+     */
+    private packagedBuiltin;
     seedBuiltinSkill(name: string): boolean;
     /** Removes a retired built-in's seed from the global dir, but only if it's untouched by the user. */
     private isUnmodifiedRetiredSeed;
@@ -919,7 +1303,12 @@ declare class SkillsService {
      * workspace folders the first read wins, the same way.
      */
     private catalog;
-    /** Inspect installed skills without seeding, refreshing or pruning global files. */
+    /**
+     * Inspect installed skills without seeding, refreshing or pruning global
+     * files. A built-in that is not seeded here still ships with Ordewell, so it
+     * is listed at global precedence: this is the catalog the planner uses even
+     * on a home that cannot hold the seeds.
+     */
     readCatalog(): SkillCatalog;
     getSkillContent(name: string): string | undefined;
 }
@@ -931,6 +1320,50 @@ declare class SkillsService {
  */
 declare function createSkillsService(workspaceRoot?: string, workspaceRepos?: readonly string[]): SkillsService;
 
+/** How many times a loop's check runs when the loop sets no `maxRounds`. */
+declare const DEFAULT_LOOP_ROUNDS = 3;
+/** The most rounds a loop may set: past it, the fix is not converging, and a person should look. */
+declare const MAX_LOOP_ROUNDS = 10;
+interface TaskLoop {
+    /** The top-level tasks, by id, that run to fix what the check found. */
+    body: string[];
+    /** The most times the check runs in one set of rounds. */
+    maxRounds: number;
+}
+/** What the loop rules read of a task; structural, so a surface's own task shape answers them too. */
+interface LoopSubject {
+    id: string;
+    status: string;
+    loop?: TaskLoop;
+    /** The round of the check's latest run; absent is round 1. */
+    loopRound?: number;
+    verdict?: {
+        outcome: string;
+        reported?: string;
+    };
+}
+/** The round of a check's latest run, or the one it is running. */
+declare function loopRoundOf(check: Pick<LoopSubject, 'loopRound'>): number;
+/**
+ * A check between rounds (ADR-0045 L3): it found the work wanting with rounds
+ * left, so its body is fixing what it found and it runs again once the fix
+ * has landed. Its stored status stays `failed`; this is what keeps that from
+ * counting as a failure.
+ */
+declare function betweenRounds(check: LoopSubject): boolean;
+/** A check that found the work wanting in its last round: the loop is over, and the check failed. */
+declare function outOfRounds(check: LoopSubject): boolean;
+/** The check whose loop has `taskId` in its body, if any. */
+declare function checkOf<T extends Pick<LoopSubject, 'loop'>>(tasks: readonly T[], taskId: string): T | undefined;
+/** Whether a task is a loop's check or in a loop's body. */
+declare function inLoop(tasks: readonly Pick<LoopSubject, 'id' | 'loop'>[], task: Pick<LoopSubject, 'id' | 'loop'>): boolean;
+/**
+ * Why a task may not be removed while it is a loop's check: its body would
+ * be left as tasks that run whatever happens. Removing a body task takes it
+ * out of its loop instead (ADR-0045 L8). Null when the removal may go ahead.
+ */
+declare function loopRemovalRefusal(task: Pick<Task, 'title' | 'loop'>): string | null;
+
 /**
  * The loop guards of an Act supervisor (ADR-0029): pure checks that stop it
  * spinning. Each answers with the trip — the note the model is refused with,
@@ -962,6 +1395,16 @@ interface AttemptShape {
     runner: string;
     model: string | null;
     effort: string | null;
+    /**
+     * A script task's body and time limit, read as a prompt is (ADR-0035):
+     * what runs is all a script's retry could change. Absent for any other task,
+     * and from a shape saved before script tasks.
+     */
+    script?: {
+        commands: readonly (readonly string[])[] | null;
+        script: string | null;
+        timeoutMs: number;
+    };
 }
 /**
  * What the loop guards remember as plain data, saved on the plan so a daemon
@@ -998,8 +1441,13 @@ interface EditMemory {
  * When the supervisor wakes during a run, and what it is told (#27). Only an
  * attention event wakes it; passes ride along as context. It keeps no clock:
  * the host stamps each event and polls on its own tick.
+ *
+ * `task_report` is a task addressed to the planner ending: one whose result a
+ * planner turn asked for and did not get before it answered (ADR-0037, R2).
+ * It is batched as any attention event is, and wakes the planner whatever the
+ * supervisor's level, since the planner asked for it.
  */
-type RunEventKind = 'task_passed' | 'task_failed' | 'waiting_input' | 'waiting_approval' | 'task_idle' | 'landing_conflict' | 'usage_limit' | 'auto_merge_stopped' | 'run_finished';
+type RunEventKind = 'task_passed' | 'task_failed' | 'waiting_input' | 'waiting_approval' | 'task_idle' | 'landing_conflict' | 'usage_limit' | 'auto_merge_stopped' | 'run_finished' | 'task_report';
 type RunEvent = {
     kind: RunEventKind;
     taskId?: string;
@@ -1012,7 +1460,17 @@ type RunEvent = {
     resumeAt?: string | null;
     /** `usage_limit` in a batch: every task the runner's limit paused in it, in arrival order. */
     taskIds?: string[];
+    /** `task_report` only: the result the planner asked for. */
+    report?: TaskReportEvent;
 };
+interface TaskReportEvent {
+    /** Whose turn started the task: the turn the report opens acts with its authority (ADR-0037, R3). */
+    authority: TurnAuthority;
+    /** Its verdict and the tail of its output, as the planner reads them: never cut to a digest line. */
+    text: string;
+    /** It passed: a pass, as far as the wake-up rate is concerned. */
+    passed: boolean;
+}
 /** What the policy holds before its next wake-up, for the plan (ADR-0029). */
 interface WakePolicySnapshot {
     /** Attention events inside the debounce window, in arrival order. */
@@ -1039,9 +1497,12 @@ interface UserStep {
     instruction: string;
     completed: boolean;
 }
-/** One deterministic signal gathered while verifying a completed task. `completion_marker` is only in verdicts saved before completion was reported through `task_complete` alone. */
+/**
+ * One deterministic signal gathered while verifying a completed task. `completion_marker` is only in verdicts saved before completion was reported through `task_complete` alone.
+ * `script_exit` is a script task's exit status, its one evidence (ADR-0035).
+ */
 interface VerificationCheck {
-    name: 'exit_code' | 'completion_marker' | 'task_complete' | 'manual';
+    name: 'exit_code' | 'completion_marker' | 'task_complete' | 'manual' | 'script_exit';
     passed: boolean;
     /** A check that did not apply. Skipped checks don't affect the verdict. */
     skipped: boolean;
@@ -1053,6 +1514,15 @@ interface Verdict {
     reason: string;
     checks: VerificationCheck[];
     decidedAt: string;
+    /**
+     * What the attempt's evidence said of the work: the status the runner's
+     * `task_complete` call reported, or a script's exit read the same way —
+     * `done` on exit 0, `failed` on a non-zero exit, a signal or its time limit,
+     * `blocked` when it could not start. A loop starts a round only on `failed`
+     * (ADR-0045 L2). Absent when nothing reported: a runner that exited without
+     * the call, Mark complete, a stopped script, a verdict saved before it was kept.
+     */
+    reported?: 'done' | 'failed' | 'blocked';
 }
 interface TaskOutputSummary {
     reviewReason: string;
@@ -1062,7 +1532,8 @@ interface TaskOutputSummary {
     logTail: string;
     capturedAt: string;
 }
-type TaskType = 'ai' | 'user';
+/** `script` is an ops task whose body Ordewell runs with no model (ADR-0035). */
+type TaskType = 'ai' | 'user' | 'script';
 /**
  * `skipped` is terminal and verdict-less: the task will not be waited for, and
  * nothing it did lands. Its dependents go ahead without it once the work it
@@ -1120,6 +1591,13 @@ interface Task {
     subtasks: Task[];
     verdict?: Verdict;
     outputSummary?: TaskOutputSummary;
+    /**
+     * The latest attempt's handoff, as the plan keeps it (ADR-0047): its
+     * summary, first findings and artifacts. The whole handoff, report and all,
+     * is in that attempt's log. Absent when the attempt handed none over, and
+     * on a plan saved before handoffs, which reads `outputSummary` instead.
+     */
+    handoff?: HandoffDigest;
     assignedModel?: TaskModelAssignment;
     assignedRunner: RunnerId;
     taskMode?: TaskMode;
@@ -1156,9 +1634,14 @@ interface Task {
      * An ops task (ADR-0020): it changes no repository files, runs at the
      * workspace root rather than in a worktree, and waits for the change tasks
      * it depends on to be merged into the user's branch. Top-level AI tasks
-     * only; absent means a change task.
+     * only; absent means a change task. A script task is one by nature and
+     * stores none (see {@link runsAsOps}).
      */
     ops?: boolean;
+    /** A top-level read-only AI task whose report returns to the planner (ADR-0037 R1). */
+    research?: boolean;
+    /** A retry still owes research's report under its original authority (ADR-0037 R3). */
+    researchOrigin?: TaskReportTo;
     /**
      * The dependencies, by title, whose work was not merged into the user's
      * branch when the user force-started this task past its merge gate
@@ -1179,8 +1662,56 @@ interface Task {
      * counts as approved to run (ADR-0029). Set by the session, never by an op.
      */
     addedBy?: 'supervisor';
+    /**
+     * An attempt of it has started, so its chat exists from then on: kept after
+     * a failure, a cancel, a skip or a completion, and restored with the plan.
+     * Set by the attempt's own start — never by a status or a manual mark.
+     */
+    attempted?: true;
     attemptUsage?: AttemptUsage[];
+    /**
+     * A script task's body (ADR-0035), exactly one of these two: argument
+     * vectors run in order with no shell, stopping at the first that fails, or
+     * one script run by the research shell's interpreter.
+     */
+    commands?: string[][];
+    script?: string;
+    /** A script task's time limit; absent means ten minutes (`DEFAULT_SCRIPT_TIMEOUT_MS`). */
+    timeoutMs?: number;
+    /** Set on a loop's check (ADR-0045): the tasks that fix what it finds, and how many times it may run. */
+    loop?: TaskLoop;
+    /**
+     * The round of a loop's check's latest run, or the one it is running;
+     * absent is round 1. Execution state, saved so a reload resumes mid-round,
+     * and started over by a retry of the check (ADR-0045 L5, L7).
+     */
+    loopRound?: number;
+    /**
+     * A planner turn waits for this task's result (ADR-0037, R2): set when the
+     * tool that started it answered before it ended, or when research lands.
+     * Cleared once its end is reported, in a turn acting for whoever started it (R3).
+     */
+    reportTo?: TaskReportTo;
 }
+/**
+ * Who started a task whose result is owed to the planner (ADR-0037, R3): a
+ * planner turn in the user's conversation, or the supervisor, at its level
+ * then, with script consent (ADR-0035) or the research profile (ADR-0037 R4).
+ */
+type TaskReportTo = ({
+    consent: ScriptConsent;
+    research?: never;
+} | {
+    research: true;
+    consent?: never;
+}) & ({
+    actor: 'planner-turn';
+} | {
+    actor: 'supervisor';
+    level: SupervisorLevel;
+});
+/** Whose authority a turn opened without the user acts with (ADR-0037, R3): the user's turn, or the supervisor's. */
+type TurnAuthority = 'user' | 'supervisor';
 type ResearchToolType = 'read_file' | 'read_files' | 'glob' | 'grep' | 'find_symbol' | 'list_dir' | 'bash' | 'fetch' | 'web_search' | 'spawn_research_agent' | 'task_query' | 'task_output' | 'task_diff'
 /**
  * A tool belonging to a harness planner's own toolbox (ADR-0009) that has no
@@ -1239,7 +1770,7 @@ interface SubagentLogEntry {
 }
 type ResearchLogEntry = ResearchStep | UserPromptEntry | SubagentLogEntry;
 interface ResearchProgress {
-    type: 'thinking' | 'tool_call' | 'tool_result' | 'plan_token' | 'interrupted' | 'liveness' | 'text_delta' | 'text_retracted' | 'usage' | 'subagent_started' | 'subagent_finished';
+    type: 'thinking' | 'tool_call' | 'tool_result' | 'plan_token' | 'interrupted' | 'liveness' | 'text_delta' | 'text_retracted' | 'usage' | 'subagent_started' | 'subagent_finished' | 'compaction';
     /** Minted by whoever runs the turn and passed through untouched; absent outside a turn. */
     turnId?: string;
     /** One continuous run of model text — text before a tool call is its own segment. */
@@ -1264,6 +1795,7 @@ interface ResearchProgress {
     outcome?: SubagentOutcome;
     digest?: string;
     usage?: UsageTotals;
+    compaction?: PlannerCompaction;
 }
 interface DiscoveredModel {
     modelId: string;
@@ -1293,9 +1825,12 @@ interface DiscoveredModel {
     /**
      * The model's context window when the runner or catalog reports it (#49).
      * Read by the planner-model lookup so context fill can be shown; absent when
-     * unknown rather than defaulted to zero.
+     * unknown rather than defaulted to zero. Gemini's is its `inputTokenLimit`:
+     * the prompt alone, the reply limited by `maxOutputTokens` apart from it.
      */
     contextWindow?: number;
+    /** The longest reply the catalog says the model is served with, when it says. */
+    maxOutputTokens?: number;
 }
 type PlanStatus = 'draft' | 'approved' | 'rejected' | 'running' | 'completed';
 /**
@@ -1312,8 +1847,8 @@ interface ConversationMessage {
      * Timeline marker: 'plan_generated' records the point in the dialogue where
      * the plan was committed (the UI anchors the plan card there on restore);
      * 'system' is a host-injected notice; 'compaction' is the summary a
-     * user-triggered compaction left in place of the earlier messages — always
-     * the transcript's first entry. 'skill_load' is a skill loaded into the
+     * compaction appended, which stands in for the earlier messages in the
+     * planner's context while the transcript keeps them (see `checkpoint`). 'skill_load' is a skill loaded into the
      * conversation, its snapshot in `skill`; one the user invoked follows the
      * message that named it. 'execution' is a call at the command seam
      * (ADR-0029), its record in `execution`. 'wake_up' is the digest a wake-up
@@ -1333,6 +1868,13 @@ interface ConversationMessage {
     execution?: ExecutionRecord;
     /** A user's message that was force sent, stopping the turn before it (ADR-0023). */
     forced?: true;
+    /**
+     * Set on a 'compaction' entry that is a checkpoint of the planner's context
+     * (ADR-0002). A 'compaction' entry without one is a legacy summary when it
+     * stands first — it replaced what it condensed — and a marker drawn but
+     * never replayed anywhere else.
+     */
+    checkpoint?: ContextCheckpoint;
     /**
      * What a reply showed, run by run, where each began (ADR-0017 A1). Beside
      * `content`, which stays the reply as the planner is told it. Absent on
@@ -1340,6 +1882,50 @@ interface ConversationMessage {
      */
     runs?: ReplyRun[];
 }
+/**
+ * Where a compaction cut the planner's context (ADR-0002): its summary stands
+ * for every transcript entry before `keptFrom`, and the entries from there on
+ * replay verbatim. Entries are only appended, or inserted at a held turn's
+ * position, which no checkpoint's cut passes, so the index never moves.
+ */
+interface ContextCheckpoint {
+    /** Stable across saves, forks and the wire, so a surface can tell this checkpoint from another with the same text. */
+    id: string;
+    /** An index into the whole transcript, at or before the checkpoint entry itself. */
+    keptFrom: number;
+    trigger: 'manual' | 'auto';
+}
+/**
+ * How a planner compaction ended. `condensed`: a summary stands in for the
+ * older context (a checkpoint was written, or a harness planner reported its
+ * own compaction done). `pruned`: older recoverable tool output was dropped
+ * from the live context alone. `unchanged`: nothing needed doing. `paused`:
+ * the context could not be brought to fit, so the planner waits.
+ */
+type PlannerCompactionOutcome = 'condensed' | 'pruned' | 'unchanged' | 'stopped' | 'failed' | 'paused';
+/**
+ * One planner compaction's lifecycle as it was observed (ADR-0017): both
+ * phases share `id`, which is the checkpoint's id when one is written. Only
+ * Ordewell's own compaction announces a start; a harness planner's native one
+ * is reported when it is over, and nothing invents the start it never sent.
+ * Sizes are only ever what a backend reported.
+ */
+type PlannerCompaction = {
+    phase: 'started';
+    id: string;
+    origin: 'ordewell';
+    trigger: ContextCheckpoint['trigger'];
+    at: string;
+} | {
+    phase: 'ended';
+    id: string;
+    origin: 'ordewell' | 'native';
+    trigger: ContextCheckpoint['trigger'];
+    outcome: PlannerCompactionOutcome;
+    at: string;
+    preTokens?: number;
+    postTokens?: number;
+};
 /**
  * One run of a planner reply's text: the segment it streamed under, its
  * settled text, and when it began. A run that never streamed (a message the
@@ -1403,6 +1989,12 @@ interface PendingPlanTurn {
     skills?: SkillLoad[];
     /** Force sent: it waits ahead of every input not forced, and its turn is its own (ADR-0023, F2). */
     forced?: true;
+    /**
+     * A supervisor input carrying a report the planner asked for (ADR-0037, R2),
+     * which opens a turn at every supervisor level: `user` for a task started in
+     * the user's turn, which the turn then acts as (R3).
+     */
+    report?: TurnAuthority;
 }
 /**
  * The run's own copy of the user's run settings (ADR-0030): taken when the
@@ -1441,7 +2033,35 @@ interface PlannerResendState {
     runner?: RunnerId;
     at?: string;
 }
+/**
+ * The planner paused on its context (ADR-0002): an API planner's call could
+ * not be brought inside its model's window, so the turn ended with nothing
+ * landed and the planner waits for the user's Retry compaction. What it
+ * keeps is bounded: the inputs stay in `pendingTurns`, and only the calls
+ * that changed something are listed, never the live context itself.
+ */
+interface PlannerContextPause {
+    /** The model the call did not fit. */
+    model: string;
+    at: string;
+    /** What the user is told: why it paused, and what Retry compaction does. */
+    reason: string;
+    /** The pending inputs the paused turn took: a retry answers these, and what arrived since waits for the turn after it. */
+    inputs: string[];
+    /**
+     * The calls the paused turn made that changed something or reached out,
+     * each with the head of what it returned (`effectLedger`). It is never
+     * replayed to the planner as a note: it is what lets a retry see that a
+     * turn which ran effects cannot start again from the transcript, and what
+     * the refusal lists for the user.
+     */
+    done?: string[];
+    /** More such calls ran than `done` keeps: the refusal could not list all of them, and a retry without the live context stays refused. */
+    doneTruncated?: true;
+}
 interface LegacyPlanState {
+    /** Research profiles the planner approved as they landed: lifting one withdraws its approval (ADR-0037 R4). */
+    researchApprovals?: string[];
     runSettings?: RunSettings;
     /** What supervision remembers across a daemon restart (ADR-0029); absent on plans saved before it existed. */
     supervision?: SupervisionSnapshot;
@@ -1466,12 +2086,21 @@ interface LegacyPlanState {
      * must leave it behind rather than share it.
      */
     isolation?: PlanIsolation;
+    /**
+     * The id of the plan's last isolated run, which closed with everything it
+     * landed merged into the user's branch; absent once a later run decides how
+     * it executes. With no run record left, it is what tells a Merge all asked
+     * for after that run from one in a plan that never isolated (ADR-0029).
+     */
+    mergedRun?: string;
     /** Kept so a reopened session shows the same token line (#49). */
     plannerUsage?: PlannerUsage;
     /** The windows reported over the session, so a reopened one knows each model's from its first call. */
     contextWindows?: ReportedWindow[];
     /** The planner hit its usage limit and the inputs its turn took wait to be sent again; absent otherwise. */
     plannerResend?: PlannerResendState;
+    /** The planner's context could not fit its model's window: its turn's inputs wait for Retry compaction; absent otherwise. */
+    plannerContextPause?: PlannerContextPause;
     /**
      * The tasks the user approved to run: every task when they executed the
      * plan, and each one they started or retried themselves since. A command
@@ -1555,11 +2184,12 @@ declare function pausedOnLimit(task: Readonly<Task>): boolean;
 /** The user's approval record, as a plan carries it (ADR-0029). */
 type ApprovalRecord = Pick<LegacyPlanState, 'approved' | 'approvedTasks'>;
 /**
- * A task the scheduler leaves for the user (ADR-0035): an AI task not started
- * yet, in a plan they approved, outside their approval record — the planner
- * added it since. It starts once they start it or execute the plan. In a plan
- * they never approved nothing is theirs yet, so nothing is singled out.
+ * A task the scheduler leaves for the user (ADR-0035): an AI or script task
+ * not started yet, in a plan they approved, outside their approval record —
+ * the planner added it since, or changed a script's body. It starts once they
+ * start it or execute the plan. In a plan they never approved nothing is
+ * theirs yet, so nothing is singled out.
  */
 declare function waitsForApproval(task: Pick<Task, 'id' | 'type' | 'status'>, record: ApprovalRecord): boolean;
 
-export { type RepoGroupLayout as $, type ApprovalRecord as A, BUILTIN_SKILL_NAMES as B, type ContextFill as C, DEFAULT_RUNNERS as D, type ExecutionActor as E, type IsolationTaskRef as F, type GuardTarget as G, type IsolationTaskRepo as H, type IWorktreeIsolation as I, type IsolationTaskStatus as J, type IsolationView as K, type LegacyPlanState as L, type ModelUsage as M, type PlanIsolation as N, type PlanState as O, type PendingPlanTurn as P, type PlanStatus as Q, type PlanUsage as R, type PlannerResendState as S, type PlannerUsage as T, type PrepareIntent as U, type PreparedTask as V, type PreservedWork as W, type PreviousWork as X, type RefusedRemoval as Y, type RepairEvidence as Z, type ReplyRun as _, type AttemptUsage as a, pausedOnLimit as a$, type ReportedWindow as a0, type ResearchLogEntry as a1, type ResearchProgress as a2, type ResearchStep as a3, type ResearchStepOutcome as a4, type ResearchToolType as a5, type RunSettings as a6, type RunnerId as a7, type RunnerSessionCost as a8, type SessionBilling as a9, type UsageTotals as aA, type Verdict as aB, type VerificationCheck as aC, addAttemptUsage as aD, addModelUsage as aE, addPlannerUsage as aF, addUsage as aG, addUsageTotals as aH, contextMeterText as aI, contextMeterTitle as aJ, costText as aK, countedSessionCost as aL, createEmptyPlan as aM, createSkillsService as aN, createTask as aO, endAttemptUsage as aP, flattenTasks as aQ, flattenTasksWithParents as aR, formatCost as aS, formatTokenCount as aT, isAwaitingReason as aU, isMeasured as aV, isSupervisorLevel as aW, isUserMessage as aX, migratePlanState as aY, modelCostTitle as aZ, partedPromptUsage as a_, type SetupFailure as aa, type ShadowedSkill as ab, type SkillAppliesTo as ac, type SkillCatalog as ad, type SkillInfo as ae, type SkillLoad as af, type SkillLoadNotice as ag, type SkillMetadata as ah, type SkillSource as ai, SkillsService as aj, type SubagentOutcome as ak, type SupervisorLevel as al, type Task as am, type TaskDiffRead as an, type TaskDiffResult as ao, type TaskIsolation as ap, type TaskIsolationState as aq, type TaskModelAssignment as ar, type TaskSkillNotice as as, type TaskSkillSnapshot as at, type TaskSnapshot as au, type TaskStatus as av, type TaskUsageSummary as aw, type TreeSnapshot as ax, type UsageLine as ay, type UsageRecord as az, type AwaitingReason as b, planUsage as b0, plannerContextFill as b1, rejoinPlanTree as b2, resumedSessionWindow as b3, startAttemptUsage as b4, subagentCostTitle as b5, taskUsageSummary as b6, tasksTotalText as b7, usageLine as b8, usageText as b9, waitsForApproval as ba, type ConversationMessage as c, type CostProvenance as d, DEFAULT_SUPERVISOR_RETRY_LIMIT as e, type DiscoveredModel as f, type ExecutionCommandName as g, type ExecutionRecord as h, type GuardTrip as i, type IntegrationDisposal as j, type InvalidSkill as k, type IsolationAvailability as l, type IsolationHandoff as m, type IsolationHandoffRepo as n, type IsolationInactiveReason as o, type IsolationLandedTask as p, type IsolationLanding as q, type IsolationMergeBlock as r, type IsolationMergeBlockReason as s, type IsolationMergeResult as t, type IsolationOutcome as u, type IsolationPruneResult as v, type IsolationRemoval as w, type IsolationRepo as x, type IsolationRun as y, type IsolationTaskRecord as z };
+export { type IsolationTaskStatus as $, type ApprovalRecord as A, BUILTIN_SKILL_NAMES as B, type ContextCheckpoint as C, DEFAULT_LOOP_ROUNDS as D, type ExecutionActor as E, type FindingSeverity as F, type GuardTarget as G, HANDOFF_LIMITS as H, type IIsolationPreview as I, type IsolationAvailability as J, type IsolationHandoff as K, type IsolationHandoffRepo as L, type IsolationInactiveReason as M, type IsolationLandedTask as N, type IsolationLanding as O, type IsolationMergeBlock as P, type IsolationMergeBlockReason as Q, type IsolationMergeResult as R, type IsolationOutcome as S, type IsolationPreview as T, type IsolationPruneResult as U, type IsolationRemoval as V, type IsolationRepo as W, type IsolationRun as X, type IsolationTaskRecord as Y, type IsolationTaskRef as Z, type IsolationTaskRepo as _, type AttemptUsage as a, type TaskSkillSnapshot as a$, type IsolationView as a0, type LegacyPlanState as a1, type LoopSubject as a2, MAX_LOOP_ROUNDS as a3, type ModelUsage as a4, type PatchFlag as a5, type PatchView as a6, type PendingPlanTurn as a7, type PlanIsolation as a8, type PlanState as a9, type RunnerSessionCost as aA, SEVERITY_LABEL as aB, type ScriptConsent as aC, type ScriptResult as aD, type SessionBilling as aE, type SetupFailure as aF, type ShadowedSkill as aG, type SkillAppliesTo as aH, type SkillCatalog as aI, type SkillInfo as aJ, type SkillLoad as aK, type SkillLoadNotice as aL, type SkillMetadata as aM, type SkillSource as aN, SkillsService as aO, type StoredHandoff as aP, type SubagentOutcome as aQ, type SupervisorLevel as aR, type Task as aS, type TaskDiffRead as aT, type TaskDiffResult as aU, type TaskIsolation as aV, type TaskIsolationState as aW, type TaskLoop as aX, type TaskModelAssignment as aY, type TaskReportTo as aZ, type TaskSkillNotice as a_, type PlanStatus as aa, type PlanUsage as ab, type PlannerCompaction as ac, type PlannerCompactionOutcome as ad, type PlannerContextPause as ae, type PlannerResendState as af, type PlannerUsage as ag, type PrepareIntent as ah, type PreparedTask as ai, type PreservedWork as aj, type PreviewRepo as ak, type PreviousWork as al, REPORT_MAX_CHARS as am, type RefusedRemoval as an, type RepairEvidence as ao, type ReplyRun as ap, type RepoGroupLayout as aq, type RepoHead as ar, type ReportedWindow as as, type ResearchLogEntry as at, type ResearchProgress as au, type ResearchStep as av, type ResearchStepOutcome as aw, type ResearchToolType as ax, type RunSettings as ay, type RunnerId as az, type AwaitingReason as b, resumedSessionWindow as b$, type TaskSnapshot as b0, type TaskStatus as b1, type TaskType as b2, type TaskUsageSummary as b3, type TreeSnapshot as b4, type UsageLine as b5, type UsageRecord as b6, type UsageTotals as b7, type Verdict as b8, type VerificationCheck as b9, handoffPreviewLines as bA, handoffReferenceText as bB, handoffWakeLines as bC, inLoop as bD, isAwaitingReason as bE, isMeasured as bF, isSupervisorLevel as bG, isUserMessage as bH, loopRemovalRefusal as bI, loopRoundOf as bJ, migratePlanState as bK, modelCostTitle as bL, namedHandoff as bM, openingLines as bN, outOfRounds as bO, partedPromptUsage as bP, patchChangesText as bQ, patchFlagText as bR, patchLines as bS, patchLinesText as bT, patchText as bU, patchView as bV, pausedOnLimit as bW, planUsage as bX, plannerContextFill as bY, readableTaskIds as bZ, rejoinPlanTree as b_, addAttemptUsage as ba, addModelUsage as bb, addPlannerUsage as bc, addUsage as bd, addUsageTotals as be, artifactLines as bf, betweenRounds as bg, boundedHandoffLines as bh, byteSize as bi, checkHandoff as bj, checkOf as bk, contextMeterText as bl, contextMeterTitle as bm, costText as bn, countedSessionCost as bo, createEmptyPlan as bp, createSkillsService as bq, createTask as br, endAttemptUsage as bs, findingLines as bt, flattenTasks as bu, flattenTasksWithParents as bv, formatCost as bw, formatTokenCount as bx, handoffDigest as by, handoffLines as bz, type ContextFill as c, savedPatchOf as c0, savedPatchView as c1, savedPatchViews as c2, severityLabel as c3, startAttemptUsage as c4, storedHandoff as c5, subagentCostTitle as c6, taskUsageSummary as c7, tasksTotalText as c8, usageLine as c9, usageText as ca, waitsForApproval as cb, withPatch as cc, worstSeverity as cd, type ConversationMessage as d, type CostProvenance as e, DEFAULT_RUNNERS as f, DEFAULT_SUPERVISOR_RETRY_LIMIT as g, DIGEST_FINDINGS as h, type DiscoveredModel as i, type ExecutionCommandName as j, type ExecutionRecord as k, type GuardTrip as l, HANDOFF_PUSH_CHARS as m, type Handoff as n, type HandoffArtifact as o, type HandoffCheck as p, type HandoffCommit as q, type HandoffDigest as r, type HandoffEvidence as s, type HandoffFinding as t, type HandoffPatch as u, type HandoffPreviewOptions as v, type HandoffTaskName as w, type IWorktreeIsolation as x, type IntegrationDisposal as y, type InvalidSkill as z };