@robota-sdk/agent-command 3.0.0-beta.100

package/dist/node/index.d.ts

@@ -0,0 +1,1053 @@
+import { IAgentJobHostContext, ICommandHostAdapterAccess, ICommandHostBackgroundTasks, ICommandHostCatalog, ICommandHostCheckpoints, ICommandHostContextReferences, ICommandHostContextWindow, ICommandHostGoal, ICommandHostMemory, ICommandHostNoCapability, ICommandHostPresetApplication, ICommandHostSessionAccess, ICommandHostSetupState, ICommandHostTerminalHandoff, ICommandHostUserInteraction, ICommandHostWorkspace, ICommandMCPActivationAdapter, ICommandModule, ICommandProductVocabulary, ICommandSandboxStatus, IContributionSource, ICreateGitProcessOptions, IGitProcessPort, IGitProcessPort as IGitProcessPort$1, IGitProcessRunOptions, IOrgPolicy, IProviderCommandModuleOptions, IProviderCommandModuleOptions as IProviderCommandModuleOptions$1, IProviderCommandModuleOptions as IProviderCommandModuleOptions$2, IProviderCommandModuleOptions as IProviderCommandModuleOptions$3, IProviderCommandSettingsAdapter, IProviderCommandSettingsAdapter as IProviderCommandSettingsAdapter$1, IProviderConnectionHost, IProviderSetupInput, ISettingsDocumentStore, ISkillRootDescriptor, ISystemCommand, IUnknownCommandModuleName, TGitProcessFailureReason, TGitProcessOutcome, TSandboxCommandMode, TSettings, TSettingsScope, TSettingsSource, TWorkspaceProjectAccess, createGitProcess, gitEnvironment } from "@robota-sdk/agent-framework";
+import { IProviderDefinition, IProviderSetupHelpLink, IProviderSetupStepDefinition, ITerminalOutput, IUserInteraction, TProviderCredentialResolver, TProviderSetupField } from "@robota-sdk/agent-core";
+import { ICommand, ICommandResult, ICommandSource, IThemeAppearanceState, IThemeCatalogueEntry, IThemeCataloguePort, IThemeCataloguePort as IThemeCataloguePort$1, TCommandInvocationSource, TReducedMotionOverride } from "@robota-sdk/agent-interface-command";
+//#region src/agent/agent-command-module.d.ts
+declare function createAgentCommandEntry(): ICommand;
+declare function createAgentSystemCommand(): ISystemCommand;
+declare class AgentCommandSource implements ICommandSource {
+  readonly name = "agent";
+  getCommands(): ICommand[];
+}
+declare function createAgentCommandModule(): ICommandModule;
+//#endregion
+//#region src/agent/agent-command.d.ts
+declare function executeAgentCommand(session: IAgentJobHostContext, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/devices/devices-command-port.d.ts
+/**
+ * What `/devices` needs from the host that keeps this device's identity.
+ *
+ * The host owns every secret: the recovery phrase is shown and read on the host's own terminal, and
+ * private keys live in its credential store. What crosses this port back to the command is ids,
+ * names, times and closed refusal reasons — nothing the command formats can carry a secret, because
+ * the command never receives one. A thrown error's message is the host's promise to the same effect.
+ */
+interface IDeviceListEntry {
+  readonly deviceId: string;
+  readonly name: string;
+  readonly thisDevice: boolean;
+  /** Whether this entry is known to hold the device-signing key. Only known for this device. */
+  readonly holdsSigningKey: boolean;
+  readonly certificateExpiresAt: number;
+}
+interface IDevicesView {
+  readonly userId: string;
+  readonly devices: readonly IDeviceListEntry[];
+  readonly revokedDeviceCount: number;
+  /** When the roster and revocation list this device holds stop being accepted. */
+  readonly listsExpireAt: number;
+}
+/** Why an operation did not happen. Closed, so no free text from the secret path reaches a result. */
+type TDevicesRefusal =
+/** No interactive terminal: the phrase is never shown on or read from anything else. */
+'no-terminal' | 'not-initialized' | 'already-initialized' |
+/** The operator cancelled at the terminal. */
+'cancelled' |
+/** The re-typed words or passphrase did not match. */
+'confirmation-failed' | 'phrase-invalid' |
+/** The phrase is valid but derives another identity than this device's. */
+'phrase-mismatch' | 'no-signing-key' | 'signing-key-expired' | 'unknown-device' | 'ambiguous-device' | 'self-revocation' |
+/** Another process changed the identity while this operation waited on the operator. */
+'changed-concurrently' |
+/** No signaling relay is configured to meet the other device through. */
+'no-relay' |
+/** What was typed is not an enrollment code. */
+'code-invalid' |
+/** The code was typed on the command line, where history keeps it. */
+'code-on-command-line' |
+/** No device waits for that code or proved it: wrong, expired, already used, or something in between. */
+'code-not-accepted' |
+/** Nobody joined before the code expired. */
+'enrollment-expired' |
+/** Too many attempts failed to prove the code; it no longer works. */
+'too-many-attempts' |
+/** The operator of either device declined. */
+'enrollment-declined' |
+/** An operator did not answer in time. */
+'enrollment-timed-out' |
+/** The connection or the exchange with the other device failed partway. */
+'enrollment-failed';
+type TDevicesOutcome<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly reason: TDevicesRefusal;
+};
+interface IDevicesInitResult {
+  readonly userId: string;
+  readonly deviceId: string;
+  readonly signingKeyId: string;
+  /** Where the private keys were kept, for the operator. */
+  readonly keyStorage?: string;
+}
+interface IDevicesRecoverResult {
+  readonly deviceId: string;
+  readonly signingKeyId: string;
+  readonly revokedSigningKeyCount: number;
+  /** Other devices that were certified by a retired signing key and must enrol again. */
+  readonly droppedDeviceCount: number;
+}
+interface IDevicesRevokeResult {
+  readonly deviceId: string;
+  readonly name: string;
+}
+/** This session's endpoint in the device mesh. */
+interface IDevicesMeshStatus {
+  /** `off`: the setting is off, or this run does not open the mesh. `failed`: it could not open. */
+  readonly state: 'off' | 'starting' | 'on' | 'failed';
+  /** Why it could not open, for `failed`. */
+  readonly reason?: string;
+  /** How this device looks for the others, in the operator's words. */
+  readonly sources: readonly string[];
+  /** The devices with an admitted link now. */
+  readonly linked: readonly {
+    readonly deviceId: string;
+    readonly name?: string;
+    readonly locality: 'same-host' | 'another-host';
+  }[];
+}
+interface IDevicesAddResult {
+  readonly deviceId: string;
+  readonly name: string;
+  /** Whether the new device said it kept what it was given. */
+  readonly confirmed: boolean;
+}
+interface IDevicesJoinResult {
+  readonly userId: string;
+  readonly deviceId: string;
+  readonly name: string;
+  /** Where the private keys were kept, for the operator. */
+  readonly keyStorage?: string;
+}
+interface IDevicesCommandPort {
+  /** This device's view of the roster, or `undefined` when it has no identity yet. */
+  list(): Promise<IDevicesView | undefined>;
+  /** The device mesh as this session runs it. Absent on a host with no device mesh. */
+  meshStatus?(): IDevicesMeshStatus;
+  /** Create the identity. Runs on the operator terminal (it shows the phrase once). */
+  init(options: {
+    readonly name?: string;
+  }): Promise<TDevicesOutcome<IDevicesInitResult>>;
+  /** Rotate the signing key from the phrase. Runs on the operator terminal. */
+  recover(): Promise<TDevicesOutcome<IDevicesRecoverResult>>;
+  /** Revoke a device by id prefix with the signing key. Confirms on the operator terminal. */
+  revoke(deviceIdPrefix: string): Promise<TDevicesOutcome<IDevicesRevokeResult>>;
+  /**
+   * Enrol another device with the signing key: show a one-time code, and certify the device that
+   * proves it once both operators confirm the string both devices show. Runs on the operator terminal.
+   */
+  add(): Promise<TDevicesOutcome<IDevicesAddResult>>;
+  /**
+   * Join the user's devices with a code another device shows, once both operators confirm the string
+   * both devices show. Runs on the operator terminal.
+   */
+  join(options: {
+    readonly name?: string;
+  }): Promise<TDevicesOutcome<IDevicesJoinResult>>;
+}
+//#endregion
+//#region src/devices/devices-command-module.d.ts
+declare function createDevicesCommandModule(port: IDevicesCommandPort): ICommandModule;
+//#endregion
+//#region src/doctor/doctor-types.d.ts
+type TDoctorCheckStatus = 'ok' | 'warn' | 'fail' | 'not-configured' | 'not-probed';
+/** The enumerated probes the read-only doctor does not run. Adding one is a spec change. */
+type TDoctorNotProbed = 'mcp-connection' | 'hook-execution' | 'owner-only-mode';
+interface IDoctorCheck {
+  /** Stable, user-typeable id (`settings.<scope>.<family>`, `storage.user`, `mcp.plugin.<id>.<server>`). */
+  readonly id: string;
+  readonly label: string;
+  readonly status: TDoctorCheckStatus;
+  /** The exact file or directory the finding is about, when there is one. */
+  readonly path?: string;
+  /** The specific cause, as the owner reported it — a state word, an issue path, an errno; never a secret. */
+  readonly cause?: string;
+  /** Free-text detail lines rendered under the check. */
+  readonly detail?: readonly string[];
+  /** Present when this run can repair the finding; names the allowlisted repair id (equal to `id`). */
+  readonly repair?: string;
+}
+interface IDoctorReport {
+  readonly checks: readonly IDoctorCheck[];
+  readonly failCount: number;
+  readonly warnCount: number;
+  /** Ids of checks whose `repair` is set in THIS run. */
+  readonly repairable: readonly string[];
+  /** Exit-code contract: `0` when `failCount === 0`, else `1`. */
+  readonly exitCode: 0 | 1;
+}
+/** One TCP reachability result; the probe is injected so tests never touch the network. */
+interface IDoctorEndpointProbeResult {
+  readonly reachable: boolean;
+  readonly elapsedMs?: number;
+  readonly error?: string;
+}
+/** What the host knows and the runner does not: the composition the shell built, and its facts. */
+interface IDoctorInputs {
+  readonly cwd: string;
+  readonly userHome: string;
+  /**
+   * The product's own user settings file — the only settings layer the repair allowlist may rewrite.
+   * The host names it; this library knows no product layout.
+   */
+  readonly userSettingsPath: string;
+  /** The product's user store root and its sessions directory, as the host lays them out. */
+  readonly userStorage: {
+    readonly root: string;
+    readonly sessions: string;
+  };
+  /** The project state root under a trusted workspace, when the host has one. */
+  readonly projectStorageRoot?: string;
+  /** Every settings source the runtime merge chain reads, in precedence order. */
+  readonly settingsSources: readonly TSettingsSource[];
+  readonly projectAccess: TWorkspaceProjectAccess;
+  readonly providerDefinitions: readonly IProviderDefinition[];
+  /** Optional host wording for remediation; omitted values use product-neutral guidance. */
+  readonly diagnosticGuidance?: {
+    readonly providerResolution?: string;
+    readonly projectTrust?: string;
+  };
+  /** Environment map (test seam; default `process.env`). */
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly contributionSources: readonly IContributionSource[];
+  readonly skillRoots: readonly ISkillRootDescriptor[];
+  /** Plugin scope directories, most specific first — the same list the session loader reads. */
+  readonly pluginsDirs: readonly string[];
+  /** Host-composed MCP activation adapter; absent means the CLI has no MCP host. */
+  readonly mcpActivation?: ICommandMCPActivationAdapter;
+  /** Checks only the host can make (Node version, terminal, CLI version); rendered first. */
+  readonly hostChecks: readonly IDoctorCheck[];
+  /** A workspace-composition failure the host converted into a check rather than a crash. */
+  readonly compositionFailure?: IDoctorCheck;
+}
+/** Storage facts about one path, probed without writing. */
+interface IDoctorPathFacts {
+  readonly exists: boolean;
+  readonly isDirectory: boolean;
+  readonly writable: boolean;
+  /** POSIX mode bits, or `undefined` when the platform does not assert them. */
+  readonly mode?: number;
+}
+/** Every side effect the runner needs, with Node defaults in `doctor-node-deps.ts`. */
+interface IDoctorDeps {
+  readonly probeEndpoint: (host: string, port: number) => Promise<IDoctorEndpointProbeResult>;
+  readonly inspectPath: (path: string) => IDoctorPathFacts;
+  /** `true` when a bare command name resolves on `PATH`, or a path-form command exists. */
+  readonly resolveCommand: (command: string) => boolean;
+  /** The platform's owner-only guarantee, from `@robota-sdk/agent-core/node`. */
+  readonly ownerOnlyGuarantee: () => 'posix-mode' | 'windows-acl';
+}
+//#endregion
+//#region src/doctor/doctor-render.d.ts
+/** Optional product wording supplied by the host; omission keeps diagnostics product-neutral. */
+interface IDoctorDisplayVocabulary {
+  readonly title?: string;
+  readonly productName?: string;
+  readonly formatRepairCommand?: (checkId: string) => string;
+  readonly repairOffer?: string;
+}
+/** Render the report as lines: a title, every check, then the summary and the repair offers. */
+declare function renderDoctorReport(report: IDoctorReport, title?: string, display?: IDoctorDisplayVocabulary): string[];
+//#endregion
+//#region src/doctor/doctor-command-module.d.ts
+declare function createDoctorCommandEntry(): ICommand;
+declare class DoctorCommandSource implements ICommandSource {
+  readonly name = "doctor";
+  getCommands(): ICommand[];
+}
+/** Register `/doctor` over the host-composed inputs; the host decides whether to supply them. */
+declare function createDoctorCommandModule(inputs: IDoctorInputs, deps?: IDoctorDeps, display?: IDoctorDisplayVocabulary): ICommandModule;
+//#endregion
+//#region src/doctor/doctor-node-deps.d.ts
+/** A bare command resolves through `PATH`; a path-form command must exist as given. */
+declare function resolveCommandOnPath(command: string, env?: Readonly<Record<string, string | undefined>>): boolean;
+declare function createNodeDoctorDeps(env?: Readonly<Record<string, string | undefined>>): IDoctorDeps;
+//#endregion
+//#region src/doctor/doctor-redaction.d.ts
+/**
+ * Mask every known secret value and every credential-shaped token in `text`.
+ *
+ * `secrets` are literal values the doctor learned from its inputs — the resolved credential, every
+ * literal `apiKey` in any settings layer (active or not), every value a `$ENV:` reference names,
+ * every `env` map value. Values shorter than four characters are not masked: they cannot be
+ * credentials and masking them would shred ordinary words.
+ */
+declare function redactDiagnosticText(text: string, secrets?: Iterable<string>): string;
+/**
+ * Collect the literal secrets a set of parsed settings layers and the environment expose:
+ * `providers.*.apiKey`, `provider.apiKey` (literal, or the value of a `$ENV:` reference), and
+ * every `env` map value. The doctor never RENDERS any of these; they feed the redactor so that a
+ * value which nonetheless reaches a message is masked.
+ */
+declare function collectSettingsSecrets(layers: ReadonlyArray<TSettings | undefined>, env: Readonly<Record<string, string | undefined>>): string[];
+//#endregion
+//#region src/doctor/doctor-repair.d.ts
+declare const STORAGE_REPAIR_ID = "storage.user";
+/** The closed allowlist for this composition: the host's user settings layer id and `storage.user`. */
+declare function doctorRepairAllowlist(inputs: IDoctorInputs): readonly string[];
+interface IDoctorRepairPlan {
+  readonly id: string;
+  /** What the writer will do, for the confirmation prompt. */
+  readonly description: string;
+  readonly path: string;
+}
+type TDoctorRepairPlanResult = {
+  readonly ok: true;
+  readonly plan: IDoctorRepairPlan;
+} | {
+  readonly ok: false;
+  readonly reason: string;
+};
+type TDoctorRepairOutcome = {
+  readonly applied: true;
+  readonly plan: IDoctorRepairPlan;
+} | {
+  readonly applied: false;
+  readonly reason: string;
+};
+declare function isDoctorRepairId(id: string, inputs: IDoctorInputs): boolean;
+/** Re-read the state now and decide whether `id` is repairable in it. Never writes. */
+declare function planDoctorRepair(id: string, inputs: IDoctorInputs, deps: IDoctorDeps): TDoctorRepairPlanResult;
+/**
+ * Plan, confirm, re-plan, write. `confirm` is the host's prompt (`--yes` supplies `() => true`); a
+ * refusal or an absent prompt writes nothing. The plan is recomputed after confirmation so a state
+ * that changed while the user was deciding is refused rather than overwritten.
+ */
+declare function applyDoctorRepair(id: string, inputs: IDoctorInputs, deps: IDoctorDeps, confirm: (plan: IDoctorRepairPlan) => Promise<boolean>): Promise<TDoctorRepairOutcome>;
+//#endregion
+//#region src/doctor/doctor-runner.d.ts
+/** Aggregate checks into the report; `fail` alone raises the exit code (CLI-067). */
+declare function buildDoctorReport(checks: readonly IDoctorCheck[]): IDoctorReport;
+/** Run every probe and return the redacted report. */
+declare function runDoctor(inputs: IDoctorInputs, deps: IDoctorDeps): Promise<IDoctorReport>;
+//#endregion
+//#region src/keybindings/keybindings-command-module.d.ts
+interface IKeybindingsFilePort {
+  ensureFile(): Promise<string>;
+}
+declare function createKeybindingsCommandEntry(): ICommand;
+declare class KeybindingsCommandSource implements ICommandSource {
+  readonly name = "keybindings";
+  getCommands(): ICommand[];
+}
+declare function createKeybindingsCommandModule(file: IKeybindingsFilePort | undefined): ICommandModule;
+//#endregion
+//#region src/default/default-command-modules.d.ts
+interface IDefaultCommandModulesOptions {
+  cwd: string;
+  userLocalStorageRoot: string;
+  /** Product-owned prefix for the interactive editor's temporary directory. */
+  editorTemporaryDirectoryPrefix?: string;
+  contributionSources?: readonly IContributionSource[];
+  skillRoots?: readonly ISkillRootDescriptor[];
+  providerDefinitions: readonly IProviderDefinition[];
+  providerSettingsAdapter: IProviderCommandSettingsAdapter$1;
+  /**
+   * CLI-083 (issue #2287) — the org policy, so `allowedProviders` and `requireApiKeyFromEnv` are
+   * reachable. This parameter existed, was removed by `92596bc6f` along with its only caller, and
+   * the consumer never stopped reading it: `provider-command-profile-operations.ts` still
+   * destructures `orgPolicy` from its options and enforces on it. Optional, so its absence stays
+   * distinguishable from a policy that allows everything — and that optionality is why nothing went
+   * red when the producer dropped it.
+   */
+  orgPolicy?: IOrgPolicy;
+  /**
+   * Where `/provider` and `/model` check a `$ENV:` or default credential variable: the host's startup
+   * snapshot when it withholds its own credentials from `process.env`. Absent, `process.env` is read.
+   */
+  providerEnvironment?: Readonly<Record<string, string | undefined>>;
+  /** Host-owned connection acquisition and transactional credential persistence. */
+  providerConnectionHost?: IProviderConnectionHost;
+  /** Host-owned resolution of an opaque saved credential reference. */
+  providerCredentialResolver?: TProviderCredentialResolver;
+  /** Optional TUI-owned file capability; absent, `/keybindings` says it belongs to an interactive terminal. */
+  keybindingsFilePort?: IKeybindingsFilePort;
+  /**
+   * SCREEN-2002: the surface's theme catalogue. Absent (print mode, `--serve`), `/theme` is still
+   * listed and says it belongs to an interactive terminal, which runs it when attached.
+   */
+  themeCataloguePort?: IThemeCataloguePort$1;
+  /**
+   * The host that keeps this device's identity (its terminal, credential store and state files).
+   * Absence means `/devices` is not registered: without it the command could do nothing.
+   */
+  devicesPort?: IDevicesCommandPort;
+  /** OBSERVABILITY-1991: host-composed doctor inputs; absence means `/doctor` is not registered. */
+  doctorInputs?: IDoctorInputs;
+  /** Product-owned diagnostic wording; absent keeps `/doctor` product-neutral. */
+  doctorDisplay?: IDoctorDisplayVocabulary;
+  /** Product-owned command to resume a saved fork; absent yields neutral host guidance. */
+  formatForkResumeCommand?: (sessionId: string) => string;
+  /** Host-owned fallback text and kill switch for session-local repeat. */
+  loopOptions?: {
+    defaultPrompt?: string;
+    resolveDefaultPrompt?: () => string;
+    disabled?: boolean;
+  };
+  /**
+   * Whitelist of module `name`s to keep. When provided, only modules whose `name`
+   * appears here survive. Omitted → all modules kept (no-regression).
+   */
+  enabledCommandModules?: readonly string[];
+  /**
+   * Blacklist of module `name`s to remove. Applied after the whitelist, so a name
+   * present in both is removed (deny > allow). Omitted → no modules removed.
+   */
+  disabledCommandModules?: readonly string[];
+}
+/**
+ * Result of {@link createDefaultCommandModules} (INFRA-032): the selected `modules` plus any preset
+ * `enabledCommandModules`/`disabledCommandModules` names that matched no built module. Unknown names
+ * are returned as data (not dropped silently) so the CLI startup path can surface a non-fatal notice.
+ */
+interface IDefaultCommandModulesResult {
+  readonly modules: readonly ICommandModule[];
+  readonly unknownModuleNames: readonly IUnknownCommandModuleName[];
+}
+declare function createDefaultCommandModules({ cwd: _cwd, userLocalStorageRoot, editorTemporaryDirectoryPrefix, contributionSources, skillRoots, providerDefinitions, providerSettingsAdapter, orgPolicy, keybindingsFilePort, themeCataloguePort, devicesPort, doctorInputs, doctorDisplay, formatForkResumeCommand, loopOptions, enabledCommandModules, disabledCommandModules, providerEnvironment, providerConnectionHost, providerCredentialResolver }: IDefaultCommandModulesOptions): IDefaultCommandModulesResult;
+//#endregion
+//#region src/background/background-command-module.d.ts
+declare function createBackgroundCommandEntry(): ICommand;
+declare class BackgroundCommandSource implements ICommandSource {
+  readonly name = "background";
+  getCommands(): ICommand[];
+}
+declare function createBackgroundCommandModule(): ICommandModule;
+//#endregion
+//#region src/background/background-command.d.ts
+declare function executeBackgroundCommand(context: ICommandHostBackgroundTasks, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/goal/goal-command-module.d.ts
+declare function createGoalCommandEntry(): ICommand;
+declare class GoalCommandSource implements ICommandSource {
+  readonly name = "goal";
+  getCommands(): ICommand[];
+}
+declare function createGoalCommandModule(): ICommandModule;
+//#endregion
+//#region src/goal/goal-command.d.ts
+declare const GOAL_COMMAND_DESCRIPTION = "Assign an autonomous goal the agent pursues across turns until satisfied.";
+declare function executeGoalCommand(context: ICommandHostGoal, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/handoff/handoff-command.d.ts
+/**
+ * `/handoff` (HANDOFF-001, issue #1864) — move this session to another machine.
+ *
+ * The command holds no protocol. It reads an injected adapter and touches no transport, for the same
+ * reason `/peers` does not: the carrier, the wire composition and the device identity are
+ * composition-root concerns and must have one owner.
+ *
+ * ## What it is FOR, which is the consent
+ *
+ * A hand-off loses things on purpose — uncommitted working-tree changes and running subprocesses
+ * stay on this machine, because moving them would make this a file-sync product and a process cannot
+ * migrate at all. Those are the operator's to lose, so they are named in the prompt BEFORE the
+ * question, not reported afterwards. A confirmation that did not mention them is not consent.
+ *
+ * ## The sentence it always ends on
+ *
+ * Every outcome that is not `done` says the session is still on this machine. That is not
+ * reassurance: it is the one invariant the whole design exists to preserve, and the operator is the
+ * person who has to know whether to keep typing here or walk to the other computer.
+ */
+type THandoffHost = ICommandHostAdapterAccess & Partial<ICommandHostUserInteraction>;
+declare function executeHandoffCommand(context: THandoffHost, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/handoff/handoff-command-module.d.ts
+declare function createHandoffCommandEntry(): ICommand;
+declare class HandoffCommandSource implements ICommandSource {
+  readonly name = "handoff";
+  getCommands(): ICommand[];
+}
+declare function createHandoffCommandModule(): ICommandModule;
+//#endregion
+//#region src/plan/plan-command-module.d.ts
+declare function createPlanCommandModule(): ICommandModule;
+//#endregion
+//#region src/compact/compact-command-module.d.ts
+declare function createCompactCommandEntry(): ICommand;
+declare class CompactCommandSource implements ICommandSource {
+  readonly name = "compact";
+  getCommands(): ICommand[];
+}
+declare function createCompactCommandModule(): ICommandModule;
+//#endregion
+//#region src/compact/compact-command.d.ts
+declare function executeCompactCommand(context: ICommandHostContextWindow & ICommandHostSessionAccess, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/context/context-command-module.d.ts
+declare function createContextCommandEntry(): ICommand;
+declare class ContextCommandSource implements ICommandSource {
+  readonly name = "context";
+  getCommands(): ICommand[];
+}
+declare function createContextCommandModule(): ICommandModule;
+//#endregion
+//#region src/context/context-command.d.ts
+/** The roles the `/context` surface reads. Named once so five signatures do not restate it. */
+type TContextCommandHost = ICommandHostAdapterAccess & ICommandHostContextReferences & ICommandHostContextWindow & ICommandHostSessionAccess;
+declare function executeContextCommand(context: TContextCommandHost, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/editor/resolve-editor.d.ts
+/**
+ * TERM-004: editor-selection seam. Resolves `$VISUAL` → `$EDITOR` → `vi` (POSIX-first; a Windows
+ * default is a TERM-007 concern). Splits on whitespace so `"code -w"` / `"subl -w"` style values work.
+ */
+interface IResolvedEditor {
+  command: string;
+  args: readonly string[];
+}
+declare function resolveEditor(): IResolvedEditor;
+//#endregion
+//#region src/editor/editor-command.d.ts
+declare const EDITOR_COMMAND_DESCRIPTION = "Compose a message in $EDITOR (optionally pre-filled with `/editor <text>`), then return it.";
+declare function executeEditorCommand(context: ICommandHostTerminalHandoff & ICommandHostWorkspace, args: string, temporaryDirectoryPrefix?: string): Promise<ICommandResult>;
+//#endregion
+//#region src/editor/editor-command-module.d.ts
+declare function createEditorCommandEntry(): ICommand;
+declare class EditorCommandSource implements ICommandSource {
+  readonly name = "editor";
+  getCommands(): ICommand[];
+}
+declare function createEditorCommandModule(temporaryDirectoryPrefix?: string): ICommandModule;
+//#endregion
+//#region src/git/git-command-module.d.ts
+declare function createGitCommandEntry(): ICommand;
+/** What the verbs need from the host: the working directory and the ask-the-user port. */
+type TGitCommandContext = Pick<ICommandHostWorkspace, 'getCwd'> & ICommandHostUserInteraction;
+declare function executeGitCommand(context: TGitCommandContext, args: string, port?: IGitProcessPort$1): Promise<ICommandResult>;
+declare class GitCommandSource implements ICommandSource {
+  readonly name = "git";
+  getCommands(): ICommand[];
+}
+interface IGitCommandModuleOptions {
+  /** The process seam; the production `createGitProcess()` by default, injectable for tests. */
+  port?: IGitProcessPort$1;
+}
+declare function createGitCommandModule(options?: IGitCommandModuleOptions): ICommandModule;
+//#endregion
+//#region src/effort/effort-command-module.d.ts
+declare function createEffortCommandEntry(): ICommand;
+declare class EffortCommandSource implements ICommandSource {
+  readonly name = "effort";
+  getCommands(): ICommand[];
+}
+declare function createEffortCommandModule(): ICommandModule;
+//#endregion
+//#region src/effort/effort-command.d.ts
+declare function executeEffortCommand(context: ICommandHostAdapterAccess & ICommandHostSessionAccess & ICommandHostUserInteraction & ICommandHostWorkspace, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/advisor/advisor-command-module.d.ts
+declare function createAdvisorCommandEntry(): ICommand;
+declare class AdvisorCommandSource implements ICommandSource {
+  readonly name = "advisor";
+  getCommands(): ICommand[];
+}
+declare function createAdvisorCommandModule(): ICommandModule;
+//#endregion
+//#region src/advisor/advisor-command.d.ts
+/** The user-settings key `/advisor` saves the default advisor under. */
+declare const ADVISOR_SETTING_KEY = "advisorModel";
+/**
+ * `/advisor` — show the advisor, set it (`<profile>` or `<profile>:<model>`), or turn it off. A
+ * change the user makes is also saved as the default for later sessions.
+ */
+declare function executeAdvisorCommand(context: ICommandHostAdapterAccess & ICommandHostWorkspace, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/exit/exit-command-module.d.ts
+declare function createExitCommandEntry(): ICommand;
+declare class ExitCommandSource implements ICommandSource {
+  readonly name = "exit";
+  getCommands(): ICommand[];
+}
+declare function createExitCommandModule(): ICommandModule;
+//#endregion
+//#region src/exit/exit-command.d.ts
+declare function executeExitCommand(context: ICommandHostUserInteraction, _args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/help/help-command-module.d.ts
+declare function createHelpCommandEntry(): ICommand;
+declare class HelpCommandSource implements ICommandSource {
+  readonly name = "help";
+  getCommands(): ICommand[];
+}
+declare function createHelpCommandModule(): ICommandModule;
+//#endregion
+//#region src/help/help-command.d.ts
+declare function executeHelpCommand(context: ICommandHostCatalog, _args: string): ICommandResult;
+//#endregion
+//#region src/theme/theme-command-module.d.ts
+declare function executeThemeCommand(catalogue: IThemeCataloguePort$1 | undefined, args: string): ICommandResult;
+declare function createThemeCommandEntry(): ICommand;
+declare class ThemeCommandSource implements ICommandSource {
+  readonly name = "theme";
+  getCommands(): ICommand[];
+}
+declare function createThemeCommandModule(catalogue: IThemeCataloguePort$1 | undefined): ICommandModule;
+//#endregion
+//#region src/language/language-command-module.d.ts
+declare function createLanguageCommandEntry(): ICommand;
+declare class LanguageCommandSource implements ICommandSource {
+  readonly name = "language";
+  getCommands(): ICommand[];
+}
+declare function createLanguageCommandModule(): ICommandModule;
+//#endregion
+//#region src/language/language-command.d.ts
+declare function executeLanguageCommand(context: ICommandHostUserInteraction, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/memory/memory-command-module.d.ts
+declare function createMemoryCommandEntry(): ICommand;
+declare class MemoryCommandSource implements ICommandSource {
+  readonly name = "memory";
+  getCommands(): ICommand[];
+}
+declare function createMemoryCommandModule(): ICommandModule;
+//#endregion
+//#region src/memory/memory-command.d.ts
+/** The host's view of the session's permission mode, when it has one. */
+type TMemoryCommandModeAccess = ICommandHostAdapterAccess & Partial<Pick<ICommandHostSessionAccess, 'getSession'>>;
+declare function executeMemoryCommand(context: ICommandHostMemory & ICommandHostWorkspace & TMemoryCommandModeAccess, rawArgs: string): Promise<ICommandResult>;
+//#endregion
+//#region src/mcp-activation/mcp-activation-command-module.d.ts
+declare function createMCPActivationCommandEntry(): ICommand;
+declare class MCPActivationCommandSource implements ICommandSource {
+  readonly name = "mcp-activation";
+  getCommands(): ICommand[];
+}
+declare function createMCPActivationCommandModule(): ICommandModule;
+//#endregion
+//#region src/mcp-activation/mcp-activation-command.d.ts
+/** What `/mcp` reaches: its port, and — to sign in — the live session and the user. */
+type TMCPActivationCommandContext = ICommandHostAdapterAccess & Pick<ICommandHostSessionAccess, 'getSession'> & ICommandHostUserInteraction & Partial<Pick<ICommandHostWorkspace, 'getCommandInvocationSource'>> & {
+  getCommandSurfaceLocalityEvidence?(): 'local' | 'remote' | undefined;
+  getCommandProductVocabulary?(): ICommandProductVocabulary | undefined;
+};
+declare function executeMCPActivationCommand(context: TMCPActivationCommandContext, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/mcp-activation/mcp-model-notice.d.ts
+/**
+ * What the MODEL is told about an MCP server it cannot use, and which user command fixes it.
+ *
+ * Fixed words only. A server's name comes from a definition a repository may write, so it is named
+ * only when it is safe to paste into any shell; otherwise the notice stays generic and points at
+ * `/mcp status`, where the user sees the name. Nothing a server or its definition returned — reason
+ * text, endpoint, header or token — ever reaches these strings.
+ *
+ * The actions themselves (approving a server, signing in, trusting a workspace) are the user's: the
+ * model can only suggest the command.
+ */
+/** Why a server's tools are unavailable, as a user action that would fix it. */
+type TMCPUserAction = 'approve' | 'sign-in' | 'trust-workspace';
+/**
+ * Where the user can act: `session` is an interactive session they can type a `/mcp` command into;
+ * `terminal` is a run with no such prompt (print, serve), where sign-in is the terminal command.
+ */
+type TMCPUserActionSurface = 'session' | 'terminal';
+/** The command the user runs for `action`; `<server>` stands for a name that cannot be shown. */
+declare function mcpUserActionCommand(serverId: string, action: TMCPUserAction, surface?: TMCPUserActionSurface, cliName?: string): string | undefined;
+/** One server's notice: what is missing and the exact command to suggest. */
+declare function mcpUserActionNotice(serverId: string, action: TMCPUserAction, surface?: TMCPUserActionSurface, cliName?: string): string;
+/**
+ * The notice for every server that could not start for a reason the user can fix, or `undefined`
+ * when there is none. Meant for the model's context at session start.
+ */
+declare function mcpUnavailableServersNotice(servers: ReadonlyMap<string, TMCPUserAction>, cliName?: string): string | undefined;
+//#endregion
+//#region src/mode/mode-command-module.d.ts
+declare function createModeCommandEntry(): ICommand;
+declare class ModeCommandSource implements ICommandSource {
+  readonly name = "mode";
+  getCommands(): ICommand[];
+}
+declare function createModeCommandModule(): ICommandModule;
+//#endregion
+//#region src/mode/mode-command.d.ts
+declare function executeModeCommand(context: ICommandHostAdapterAccess & ICommandHostSessionAccess & ICommandHostUserInteraction, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/model/model-command-module.d.ts
+declare function createModelCommandEntry(): ICommand;
+declare class ModelCommandSource implements ICommandSource {
+  readonly name = "model";
+  getCommands(): ICommand[];
+}
+declare function createModelCommandModule(options: IProviderCommandModuleOptions$3): ICommandModule;
+//#endregion
+//#region src/model/model-command.d.ts
+type TModelCommandContext = ICommandHostSessionAccess & ICommandHostUserInteraction;
+declare function executeModelCommand(context: TModelCommandContext, args: string, options: IProviderCommandModuleOptions$1): Promise<ICommandResult>;
+//#endregion
+//#region src/sandbox/sandbox-command-module.d.ts
+declare class SandboxCommandSource implements ICommandSource {
+  readonly name = "sandbox";
+  getCommands(): ICommand[];
+}
+declare function createSandboxCommandModule(): ICommandModule;
+//#endregion
+//#region src/sandbox/sandbox-command.d.ts
+declare const SANDBOX_MODES: readonly {
+  readonly mode: TSandboxCommandMode;
+  readonly description: string;
+}[];
+declare function formatSandboxStatus(status: ICommandSandboxStatus): string;
+declare function executeSandboxCommand(context: ICommandHostAdapterAccess & ICommandHostUserInteraction, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/output-style/output-style-command-module.d.ts
+declare function executeOutputStyleCommand(context: ICommandHostAdapterAccess & ICommandHostSessionAccess & ICommandHostUserInteraction, args: string): Promise<ICommandResult>;
+declare function createOutputStyleCommandEntry(): ICommand;
+declare class OutputStyleCommandSource implements ICommandSource {
+  readonly name = "output-style";
+  getCommands(): ICommand[];
+}
+declare function createOutputStyleCommandModule(): ICommandModule;
+//#endregion
+//#region src/permissions/permissions-command-module.d.ts
+declare function createPermissionsCommandEntry(): ICommand;
+declare class PermissionsCommandSource implements ICommandSource {
+  readonly name = "permissions";
+  getCommands(): ICommand[];
+}
+declare function createPermissionsCommandModule(): ICommandModule;
+//#endregion
+//#region src/permissions/permissions-command.d.ts
+declare function executePermissionsCommand(context: ICommandHostAdapterAccess & ICommandHostSessionAccess, args: string): ICommandResult;
+//#endregion
+//#region src/plugin/plugin-command-module.d.ts
+declare function createPluginCommandEntry(): ICommand;
+declare function createReloadPluginsCommandEntry(): ICommand;
+declare class PluginManagerCommandSource implements ICommandSource {
+  readonly name = "plugin-manager";
+  getCommands(): ICommand[];
+}
+declare function createPluginCommandModule(): ICommandModule;
+//#endregion
+//#region src/plugin/plugin-command.d.ts
+/** What `/plugin` reaches: its adapter port, and — for install/uninstall — this connection's locality. */
+type TPluginCommandContext = ICommandHostAdapterAccess & Partial<Pick<ICommandHostWorkspace, 'getCommandSurfaceLocality'>>;
+declare function executePluginCommand(context: TPluginCommandContext, args: string): Promise<ICommandResult>;
+declare function executeReloadPluginsCommand(context: ICommandHostAdapterAccess, _args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/preset/preset-command-module.d.ts
+declare function createPresetCommandEntry(): ICommand;
+declare class PresetCommandSource implements ICommandSource {
+  readonly name = "preset";
+  getCommands(): ICommand[];
+}
+declare function createPresetCommandModule(): ICommandModule;
+//#endregion
+//#region src/preset/preset-command.d.ts
+declare function executePresetCommand(context: ICommandHostPresetApplication & ICommandHostSessionAccess & ICommandHostUserInteraction & ICommandHostAdapterAccess, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/shell/resolve-shell.d.ts
+interface IResolvedShell {
+  /** Executable to spawn. */
+  command: string;
+  /** Args for an interactive shell session (drop-to-shell). */
+  interactiveArgs: readonly string[];
+  /** Args to run a single command string non-interactively. */
+  commandArgs(command: string): readonly string[];
+}
+/** Resolve the interactive shell for the current platform via the agent-core SSOT resolver. */
+declare function resolveShell(executable?: string): IResolvedShell;
+//#endregion
+//#region src/shell/spawn-inherited.d.ts
+declare function spawnInherited(command: string, args: readonly string[], cwd: string): Promise<number>;
+//#endregion
+//#region src/shell/shell-command.d.ts
+declare const SHELL_COMMAND_DESCRIPTION = "Drop to an interactive shell (or run `/shell <command>` interactively), then return to the agent.";
+declare function executeShellCommand(context: ICommandHostTerminalHandoff & ICommandHostWorkspace, args: string, executable?: string): Promise<ICommandResult>;
+//#endregion
+//#region src/shell/shell-command-module.d.ts
+declare function createShellCommandEntry(): ICommand;
+declare class ShellCommandSource implements ICommandSource {
+  readonly name = "shell";
+  getCommands(): ICommand[];
+}
+declare function createShellCommandModule(executable?: string): ICommandModule;
+//#endregion
+//#region src/provider/provider-command-module.d.ts
+declare function createProviderCommandEntry(): ICommand;
+declare class ProviderCommandSource implements ICommandSource {
+  readonly name = "provider";
+  getCommands(): ICommand[];
+}
+declare function createProviderCommandModule(options: IProviderCommandModuleOptions$2): ICommandModule;
+//#endregion
+//#region src/provider/provider-command-execution.d.ts
+declare function executeProviderCommand(context: ICommandHostUserInteraction & ICommandHostSetupState, args: string, options: IProviderCommandModuleOptions$1): Promise<ICommandResult>;
+//#endregion
+//#region src/provider/provider-setup-flow.d.ts
+type TProviderSetupType = string;
+type TPromptInput = (label: string, masked?: boolean, options?: {
+  signal?: AbortSignal;
+}) => Promise<string>;
+interface IProviderSetupPromptStep extends IProviderSetupStepDefinition {
+  key: TProviderSetupField;
+}
+interface IProviderSetupFlowState {
+  type: TProviderSetupType;
+  steps: readonly IProviderSetupPromptStep[];
+  setupHelpLinks: readonly IProviderSetupHelpLink[];
+  stepIndex: number;
+  values: Partial<Record<TProviderSetupField, string>>;
+  existingProfileNames: readonly string[];
+  profileName?: string;
+  setCurrent?: boolean;
+}
+interface IProviderSetupFlowOptions {
+  includeEditOnlySteps?: boolean;
+  existingProfileNames?: readonly string[];
+  initialValues?: Partial<Record<TProviderSetupField, string>>;
+  profileName?: string;
+  setCurrent?: boolean;
+}
+type TProviderSetupFlowSubmitResult = {
+  status: 'next';
+  state: IProviderSetupFlowState;
+} | {
+  status: 'complete';
+  input: IProviderSetupInput;
+} | {
+  status: 'error';
+  state: IProviderSetupFlowState;
+  message: string;
+};
+declare function createProviderSetupFlow(type: TProviderSetupType, providerDefinitions: readonly IProviderDefinition[], options?: IProviderSetupFlowOptions): IProviderSetupFlowState;
+declare function formatProviderSetupSelectionPrompt(providerDefinitions: readonly IProviderDefinition[]): string;
+declare function resolveProviderSetupSelection(rawValue: string, providerDefinitions: readonly IProviderDefinition[]): TProviderSetupType;
+declare function getProviderSetupStep(state: IProviderSetupFlowState): IProviderSetupPromptStep;
+declare function submitProviderSetupValue(state: IProviderSetupFlowState, rawValue: string): TProviderSetupFlowSubmitResult;
+declare function runProviderSetupPromptFlow(type: TProviderSetupType, promptInput: TPromptInput, providerDefinitions: readonly IProviderDefinition[], options?: IProviderSetupFlowOptions): Promise<IProviderSetupInput>;
+declare function formatProviderSetupPromptLabel(step: IProviderSetupPromptStep, setupHelpLinks?: readonly IProviderSetupHelpLink[]): string;
+declare function formatProviderSetupChoiceLabel(definition: IProviderDefinition): string;
+declare function formatProviderSetupHelpLinks(setupHelpLinks?: readonly IProviderSetupHelpLink[]): string;
+declare function validateProviderSetupValue(step: IProviderSetupPromptStep, value: string): string | undefined;
+//#endregion
+//#region src/provider/provider-startup.d.ts
+interface IProviderStartupContext {
+  provider?: string;
+  settingsScope?: TSettingsScope;
+  settingsSources: readonly TSettingsSource[];
+  settingsStores: readonly ISettingsDocumentStore[];
+  /** Selected host snapshot for configure-time credential reference checks. */
+  env?: Record<string, string | undefined>;
+  connectionHost?: IProviderConnectionHost;
+  orgPolicy?: IOrgPolicy;
+  interaction?: IUserInteraction;
+}
+interface IEnsureProviderConfigOptions {
+  formatError: (defs: readonly IProviderDefinition[]) => string;
+  isInteractive?: () => boolean;
+  /** Environment map for env-default synthesis (test seam, default: process.env). */
+  env?: Record<string, string | undefined>;
+}
+declare function runProviderStartupSetup(cwd: string, ctx: IProviderStartupContext, promptInput: TPromptInput, terminal: ITerminalOutput, providerDefinitions: readonly IProviderDefinition[]): Promise<void>;
+declare function ensureProviderConfig(cwd: string, ctx: IProviderStartupContext, promptInput: TPromptInput, terminal: ITerminalOutput, providerDefinitions: readonly IProviderDefinition[], options: IEnsureProviderConfigOptions): Promise<void>;
+//#endregion
+//#region src/remote-control/remote-control-command-module.d.ts
+declare function createRemoteControlCommandEntry(): ICommand;
+declare class RemoteControlCommandSource implements ICommandSource {
+  readonly name = "remote-control";
+  getCommands(): ICommand[];
+}
+declare function createRemoteControlCommandModule(): ICommandModule;
+//#endregion
+//#region src/remote-control/remote-control-command.d.ts
+declare function executeRemoteControlCommand(context: ICommandHostAdapterAccess & Pick<ICommandHostWorkspace, 'getCommandInvocationSource'>, args: string): ICommandResult;
+//#endregion
+//#region src/reset/reset-command-module.d.ts
+declare function createResetCommandEntry(): ICommand;
+declare function createResetCommandModule(): ICommandModule;
+//#endregion
+//#region src/reset/reset-command.d.ts
+declare function executeResetCommand(): ICommandResult;
+//#endregion
+//#region src/rewind/rewind-command-module.d.ts
+declare class RewindCommandSource implements ICommandSource {
+  readonly name = "rewind";
+  getCommands(): ICommand[];
+}
+declare function createRewindCommandModule(): ICommandModule;
+//#endregion
+//#region src/rewind/rewind-command.d.ts
+type TRewindCommandContext = ICommandHostCheckpoints & {
+  getCommandProductVocabulary?(): ICommandProductVocabulary | undefined;
+};
+declare function executeRewindCommand(context: TRewindCommandContext, rawArgs: string): Promise<ICommandResult>;
+//#endregion
+//#region src/schedule/loop-command.d.ts
+interface ILoopCommandOptions {
+  /** Product-host-owned maintenance text, used only when the operator omits a prompt. */
+  defaultPrompt?: string;
+  /** Re-read the project/user default for each new loop; an explicit prompt never calls this. */
+  resolveDefaultPrompt?: () => string;
+  /** Host kill switch; listing and stopping existing loops remain available. */
+  disabled?: boolean;
+}
+/**
+ * #3288 §1: who invoked `/loop`, and how to ask them. `ui` is the injected "ask the user" port
+ * (absent for a headless/automation host — see `ICommandHostUserInteraction`); `source` is the
+ * command's own invocation source. Defaults to `{ ui: undefined, source: 'user' }` when the caller
+ * omits it, matching every pre-existing (headless) call site: proceed unconfirmed, the same as
+ * before this gate existed.
+ */
+interface ILoopInvocationContext {
+  readonly ui: IUserInteraction | undefined;
+  readonly source: TCommandInvocationSource;
+}
+declare function executeLoopCommand(host: Pick<IAgentJobHostContext, 'spawnScheduledWake' | 'listSchedules' | 'createSelfPacedLoop' | 'listSelfPacedLoops' | 'stopSelfPacedLoop'>, cancelBackgroundTask: (taskId: string, reason: string) => Promise<void>, args: string, options?: ILoopCommandOptions, invocation?: ILoopInvocationContext): Promise<ICommandResult>;
+//#endregion
+//#region src/schedule/schedule-command-module.d.ts
+declare function createScheduleCommandEntry(): ICommand;
+declare function createMonitorCommandEntry(): ICommand;
+declare function createLoopCommandEntry(): ICommand;
+declare class ScheduleCommandSource implements ICommandSource {
+  readonly name = "schedule";
+  getCommands(): ICommand[];
+}
+declare function createScheduleCommandModule(options?: ILoopCommandOptions): ICommandModule;
+//#endregion
+//#region src/schedule/schedule-command.d.ts
+declare function executeScheduleCommand(host: IAgentJobHostContext, args: string, now?: number): Promise<ICommandResult>;
+declare function executeMonitorCommand(host: IAgentJobHostContext, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/schedule/schedule-spec-parser.d.ts
+/**
+ * FLOW-005: parse the `<when>` portion of `/schedule` into a cron expression croner accepts.
+ *
+ * Two forms:
+ *   in <N><unit> <instruction>     — one-shot, fires once at now + duration (s|m|h|d)
+ *   cron "<expr>" <instruction>    — recurring, a standard cron expression
+ */
+interface IScheduleSpec {
+  cronExpression: string;
+  instruction: string;
+  recurring: boolean;
+}
+type TScheduleParseResult = {
+  ok: true;
+  spec: IScheduleSpec;
+} | {
+  ok: false;
+  error: string;
+};
+declare function parseScheduleSpec(args: string, now: number): TScheduleParseResult;
+//#endregion
+//#region src/session/session-command.d.ts
+declare const CLEAR_COMMAND_MESSAGE = "Conversation cleared.";
+declare function executeClearCommand(context: ICommandHostSessionAccess & ICommandHostUserInteraction, _args: string): Promise<ICommandResult>;
+declare function executeRenameCommand(_context: ICommandHostNoCapability, args: string): ICommandResult;
+declare function executeResumeCommand(): ICommandResult;
+type TCostCommandContext = ICommandHostSessionAccess & ICommandHostWorkspace & ICommandHostAdapterAccess;
+declare function executeCostCommand(context: TCostCommandContext, args: string): ICommandResult;
+declare function executeValidateSessionCommand(context: ICommandHostSessionAccess & ICommandHostWorkspace, _args: string): ICommandResult;
+//#endregion
+//#region src/session/session-command-module.d.ts
+declare function createClearCommandEntry(): ICommand;
+declare function createRenameCommandEntry(): ICommand;
+declare function createResumeCommandEntry(): ICommand;
+declare function createCostCommandEntry(): ICommand;
+declare function createValidateSessionCommandEntry(): ICommand;
+declare class SessionCommandSource implements ICommandSource {
+  readonly name = "session";
+  getCommands(): ICommand[];
+}
+declare function createSessionCommandModule(): ICommandModule;
+//#endregion
+//#region src/settings/settings-command-module.d.ts
+declare function createSettingsCommandEntry(): ICommand;
+declare class SettingsCommandSource implements ICommandSource {
+  readonly name = "settings";
+  getCommands(): ICommand[];
+}
+declare function createSettingsCommandModule(): ICommandModule;
+//#endregion
+//#region src/skills/skills-command-module.d.ts
+interface ISkillsCommandModuleOptions {
+  readonly contributionSources: readonly IContributionSource[];
+  readonly skillRoots?: readonly ISkillRootDescriptor[];
+}
+declare function createSkillsCommandEntry(): ICommand;
+declare class SkillsCommandSource implements ICommandSource {
+  readonly name = "skills";
+  getCommands(): ICommand[];
+}
+declare function createSkillsCommandModule(options: ISkillsCommandModuleOptions): ICommandModule;
+//#endregion
+//#region src/skills/skills-command.d.ts
+declare const SKILLS_COMMAND_DESCRIPTION = "List registered skills, or activate one by name";
+declare function executeSkillsCommand(context: ICommandHostCatalog & ICommandHostWorkspace, args?: string): Promise<ICommandResult>;
+//#endregion
+//#region src/statusline/statusline-command-module.d.ts
+declare function createStatusLineCommandEntry(): ICommand;
+declare class StatusLineCommandSource implements ICommandSource {
+  readonly name = "statusline";
+  getCommands(): ICommand[];
+}
+declare function createStatusLineCommandModule(): ICommandModule;
+//#endregion
+//#region src/statusline/statusline-command.d.ts
+declare const STATUSLINE_USAGE: string;
+declare function executeStatusLineCommand(_context: ICommandHostNoCapability, args: string): ICommandResult;
+//#endregion
+//#region src/terminal-client/terminal-client-commands.d.ts
+/** A command the terminal runs itself, with the terminal's own handoff and working directory. */
+interface ITerminalClientCommand {
+  readonly name: string;
+  execute(host: ICommandHostTerminalHandoff & ICommandHostWorkspace, args: string): ICommandResult | Promise<ICommandResult>;
+}
+/** The terminal's own capabilities — the same ones its in-process command modules are given. */
+interface ITerminalClientCommandOptions {
+  /** The shell `/shell` runs; absent → the platform shell, as for the in-process command. */
+  readonly shellExecutable?: string;
+  /** Product-owned prefix for `/editor`'s temporary directory; absent → the command's default. */
+  readonly editorTemporaryDirectoryPrefix?: string;
+  /** Absent → `/keybindings` answers where key bindings live, as the in-process command does. */
+  readonly keybindingsFile?: IKeybindingsFilePort;
+  /** Absent → `/theme` answers where themes live, as the in-process command does. */
+  readonly themeCatalogue?: IThemeCataloguePort$1;
+  /**
+   * The same module selection the default assembly is given (`agent-command-shell`, …): a module it
+   * leaves out is left out here too, so an attached terminal offers no command a standalone one
+   * would not. Absent → every client-run module.
+   */
+  readonly enabledCommandModules?: readonly string[];
+  /** Applied after `enabledCommandModules`, as in the default assembly (deny > allow). */
+  readonly disabledCommandModules?: readonly string[];
+}
+/**
+ * Every client-run command the module selection keeps, whether or not its port is given. The set
+ * shrinks only with the selection, never with a missing port: the attached terminal routes by it, so
+ * a selected command left out would run on the daemon instead — and without its port the command
+ * still answers as its in-process twin does.
+ */
+declare function createTerminalClientCommands(options: ITerminalClientCommandOptions): readonly ITerminalClientCommand[];
+//#endregion
+//#region src/user-local/user-local-command-module.d.ts
+declare function createUserLocalCommandEntry(): ICommand;
+declare class UserLocalCommandSource implements ICommandSource {
+  readonly name = "user-local";
+  getCommands(): ICommand[];
+}
+declare function createUserLocalCommandModule(storageRoot: string): ICommandModule;
+//#endregion
+//#region src/user-local/user-local-command-constants.d.ts
+declare const USER_LOCAL_COMMAND_DESCRIPTION = "Inspect user-local storage and memory state.";
+declare const USER_LOCAL_COMMAND_ARGUMENT_HINT = "storage list [--format json] | memory set/list/inspect/disable/delete";
+declare const USER_LOCAL_COMMAND_USAGE = "Usage: user-local storage list [--format json] | user-local memory set <category> <key> <value> --summary <summary> --source <source> | user-local memory list [--format json] | user-local memory inspect <category> <key> [--format json] | user-local memory disable <category> <key> | user-local memory delete <category> <key>";
+//#endregion
+//#region src/user-local/user-local-command.d.ts
+interface IUserLocalDirectCommandOptions {
+  readonly cwd: string;
+  readonly storageRoot: string;
+  readonly argv: readonly string[];
+  readonly format?: string;
+  readonly summary?: string;
+  readonly source?: string;
+}
+declare function executeUserLocalDirectCommand(options: IUserLocalDirectCommandOptions): Promise<ICommandResult>;
+declare function executeUserLocalCommand(context: ICommandHostWorkspace, rawArgs: string, storageRoot: string): Promise<ICommandResult>;
+//#endregion
+export { ADVISOR_SETTING_KEY, AdvisorCommandSource, AgentCommandSource, BackgroundCommandSource, CLEAR_COMMAND_MESSAGE, CompactCommandSource, ContextCommandSource, DoctorCommandSource, EDITOR_COMMAND_DESCRIPTION, EditorCommandSource, EffortCommandSource, ExitCommandSource, GOAL_COMMAND_DESCRIPTION, GitCommandSource, GoalCommandSource, HandoffCommandSource, HelpCommandSource, type ICreateGitProcessOptions, type IDefaultCommandModulesOptions, type IDefaultCommandModulesResult, type IDeviceListEntry, type IDevicesAddResult, type IDevicesCommandPort, type IDevicesInitResult, type IDevicesJoinResult, type IDevicesMeshStatus, type IDevicesRecoverResult, type IDevicesRevokeResult, type IDevicesView, type IDoctorCheck, type IDoctorDeps, type IDoctorDisplayVocabulary, type IDoctorEndpointProbeResult, type IDoctorInputs, type IDoctorPathFacts, type IDoctorRepairPlan, type IDoctorReport, type IEnsureProviderConfigOptions, type IGitCommandModuleOptions, type IGitProcessPort, type IGitProcessRunOptions, type IKeybindingsFilePort, type ILoopCommandOptions, type IProviderCommandModuleOptions, type IProviderCommandSettingsAdapter, type IProviderSetupFlowOptions, type IProviderSetupFlowState, type IProviderSetupPromptStep, type IProviderStartupContext, type IResolvedEditor, type IResolvedShell, type IScheduleSpec, type ISkillsCommandModuleOptions, type ITerminalClientCommand, type ITerminalClientCommandOptions, type IThemeAppearanceState, type IThemeCatalogueEntry, type IThemeCataloguePort, type IUserLocalDirectCommandOptions, KeybindingsCommandSource, LanguageCommandSource, MCPActivationCommandSource, MemoryCommandSource, ModeCommandSource, ModelCommandSource, OutputStyleCommandSource, PermissionsCommandSource, PluginManagerCommandSource, PresetCommandSource, ProviderCommandSource, RemoteControlCommandSource, RewindCommandSource, SANDBOX_MODES, SHELL_COMMAND_DESCRIPTION, SKILLS_COMMAND_DESCRIPTION, STATUSLINE_USAGE, STORAGE_REPAIR_ID, SandboxCommandSource, ScheduleCommandSource, SessionCommandSource, SettingsCommandSource, ShellCommandSource, SkillsCommandSource, StatusLineCommandSource, type TDevicesOutcome, type TDevicesRefusal, type TDoctorCheckStatus, type TDoctorNotProbed, type TDoctorRepairOutcome, type TDoctorRepairPlanResult, type TGitCommandContext, type TGitProcessFailureReason, type TGitProcessOutcome, type TMCPUserAction, type TMCPUserActionSurface, type TPromptInput, type TProviderSetupFlowSubmitResult, type TProviderSetupType, type TReducedMotionOverride, type TScheduleParseResult, ThemeCommandSource, USER_LOCAL_COMMAND_ARGUMENT_HINT, USER_LOCAL_COMMAND_DESCRIPTION, USER_LOCAL_COMMAND_USAGE, UserLocalCommandSource, applyDoctorRepair, buildDoctorReport, collectSettingsSecrets, createAdvisorCommandEntry, createAdvisorCommandModule, createAgentCommandEntry, createAgentCommandModule, createAgentSystemCommand, createBackgroundCommandEntry, createBackgroundCommandModule, createClearCommandEntry, createCompactCommandEntry, createCompactCommandModule, createContextCommandEntry, createContextCommandModule, createCostCommandEntry, createDefaultCommandModules, createDevicesCommandModule, createDoctorCommandEntry, createDoctorCommandModule, createEditorCommandEntry, createEditorCommandModule, createEffortCommandEntry, createEffortCommandModule, createExitCommandEntry, createExitCommandModule, createGitCommandEntry, createGitCommandModule, createGitProcess, createGoalCommandEntry, createGoalCommandModule, createHandoffCommandEntry, createHandoffCommandModule, createHelpCommandEntry, createHelpCommandModule, createKeybindingsCommandEntry, createKeybindingsCommandModule, createLanguageCommandEntry, createLanguageCommandModule, createLoopCommandEntry, createMCPActivationCommandEntry, createMCPActivationCommandModule, createMemoryCommandEntry, createMemoryCommandModule, createModeCommandEntry, createModeCommandModule, createModelCommandEntry, createModelCommandModule, createMonitorCommandEntry, createNodeDoctorDeps, createOutputStyleCommandEntry, createOutputStyleCommandModule, createPermissionsCommandEntry, createPermissionsCommandModule, createPlanCommandModule, createPluginCommandEntry, createPluginCommandModule, createPresetCommandEntry, createPresetCommandModule, createProviderCommandEntry, createProviderCommandModule, createProviderSetupFlow, createReloadPluginsCommandEntry, createRemoteControlCommandEntry, createRemoteControlCommandModule, createRenameCommandEntry, createResetCommandEntry, createResetCommandModule, createResumeCommandEntry, createRewindCommandModule, createSandboxCommandModule, createScheduleCommandEntry, createScheduleCommandModule, createSessionCommandModule, createSettingsCommandEntry, createSettingsCommandModule, createShellCommandEntry, createShellCommandModule, createSkillsCommandEntry, createSkillsCommandModule, createStatusLineCommandEntry, createStatusLineCommandModule, createTerminalClientCommands, createThemeCommandEntry, createThemeCommandModule, createUserLocalCommandEntry, createUserLocalCommandModule, createValidateSessionCommandEntry, doctorRepairAllowlist, ensureProviderConfig, executeAdvisorCommand, executeAgentCommand, executeBackgroundCommand, executeClearCommand, executeCompactCommand, executeContextCommand, executeCostCommand, executeEditorCommand, executeEffortCommand, executeExitCommand, executeGitCommand, executeGoalCommand, executeHandoffCommand, executeHelpCommand, executeLanguageCommand, executeLoopCommand, executeMCPActivationCommand, executeMemoryCommand, executeModeCommand, executeModelCommand, executeMonitorCommand, executeOutputStyleCommand, executePermissionsCommand, executePluginCommand, executePresetCommand, executeProviderCommand, executeReloadPluginsCommand, executeRemoteControlCommand, executeRenameCommand, executeResetCommand, executeResumeCommand, executeRewindCommand, executeSandboxCommand, executeScheduleCommand, executeShellCommand, executeSkillsCommand, executeStatusLineCommand, executeThemeCommand, executeUserLocalCommand, executeUserLocalDirectCommand, executeValidateSessionCommand, formatProviderSetupChoiceLabel, formatProviderSetupHelpLinks, formatProviderSetupPromptLabel, formatProviderSetupSelectionPrompt, formatSandboxStatus, getProviderSetupStep, gitEnvironment, isDoctorRepairId, mcpUnavailableServersNotice, mcpUserActionCommand, mcpUserActionNotice, parseScheduleSpec, planDoctorRepair, redactDiagnosticText, renderDoctorReport, resolveCommandOnPath, resolveEditor, resolveProviderSetupSelection, resolveShell, runDoctor, runProviderSetupPromptFlow, runProviderStartupSetup, spawnInherited, submitProviderSetupValue, validateProviderSetupValue };
+//# sourceMappingURL=index.d.ts.map