@ordewell/core 0.4.9 → 0.4.11

package/dist/index.d.ts

@@ -1,13 +1,16 @@
-import { h as RunnerId, c as PlanStatus, L as LegacyPlanState, d as ResearchProgress, a as DiscoveredModel, T as Task, R as ResearchLogEntry, C as ConversationMessage, n as TaskSnapshot, Q as QueuedMessage, A as ActiveTaskSession, g as ResearchToolType, u as Verdict, e as ResearchStep, b as PlanState } from './Task-1NwmUImI.js';
-export { D as DiscoveredMode, M as Message, P as PlanModificationWarnings, f as ResearchStepOutcome, S as StreamEvent, i as StreamStepEvent, j as StreamThinkingEvent, k as TaskMode, l as TaskModelAssignment, m as TaskOutputSummary, o as TaskStatus, p as TaskType, q as ThinkingBlock, U as UserPromptEntry, r as UserStep, V as ValidationCheck, s as ValidationContext, t as ValidationResult, v as VerificationCheck, w as addTaskToPlan, x as createEmptyPlan, y as createTask, z as emptyWarnings, B as flattenTasks, E as migrateLegacyPlan, F as migratePlanState, G as migrateTask, H as removeTaskFromPlan, I as renumberTasks, J as updateTaskInPlan, K as validateModifiedPlan, N as warningsText } from './Task-1NwmUImI.js';
-import { n as IFileSystem, I as IApproval, R as ReadFileOpts, T as ToolOutcome, k as GrepOptions, j as GlobOptions, i as FindSymbolOptions, f as ApprovalRequest, m as IConfig, A as AiProvider, z as ProviderModelLists, c as ApprovalMode, q as ITerminalSession, p as ITerminalRunner, K as RunnerRegistry, s as OrchestratorOption, b as ApprovalKind, g as ApprovalSource, H as RunnerInvocation, o as IPluginStore, J as RunnerPluginManifest, E as ResolveContext } from './ITerminalRunner-CbE6gKLI.js';
-export { a as AllProviderModels, d as ApprovalPolicy, e as ApprovalPolicyOptions, C as CatalogModel, D as DENY_ALL, h as DiscoveryCommand, F as FetchAllProviderModelsOptions, G as GREP_DEFAULT_HEAD_LIMIT, l as GrepOutputMode, M as ModelCatalog, r as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, P as PluginCloneFn, t as PluginEntry, u as PluginFeatures, v as PluginMode, w as PluginModelDiscovery, x as PluginRunnerDef, y as ProviderCredentialSource, B as ProviderModelsResult, S as SEARCH_EXCLUSIONS, L as collectProviderCredentials, N as enabledRunners, Q as fetchAllProviderModels, U as isReservedRunnerName, V as knownModelId, W as resolveModelShortcut, X as resolveProvider, Y as toOrchestratorOptions } from './ITerminalRunner-CbE6gKLI.js';
-import { R as RunnerModeInfo, b as PlanParseError } from './parsing-RjN9JbyG.js';
-export { M as ManifestLookup, P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, T as TASK_OPS_ENVELOPE_KEY, c as buildModeGuide, d as checkDepsResolve, e as checkImmutableLog, f as checkInProgress, g as checkNoCycles, h as checkUniqueIds, i as escapeControlCharsInStrings, j as extractJsonObject, k as extractObjectWithBalance, l as extractObjectsWithKey, m as filteredBuildModes, n as looksLikePlanAttempt, p as parsePartialPlan, o as parsePlanJson, r as resolveDefaultMode, q as resolveTaskMode, s as runnerModesFrom, t as stripModelNoise, u as stripTrailingCommas, v as validatePlanModification } from './parsing-RjN9JbyG.js';
-import { T as TaskOp } from './plan-utils-Cgc0cCH1.js';
-export { A as ApplyTaskOpsResult, a as TaskRef, b as applyTaskOps, c as canMergeTasks, d as canSetDependencies, e as canSplitTask, f as classifyOutcome, g as dependencyCandidates, h as dependentsOf, p as parseTaskOpsJson, s as summarizeToolCall, t as textHasTaskOps } from './plan-utils-Cgc0cCH1.js';
+import { h as RunnerId, c as PlanStatus, L as LegacyPlanState, a as DiscoveredModel, T as Task, d as ResearchProgress, R as ResearchLogEntry, C as ConversationMessage, n as TaskSnapshot, Q as QueuedMessage, A as ActiveTaskSession, g as ResearchToolType, v as Verdict, e as ResearchStep, b as PlanState } from './Task-cGrfYRXK.js';
+export { D as DiscoveredMode, M as Message, P as PlanModificationWarnings, f as ResearchStepOutcome, S as StreamEvent, i as StreamStepEvent, j as StreamThinkingEvent, k as TaskMode, l as TaskModelAssignment, m as TaskOutputSummary, o as TaskStatus, p as TaskType, q as TaskWithParent, r as ThinkingBlock, U as UserPromptEntry, s as UserStep, V as ValidationCheck, t as ValidationContext, u as ValidationResult, w as VerificationCheck, x as addTaskToPlan, y as createEmptyPlan, z as createTask, B as emptyWarnings, E as flattenTasks, F as flattenTasksWithParents, G as migrateLegacyPlan, H as migratePlanState, I as migrateTask, J as removeTaskFromPlan, K as renumberTasks, N as updateTaskInPlan, O as validateModifiedPlan, W as warningsText } from './Task-cGrfYRXK.js';
+import { n as IFileSystem, I as IApproval, R as ReadFileOpts, T as ToolOutcome, k as GrepOptions, j as GlobOptions, i as FindSymbolOptions, f as ApprovalRequest, m as IConfig, A as AiProvider, z as ProviderModelLists, c as ApprovalMode, q as ITerminalSession, p as ITerminalRunner, K as RunnerRegistry, s as OrchestratorOption, b as ApprovalKind, g as ApprovalSource, H as RunnerInvocation, o as IPluginStore, J as RunnerPluginManifest, E as ResolveContext } from './ITerminalRunner-DVwORcV9.js';
+export { a as AllProviderModels, d as ApprovalPolicy, e as ApprovalPolicyOptions, C as CatalogModel, D as DENY_ALL, h as DiscoveryCommand, F as FetchAllProviderModelsOptions, G as GREP_DEFAULT_HEAD_LIMIT, l as GrepOutputMode, M as ModelCatalog, r as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, P as PluginCloneFn, t as PluginEntry, u as PluginFeatures, v as PluginMode, w as PluginModelDiscovery, x as PluginRunnerDef, y as ProviderCredentialSource, B as ProviderModelsResult, S as SEARCH_EXCLUSIONS, L as collectProviderCredentials, N as enabledRunners, Q as fetchAllProviderModels, U as isReservedRunnerName, V as knownModelId, W as resolveModelShortcut, X as resolveProvider, Y as toOrchestratorOptions } from './ITerminalRunner-DVwORcV9.js';
+import { R as RunnerModeInfo } from './ModeResolver-CzZd-i6T.js';
+export { M as ManifestLookup, b as buildModeGuide, f as filteredBuildModes, r as resolveDefaultMode, a as resolveTaskMode, c as runnerModesFrom } from './ModeResolver-CzZd-i6T.js';
+import { T as TaskOp } from './plan-utils-akoB6YCL.js';
+export { A as ApplyTaskOpsResult, a as TaskRef, b as applyTaskOps, c as canMergeTasks, d as canSetDependencies, e as canSplitTask, f as classifyOutcome, g as dependencyCandidates, h as dependentsOf, p as parseTaskOpsJson, s as summarizeToolCall, t as textHasTaskOps } from './plan-utils-akoB6YCL.js';
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
+import { b as PlanParseError } from './parsing-D87zKtTe.js';
+export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, T as TASK_OPS_ENVELOPE_KEY, c as TASK_QUERY_ENVELOPE_KEY, d as checkDepsResolve, e as checkImmutableLog, f as checkInProgress, g as checkNoCycles, h as checkUniqueIds, i as escapeControlCharsInStrings, j as extractJsonObject, k as extractObjectWithBalance, l as extractObjectsWithKey, m as looksLikePlanAttempt, p as parsePartialPlan, n as parsePlanJson, s as stripModelNoise, o as stripTrailingCommas, v as validatePlanModification } from './parsing-D87zKtTe.js';
+export { resolveOrderLabel, taskOrderLabel } from './order-labels.js';
 
 interface SessionMeta {
     id: string;
@@ -557,24 +560,12 @@ declare class ConsoleLogger implements ILogger {
 declare const defaultLogger: ILogger;
 
 interface UserSettings {
-    grillMe: {
-        enabled: boolean;
-    };
     tdd: {
         enabled: boolean;
     };
-    prd: {
-        enabled: boolean;
-    };
-    review: {
-        enabled: boolean;
-    };
     verification: {
         enabled: boolean;
     };
-    researchSubagents: {
-        enabled: boolean;
-    };
     modelAllowlist?: Record<string, string[]>;
     /** Last model (and its thinking effort) the user chose for each planner backend, keyed by AiProvider id. */
     plannerModels?: Record<string, {
@@ -592,10 +583,10 @@ interface UserSettings {
  * Ordewell processes on one machine can hold *different* settings at the same
  * time. Without it the file is a single shared mutable global: the benchmark
  * harness runs parallel lanes that each pin the mode toggles, and because
- * `getAll()` re-reads whenever the mtime moves, a lane needing
- * `researchSubagents: true` would silently plan with `false` the moment another
- * lane pinned its own — turning an A/B of that toggle into a comparison of one
- * condition against itself.
+ * `getAll()` re-reads whenever the mtime moves, a lane needing a toggle
+ * `true` would silently plan with `false` the moment another lane pinned its
+ * own — turning an A/B of that toggle into a comparison of one condition
+ * against itself.
  */
 declare function getSettingsPath(): string;
 declare class SettingsService {
@@ -605,18 +596,10 @@ declare class SettingsService {
     constructor(filePath?: string);
     getAll(): UserSettings;
     private fileMtimeMs;
-    getGrillMe(): boolean;
     getTdd(): boolean;
-    getPrd(): boolean;
-    setGrillMe(enabled: boolean): void;
     setTdd(enabled: boolean): void;
-    setPrd(enabled: boolean): void;
-    getReview(): boolean;
-    setReview(enabled: boolean): void;
     getVerification(): boolean;
     setVerification(enabled: boolean): void;
-    getResearchSubagents(): boolean;
-    setResearchSubagents(enabled: boolean): void;
     getModelAllowlist(runner: string): string[] | undefined;
     setModelAllowlist(runner: string, ids: string[] | undefined): void;
     getPlannerModel(provider: string): {
@@ -635,12 +618,8 @@ declare class SettingsService {
 
 /** How the same toggle is named once a host has read it off disk. */
 interface PlannerRuntimeToggles {
-    grillMeEnabled: boolean;
     tddEnabled: boolean;
-    prdEnabled: boolean;
-    reviewEnabled: boolean;
     verificationEnabled: boolean;
-    researchSubagentsEnabled: boolean;
 }
 /**
  * The planner-facing mode set for one operation. Replaces the boolean tail that
@@ -649,13 +628,68 @@ interface PlannerRuntimeToggles {
  */
 interface PlannerModes {
     autonomousDefault: boolean;
-    grillMe: boolean;
-    prd: boolean;
-    review: boolean;
     verification: boolean;
-    researchSubagents: boolean;
 }
 
+/**
+ * The planner's read channel: a `{"taskQuery":{...}}` reply asking Ordewell to
+ * show it what the per-turn plan block deliberately leaves out.
+ *
+ * The plan block carries only short fields, so a planner asked to "add a line
+ * to task 3's prompt" would be rewriting text it has never read. Inlining every
+ * body on every turn was rejected — a twenty-task plan re-sends thousands of
+ * tokens per message — so the planner asks instead, and pays for the detail
+ * only on the turns it uses it.
+ *
+ * This module owns the wire shape and the rendering of the answer; the loop,
+ * the budgets and the injection live in the Session, and the classification
+ * lives in PlanRepair alongside the plan and task-ops envelopes.
+ */
+/** The long fields a query may ask for. Everything else is already in the plan block. */
+declare const TASK_QUERY_FIELDS: readonly ["description", "prompt", "userSteps", "verdict", "outputSummary", "userStoriesCovered"];
+type TaskQueryField = typeof TASK_QUERY_FIELDS[number];
+interface TaskQuery {
+    /** Task references to read in full — an id, "#order", a bare order, or a title. */
+    tasks: string[];
+    /** Narrows what comes back. Omitted means every field in {@link TASK_QUERY_FIELDS}. */
+    fields?: TaskQueryField[];
+    /** Also return the full runner/model catalog with labels, variants and mode descriptions. */
+    catalog: boolean;
+}
+declare function textHasTaskQuery(text: string): boolean;
+/** Parse a `{"taskQuery":...}` reply. Throws PlanParseError when the JSON is unusable. */
+declare function parseTaskQueryJson(text: string): TaskQuery;
+/** Stable identity of a query, so a turn can recognise the planner asking the same thing twice. */
+declare function taskQuerySignature(query: TaskQuery): string;
+/** What a full-catalog read is answered from. Models arrive already allowlist-filtered. */
+interface TaskQueryCatalog {
+    runners: RunnerId[];
+    models: Partial<Record<RunnerId, DiscoveredModel[]>>;
+    modes: Record<RunnerId, RunnerModeInfo[]>;
+    autonomousDefault: boolean;
+}
+/**
+ * Appended when the planner has spent its read budget, or asked the identical
+ * question twice. The detail still comes back — refusing it would leave the
+ * planner editing text it has not read, which is the whole failure this
+ * channel exists to prevent — but the turn is told to land.
+ */
+declare const TASK_QUERY_ANSWER_OR_OPS: string;
+/**
+ * The protocol as the planner is taught it, owned here beside the parser so the
+ * two cannot drift. Both planner backends get these lines verbatim (ADR-0009):
+ * a harness planner has no tool loop to reach, so the envelope is the channel.
+ */
+declare const TASK_QUERY_PROTOCOL: string[];
+/** The one-line reminder the per-turn plan block carries, so the protocol has a single owner. */
+declare const TASK_QUERY_REMINDER = "- To READ a task in full (prompt, user steps, verdict, output, user stories) or the whole model/mode catalog before editing, reply with ONLY {\"taskQuery\":{\"tasks\":[\"<id or #order>\"],\"catalog\":true}} \u2014 it changes nothing, and you then reply again with your ops.";
+/**
+ * Render the injected answer to one read. Never persisted — it is context for
+ * the planner's next reply and nothing else — so it is built fresh from live
+ * state on every query rather than cached.
+ */
+declare function renderTaskQueryAnswer(query: TaskQuery, tasks: Task[], catalog: TaskQueryCatalog): string;
+
 declare abstract class AbstractTerminalSession implements ITerminalSession {
     id: string;
     taskId: string;
@@ -928,6 +962,17 @@ type AgentEvent =
     name: string;
     detail: string;
 }
+/**
+ * The agent delegated work to a subagent it left running in the background,
+ * and may end its turn before that work reports. Ordewell's conversation is
+ * request/response: a turn that ends hands control back to the user, and
+ * anything the agent says afterwards arrives with no turn open and is lost.
+ * Naming the launch is what lets the service ask for the results in time.
+ */
+ | {
+    type: 'background_agent';
+    id: string;
+}
 /** The agent finished its turn and is waiting for the next user message. */
  | {
     type: 'turn_end';
@@ -1056,8 +1101,8 @@ declare class CliAgentAiService implements IAiService {
     /**
      * Drive one user message to a settled planner turn. Same shape as the API
      * backend's conversation loop minus the tool rounds — those belong to the
-     * agent now — and with the same three policies layered on top: the PRD gate,
-     * the empty-reply nudge, and a bounded corrective re-emit for botched JSON.
+     * agent now — and with the same two policies layered on top: the
+     * empty-reply nudge, and a bounded corrective re-emit for botched JSON.
      */
     private runConversation;
     /**
@@ -1110,12 +1155,7 @@ interface ConversationRequest {
     fetcher?: IWebFetcher;
     runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
     autonomousDefault?: boolean;
-    grillMeEnabled?: boolean;
-    prdEnabled?: boolean;
-    reviewEnabled?: boolean;
     verificationEnabled?: boolean;
-    /** Declare the spawn_research_agent tool to the planner (issue #34, default off). */
-    researchSubagentsEnabled?: boolean;
     signal?: AbortSignal;
     /**
      * Persisted dialogue to seed a resumed conversation (session reload). The
@@ -1132,9 +1172,11 @@ interface ConversationRequest {
 }
 /**
  * One planner turn's outcome. The planner talks to the user (`message`),
- * commits a full plan (`plan`, a `{tasks:[...]}` JSON object), or emits
- * targeted task edits (`task_ops`, a `{taskOps:[...]}` JSON object). The
- * Session validates and applies task ops atomically; the AI service only
+ * commits a full plan (`plan`, a `{tasks:[...]}` JSON object), emits targeted
+ * task edits (`task_ops`, a `{taskOps:[...]}` JSON object), or asks to read
+ * task bodies and the full catalog before editing (`task_query`, a
+ * `{taskQuery:{...}}` JSON object). The Session validates and applies task ops
+ * atomically and answers queries out of its own state; the AI service only
  * parses them.
  */
 type ConversationTurn = {
@@ -1151,6 +1193,11 @@ type ConversationTurn = {
     ops: TaskOp[];
     text: string;
     researchLog: ResearchLogEntry[];
+} | {
+    kind: 'task_query';
+    query: TaskQuery;
+    text: string;
+    researchLog: ResearchLogEntry[];
 };
 interface IAiService {
     /**
@@ -1255,12 +1302,6 @@ interface ConversationTurnContext {
     runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
     autonomousDefault?: boolean;
     fetcher?: IWebFetcher;
-    /** PRD toggle: a plan must not commit before a PRD block has appeared. */
-    prdEnabled?: boolean;
-    /** Set once any turn carries an ORDEWELL_PRD block; gates the missing-PRD nudge. */
-    prdCaptured?: boolean;
-    /** The missing-PRD corrective nudge is sent at most once per conversation. */
-    prdNudgeSent?: boolean;
 }
 declare abstract class BaseAiService {
     protected config: IConfig;
@@ -1269,8 +1310,6 @@ declare abstract class BaseAiService {
         setProgress: (fn: (p: ResearchProgress) => void) => void;
     } | null;
     protected activeAbort: AbortController | null;
-    /** researchSubagents toggle (issue #34): set per operation from the live settings snapshot; off means bit-for-bit sequential behavior. */
-    protected researchSubagentsEnabled: boolean;
     constructor(config: IConfig);
     abstract reset(): void;
     abstract ensureInit(): void;
@@ -1546,6 +1585,8 @@ declare class TaskOrchestrator {
     private observers;
     private tddEnabled;
     constructor(config: IConfig, notifications: INotification, terminalRunner: ITerminalRunner, store?: PlanStore);
+    /** Advisory silence timestamp for a task's live runner, or null if not idle. */
+    getIdleSince(taskId: string): string | null;
     get storeInstance(): PlanStore;
     setWorkspaceRoot(fn: () => string): void;
     setRegistry(registry: RunnerRegistry): void;
@@ -1993,12 +2034,19 @@ declare abstract class StdioAgentAdapter implements AgentAdapter {
     /** Set for the duration of a turn. Outside one, events are buffered rather than dropped. */
     private turnEmit;
     /**
-     * Events the agent produced between turns — in practice the startup warnings
-     * that arrive during the handshake. Dropping them hid the one diagnostic
-     * that explains a planner which cannot read the workspace, so they are held
-     * until a turn exists to show them in.
+     * Events the agent produced before its first turn — in practice the startup
+     * warnings that arrive during the handshake. Dropping them hid the one
+     * diagnostic that explains a planner which cannot read the workspace, so they
+     * are held until a turn exists to show them in.
+     *
+     * Only before the *first* turn. Once one has run, anything arriving outside a
+     * turn is that closed turn's straggling work — a backgrounded subagent
+     * finishing, a late read — and replaying it into the next turn presents it as
+     * research done for the user's new message.
      */
     private betweenTurns;
+    /** Set once a turn has ended: after that, out-of-turn events are stale, not startup. */
+    private hadTurn;
     private disposed;
     /** Resolves when the process ends, so a handshake can lose the race instead of waiting out its timeout. */
     protected processEnded: Promise<void>;
@@ -2041,6 +2089,8 @@ declare abstract class StdioAgentAdapter implements AgentAdapter {
  */
 declare class ClaudeCodeAdapter extends StdioAgentAdapter {
     readonly agentId = "claude-code";
+    /** Whether this turn has already emitted reply text — see {@link handleLine}. */
+    private turnHasText;
     protected spawnSpec(opts: AgentStartOptions): SpawnSpec;
     protected turnPayload(message: string): string;
     protected handleLine(line: string, emit: (event: AgentEvent) => void): void;
@@ -2127,6 +2177,8 @@ declare class OpenCodeAdapter implements AgentAdapter {
     private exited;
     private disposed;
     private opts;
+    /** Whether this turn has already emitted reply text — see {@link emitPart}. */
+    private turnHasText;
     constructor(deps: AgentProcessDeps);
     start(opts: AgentStartOptions): Promise<void>;
     send(message: string, onEvent: (event: AgentEvent) => void, signal?: AbortSignal): Promise<void>;
@@ -2174,6 +2226,39 @@ declare function mapAgentTool(name: string): MappedTool;
  */
 declare function normalizeAgentArgs(tool: ResearchToolType, args: Record<string, unknown>): Record<string, unknown>;
 
+declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec"];
+interface SkillMetadata {
+    name: string;
+    description: string;
+    disableModelInvocation?: boolean;
+}
+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;
+    /** Whether this came from global (~/.ordewell/skills/) or local (.ordewell/skills/) */
+    source: 'global' | 'local';
+}
+declare class SkillsService {
+    private workspaceRoot?;
+    constructor(workspaceRoot?: string | undefined);
+    private localDir;
+    private globalDir;
+    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;
+    findSkill(name: string): SkillInfo | undefined;
+    listSkills(): SkillInfo[];
+    getSkillContent(name: string): string | undefined;
+}
+declare function createSkillsService(workspaceRoot?: string): SkillsService;
+
 type SerializedTaskStatus = {
     id: string;
     status: string;
@@ -2182,6 +2267,8 @@ type SerializedTaskStatus = {
         reason: string;
         checks: Verdict['checks'];
     } | null;
+    /** Advisory silence timestamp from VerdictEngine — not part of task status semantics. */
+    idleSince?: string | null;
 };
 type SerializedTask = {
     id: string;
@@ -2296,7 +2383,7 @@ type SessionMessage = {
 };
 type SessionBroadcaster = (msg: SessionMessage) => void;
 declare function serializeTask(t: Task): SerializedTask;
-declare function serializeTaskStatus(t: Task): SerializedTaskStatus;
+declare function serializeTaskStatus(t: Task, idleSince?: string | null): SerializedTaskStatus;
 declare function serializePlan(plan: LegacyPlanState): SerializedPlan;
 declare function executionSummary(tasks: Task[]): {
     total: number;
@@ -2327,11 +2414,7 @@ type SessionPlanner = Pick<Planner, 'generate' | 'modify' | 'modifyDuringExecuti
 /** Runtime prefs read live — may toggle between operations. */
 interface SessionRuntimeSettings {
     tddEnabled: boolean;
-    grillMeEnabled: boolean;
-    prdEnabled?: boolean;
-    reviewEnabled?: boolean;
     verificationEnabled?: boolean;
-    researchSubagentsEnabled?: boolean;
     modelAllowlist?: Record<string, string[]>;
 }
 /**
@@ -2342,11 +2425,19 @@ interface SessionRuntimeSettings {
  * is not a toggle.
  */
 declare function sessionRuntimeSettings(settings: UserSettings): SessionRuntimeSettings;
+/**
+ * Resolve a `/skill-name` invocation to the skill's markdown content. Pure and
+ * exported so surfaces and verification can drive substitution without a full
+ * Session. Plain text passes through unchanged; an unknown skill becomes a
+ * notice naming what IS available instead of a bare slash token that a runner
+ * would mis-resolve in its own skills directory.
+ */
+declare function resolveSkillInvocation(text: string, skillsService: Pick<SkillsService, 'findSkill' | 'listSkills'>): string;
 /**
  * Everything a delivery surface constructs to host a session. Structural config
  * (enabledRunners, orchestratorModel, providerModelLists) is snapshotted inside
  * `config` at construction and never re-read from the environment. Runtime
- * settings (tdd, grillMe) are read live via the `settings` callback so a toggle
+ * settings (tdd, verification) are read live via the `settings` callback so a toggle
  * between generate and execute takes effect.
  */
 interface SessionDeps {
@@ -2362,7 +2453,7 @@ interface SessionDeps {
     broadcast: SessionBroadcaster;
     /** Shared across sessions — sole producer of model catalogs and routing lists. */
     modelResolver: ModelResolver;
-    /** Live runtime settings (tdd, grillMe). Read at each operation that needs them. */
+    /** Live runtime settings (tdd, verification). Read at each operation that needs them. */
     settings: () => SessionRuntimeSettings;
     /**
      * Host-assigned session id. When set, every persist writes under this id so
@@ -2378,6 +2469,11 @@ interface SessionDeps {
     aiService?: IAiService;
     /** Plan-generation seam. Defaults to a Planner over the session's aiService. */
     planner?: SessionPlanner;
+    /**
+     * Skill lookup for /skill-name interception. Defaults to a SkillsService
+     * over the session's workspace root.
+     */
+    skillsService?: SkillsService;
 }
 /**
  * The per-session execution stack — deepened from a wiring bag into the
@@ -2419,6 +2515,7 @@ declare class Session {
     private unsubObserver;
     private readonly hostSessionId?;
     private currentSessionId;
+    private readonly skillsService;
     constructor(deps: SessionDeps);
     /**
      * The planner transport for the provider configured *right now* (ADR-0009).
@@ -2475,6 +2572,15 @@ declare class Session {
      */
     reset(): void;
     private runnerModesFor;
+    /**
+     * The catalog a model/task-mode edit is checked against — the same
+     * discovered models and manifest modes the per-turn catalog block shows the
+     * planner, so a refusal here can never name something invalid that the
+     * planner was never told about. `modelsCache` is read live, not filtered by
+     * the allowlist here — {@link checkModelAndModeValidity} narrows by
+     * allowlist itself, the same way `coerceAssignments` does.
+     */
+    private editCatalog;
     get planState(): LegacyPlanState | null;
     /**
      * The live plan in the shape a saved session is read back as. The disk
@@ -2513,10 +2619,30 @@ declare class Session {
      */
     startPlanning(goal: string, runners: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
     /**
-     * Every subsequent user reply in the planning conversation — grill-me
-     * answers, PRD accept/adjust, outline confirm. One branch, no phase ladder.
+     * Every subsequent user reply in the planning conversation — clarifying
+     * answers, outline confirm. One branch, no phase ladder.
      */
     continueConversation(userMessage: string, options?: GeneratePlanOptions): Promise<LegacyPlanState>;
+    /**
+     * Answer every read the planner emits until it says something else.
+     *
+     * The channel is a text envelope rather than a registered tool because the
+     * protocol has to be identical on both planner backends (ADR-0009): Ordewell
+     * owns a tool loop only in the API case, and a harness planner running as a
+     * coding-agent subprocess can only be reached this way.
+     *
+     * Draining here — outside {@link repairLoop} — is what keeps reads free of
+     * the repair budget. A planner that looks a task up and *then* fumbles its
+     * ops JSON still gets its two corrective retries; charging it for the read
+     * would cost it the chance to fix the edit.
+     */
+    private drainTaskQueries;
+    /**
+     * Render one read out of live state. Never persisted to the transcript: the
+     * detail is context for the planner's next reply, and re-sending it on every
+     * later turn is exactly the cost this channel exists to avoid.
+     */
+    private taskQueryAnswer;
     /**
      * Drive a planner turn to a persisted, broadcast outcome. Task edits apply
      * atomically; validation failures are fed back to the model for up to 2
@@ -2525,6 +2651,24 @@ declare class Session {
      * path, not two.
      */
     private settleTurn;
+    /**
+     * The catalog the planner may actually draw from — model ids and task-mode
+     * ids, per selected runner — emitted on EVERY turn, before any plan exists
+     * or after. The system prompt shows this once at conversation start; a long
+     * clarifying conversation outlives that single showing and the planner
+     * starts misquoting it, so this re-states it per turn instead.
+     *
+     * Built from the allowlist-filtered view (`filterModelsForPrompt`), the same
+     * one the system prompt used — a restricted allowlist stays a hard bound on
+     * every turn, not just the first. `this.modelsCache` itself is never
+     * filtered: `coerceAssignments` needs the full discovered catalog alongside
+     * the allowlist to resolve labels and clamp effort to real variants.
+     *
+     * Reads `this.plan.runners` live, so a runner admitted mid-session by a
+     * retarget (`admitRunner`) is filtered and shown like every other — there is
+     * no separate "originally selected" list to fall stale.
+     */
+    private catalogBlock;
     /**
      * The "you are here" block for post-plan chat: current tasks with stable
      * references, plus the task-ops protocol. Injected per turn (never
@@ -2545,6 +2689,15 @@ declare class Session {
     private resumeConversation;
     /** Whether the planner conversation is live (started and not yet committed to a plan). */
     get isConversationActive(): boolean;
+    /**
+     * Intercept a skill invocation (/skill-name) and substitute the skill's
+     * markdown content BEFORE the message reaches the planner. Prevents runners
+     * (Claude Code, OpenCode) from trying to resolve the skill in their own
+     * directory instead of .ordewell/skills/. An unknown skill is surfaced to
+     * the planner as a notice naming what IS available, rather than passing a
+     * bare /unknown through to be mis-resolved.
+     */
+    private resolveSkillInvocation;
     /** Append one dialogue entry to the persisted transcript. Callers persist via the mutatePlan ritual. */
     private appendTranscript;
     /** Commit a settled (non-task_ops) turn. Both branches run the mutatePlan ritual. */
@@ -2594,10 +2747,14 @@ declare class Session {
      */
     private editPlan;
     /**
-     * Patch one task's fields. A hand-set dependency list is the one patch that
-     * can leave the plan unschedulable, so it goes through the same
-     * {@link canSetDependencies} guard the planner's pickers use rather than a
-     * second copy of the rule — and throws, so the surface can say why.
+     * Patch one task's fields. A hand-set dependency list, or a type flip
+     * between AI and MAN, are the patches that can leave a task incoherent
+     * (unschedulable, or carrying fields that mean nothing for its new type),
+     * so both go through the same {@link validateTaskEdit} guard the planner's
+     * task-ops applier uses (as the 'direct' actor, which skips the lock rule)
+     * rather than a second copy of the rules — and throws, so the surface can
+     * say why. Gated on the task existing so an edit to an unknown id still
+     * falls through to the no-op `store.update` below instead of throwing.
      */
     updateTask(taskId: string, changes: Partial<Task>): Promise<LegacyPlanState | null>;
     /**
@@ -2689,8 +2846,27 @@ declare class Session {
     get aiServiceInstance(): IAiService;
 }
 
+/**
+ * Where Ordewell keeps machine-global data (settings, daemon tokens, caches,
+ * user plugins). A single home for everything not tied to a project directory,
+ * so per-project state in `.ordewell/` and global state never collide.
+ */
+declare function globalDataDir(): string;
+/**
+ * One-time lift of a pre-`.ordewell` install's files into the new location.
+ * Each file/dir is checked independently — old exists, new doesn't — rather
+ * than gating the whole thing on "new dir doesn't exist yet". A machine that
+ * migrated `settings.json` under an earlier release already has `globalDataDir()`
+ * on disk, which would otherwise permanently skip lifting anything added to
+ * this list later (`.env` did exactly that: real API keys stranded in the old
+ * dir because the settings.json move had already made the new dir exist).
+ */
+declare function migrateOldConfigDir(): void;
+
 type VerdictListener = (taskId: string, verdict: Verdict, output: string) => void;
 type CheckpointListener = (taskId: string, summary: string) => void;
+/** Fires on every idleSince transition (null→timestamp on silence, timestamp→null on resume/teardown). */
+type IdleListener = (taskId: string, idleSince: string | null) => void;
 declare class VerdictEngine {
     private markerSeen;
     private buffers;
@@ -2698,6 +2874,7 @@ declare class VerdictEngine {
     private pausedSessions;
     private listeners;
     private checkpointListeners;
+    private idleListeners;
     /**
      * Per-task generation counter. Incremented on every watch() and clear().
      * Stale callbacks (from a prior session whose generation doesn't match
@@ -2705,8 +2882,17 @@ declare class VerdictEngine {
      * wrong session.
      */
     private generations;
+    private idleTimers;
+    private idleSince;
     onVerdict(listener: VerdictListener): void;
     onCheckpoint(listener: CheckpointListener): void;
+    onIdleChange(listener: IdleListener): void;
+    /** Advisory silence timestamp for a task, or null if it isn't idle. */
+    getIdleSince(taskId: string): string | null;
+    /** Restart the silence timer on fresh output; broadcasts the null transition if it was idle. */
+    private touchIdle;
+    /** Tear down idle tracking for a task; broadcasts the null transition if it was idle. */
+    private clearIdle;
     approveCheckpoint(taskId: string): void;
     rejectCheckpoint(taskId: string, reason: string): void;
     /**
@@ -2793,7 +2979,7 @@ declare function runnerAssignment(catalog: RunnerCatalog, current?: Pick<Task, '
  */
 declare function retargetTaskRunner(task: Task, runner: RunnerId, catalog: RunnerCatalog): Partial<Task>;
 
-declare function buildResearchToolsPrompt(subagentsEnabled?: boolean): string;
+declare function buildResearchToolsPrompt(): string;
 /**
  * System prompt for one read-only research subagent (issue #34). The digest
  * contract matters: the reply goes back to the planner as a tool result, so it
@@ -2801,7 +2987,7 @@ declare function buildResearchToolsPrompt(subagentsEnabled?: boolean): string;
  * never a task plan.
  */
 declare function buildSubagentSystemPrompt(): string;
-declare function buildConversationSystemPrompt(goal: string, context: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean, grillMeEnabled?: boolean, prdEnabled?: boolean, reviewEnabled?: boolean, verificationEnabled?: boolean, 
+declare function buildConversationSystemPrompt(goal: string, context: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean, verificationEnabled?: boolean, 
 /** Harness planner (ADR-0009): the agent owns its own tools and research budget. */
 harnessMode?: boolean): string;
 declare const CORE_PLANNER_PROMPT: string;
@@ -2839,7 +3025,7 @@ declare function buildSplitPrompt(taskId: string, tasks: Task[]): string;
  *   driver (it also runs the tool rounds) but delegates classification here.
  * - The corrective prompt texts live here, once.
  *
- * Policies stay at the call sites (PRD nudge, ops validation, abort guards) —
+ * Policies stay at the call sites (ops validation, abort guards) —
  * they are inputs to the loop, not part of it.
  */
 type RepairVerdict<T> = {
@@ -2885,6 +3071,8 @@ declare function reEmitPlanPrompt(detail: string): string;
 declare function truncatedPlanReEmitPrompt(historyCompacted: boolean): string;
 /** A task-ops attempt was botched (unparseable JSON): re-emit the ops object. */
 declare function reEmitTaskOpsPrompt(detail: string): string;
+/** A read attempt was botched (unparseable or unknown selector): re-emit the query object. */
+declare function reEmitTaskQueryPrompt(detail: string): string;
 /** Task ops parsed but failed semantic validation (cycles, unknown refs, locked tasks). */
 declare function taskOpsRejectedPrompt(errors: string[]): string;
 /** A modified plan failed validation during execution: full re-prompt feedback block. */
@@ -2896,6 +3084,11 @@ type PlannerReplyClassification = {
     kind: 'task_ops';
     ops: TaskOp[];
 }
+/** A read: show me these tasks in full (and/or the whole catalog) before I edit anything. */
+ | {
+    kind: 'task_query';
+    query: TaskQuery;
+}
 /** Clearly attempted a plan (tasks-keyed object, or JSON cut off mid-stream) and botched it — worth a corrective retry. */
  | {
     kind: 'broken_plan';
@@ -2905,6 +3098,11 @@ type PlannerReplyClassification = {
  | {
     kind: 'broken_task_ops';
     error: PlanParseError;
+}
+/** Clearly attempted a read and botched it — worth a corrective retry. */
+ | {
+    kind: 'broken_task_query';
+    error: PlanParseError;
 } | {
     kind: 'prose';
 };
@@ -2957,7 +3155,13 @@ declare function summarizeOutput(reviewReason: string | undefined, output: strin
 declare function collectDirectDependencyOutputs(task: Task, allTasks: Task[]): PriorOutput[];
 declare function renderPriorOutputs(outputs: PriorOutput[]): string;
 declare function augmentPromptWithPriorOutputs(task: Task, allTasks: Task[]): string;
-declare function renderPlanMap(allTasks: Task[], currentTaskId: string, opts?: {
+/**
+ * Numbered task list for the model's context. `planTasks` is the nested task
+ * tree; subtasks render indented under their parent with the same dotted
+ * `taskOrderLabel` the other surfaces use, so an `N.M` the model echoes back
+ * matches what `resolveTaskId` accepts.
+ */
+declare function renderPlanMap(planTasks: Task[], currentTaskId: string, opts?: {
     maxEntries?: number;
 }): string;
 interface ComposeOptions {
@@ -3492,4 +3696,4 @@ declare class PlannerModelMemory {
     recall(provider: string, catalog: PlannerModelCandidate[]): PlannerModelRecall;
 }
 
-export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AgentAdapter, type AgentAdapterFactory, type AgentEvent, type AgentProcessDeps, type AgentStartOptions, AiProvider, ApprovalKind, ApprovalMode, ApprovalRequest, ApprovalSource, BaseAiService, BaseConfig, BaseFileSystem, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CappedRows, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, CommandLineTooLongError, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, ConversationMessage, type ConversationRequest, type ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DiscoveredModel, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecFileFn, type ExecImpl, ExecutableNotFoundError, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GeminiService, GlobOptions, type GrepInvocation, GrepOptions, type HasBinFn, HeadlessRunner, type HeadlessRunnerDeps, HeadlessSession, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LineBuffer, type MappedTool, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, PLUGIN_NAME_PATTERN, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PluginSource, type PrdBlock, type PreparedLaunch, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, QueuedMessage, REFUSED_COMMANDS, ReadFileOpts, type RepairLoopOpts, type RepairVerdict, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchStep, ResearchToolType, type ResearchTurn, ResolveContext, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, type RunnerSpawnOptions, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SerializedPlan, type SerializedTask, type SerializedTaskStatus, Session, type SessionBroadcaster, type SessionData, type SessionDeps, type SessionMessage, type SessionMeta, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SpawnSpec, StdioAgentAdapter, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, TaskOp, TaskOrchestrator, TaskSnapshot, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildShellInvocation, buildSplitPrompt, buildSubagentSystemPrompt, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, configuredProviders, createAiService, daemonTokenPath, defaultLogger, definitionPattern, deleteSession, discoverGeminiModels, effectiveAllowlist, ensureDir, ensureStateDirIgnored, executionLogBlock, executionSummary, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, grantScopeFor, hasTmux, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, loadSession, loadSessionPlanState, loadState, mapAgentTool, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, pendingEditRulesBlock, planDirectLaunch, planShellLaunch, posixShellQuote, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, readDaemonToken, referencePattern, renderPlanMap, renderPriorOutputs, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveWithin, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, serializePlan, serializeTask, serializeTaskStatus, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, taskOpsRejectedPrompt, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, wrapWithPty };
+export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AgentAdapter, type AgentAdapterFactory, type AgentEvent, type AgentProcessDeps, type AgentStartOptions, AiProvider, ApprovalKind, ApprovalMode, ApprovalRequest, ApprovalSource, BUILTIN_SKILL_NAMES, BaseAiService, BaseConfig, BaseFileSystem, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CappedRows, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, CommandLineTooLongError, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, ConversationMessage, type ConversationRequest, type ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DiscoveredModel, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecFileFn, type ExecImpl, ExecutableNotFoundError, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GeminiService, GlobOptions, type GrepInvocation, GrepOptions, type HasBinFn, HeadlessRunner, type HeadlessRunnerDeps, HeadlessSession, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LineBuffer, type MappedTool, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, PLUGIN_NAME_PATTERN, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PluginSource, type PrdBlock, type PreparedLaunch, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, QueuedMessage, REFUSED_COMMANDS, ReadFileOpts, type RepairLoopOpts, type RepairVerdict, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchStep, ResearchToolType, type ResearchTurn, ResolveContext, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, type RunnerSpawnOptions, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SerializedPlan, type SerializedTask, type SerializedTaskStatus, Session, type SessionBroadcaster, type SessionData, type SessionDeps, type SessionMessage, type SessionMeta, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SkillInfo, type SkillMetadata, SkillsService, type SpawnSpec, StdioAgentAdapter, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, TaskOp, TaskOrchestrator, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskSnapshot, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildShellInvocation, buildSplitPrompt, buildSubagentSystemPrompt, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, configuredProviders, createAiService, createSkillsService, daemonTokenPath, defaultLogger, definitionPattern, deleteSession, discoverGeminiModels, effectiveAllowlist, ensureDir, ensureStateDirIgnored, executionLogBlock, executionSummary, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, hasTmux, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, parseTaskQueryJson, pendingEditRulesBlock, planDirectLaunch, planShellLaunch, posixShellQuote, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, referencePattern, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveWithin, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, serializePlan, serializeTask, serializeTaskStatus, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, wrapWithPty };