@ordewell/core 0.9.1 → 0.10.0

package/dist/{IRunner-D6YfbmHn.d.mts → IRunner-hWAJC4hg.d.mts}

@@ -1,5 +1,5 @@
 import { ChildProcess } from 'child_process';
-import { ao as UsageRecord, a8 as SubagentOutcome, W as RunnerId, ag as TaskSkillSnapshot } from './Task-1Q19y7sZ.mjs';
+import { ao as UsageRecord, aa as SubagentOutcome, $ as RunnerId, aj as TaskSkillSnapshot } from './Task-CxwnCJLi.mjs';
 import { z } from 'zod/v4';
 
 /**
@@ -298,6 +298,7 @@ type ApprovalMode = 'ask' | 'allow' | 'deny';
  * The configured mode. `auto` follows the autonomy level (ADR-0026): Guarded
  * asks, Full runs the allowlist alone and asks nobody, so a planner in Full
  * never waits on a person and never acts outside its standing approvals.
+ * Web reads are the exception at both levels.
  */
 type ApprovalModeSetting = ApprovalMode | 'auto';
 declare function effectiveApprovalMode(setting: ApprovalModeSetting, autonomous: boolean, kind?: ApprovalKind): ApprovalMode;
@@ -377,9 +378,10 @@ declare class ApprovalPolicy implements IApproval {
  * scoped to that one tool. `web_search` is scoped to the search provider, the
  * party that receives every query (ADR-0027). `mcp_server` is starting an MCP
  * server the repository declares for a planner, scoped to its definition
- * (ADR-0028).
+ * (ADR-0028). `task_start` is the planner asking to start work through the
+ * command seam in Guarded (ADR-0029), asked afresh every time.
  */
-type ApprovalKind = 'external_path' | 'shell_command' | 'url_fetch' | 'web_search' | 'mcp_tool' | 'mcp_server' | 'runner_tool';
+type ApprovalKind = 'external_path' | 'shell_command' | 'url_fetch' | 'web_search' | 'mcp_tool' | 'mcp_server' | 'runner_tool' | 'task_start';
 interface ApprovalRequest {
     kind: ApprovalKind;
     /** Credentials, data and redirects need a fresh human answer for each invocation. */
@@ -505,8 +507,8 @@ declare const submitPlanInput: z.ZodObject<{
         title: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         type: z.ZodOptional<z.ZodEnum<{
-            ai: "ai";
             user: "user";
+            ai: "ai";
         }>>;
         dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
         prompt: z.ZodOptional<z.ZodString>;
@@ -520,7 +522,7 @@ declare const submitPlanInput: z.ZodObject<{
             modelLabel: z.ZodOptional<z.ZodString>;
             thinkingEffort: z.ZodOptional<z.ZodString>;
         }, z.core.$loose>>;
-        taskMode: z.ZodOptional<z.ZodString>;
+        readOnly: z.ZodOptional<z.ZodBoolean>;
         autonomy: z.ZodOptional<z.ZodEnum<{
             AFK: "AFK";
             HITL: "HITL";
@@ -580,10 +582,72 @@ declare const taskQueryInput: z.ZodObject<{
     catalog: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 declare const taskOutputInput: z.ZodObject<{
+    attempt: z.ZodOptional<z.ZodNumber>;
+    kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        text: "text";
+        error: "error";
+        command: "command";
+        thinking: "thinking";
+        task_skills: "task_skills";
+        turn_start: "turn_start";
+        command_output: "command_output";
+        compaction: "compaction";
+        runner_loaded: "runner_loaded";
+        turn_end: "turn_end";
+        text_delta: "text_delta";
+        thinking_delta: "thinking_delta";
+        tool_call: "tool_call";
+        tool_result: "tool_result";
+        subagent_started: "subagent_started";
+        subagent_finished: "subagent_finished";
+        usage: "usage";
+        message_queued: "message_queued";
+        message_removed: "message_removed";
+        message_undelivered: "message_undelivered";
+        message_handed_over: "message_handed_over";
+        message_delivered: "message_delivered";
+        approval_requested: "approval_requested";
+        approval_decided: "approval_decided";
+        approval_withdrawn: "approval_withdrawn";
+        runner_ended: "runner_ended";
+    }>>>;
+    task: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    lines: z.ZodOptional<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const taskDiffInput: z.ZodObject<{
     task: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    repo: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
     lines: z.ZodOptional<z.ZodNumber>;
     since: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
+declare const runPlanInput: z.ZodObject<{}, z.core.$strip>;
+declare const oneTaskInput: z.ZodObject<{
+    task: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strip>;
+declare const retryTaskInput: z.ZodObject<{
+    task: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    from: z.ZodEnum<{
+        fresh: "fresh";
+        session: "session";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const skipTaskInput: z.ZodObject<{
+    task: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+declare const messageTaskInput: z.ZodObject<{
+    task: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    text: z.ZodString;
+}, z.core.$strip>;
+declare const answerApprovalInput: z.ZodObject<{
+    task: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    approval: z.ZodOptional<z.ZodString>;
+    answer: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 type TaskCompleteArgs = z.infer<typeof taskCompleteInput>;
 type CheckpointArgs = z.infer<typeof checkpointInput>;
 type ListRunnersArgs = z.infer<typeof listRunnersInput>;
@@ -596,6 +660,13 @@ type SubmitPlanArgs = z.infer<typeof submitPlanInput>;
 type EditPlanArgs = z.infer<typeof editPlanInput>;
 type TaskQueryArgs = z.infer<typeof taskQueryInput>;
 type TaskOutputArgs = z.infer<typeof taskOutputInput>;
+type TaskDiffArgs = z.infer<typeof taskDiffInput>;
+type RunPlanArgs = z.infer<typeof runPlanInput>;
+type OneTaskArgs = z.infer<typeof oneTaskInput>;
+type RetryTaskArgs = z.infer<typeof retryTaskInput>;
+type MessageTaskArgs = z.infer<typeof messageTaskInput>;
+type SkipTaskArgs = z.infer<typeof skipTaskInput>;
+type AnswerApprovalArgs = z.infer<typeof answerApprovalInput>;
 /** What a handler answers with. `isError` marks a refusal the caller should act on. */
 interface McpToolReply {
     text: string;
@@ -635,6 +706,16 @@ interface PlannerToolHandler {
     editPlan?: Run<EditPlanArgs>;
     taskQuery?: Run<TaskQueryArgs>;
     taskOutput?: Run<TaskOutputArgs>;
+    taskDiff?: Run<TaskDiffArgs>;
+    runPlan?: Run<RunPlanArgs>;
+    runTask?: Run<OneTaskArgs>;
+    stopTask?: Run<OneTaskArgs>;
+    stopRun?: Run<RunPlanArgs>;
+    retryTask?: Run<RetryTaskArgs>;
+    skipTask?: Run<SkipTaskArgs>;
+    messageTask?: Run<MessageTaskArgs>;
+    answerApproval?: Run<AnswerApprovalArgs>;
+    mergeAll?: Run<RunPlanArgs>;
 }
 interface McpTool<H> {
     name: string;
@@ -651,7 +732,19 @@ interface McpTool<H> {
 }
 /** The task tool whose call settles the attempt (ADR-0022, V1). */
 declare const TASK_COMPLETE_TOOL = "task_complete";
+/**
+ * How a task is told to end. It rides in the runner's instructions rather than
+ * in the first message: a runner compacts its own context and rewrites that
+ * message into a summary, while its instructions are re-applied whole.
+ */
+declare const TASK_COMPLETION_CONTRACT: string;
 declare const TASK_TOOLS: readonly McpTool<TaskToolHandler>[];
+/**
+ * The planner's execution tools (ADR-0029, #91): each call goes to the
+ * session's command seam, which checks it, asks the user where consent needs
+ * one, and records it. The API planner offers the same tools as its own.
+ */
+declare const PLANNER_EXECUTION_TOOLS: readonly McpTool<PlannerToolHandler>[];
 declare const PLANNER_TOOLS: readonly McpTool<PlannerToolHandler>[];
 
 /**
@@ -756,6 +849,33 @@ interface ProjectMcpServer {
     definition: Record<string, unknown>;
 }
 
+/**
+ * What a runner command is to the runner that offers it: a `builtin` of the
+ * harness itself (`/compact`, `/model`), a `skill`, or any other `command` —
+ * a user's or a project's custom command, an MCP prompt.
+ */
+type RunnerCommandKind = 'command' | 'skill' | 'builtin';
+/**
+ * One slash command a task's runner offers, as the runner itself reported it
+ * (#66). Ordewell transports it and records it; it never interprets one.
+ */
+interface RunnerCommand {
+    name: string;
+    description: string;
+    /** How the runner describes its arguments (`<model>`, `[name]`); absent when it takes none it names. */
+    argumentHint?: string;
+    kind: RunnerCommandKind;
+    /** Other names the runner answers to for the same command. */
+    aliases?: string[];
+}
+/** An MCP server a runner loaded for a task, and the state the runner reported it in. */
+interface RunnerMcpServer {
+    name: string;
+    status?: string;
+}
+/** The command `name` names, by its own name or an alias. */
+declare function findRunnerCommand(commands: readonly RunnerCommand[], name: string): RunnerCommand | undefined;
+
 /**
  * The harness-planner transport contract (ADR-0009).
  *
@@ -908,6 +1028,28 @@ type AgentEvent =
  | {
     type: 'error';
     message: string;
+}
+/**
+ * What the runner loaded for this process from the user's and the
+ * project's own setup (#66): its commands and skills, and its MCP servers.
+ * Once per process, as it starts its first turn.
+ */
+ | {
+    type: 'runner_loaded';
+    commands: RunnerCommand[];
+    mcpServers: RunnerMcpServer[];
+}
+/** The runner compacted its own context: asked to (`manual`) or on its own (`auto`). */
+ | {
+    type: 'compaction';
+    trigger: 'manual' | 'auto';
+    preTokens?: number;
+    postTokens?: number;
+}
+/** What a runner command that runs without the model printed, as the runner reported it. */
+ | {
+    type: 'command_output';
+    text: string;
 };
 /**
  * What a planner's permission request is for, read from the runner's own
@@ -1052,6 +1194,13 @@ interface AgentAdapter {
      * Absent on an adapter that gives the planner every one it starts.
      */
     unusableProjectServers?(): ProjectMcpServer[];
+    /**
+     * Whether `abs`, already resolved on disk, is output this runner saved
+     * outside the workspace for this session and told its planner to read back
+     * (ADR-0032). The planner reads it as it reads the workspace. Absent on a
+     * runner that saves none.
+     */
+    savedOutput?(abs: string): boolean;
     /**
      * Answer an open `permission_request`. False when the id is not open — it
      * was answered, cancelled, or never asked. Absent on an adapter that leaves
@@ -1076,8 +1225,11 @@ interface TaskModeAgentAdapter extends AgentAdapter {
      * for a planner and wrong for a task, which may report completion there.
      */
     onOutOfTurn?(listener: (event: AgentEvent) => void): void;
-    /** Registers a listener for the process ending, for any reason. Fires at most once. */
-    onProcessExit(listener: (code: number) => void): void;
+    /**
+     * Registers a listener for the process ending, for any reason. Fires at most
+     * once. `lastWords` is how it ended, with its stderr tail.
+     */
+    onProcessExit(listener: (code: number, lastWords?: string) => void): void;
     /**
      * Hand a message to the running turn, for the runner to show the model at
      * its next step boundary (ADR-0023, D1–D2). Resolves true once the runner
@@ -1089,6 +1241,18 @@ interface TaskModeAgentAdapter extends AgentAdapter {
      */
     steer?(id: string, text: string): Promise<boolean>;
     answerPermission(id: string, decision: ApprovalDecision): boolean;
+    /**
+     * The slash commands the runner offers this session — its built-ins, the
+     * user's and the project's skills and custom commands (#66) — as it
+     * reported them. Empty until it has; absent on a runner that reports none.
+     */
+    commands?(): RunnerCommand[];
+    /**
+     * Run the runner's own command `name` as a turn, the way {@link send} runs
+     * a message: resolves when the turn ends. Absent on a runner whose
+     * commands cannot be invoked over its protocol.
+     */
+    invokeCommand?(name: string, args: string, onEvent: (event: AgentEvent) => void, signal?: AbortSignal): Promise<void>;
 }
 type SpawnFn = (command: string, args: string[], options: {
     env: NodeJS.ProcessEnv;
@@ -1242,6 +1406,16 @@ interface RunnerMode {
     autonomous?: boolean;
     /** Marks this mode as the runner's conservative build mode — the resolved default when autonomous mode is OFF. */
     safe?: boolean;
+    /** Marks this mode as the runner's read-only mode — what a task the planner marks read-only runs in (ADR-0031). */
+    readOnly?: boolean;
+    /** The mode runs under an OS sandbox, so a host where the runner's sandbox cannot start cannot offer it. */
+    sandboxed?: boolean;
+    /**
+     * Why this mode cannot be used on this host. Set by the registry from a host
+     * probe, never by a manifest: a mode with a reason is listed, so the user is
+     * told, but never assigned, kept or run.
+     */
+    unavailable?: string;
 }
 interface RunnerEntry {
     manifest: RunnerManifest;
@@ -1438,6 +1612,9 @@ declare function enabledRunners(cfg: IConfig): RunnerId[];
 
 declare class RunnerRegistry {
     private readonly runners;
+    private readonly unavailableModes;
+    /** Mark modes of a runner unusable on this host, by mode id and reason; an empty record clears them. */
+    setUnavailableModes(id: string, reasons: Record<string, string>): void;
     get(id: string): RunnerEntry | undefined;
     getManifest(id: string): RunnerManifest | undefined;
     list(): RunnerEntry[];
@@ -1447,6 +1624,11 @@ declare class RunnerRegistry {
 
 /** How a structured turn ended. `failed` carries the agent's own words in the preceding `error` event. */
 type StructuredTurnEnd = 'completed' | 'interrupted' | 'failed';
+/**
+ * Who sent a task message that is not the user's: Ordewell itself, for the
+ * completion reminder (ADR-0018, W1). Absent means the user.
+ */
+type TaskMessageFrom = 'ordewell';
 /**
  * One normalized event from a structured task (ADR-0018, O1b): the adapter's
  * events, with the turn made explicit at both ends and the message queue (M1)
@@ -1458,13 +1640,17 @@ type StructuredEvent = Exclude<AgentEvent, {
 }>
 /**
  * `text` is the user message the turn answers; `messageId` is set when it had
- * waited in the queue, `forced` when it was force sent (ADR-0023, Q2).
+ * waited in the queue, `forced` when it was force sent (ADR-0023, Q2), `from`
+ * when Ordewell sent it. `command` is set on a turn that runs the runner's
+ * own command (#66); `text` is then that command as the runner read it.
  */
  | {
     type: 'turn_start';
     text: string;
     messageId?: string;
     forced?: boolean;
+    from?: TaskMessageFrom;
+    command?: InvokedCommand;
 } | {
     type: 'turn_end';
     reason: StructuredTurnEnd;
@@ -1472,13 +1658,15 @@ type StructuredEvent = Exclude<AgentEvent, {
 /**
  * Waiting in Ordewell's queue — again, for a message the runner was handed
  * and let go of (ADR-0023, D4). `forced` puts it ahead of the rest, behind
- * earlier forced ones (F2); a message already listed moves there.
+ * earlier forced ones (F2); a message already listed moves there, still
+ * handed over if it was.
  */
  | {
     type: 'message_queued';
     messageId: string;
     text: string;
     forced?: boolean;
+    from?: TaskMessageFrom;
 } | {
     type: 'message_removed';
     messageId: string;
@@ -1486,6 +1674,7 @@ type StructuredEvent = Exclude<AgentEvent, {
     type: 'message_undelivered';
     messageId: string;
     text: string;
+    from?: TaskMessageFrom;
 }
 /** The runner accepted the message into its running turn; it can no longer be taken back (ADR-0023, D3). */
  | {
@@ -1497,6 +1686,7 @@ type StructuredEvent = Exclude<AgentEvent, {
     type: 'message_delivered';
     messageId: string;
     text: string;
+    from?: TaskMessageFrom;
 }
 /** An open `permission_request` was answered, by whoever answered it (ADR-0018, A1). */
  | {
@@ -1509,13 +1699,19 @@ type StructuredEvent = Exclude<AgentEvent, {
     type: 'permission_withdrawn';
     id: string;
 };
+/** A runner command a user invoked, with its arguments as typed. */
+interface InvokedCommand {
+    name: string;
+    args?: string;
+}
 interface QueuedTaskMessage {
     id: string;
     text: string;
     /** The runner has it and owes a delivery, so it cannot be taken back (ADR-0023, Q1). */
     handedOver?: boolean;
-    /** Force sent: it goes out as soon as the running turn is interrupted (ADR-0023, F1). */
+    /** Force sent: it goes first once the running turn is interrupted (ADR-0023, F1). Every listed message can be, handed over or not. */
     forced?: boolean;
+    from?: TaskMessageFrom;
 }
 interface IRunnerSession {
     id: string;
@@ -1533,8 +1729,9 @@ interface IRunnerSession {
      * Send a user message: at once when idle; while a turn runs, handed to the
      * runner for its next step where it can take one, otherwise queued until
      * the turn ends (ADR-0023). Returns its id, for {@link removeQueued}.
+     * `from` marks a message Ordewell sent rather than the user.
      */
-    sendMessage(text: string): string;
+    sendMessage(text: string, from?: TaskMessageFrom): string;
     /**
      * Force send (ADR-0023, F1–F3): interrupt the running turn, as
      * {@link interrupt} does, and deliver this message as the turn that
@@ -1542,7 +1739,11 @@ interface IRunnerSession {
      * input in between. With no turn running it is {@link sendMessage}.
      */
     forceSend(text: string): string;
-    /** Force send a message still queued, by id. False once it was handed over or delivered. */
+    /**
+     * Force send a message not yet delivered, by id — queued, or handed over,
+     * which is not sent twice: the interrupt makes it go first (ADR-0023, F1).
+     * False once it was delivered.
+     */
     forceSendQueued(id: string): boolean;
     /** Take a message back before the runner has it. False once it was handed over or delivered. */
     removeQueued(id: string): boolean;
@@ -1556,6 +1757,20 @@ interface IRunnerSession {
     interrupt(): Promise<void>;
     /** The runner's own session id once announced — what a continue resumes (ADR-0018, K1). */
     nativeSessionId(): string | null;
+    /**
+     * The slash commands the runner offers this task (#66): its built-ins and
+     * the user's and the project's skills and custom commands. Empty for a
+     * runner that reports none.
+     */
+    commands(): RunnerCommand[];
+    /**
+     * Run the runner's own command `name` as a turn of its own: at once when
+     * idle, otherwise queued behind the running turn — never handed into it,
+     * where a runner reads it as text. A runner whose commands cannot be invoked
+     * over its protocol is sent `/name args` as a message. Returns its id, as
+     * {@link sendMessage} does.
+     */
+    invokeCommand(name: string, args?: string): string;
     /**
      * Answer a `permission_request` this session emitted, by its event id. False
      * when it is no longer open — answered, withdrawn, or never asked.
@@ -1618,4 +1833,4 @@ interface IRunner {
     activeCount: number;
 }
 
-export { type PlannerTokenScope as $, AUTO_COMMANDS as A, type ListModelsArgs as B, type CatalogModel as C, DEFAULT_PLANNER_ALLOWLIST as D, type EditPlanArgs as E, type FetchAllProviderModelsOptions as F, GIT_READONLY_SUBCOMMANDS as G, type ListRunnersArgs as H, type IApproval as I, type LoadSkillArgs as J, type McpCredential as K, LineBuffer as L, type McpClientConfig as M, type McpTool as N, type McpToolContext as O, type McpToolReply as P, ModelCatalog as Q, type ModelShortcut as R, ORCHESTRATOR_SHORTCUTS as S, ORDEWELL_MCP_PATH as T, ORDEWELL_MCP_SERVER_NAME as U, type OrchestratorOption as V, OrdewellMcpServer as W, type OwnerOnlyFile as X, PLANNER_TOOLS as Y, type PlannerAllowlist as Z, type PlannerStartOptions as _, type AgentAdapter as a, type PlannerToolHandler as a0, type ProjectMcpServer as a1, type ProviderCredentialSource as a2, type ProviderModelLists as a3, type ProviderModelsResult as a4, type QueuedTaskMessage as a5, REFUSED_COMMANDS as a6, type ResearchShell as a7, type ResearchShellDeps as a8, type RunCommandArgs as a9, collectProviderCredentials as aA, commandAllowedBy as aB, effectiveApprovalMode as aC, enabledRunners as aD, fetchAllProviderModels as aE, isGranted as aF, isRunnerApproval as aG, knownModelId as aH, mcpClientConfig as aI, ownerOnlyConfigFile as aJ, parseAllowlist as aK, parseApprovalModeSetting as aL, researchShellWarning as aM, researchToolsPath as aN, resolveModelShortcut as aO, resolveProvider as aP, resolveResearchShell as aQ, scopeAllowed as aR, sharedMcpServer as aS, toApprovalDecision as aT, toOrchestratorOptions as aU, toolAllowed as aV, type RunnerEntry as aa, type RunnerFeatures as ab, type RunnerManifest as ac, type RunnerMode as ad, type RunnerModelDiscovery as ae, RunnerRegistry as af, type ShellDialect as ag, type SpawnFn as ah, type StandingDecision as ai, type StructuredEvent as aj, type StructuredTurnEnd as ak, type SubmitPlanArgs as al, TASK_COMPLETE_TOOL as am, TASK_TOOLS as an, type TaskCompleteArgs as ao, type TaskModeAgentAdapter as ap, TaskModeUnsupportedError as aq, type TaskOutputArgs as ar, type TaskQueryArgs as as, type TaskRunnerFlags as at, type TaskStartOptions as au, type TaskTokenScope as av, type TaskToolHandler as aw, approvalScopes as ax, classifyCommand as ay, clearResearchShellCache as az, type AgentAdapterFactory as b, type AgentEvent as c, type AgentProcessDeps as d, type AgentStartOptions as e, type AiProvider as f, type AllProviderModels as g, type ApprovalAnswer as h, type ApprovalDecision as i, type ApprovalKind as j, type ApprovalMode as k, type ApprovalModeSetting as l, ApprovalPolicy as m, type ApprovalPolicyOptions as n, type ApprovalRequest as o, type ApprovalSource as p, type CheckpointAnswer as q, type CheckpointArgs as r, type CommandClassification as s, type CommandTier as t, type CommandWords as u, DENY_ALL as v, type DiscoveryCommand as w, type IConfig as x, type IRunner as y, type IRunnerSession as z };
+export { type OwnerOnlyFile as $, AUTO_COMMANDS as A, type IRunnerSession as B, type CatalogModel as C, DEFAULT_PLANNER_ALLOWLIST as D, type EditPlanArgs as E, type FetchAllProviderModelsOptions as F, GIT_READONLY_SUBCOMMANDS as G, type InvokedCommand as H, type IApproval as I, type ListModelsArgs as J, type ListRunnersArgs as K, LineBuffer as L, type LoadSkillArgs as M, type McpClientConfig as N, type McpCredential as O, type McpTool as P, type McpToolContext as Q, type McpToolReply as R, type MessageTaskArgs as S, ModelCatalog as T, type ModelShortcut as U, ORCHESTRATOR_SHORTCUTS as V, ORDEWELL_MCP_PATH as W, ORDEWELL_MCP_SERVER_NAME as X, type OneTaskArgs as Y, type OrchestratorOption as Z, OrdewellMcpServer as _, type AgentAdapter as a, researchToolsPath as a$, PLANNER_EXECUTION_TOOLS as a0, PLANNER_TOOLS as a1, type PlannerAllowlist as a2, type PlannerStartOptions as a3, type PlannerTokenScope as a4, type PlannerToolHandler as a5, type ProjectMcpServer as a6, type ProviderCredentialSource as a7, type ProviderModelLists as a8, type ProviderModelsResult as a9, type TaskDiffArgs as aA, type TaskMessageFrom as aB, type TaskModeAgentAdapter as aC, TaskModeUnsupportedError as aD, type TaskOutputArgs as aE, type TaskQueryArgs as aF, type TaskRunnerFlags as aG, type TaskStartOptions as aH, type TaskTokenScope as aI, type TaskToolHandler as aJ, approvalScopes as aK, classifyCommand as aL, clearResearchShellCache as aM, collectProviderCredentials as aN, commandAllowedBy as aO, effectiveApprovalMode as aP, enabledRunners as aQ, fetchAllProviderModels as aR, findRunnerCommand as aS, isGranted as aT, isRunnerApproval as aU, knownModelId as aV, mcpClientConfig as aW, ownerOnlyConfigFile as aX, parseAllowlist as aY, parseApprovalModeSetting as aZ, researchShellWarning as a_, type QueuedTaskMessage as aa, REFUSED_COMMANDS as ab, type ResearchShell as ac, type ResearchShellDeps as ad, type RetryTaskArgs as ae, type RunCommandArgs as af, type RunPlanArgs as ag, type RunnerCommand as ah, type RunnerCommandKind as ai, type RunnerEntry as aj, type RunnerFeatures as ak, type RunnerManifest as al, type RunnerMcpServer as am, type RunnerMode as an, type RunnerModelDiscovery as ao, RunnerRegistry as ap, type ShellDialect as aq, type SpawnFn as ar, type StandingDecision as as, type StructuredEvent as at, type StructuredTurnEnd as au, type SubmitPlanArgs as av, TASK_COMPLETE_TOOL as aw, TASK_COMPLETION_CONTRACT as ax, TASK_TOOLS as ay, type TaskCompleteArgs as az, type AgentAdapterFactory as b, resolveModelShortcut as b0, resolveProvider as b1, resolveResearchShell as b2, scopeAllowed as b3, sharedMcpServer as b4, toApprovalDecision as b5, toOrchestratorOptions as b6, toolAllowed as b7, type AgentEvent as c, type AgentProcessDeps as d, type AgentStartOptions as e, type AiProvider as f, type AllProviderModels as g, type AnswerApprovalArgs as h, type ApprovalAnswer as i, type ApprovalDecision as j, type ApprovalKind as k, type ApprovalMode as l, type ApprovalModeSetting as m, ApprovalPolicy as n, type ApprovalPolicyOptions as o, type ApprovalRequest as p, type ApprovalSource as q, type CheckpointAnswer as r, type CheckpointArgs as s, type CommandClassification as t, type CommandTier as u, type CommandWords as v, DENY_ALL as w, type DiscoveryCommand as x, type IConfig as y, type IRunner as z };

package/dist/ModeResolver-m1d8Cb-j.d.mts

@@ -0,0 +1,35 @@
+import { $ as RunnerId } from './Task-CxwnCJLi.mjs';
+
+interface RunnerModeInfo {
+    id: string;
+    label: string;
+    description: string;
+    autonomous?: boolean;
+    safe?: boolean;
+    readOnly?: boolean;
+    sandboxed?: boolean;
+    /** Why this mode cannot be used on this host (a failed probe); such a mode is shown, never assigned. */
+    unavailable?: string;
+}
+/** The slice of RunnerRegistry this module needs — structural, so nothing here depends on the manifest layer. */
+interface ManifestLookup {
+    getManifest(runner: RunnerId): {
+        modes?: RunnerModeInfo[];
+    } | undefined;
+}
+/**
+ * A runner's modes are declared only in its manifest, never through a service,
+ * so every caller that needs them fuses registry and runner list by hand. This
+ * is that fusion, in one place: the planner prompt, the mode pickers on each
+ * surface, and the runner-change retarget all read modes the same way.
+ *
+ * A runner with no modes maps to `[]` rather than being dropped — callers
+ * distinguish "declares no modes" from "not asked about".
+ */
+declare function runnerModesFrom(registry: ManifestLookup, runners: RunnerId[]): Record<RunnerId, RunnerModeInfo[]>;
+/** The user-facing name of the `autonomousMode` boolean's two states. */
+declare function autonomyLevelLabel(autonomous: boolean): 'Full' | 'Guarded';
+/** `full`/`guarded` name the levels; `on`/`off` and `auto` are older words for them. Null for anything else. */
+declare function parseAutonomyLevel(arg: string | undefined): boolean | null;
+
+export { type RunnerModeInfo as R, autonomyLevelLabel as a, parseAutonomyLevel as p, runnerModesFrom as r };

package/dist/ModeResolver-u5ZhRC8x.d.ts

@@ -0,0 +1,35 @@
+import { $ as RunnerId } from './Task-CxwnCJLi.js';
+
+interface RunnerModeInfo {
+    id: string;
+    label: string;
+    description: string;
+    autonomous?: boolean;
+    safe?: boolean;
+    readOnly?: boolean;
+    sandboxed?: boolean;
+    /** Why this mode cannot be used on this host (a failed probe); such a mode is shown, never assigned. */
+    unavailable?: string;
+}
+/** The slice of RunnerRegistry this module needs — structural, so nothing here depends on the manifest layer. */
+interface ManifestLookup {
+    getManifest(runner: RunnerId): {
+        modes?: RunnerModeInfo[];
+    } | undefined;
+}
+/**
+ * A runner's modes are declared only in its manifest, never through a service,
+ * so every caller that needs them fuses registry and runner list by hand. This
+ * is that fusion, in one place: the planner prompt, the mode pickers on each
+ * surface, and the runner-change retarget all read modes the same way.
+ *
+ * A runner with no modes maps to `[]` rather than being dropped — callers
+ * distinguish "declares no modes" from "not asked about".
+ */
+declare function runnerModesFrom(registry: ManifestLookup, runners: RunnerId[]): Record<RunnerId, RunnerModeInfo[]>;
+/** The user-facing name of the `autonomousMode` boolean's two states. */
+declare function autonomyLevelLabel(autonomous: boolean): 'Full' | 'Guarded';
+/** `full`/`guarded` name the levels; `on`/`off` and `auto` are older words for them. Null for anything else. */
+declare function parseAutonomyLevel(arg: string | undefined): boolean | null;
+
+export { type RunnerModeInfo as R, autonomyLevelLabel as a, parseAutonomyLevel as p, runnerModesFrom as r };