@ordewell/core 0.7.1 → 0.8.0

package/dist/Task-1Q19y7sZ.d.ts

@@ -0,0 +1,1122 @@
+/**
+ * Why isolated execution is unavailable for a workspace. The orchestrator needs
+ * the reason, not just a boolean: `dirty` is offered a stash or an explicit
+ * "run without isolation", while the others fall back to the shared
+ * workspace root with a one-line notice.
+ */
+type IsolationInactiveReason = 'disabled' | 'git-missing' | 'not-git' | 'no-commits' | 'dirty';
+/**
+ * `repos` names, relative to the workspace, the repositories behind the answer:
+ * when active, the ones that will isolate, with `shared` the paths every task
+ * will share live — loose entries of the workspace root, or, for a lone
+ * repository, the repositories nested inside it; otherwise the dirty ones of a
+ * `dirty` group, or the commitless ones of a `no-commits` group. A group of one
+ * names none.
+ */
+type IsolationAvailability = {
+    active: true;
+    repos?: string[];
+    shared?: string[];
+} | {
+    active: false;
+    reason: IsolationInactiveReason;
+    repos?: string[];
+};
+/**
+ * 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
+ * nothing shared, unless it holds nested repositories, which are shared live
+ * and named in `shared`.
+ */
+interface RepoGroupLayout {
+    repos: string[];
+    shared: string[];
+}
+type IsolationOutcome = 'merged' | 'conflict' | 'failed';
+/**
+ * `active` — worktree exists, a runner may be writing to it.
+ * `kept` — released with its worktree and branch preserved for inspection.
+ * `conflict` — integration stopped on a merge conflict; worktree and refs kept.
+ * `repairing` — a conflict repair (ADR-0015) is working in the kept worktree;
+ *   one that ends without landing leaves the task `conflict` again.
+ * `failed` — integration hit a git error other than a conflict; refs kept.
+ * `merged` — landed on the integration branch; worktree and task branch removed.
+ */
+type IsolationTaskStatus = 'active' | 'kept' | 'conflict' | 'repairing' | 'failed' | 'merged';
+/** One repo's share of a task: its worktree inside the task workspace. */
+interface IsolationTaskRepo {
+    /** Absolute path of this repo's worktree: the task workspace joined with the repo's path. */
+    worktree: string;
+    /**
+     * Paths linked from the real workspace and kept out of the task's commit:
+     * the artifacts bootstrapped from the real repo, and a lone repository's
+     * nested repositories (`run.shared`). Recorded because a symlink is not
+     * matched by an ignore rule such as `node_modules/` and would otherwise be
+     * committed.
+     */
+    linked: string[];
+    /** Whether the task brought commits to this repo; unknown until it first integrates. */
+    changed?: boolean;
+    /**
+     * The integration tip right after the task landed here: what the user's
+     * HEAD must contain for the task's work to count as merged (ADR-0020).
+     */
+    landedTip?: string;
+}
+interface IsolationTaskRecord {
+    taskId: string;
+    order: number;
+    title: string;
+    /** One branch name, the same in every repo, so a task is one name to look up across the group. */
+    branch: string;
+    /**
+     * Absolute path of the task workspace, holding one worktree per repo at the
+     * repo's path. The Runner's cwd is inside it when the workspace is a repo
+     * subdirectory; for a group of one it is the worktree.
+     */
+    workspace: string;
+    /** For the task as a whole: landing is atomic across the repos it changed. */
+    status: IsolationTaskStatus;
+    /** Keyed by repo path. */
+    repos: Record<string, IsolationTaskRepo>;
+    /** The repo whose merge stopped the task from landing, while `status` is `conflict` or `failed`. */
+    conflictRepo?: string;
+    /**
+     * What a `failed` landing stopped on, in words a surface can repeat — a
+     * missing worktree is the common one. Cleared by the next landing attempt,
+     * so a stale reason cannot outlive the failure it explains.
+     */
+    landingError?: string;
+    /** Repo-relative paths, in `conflictRepo`, that conflicted; set only while `status` is `conflict` or `repairing`. */
+    conflictFiles?: string[];
+    /**
+     * Conflict repairs started for this task (ADR-0015). Counted when one starts,
+     * so a crash cannot hand the spent attempt back; absent reads as none.
+     */
+    repairs?: number;
+    /**
+     * Keyed by repo path: each changed repo's integration tip when the repair in
+     * flight started — what the task branch must contain before it may land.
+     * Set only while `status` is `repairing`.
+     */
+    repairBase?: Record<string, string>;
+    /**
+     * Every file a repair was started for, across all of them: as `conflictFiles`
+     * names it in a group of one, prefixed with its repo's path in a group.
+     */
+    repairedFiles?: string[];
+    /**
+     * 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. What
+     * a merge gate waits for (ADR-0020).
+     */
+    inHead?: true;
+}
+/**
+ * A task's landing in flight: each changed repo's integration tip from before
+ * the task's merge. On the run rather than the task record because it must
+ * outlive that record — a retry drops and recreates it — until every repo is
+ * back at its tip or the task has landed.
+ */
+interface IsolationLanding {
+    taskId: string;
+    /** Keyed by repo path. */
+    tips: Record<string, string>;
+}
+/**
+ * One repository of the group (ADR-0014). Every git operation on it runs in
+ * `root`, never in the workspace root.
+ */
+interface IsolationRepo {
+    /** Relative to the workspace root; `.` when the workspace is itself the repository. */
+    path: string;
+    /**
+     * Absolute: the workspace root joined with `path`. For a group of one that is
+     * the workspace root, which may be a subdirectory of the repository.
+     */
+    root: string;
+    /** The commit checked out at run start. Switching branches mid-run does not retarget it. */
+    baseRef: string;
+    /** Branch name checked out at run start; absent on a detached HEAD. */
+    baseBranch?: string;
+    integrationBranch: string;
+}
+/**
+ * One Execute-Plan click or one manual task run over the workspace's repo
+ * group. Plain JSON on purpose: the orchestrator persists it with the plan
+ * state so a resumed session can find its integration branches again. The
+ * module mutates `tasks` in place.
+ */
+interface IsolationRun {
+    id: string;
+    workspaceRoot: string;
+    repos: IsolationRepo[];
+    /**
+     * Workspace paths outside every isolated repo, linked live into each task
+     * workspace: loose entries of the workspace root, the entries beside a deeper
+     * repo, and `sharedRepos`. For a lone repository, the repositories nested
+     * inside it, which cannot be isolated with it and so are linked live instead.
+     * Empty when a group of one holds no nested repositories.
+     */
+    shared: string[];
+    /** Repos of the group that could not be isolated — no commits, or git refused a worktree — and are among `shared`. */
+    sharedRepos: string[];
+    /** Keyed by task id — ids are unique within one plan and a run belongs to one plan. */
+    tasks: Record<string, IsolationTaskRecord>;
+    /**
+     * Set before a task's first merge and cleared once it has landed or been
+     * rolled back. One found set — after a crash, or a rollback git refused —
+     * names exactly what to return each repo's integration branch to.
+     */
+    landing?: IsolationLanding;
+}
+/**
+ * What a plan persists of isolated execution (`LegacyPlanState.isolation`): its
+ * run, and which added tasks resolve which conflicts. Belongs to that plan and
+ * its branches alone, so a copy of the plan (a fork) must not carry it.
+ */
+interface PlanIsolation {
+    run: IsolationRun;
+    /** Resolver task id → the conflicted task whose branch it merges. */
+    resolvers: Record<string, string>;
+}
+/**
+ * A task's isolation as a surface shows it. `kept` covers every record whose
+ * worktree stays for inspection — a failed verdict, an interrupted attempt, an
+ * integration git refused — because to the user they are one thing: work that
+ * did not land and can be looked at. `none` is a task with no worktree in a plan
+ * that has an isolation run.
+ */
+type TaskIsolationState = 'none' | 'active' | 'integrated' | 'conflict' | 'repairing' | 'kept';
+type TaskIsolation = {
+    state: 'none';
+} | {
+    state: Exclude<TaskIsolationState, 'none'>;
+    branch: string;
+    /** The task workspace; for a group of one, the task's worktree. */
+    worktree: string;
+    /** Paths of the repos the task changed. */
+    repos: string[];
+    conflictRepo?: string;
+    /** Repo-relative paths, in `conflictRepo`, that conflicted. */
+    conflictFiles?: string[];
+    /** The conflict repair running or last run, of the most a task may have; absent before its first. */
+    repair?: {
+        attempt: number;
+        limit: number;
+    };
+    /** What {@link IsolationTaskRecord.repairedFiles} says. */
+    repairedFiles?: string[];
+};
+interface IsolationLandedTask {
+    taskId: string;
+    order: number;
+    title: string;
+    /** Set when the task landed only after a conflict repair (ADR-0015): the files it was started for. */
+    repairedFiles?: string[];
+}
+interface IsolationHandoffRepo {
+    path: string;
+    integrationBranch: string;
+    baseRef: string;
+    /** Tasks whose work landed in this repo, in plan order. */
+    landed: IsolationLandedTask[];
+}
+interface IsolationHandoff {
+    repos: IsolationHandoffRepo[];
+    /** Tasks that landed on the integration branches, in plan order. */
+    landed: IsolationLandedTask[];
+}
+/** A plan's isolation as a surface shows it: a mark for each task the run touched, and its handoff. */
+interface IsolationView {
+    tasks: Record<string, TaskIsolation>;
+    handoff: IsolationHandoff;
+}
+/**
+ * Why "Merge all" would not touch a repo. `partial-landing`: a task's landing
+ * was interrupted and could not be rolled back there, so its integration
+ * branch holds part of a task.
+ */
+type IsolationMergeBlockReason = 'merge-in-progress' | 'conflict' | 'uncommitted-changes' | 'partial-landing' | 'git-error';
+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. */
+    files: string[];
+}
+/**
+ * How "Merge all" went.
+ * - `merged`: every repo with work on its integration branch took it.
+ * - `blocked`: the preflight found repos that could not, so nothing was
+ *   touched anywhere; `blocked` says which and why.
+ * - `conflict` / `failed`: a merge stopped in `repo` — on git older than 2.38,
+ *   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 group of one is blocked only by a partial landing; otherwise its one merge
+ * lands or is aborted whole, so it reports as it always has.
+ */
+type IsolationMergeResult = {
+    outcome: 'merged';
+} | {
+    outcome: 'blocked';
+    blocked: IsolationMergeBlock[];
+} | {
+    outcome: 'conflict' | 'failed';
+    repo: string;
+    files?: string[];
+    landed?: string[];
+};
+/**
+ * What `discard` does with each repo's integration branch: `keep` it for review
+ * or merge, `delete` it, or delete it only in the repos whose checked-out HEAD
+ * already contains it (`delete-merged`) — the one way that can never give up
+ * landed work the user has not merged.
+ */
+type IntegrationDisposal = 'keep' | 'delete' | 'delete-merged';
+/**
+ * Whether a conflict repair's work may land. `not-merged`: the task branch in
+ * `repo` does not contain the tip the repair started from. `conflict-markers`:
+ * it adds leftover conflict markers to `files`. `failed`: git could not tell.
+ */
+type RepairEvidence = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'not-merged' | 'conflict-markers' | 'failed';
+    repo: string;
+    files?: string[];
+};
+interface PreparedTask {
+    cwd: string;
+    branch: string;
+    /**
+     * Paths, relative to the task workspace, that are copies rather than links
+     * because a hard link was impossible (Windows, another volume). Edits to them
+     * stay in the task, so the user is told.
+     */
+    copied: string[];
+    /** What the attempt this one replaces left unlanded, kept on a branch before its worktree went; absent when nothing was. */
+    preserved?: PreservedWork[];
+}
+/** A task as a removal names it. */
+type IsolationTaskRef = Pick<IsolationTaskRecord, 'taskId' | 'order' | 'title'>;
+/**
+ * Work a removal found that had not landed — edits never committed, or
+ * commits only the task's branch carried — committed and kept on `branch`,
+ * a branch of its own under `ordewell-preserved/`, before the worktree went.
+ */
+interface PreservedWork {
+    /** Absent for a leftover directory no task record owned. */
+    task?: IsolationTaskRef;
+    repo: string;
+    branch: string;
+    /** The commit `branch` points at. */
+    commit: string;
+}
+/** A worktree a removal left in place, because the work in it could not be kept any other way. */
+interface RefusedRemoval {
+    /** Absent for a leftover directory no task record owned. */
+    task?: IsolationTaskRef;
+    worktree: string;
+    /** What stopped git keeping it, in words a surface can repeat. */
+    reason: string;
+}
+/**
+ * What removing task worktrees did in place of deleting work. A removal never
+ * deletes work that has not landed: it keeps it on a branch first
+ * (`preserved`), and where it cannot, it leaves that worktree alone
+ * (`refused`) — so the record of a refused task stays too.
+ */
+interface IsolationRemoval {
+    preserved: PreservedWork[];
+    refused: RefusedRemoval[];
+}
+/**
+ * What a crash-recovery prune found and left alone: task records that were
+ * `active` yet still held unlanded work, so the prune kept them as `kept`
+ * rather than deleting work no one else has.
+ */
+interface IsolationPruneResult extends IsolationRemoval {
+    kept: IsolationTaskRef[];
+}
+/**
+ * The tracked changes of a workspace's repos at one moment, against each
+ * repo's HEAD: repo path → file path → the content it held then. What an ops
+ * task's tree check compares against (ADR-0020).
+ */
+type TreeSnapshot = Record<string, Record<string, string>>;
+interface IWorktreeIsolation {
+    /**
+     * A repo group with at least one repo to isolate, a clean tracked tree in
+     * each, and the config enabled; otherwise the reason it is not.
+     */
+    isActive(workspaceRoot: string): Promise<IsolationAvailability>;
+    /**
+     * Put the tracked changes of every dirty repo of the group on its git stash,
+     * the user's way out of a `dirty` refusal. Untracked files stay: they never
+     * block isolation.
+     */
+    stash(workspaceRoot: string): Promise<void>;
+    /**
+     * Mint a run: resolve each repo's base ref to a commit now, and share the
+     * repos that cannot be isolated. Only meaningful after `isActive` said yes;
+     * throws when no repo of the group can be isolated after all.
+     */
+    startRun(workspaceRoot: string): Promise<IsolationRun>;
+    /**
+     * Create the task workspace — one worktree per isolated repo from its
+     * integration tip, the shared paths linked in — and return the cwd to spawn
+     * the Runner into. A second `prepare` for the same task is a retry: the old
+     * attempt is discarded and the workspace recreated from the tips, so the
+     * task sees everything its predecessors have integrated.
+     */
+    prepare(task: Task, run: IsolationRun): 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
+     * changed repo's integration tip as `repairBase`, counts the repair, and
+     * moves the task to `repairing`. Throws for a task that is not `conflict`.
+     */
+    reopen(task: Task, run: IsolationRun): Promise<PreparedTask>;
+    /**
+     * The evidence a repair must show before it lands: its work committed, and
+     * in each repo of `repairBase` the task branch containing that tip
+     * (`git merge-base --is-ancestor`) and adding no leftover conflict markers
+     * (`git diff --check`; whitespace warnings do not count). Changes nothing
+     * else: a task that fails stays `repairing` until released.
+     */
+    verifyRepair(task: Task, run: IsolationRun): Promise<RepairEvidence>;
+    /**
+     * Land the task atomically across the repos it changed: commit each
+     * worktree, then `git merge --no-ff` the task branch into each changed
+     * repo's integration branch. If any merge conflicts or fails, it is aborted
+     * and the merges already made for the task are reset away, so `merged`
+     * always means the whole task landed. Serialized inside the module; among
+     * 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.
+     *
+     * `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.
+     */
+    integrate(task: Task, run: IsolationRun, persist?: () => void): 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
+     * whose work cannot be kept stays, off `active`. `keep: true` leaves the
+     * 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-0007).
+     */
+    release(run: IsolationRun, taskId: string, opts: {
+        keep: boolean;
+    }): Promise<IsolationRemoval>;
+    /** End of run: park the integration branch for review and report what landed. */
+    handoff(run: IsolationRun): Promise<IsolationHandoff>;
+    /**
+     * Drop what a crash left behind: a landing it interrupted is rolled back in
+     * every repo, a repair it interrupted leaves its task `conflict`, then stale
+     * active worktrees and directories no record owns go. An `active` record
+     * that still holds unlanded work — commits its branch alone carries, or
+     * edits in its worktree — is not a crash orphan: it may belong to a runner
+     * another host is still driving, so it is kept as `kept` and named in the
+     * result. A leftover directory holding work is kept on a branch before it
+     * goes, as {@link release} does.
+     */
+    pruneOrphans(run: IsolationRun): Promise<IsolationPruneResult>;
+    /** Unified diff of each repo's integration branch against its base ref. */
+    reviewDiff(run: IsolationRun): Promise<string>;
+    /**
+     * Mark the landed tasks whose work the checked-out HEAD now contains in
+     * every repo they changed (`git merge-base --is-ancestor`), and return their
+     * ids. Only adds marks: a task found merged stays merged.
+     */
+    findInHead(run: IsolationRun): Promise<string[]>;
+    /**
+     * The tracked changes of each committed repo of the workspace's group,
+     * except those in `exclude`; null when there is no repo to snapshot.
+     * Untracked and ignored files never count.
+     */
+    snapshotTree(workspaceRoot: string, exclude: readonly string[]): Promise<TreeSnapshot | null>;
+    /**
+     * Tracked files whose content differs from what `snapshot` recorded: new
+     * changes, and further changes to files already changed then. Paths are
+     * from the workspace root. A repo git cannot read now is left out.
+     */
+    changedSince(workspaceRoot: string, snapshot: TreeSnapshot): Promise<string[]>;
+    /**
+     * "Merge all": merge each repo's integration branch into whatever the user
+     * has checked out there. The one irreversible step, so it only ever happens
+     * when a caller asks for it. Every repo with work is preflighted first — no
+     * merge of the user's in progress, no conflict against their HEAD, no
+     * uncommitted edit to a file the merge changes — and unless all pass,
+     * nothing is merged anywhere. Only a merge Ordewell itself just started is
+     * ever aborted; nothing of the user's is reset. Waits for a landing in
+     * flight and holds the next back, so a merge during a run takes the
+     * integration branches between two landings, never part of one.
+     */
+    mergeIntoCheckedOut(run: IsolationRun): Promise<IsolationMergeResult>;
+    /**
+     * Remove every worktree and task branch of the run, and settle each repo's
+     * integration branch as `integration` says. Anything but `keep` also clears
+     * the run's task records, except those of worktrees it refused to remove.
+     * Work that had not landed is kept on a branch first, as {@link release} does.
+     */
+    discard(run: IsolationRun, opts: {
+        integration: IntegrationDisposal;
+    }): Promise<IsolationRemoval>;
+    /**
+     * Clear what other runs left in each repo of `run`'s group: every
+     * `ordewell/<run-id>/…` branch the repo's checked-out HEAD already contains.
+     * Never a branch of `run` itself, one a worktree has checked out, or any
+     * branch of a run that still has a worktree — that run may be live in
+     * another plan. Tries every repo, then throws naming those where git failed.
+     */
+    sweep(run: IsolationRun): Promise<void>;
+}
+
+/**
+ * What one model call consumed, as its provider or runner reported it. Shared
+ * by the planner's usage line (#49) and per-attempt task usage (#26): a record
+ * says nothing about who asked for the call, so either can hold a list of them.
+ *
+ * Every measure is optional because backends report different subsets. An
+ * absent field means "not reported" — never zero — so a total can tell the two
+ * apart.
+ */
+interface UsageRecord {
+    /** The provider or runner id that reported the call — `openai`, `claude-code`, … */
+    source: string;
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    /** The share of `inputTokens` served from the provider's prompt cache. */
+    cachedInputTokens?: number;
+    /**
+     * Filled only from a provider's or runner's own report, never from a price
+     * table or an estimate: prices go stale, and a subscription runner has no
+     * per-token price at all. No report means no cost, not a guessed one.
+     */
+    reportedCost?: {
+        amount: number;
+        currency: string;
+    };
+    /** The model's context window, when the runner itself reports it. */
+    contextWindow?: number;
+    /** Set when a subagent made the call; its usage still counts toward the total. */
+    subagentId?: string;
+}
+/**
+ * A running sum of {@link UsageRecord}s. A measure stays absent until some
+ * record reports it. Cost is kept per currency: two runners may bill in
+ * different ones, and there is no honest exchange rate to fold them together.
+ */
+interface UsageTotals {
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    reportedCost?: Record<string, number>;
+}
+/**
+ * The input side of a call whose provider reports its prompt in parts — the
+ * uncached tail, with cache reads and cache writes beside it rather than inside
+ * it (Anthropic, and OpenCode after it). The prompt the model saw is all three;
+ * only the reads were served from cache, since a write is billed as fresh
+ * input. A part left unreported adds nothing, and with no part reported there
+ * is no measure at all.
+ */
+declare function partedPromptUsage(parts: {
+    uncached?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}): Pick<UsageRecord, 'inputTokens' | 'cachedInputTokens'>;
+declare function addUsage(totals: UsageTotals, record: UsageRecord): UsageTotals;
+/**
+ * What the planner has consumed over a session (#49). `totals` includes every
+ * `bySubagent` entry. `lastPromptTokens` and `contextWindow` track the
+ * planner's own calls only — a subagent runs its own model, whose window says
+ * nothing about the planner's.
+ */
+interface PlannerUsage {
+    totals: UsageTotals;
+    bySubagent?: Record<string, UsageTotals>;
+    lastPromptTokens?: number;
+    contextWindow?: number;
+}
+declare function addPlannerUsage(usage: PlannerUsage, record: UsageRecord): PlannerUsage;
+/** Whether any measure was reported: a token line of nothing but blanks says nothing. */
+declare function isMeasured(totals: UsageTotals): boolean;
+/** What the token line shows of a ledger — live from its broadcast, or reloaded from the saved one. */
+interface UsageLine {
+    totals: UsageTotals;
+    bySubagent?: Record<string, UsageTotals>;
+    contextFill?: {
+        usedTokens: number;
+        windowTokens: number;
+    };
+}
+declare function usageLine(usage: PlannerUsage): UsageLine;
+/**
+ * The last planner prompt against its window, or undefined while either is
+ * unknown. `usedTokens` is the prompt total as reported, cached tokens
+ * included: a cached token still occupies the window, so subtracting the
+ * cached share would understate how full the context is. A window of 0 is
+ * treated as unknown — never guessed.
+ */
+declare function plannerContextFill(usage: PlannerUsage): {
+    usedTokens: number;
+    windowTokens: number;
+} | undefined;
+
+declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec", "improve-codebase-architecture", "tdd"];
+interface SkillMetadata {
+    name: string;
+    description: string;
+    disableModelInvocation?: boolean;
+}
+/** Who a skill is for: the planner's conversation, or a runner's task prompt. */
+type SkillAppliesTo = 'planner' | 'task';
+/** `global` is ~/.ordewell/skills/ (built-in seeds included); `workspace` is a `.ordewell/skills/` of the workspace's (see {@link workspaceSkillRoots}). */
+type SkillSource = 'global' | 'workspace';
+interface SkillInfo {
+    name: string;
+    description: string;
+    metadata: SkillMetadata;
+    /** Full content of SKILL.md with frontmatter stripped */
+    content: string;
+    /** Absolute path to the SKILL.md file */
+    path: string;
+    source: SkillSource;
+    /** Frontmatter `applies-to`; absent or unrecognised reads as `planner`. */
+    appliesTo: SkillAppliesTo;
+    /** False when frontmatter sets `disable-model-invocation: true`. */
+    modelInvocable: boolean;
+    /** Frontmatter `user-invocable`; false makes the skill model-only. */
+    userInvocable: boolean;
+}
+/** A workspace skill hidden because a global skill, or a workspace one read before it, has the same name. */
+interface ShadowedSkill {
+    skill: SkillInfo;
+    shadowedBy: SkillInfo;
+}
+/** A skill folder no name can reach — `/name`, a plan and a spawn all use the folder name — so it is listed nowhere. */
+interface InvalidSkill {
+    name: string;
+    /** Absolute path to the folder's SKILL.md. */
+    path: string;
+    source: SkillSource;
+    reason: string;
+}
+/** A skills folder's catalog: what wins, what a winner hides, and the folders skipped for their name. */
+interface SkillCatalog {
+    skills: SkillInfo[];
+    shadowed: ShadowedSkill[];
+    invalid: InvalidSkill[];
+}
+declare class SkillsService {
+    private readonly workspaceRoots;
+    /** `workspaceRoots` in the order they win, as {@link workspaceSkillRoots} gives them. */
+    constructor(workspaceRoots?: string | readonly string[]);
+    /**
+     * The same global skills, with the workspace ones read from `roots` instead —
+     * a task's worktrees, whose `.ordewell/skills/` are their own committed copies.
+     */
+    forRoot(roots: string | readonly string[]): SkillsService;
+    /** Where {@link findSkill} looks, in the order it looks — global first. */
+    searchedDirs(): string[];
+    private workspaceDirs;
+    private globalDir;
+    private readSeedManifest;
+    private recordSeed;
+    /** A seed the user never edited: safe to replace with a newer built-in. */
+    private isUntouchedSeed;
+    private seed;
+    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;
+    private pruneRetired;
+    /** A name no skill could have resolves to nothing: it is joined into a path, so `../x` would read outside the skill dirs. */
+    findSkill(name: string): SkillInfo | undefined;
+    listSkills(): SkillInfo[];
+    /** Workspace skills skipped by `listSkills` and `findSkill` because one that wins has the same name. */
+    listShadowed(): ShadowedSkill[];
+    /**
+     * Global wins a name clash: a repository's committed skill must not be able
+     * to silently replace one the user installed, built-ins included. Among
+     * workspace folders the first read wins, the same way.
+     */
+    private catalog;
+    /** Inspect installed skills without seeding, refreshing or pruning global files. */
+    readCatalog(): SkillCatalog;
+    getSkillContent(name: string): string | undefined;
+}
+/**
+ * The skills a workspace sees outside any task — every listing, picker and
+ * catalog before a task worktree exists: global, then the folders a spawn
+ * reads (see {@link workspaceSkillRoots}), each repo's as checked out in the
+ * workspace. `workspaceRepos` is the setting that names a repo group.
+ */
+declare function createSkillsService(workspaceRoot?: string, workspaceRepos?: readonly string[]): SkillsService;
+
+interface UserStep {
+    order: number;
+    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. */
+interface VerificationCheck {
+    name: 'exit_code' | 'completion_marker' | 'task_complete' | 'manual';
+    passed: boolean;
+    /** A check that did not apply. Skipped checks don't affect the verdict. */
+    skipped: boolean;
+    detail: string;
+}
+/** Evidence-based verdict for a completed task. Single end-to-end outcome produced by verification. */
+interface Verdict {
+    outcome: 'pass' | 'fail';
+    reason: string;
+    checks: VerificationCheck[];
+    decidedAt: string;
+}
+interface TaskOutputSummary {
+    reviewReason: string;
+    logTail: string;
+    capturedAt: string;
+}
+type TaskType = 'ai' | 'user';
+type TaskStatus = 'pending' | 'approved' | 'in_progress' | 'completed' | 'failed' | 'blocked' | 'awaiting_user';
+type TaskMode = string;
+/**
+ * Why an `awaiting_user` task waits (ADR-0018, W1): a structured turn that
+ * ended without a `task_complete` call, a checkpoint question, work that did not
+ * land, or an ops task that changed tracked files (ADR-0020). Saved, so no
+ * surface has to guess it from whether an attempt is live.
+ */
+type AwaitingReason = 'input' | 'checkpoint' | 'conflict' | 'files-changed';
+declare function isAwaitingReason(value: unknown): value is AwaitingReason;
+interface TaskModelAssignment {
+    modelId: string;
+    modelLabel: string;
+    thinkingEffort?: string;
+    /**
+     * All variant ids the model offered when this assignment was made. Carried
+     * on the assignment because runners need it at spawn time (opencode's TUI
+     * only honors an assigned variant when the others are config-disabled) and
+     * the discovery catalog isn't available there.
+     */
+    availableVariants?: string[];
+}
+type RunnerId = string;
+/**
+ * Bring loaded tasks to the structured-only shape, in place. A task saved
+ * while the terminal transport existed may say it ran there, and why; neither
+ * means anything now, and such a task left no session to continue. Its
+ * completion marker id went with the text markers: completion is reported
+ * only through `task_complete`.
+ */
+declare function migrateLoadedTasks(tasks: readonly Task[]): void;
+/**
+ * A task skill as one attempt received it: read from the task's own worktree
+ * (or global) at spawn, kept so the user can see what the runner was told
+ * even after the skill's file changes.
+ */
+interface TaskSkillSnapshot {
+    name: string;
+    source: SkillSource;
+    path: string;
+    content: string;
+}
+/** A task skill as a surface is told of it: the body stays in the task's log file and the session. */
+type TaskSkillNotice = Omit<TaskSkillSnapshot, 'content'>;
+interface Task {
+    id: string;
+    order: number;
+    title: string;
+    description: string;
+    type: TaskType;
+    status: TaskStatus;
+    dependencies: string[];
+    prompt?: string;
+    userSteps?: UserStep[];
+    subtasks: Task[];
+    verdict?: Verdict;
+    outputSummary?: TaskOutputSummary;
+    assignedModel?: TaskModelAssignment;
+    assignedRunner: RunnerId;
+    thinkingEffort?: string;
+    taskMode?: TaskMode;
+    autonomy?: 'AFK' | 'HITL';
+    sliceType?: 'HITL' | 'AFK';
+    userStoriesCovered?: string[];
+    /** The runner's saved session for a later continue; cleared when a fresh attempt starts. */
+    runnerSessionId?: string;
+    /** Set only while `status` is `awaiting_user`, and not always then — a usage-limit pause has none. */
+    awaitingReason?: AwaitingReason;
+    /**
+     * 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.
+     */
+    ops?: boolean;
+    /**
+     * 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
+     * (ADR-0020). Cleared when the task is retried.
+     */
+    forcedPastGate?: string[];
+    /**
+     * Task skills (`applies-to: task`) attached by name. Their bodies are put in
+     * the runner's prompt at spawn, resolved where the task runs — a subtask's
+     * are its own, never its parent's. Absent means none.
+     */
+    skills?: string[];
+    /** The skills the latest attempt was given, as read when it spawned. */
+    attemptSkills?: TaskSkillSnapshot[];
+}
+interface DiscoveredMode {
+    id: string;
+    label: string;
+    description: string;
+}
+type ResearchToolType = 'read_file' | 'read_files' | 'glob' | 'grep' | 'find_symbol' | 'list_dir' | 'bash' | 'fetch' | 'web_search' | 'spawn_research_agent'
+/**
+ * A tool belonging to a harness planner's own toolbox (ADR-0009) that has no
+ * Ordewell equivalent — Edit, WebFetch, TodoWrite, whatever a coding agent
+ * ships next. The real name travels in `toolLabel` rather than being
+ * relabelled as a tool it is not; the union stays closed so the
+ * exhaustiveness checks in every surface's icon/label switch survive.
+ */
+ | 'agent_tool';
+/**
+ * What happened when a research tool call ran, for honest per-surface
+ * rendering. The broadcast seam carries this on every `research_step_done` so
+ * surfaces do not have to pattern-match refusal text to tell a refused `rm`
+ * from a successful `rm` — the old render path flipped a `✓` for both.
+ */
+type ResearchStepOutcome = 'success' | 'failure' | 'refused' | 'denied' | 'not_executed';
+interface ResearchStep {
+    id: string;
+    tool: ResearchToolType;
+    /** The tool's own name when it came from a harness planner — always set for `agent_tool`. */
+    toolLabel?: string;
+    args: string;
+    result: string;
+    success: boolean;
+    outcome: ResearchStepOutcome;
+    /** The model's tool_call id, so a surface can match `tool_result` to the
+     * pending `tool_call` it announced — robust under parallel same-tool rounds. */
+    toolCallId?: string;
+    /** The research subagent that ran the call, so a reload regroups it under that subagent. */
+    subagentId?: string;
+    timestamp: string;
+    thinkingText?: string;
+}
+interface UserPromptEntry {
+    id: string;
+    type: 'user_prompt' | 'system';
+    content: string;
+    timestamp: string;
+}
+type SubagentOutcome = 'done' | 'failed' | 'stopped';
+/**
+ * One subagent's whole run, logged when it finishes: what it was asked, how it
+ * ended and what it reported. Its steps stay separate entries carrying the same
+ * `subagentId`, so an older reader that knows only steps still shows them.
+ */
+interface SubagentLogEntry {
+    id: string;
+    type: 'subagent';
+    subagentId: string;
+    brief: string;
+    model?: string;
+    outcome: SubagentOutcome;
+    digest: string;
+    usage?: UsageTotals;
+    timestamp: string;
+}
+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';
+    /** 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. */
+    segmentId?: string;
+    text?: string;
+    tool?: string;
+    /** Harness planners (ADR-0009): the agent's own name for a tool Ordewell has no member for. */
+    toolLabel?: string;
+    toolArgs?: string;
+    toolResult?: string;
+    planToken?: string;
+    step?: ResearchStep;
+    /** The model's tool_call id, threaded on tool_call and tool_result so a
+     * surface can match the result to its pending call — robust under parallel
+     * same-tool rounds where LIFO-by-name matching mislabels summaries. */
+    toolCallId?: string;
+    /** Present when this event originates from (or reports on) one spawned research subagent (issue #34). */
+    subagentId?: string;
+    record?: UsageRecord;
+    brief?: string;
+    model?: string;
+    outcome?: SubagentOutcome;
+    digest?: string;
+    usage?: UsageTotals;
+}
+interface ThinkingBlock {
+    id: string;
+    text: string;
+}
+interface StreamThinkingEvent {
+    type: 'thinking';
+    block: ThinkingBlock;
+}
+interface StreamStepEvent {
+    type: 'step';
+    step: ResearchStep;
+}
+type StreamEvent = StreamThinkingEvent | StreamStepEvent;
+interface DiscoveredModel {
+    modelId: string;
+    modelLabel: string;
+    runnerProvider?: string;
+    /**
+     * Human-facing provider name as the runner itself reports it (e.g.
+     * "OpenCode Zen" for `runnerProvider: 'opencode'`). Populated from the
+     * runner's own provider catalog when available; when absent the UI derives a
+     * label from `runnerProvider` by title-casing.
+     */
+    runnerProviderLabel?: string;
+    /**
+     * The runner whose catalog listed this model. Stamped once, at the single
+     * `ModelDiscovery.discover` choke point, so a flat cross-runner list can
+     * still say where each entry came from — `runnerProvider` alone cannot:
+     * OpenCode reports most of its catalog as `openrouter`, which names the
+     * serving backend, not the agent Ordewell would spawn.
+     */
+    runnerId?: string;
+    /** The runner's display name (`OpenCode`), from its manifest. */
+    runnerLabel?: string;
+    variants: {
+        id: string;
+        label: string;
+    }[];
+    /**
+     * 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.
+     */
+    contextWindow?: number;
+}
+type PlanStatus = 'draft' | 'approved' | 'rejected' | 'running' | 'completed';
+/**
+ * One entry of the planner's persisted dialogue (ADR-0002). The single source
+ * of truth for both UI redisplay and conversational context. Tool-call results
+ * are NOT stored here — they live in the AI service's tool-use history;
+ * `researchLog` remains the persisted tool trace for the UI.
+ */
+interface ConversationMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: string;
+    /**
+     * 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
+     * conversation, its snapshot in `skill`; one the user invoked follows the
+     * message that named it. Absent for ordinary chat turns, so sessions saved
+     * before markers existed degrade gracefully.
+     */
+    kind?: 'plan_generated' | 'system' | 'compaction' | 'skill_load';
+    /** Present exactly when `kind` is 'skill_load'. */
+    skill?: SkillLoad;
+}
+/**
+ * A skill's SKILL.md as it was when loaded into a planner conversation. A
+ * snapshot rather than a reference: a resumed, forked or rewound conversation
+ * replays the body the planner originally saw, even after the file changed or
+ * was deleted.
+ */
+interface SkillLoad {
+    invokedBy: 'user' | 'planner';
+    name: string;
+    source: SkillSource;
+    /** The SKILL.md that won, home-abbreviated (`~/...`): which copy loaded is what a reader needs from it. */
+    path: string;
+    content: string;
+    /**
+     * Set when the user named a task skill: it is not loaded into the planner's
+     * context, which is only told to attach it to the tasks it fits. `content`
+     * is empty; the description is what the planner's directive quotes.
+     */
+    attaches?: {
+        description: string;
+    };
+}
+/** A skill load as a surface announces it — the body stays with the transcript. */
+type SkillLoadNotice = Omit<SkillLoad, 'content'>;
+/** A message the user sent, as opposed to a skill load their message caused. */
+declare function isUserMessage(entry: ConversationMessage): boolean;
+interface QueuedMessage {
+    id: string;
+    text: string;
+    timestamp: string;
+    /** What its `/name` tokens loaded when it was sent: the drain composes them with the text, as a live send does. */
+    skills?: SkillLoad[];
+}
+interface PlanModificationWarnings {
+    deletedCompleted: string[];
+    changedCompleted: string[];
+    deletedInProgress: string[];
+    modifiedInProgress: string[];
+    brokenDependencies: string[];
+}
+declare function emptyWarnings(): PlanModificationWarnings;
+interface LegacyPlanState {
+    tasks: Task[];
+    generatedAt: string;
+    status: PlanStatus;
+    runners: RunnerId[];
+    lastUpdated: string;
+    researchLog?: ResearchLogEntry[];
+    /** The planner dialogue — user messages and assistant messages, in order (ADR-0002). */
+    conversationHistory?: ConversationMessage[];
+    /** Full markdown PRD once written by the planner (PRD mode), also saved to .scratch/<slug>/PRD.md. */
+    prdMarkdown?: string;
+    /** Follow-ups queued while tasks execute — applied as plan modifications between batches. */
+    queuedMessages?: QueuedMessage[];
+    /**
+     * The plan's isolation run (ADR-0013), written from the orchestrator at
+     * persist time and read back only when a saved plan is adopted. It names
+     * branches and worktrees that belong to this plan alone: a fork of the plan
+     * must leave it behind rather than share it.
+     */
+    isolation?: PlanIsolation;
+    /** Kept so a reopened session shows the same token line (#49). */
+    plannerUsage?: PlannerUsage;
+}
+interface Message {
+    id: string;
+    role: 'user' | 'planner' | 'system';
+    content: string;
+    timestamp: number;
+}
+interface TaskSnapshot extends Task {
+    completedAt: number;
+    verdict?: Verdict;
+    retryCount: number;
+    finalized: boolean;
+}
+type PlanState = {
+    phase: 'planning';
+    history: Message[];
+    message: string;
+    pendingTasks: Task[];
+} | {
+    phase: 'executing';
+    history: Message[];
+    message: string;
+    executionLog: TaskSnapshot[];
+    pendingTasks: Task[];
+    goal: string;
+    runners: string[];
+    status: PlanStatus;
+};
+declare function migratePlanState(raw: unknown): PlanState;
+declare function migrateLegacyPlan(legacy: LegacyPlanState): PlanState;
+
+declare function createTask(overrides?: Partial<Task>): Task;
+declare function isSkillName(name: string): boolean;
+/**
+ * The `skills` field as a task stores it, however it arrived: the planner's
+ * JSON is untyped. Names are trimmed, lower-cased and deduplicated, and one
+ * no skill could have is dropped; none at all is stored absent, so a plan
+ * without skills reads exactly as it did before them.
+ */
+declare function skillNames(value: unknown): string[] | undefined;
+/**
+ * The skills of a task a merge or a split makes from others: what the edit
+ * chose when it named any, none when it chose an explicit `[]`, else what the
+ * tasks it came from had — a malformed value is not a request to drop them.
+ */
+declare function inheritedSkills(chosen: unknown, inherited: readonly string[] | undefined): string[] | undefined;
+/**
+ * The `ops` flag as a task stores it (ADR-0020), however it arrived. Only a
+ * literal `true` on an AI task marks an ops task: the planner's JSON is
+ * untyped, and a quoted "true" read as ops would move a task out of its
+ * worktree. Anything else is a change task, stored absent so saved plans need
+ * no migration. Whether the task may be ops at all — a subtask may not — is
+ * for whoever knows where it sits: parsing drops the flag, an edit refuses it.
+ */
+declare function opsFlag(value: unknown, type?: Task['type']): true | undefined;
+/**
+ * The flag of a task a merge or a split makes from others: what the edit
+ * chose, else ops only when every task it came from was. A merge that takes
+ * in a change edits files, so it is a change; a split part runs where its
+ * task did.
+ */
+declare function inheritedOps(from: readonly Pick<Task, 'ops'>[], chosen?: boolean): boolean;
+/** The runner set a plan has until one is chosen: the one runner every host ships. */
+declare const DEFAULT_RUNNERS: readonly RunnerId[];
+declare function createEmptyPlan(): LegacyPlanState;
+declare function flattenTasks(tasks: readonly Task[]): Task[];
+/** A flattened task with the parent it hangs under, null for a top-level task. */
+interface TaskWithParent {
+    task: Task;
+    parent: Task | null;
+}
+declare function flattenTasksWithParents(tasks: readonly Task[]): TaskWithParent[];
+declare function migrateTask(task: Record<string, unknown>): Task;
+declare function addTaskToPlan(tasks: readonly Task[], partial: Partial<Task>): Task[];
+declare function removeTaskFromPlan(tasks: readonly Task[], taskId: string): Task[];
+declare function updateTaskInPlan(tasks: readonly Task[], taskId: string, changes: Partial<Task>): Task[];
+declare function renumberTasks(tasks: readonly Task[]): Task[];
+/**
+ * Lay a planner-written task list over the plan it rewrites without letting it
+ * change execution state. A planner restates tasks; it never witnessed one run,
+ * so the status it writes is not evidence. A settled task is kept exactly as
+ * it stands wherever the rewrite names it, and put back beside its old
+ * neighbour where the rewrite leaves it out. Every other task keeps the status
+ * it had; a task the rewrite adds starts pending.
+ */
+declare function keepExecutionState(current: readonly Task[], rewrite: Task[]): Task[];
+/** What only execution reads; {@link keepExecutionState} puts it back on whatever a planner returns. */
+declare const EXECUTION_ONLY: readonly ["attemptSkills", "runnerSessionId", "awaitingReason", "forcedPastGate", "outputSummary"];
+type PlannerTaskView = Omit<Task, typeof EXECUTION_ONLY[number] | 'subtasks'> & {
+    subtasks: PlannerTaskView[];
+};
+/**
+ * A task as a planner prompt carries it. An attempt's skill snapshots are
+ * whole SKILL.md bodies and an output summary holds a log tail: sent on every
+ * planner call, they cost tokens and invite the planner to edit state it does
+ * not own.
+ */
+declare function plannerTaskView(task: Task): PlannerTaskView;
+declare function validateModifiedPlan(original: Task[], modified: Task[]): PlanModificationWarnings;
+interface ActiveTaskSession {
+    id: string;
+    taskId: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+interface ValidationContext {
+    executionLog: TaskSnapshot[];
+    oldPending: Task[];
+    newPending: Task[];
+    activeSessions: Map<string, ActiveTaskSession>;
+}
+type ValidationCheck = (ctx: ValidationContext) => ValidationResult;
+declare function warningsText(w: PlanModificationWarnings): string | null;
+
+export { type SkillLoad as $, type ActiveTaskSession as A, BUILTIN_SKILL_NAMES as B, type ConversationMessage as C, DEFAULT_RUNNERS as D, type PlanStatus as E, type PlannerTaskView as F, type PlannerUsage as G, type PreparedTask as H, type IWorktreeIsolation as I, type PreservedWork as J, type RepairEvidence as K, type LegacyPlanState as L, type Message as M, type RepoGroupLayout as N, type ResearchLogEntry as O, type PlanIsolation as P, type QueuedMessage as Q, type RefusedRemoval as R, type ResearchProgress as S, type ResearchStep as T, type ResearchStepOutcome as U, type ResearchToolType as V, type RunnerId as W, type ShadowedSkill as X, type SkillAppliesTo as Y, type SkillCatalog as Z, type SkillInfo as _, type AwaitingReason as a, warningsText as a$, type SkillLoadNotice as a0, type SkillMetadata as a1, type SkillSource as a2, SkillsService as a3, type StreamEvent as a4, type StreamStepEvent as a5, type StreamThinkingEvent as a6, type SubagentLogEntry as a7, type SubagentOutcome as a8, type Task as a9, createEmptyPlan as aA, createSkillsService as aB, createTask as aC, emptyWarnings as aD, flattenTasks as aE, flattenTasksWithParents as aF, inheritedOps as aG, inheritedSkills as aH, isAwaitingReason as aI, isMeasured as aJ, isSkillName as aK, isUserMessage as aL, keepExecutionState as aM, migrateLegacyPlan as aN, migrateLoadedTasks as aO, migratePlanState as aP, migrateTask as aQ, opsFlag as aR, partedPromptUsage as aS, plannerContextFill as aT, plannerTaskView as aU, removeTaskFromPlan as aV, renumberTasks as aW, skillNames as aX, updateTaskInPlan as aY, usageLine as aZ, validateModifiedPlan as a_, type TaskIsolation as aa, type TaskIsolationState as ab, type TaskMode as ac, type TaskModelAssignment as ad, type TaskOutputSummary as ae, type TaskSkillNotice as af, type TaskSkillSnapshot as ag, type TaskSnapshot as ah, type TaskStatus as ai, type TaskType as aj, type TaskWithParent as ak, type ThinkingBlock as al, type TreeSnapshot as am, type UsageLine as an, type UsageRecord as ao, type UsageTotals as ap, type UserPromptEntry as aq, type UserStep as ar, type ValidationCheck as as, type ValidationContext as at, type ValidationResult as au, type Verdict as av, type VerificationCheck as aw, addPlannerUsage as ax, addTaskToPlan as ay, addUsage as az, type DiscoveredMode as b, type DiscoveredModel as c, type IntegrationDisposal as d, type InvalidSkill as e, type IsolationAvailability as f, type IsolationHandoff as g, type IsolationHandoffRepo as h, type IsolationInactiveReason as i, type IsolationLandedTask as j, type IsolationLanding as k, type IsolationMergeBlock as l, type IsolationMergeBlockReason as m, type IsolationMergeResult as n, type IsolationOutcome as o, type IsolationPruneResult as p, type IsolationRemoval as q, type IsolationRepo as r, type IsolationRun as s, type IsolationTaskRecord as t, type IsolationTaskRef as u, type IsolationTaskRepo as v, type IsolationTaskStatus as w, type IsolationView as x, type PlanModificationWarnings as y, type PlanState as z };