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

package/dist/node/index.d.cts

@@ -0,0 +1,2192 @@
+import { $ as PluginCommandSource, $a as TCommandModuleSessionRequirement, $c as TWorkspaceProjectSettingsWriteDecision, $i as TSettingsData, $l as IEditCheckpointFileRecord, $n as inspectCommandEditCheckpoint, $o as GoalController, $r as formatCommandPermissionsMessage, $s as IHandoffProgress, $t as evaluateReversibleToolSafety, A as resolvePromptFileReferencePaths, Aa as removeCommandContextReference, Ac as WorkspaceProjectSessionStore, Ai as IModelListSelection, Al as IExecutionWorkspaceTaskSpawner, An as createSkillCommand, Ao as ISemanticMemoryAdapter, Ar as TAppearanceSettingsPatch, As as ICommandExternalEventsAdapter, At as ICreateSessionOptions, B as TPermissionResultValue$1, Ba as IProviderProfileSettings, Bc as IWorkspaceProjectMutation, Bi as mergeSettings, Bl as EXECUTION_ORIGIN_METADATA_KEYS, Bn as MEMORY_COMMAND_ARGUMENT_HINT, Bo as IAppendMemoryResult, Br as readStatusLineSettings, Bs as ICommandMCPSourceProblem, Bt as ISubagentPromptOptions, C as TExternalEventSettlement, Ca as addCommandContextReference, Cc as isSafeSessionId, Ci as formatCommandBackgroundTaskList, Cl as IAgentJobMonitors, Cn as listFrameworkProjectContributionPaths, Co as IMemoryBudget, Cr as RELOAD_PLUGINS_COMMAND_DESCRIPTION, Cs as TPromptFileReferenceDiagnosticCode, Ct as storeAgentToolDeps, Cu as TFrontmatterDecodeResult, D as sandboxApprovalFor, Da as readAutoCompactThreshold, Dc as resolveLatestSessionId, Di as HELP_COMMAND_DESCRIPTION, Dl as IBackgroundTaskRunner, Dn as ISkillSourceSkip, Do as IMemoryTopicMutationResult, Dr as APPEARANCE_SETTINGS_KEYS, Ds as ICommandCostBudgetAdapter, Dt as preprocessShellCommands, E as resolveSubagentLogDir, Ea as listCommandContextReferences, Ec as listUnreadableSessionsForWorkspace, Ei as readCommandBackgroundTaskLog, El as MonitorCommandRefusedError, En as ISkillSourceInspection, Eo as IMemoryStore, Er as resolvePluginCommandAdapter, Es as ICommandCostBudget, Et as TShellExecFn, F as formatPromptFileReferenceDiagnostics, Fa as IProviderCommandSettingsAdapter, Fc as IWorkspaceAncestorTextEntry, Fi as createProviderFromSettings, Fl as createMainThreadDetailPage, Fn as IResolvedConfig, Fo as IMemoryPendingRecord, Fr as STATUSLINE_COMMAND_ARGUMENT_HINT, Fs as ICommandMCPOAuthLoginRequest, Ft as TSubagentRunnerFactory, G as createSkillExecutionPort, Ga as buildProviderProfile, Gc as IWorkspaceTrustGrant, Gi as IProviderSwitchOptions, Gl as parseExecutionWorkspaceEntryId, Gn as hasSensitiveCommandMemoryContent, Go as ProjectMemoryStore, Gr as PERMISSIONS_COMMAND_DESCRIPTION, Gs as ICommandPickerAdapter, Gt as IReversibleExecutionOptions, H as IRemoteCommandPolicy, Ha as IProviderSetupInput, Hc as IWorkspaceProjectSettingsWriter, Hi as resolveActiveProvider, Hl as createBackgroundTaskExecutionEntryId, Hn as MEMORY_COMMAND_USAGE, Ho as IStartupMemory, Hr as applyPresetToSession, Hs as ICommandOutputStyleSummary, Ht as assembleSubagentPrompt, I as hasBlockingPromptFileReferenceDiagnostics, Ia as IProviderConnectionHost, Ic as IWorkspaceDirectoryEntry, Ii as readMergedProviderSettings, Il as IResolveExecutionAttachInput, In as TEnvResolvedSettings, Io as IMemoryRetrievalResult, Ir as STATUSLINE_COMMAND_DESCRIPTION, Is as ICommandMCPOAuthLoginResult, It as createInProcessSubagentRunner, J as ISkillExecutionResult, Ja as mergeProviderPatch, Jc as TWorkspaceContributionKind, Ji as applyProviderSwitch, Jl as summarizeBackgroundJobGroup, Jn as recordCommandMemoryEvent, Jo as buildGoalStartPrompt, Jr as PERMISSION_MODE_LABELS, Js as ICommandSandboxAdapter, Jt as IReversibleToolSafetyReport, K as IForkExecutionOptions, Ka as buildProviderSetupPatch, Kc as IWorkspaceTrustStore, Ki as applyActiveModelChange, Kl as BackgroundJobOrchestrator, Kn as isCommandMemoryType, Ko as isMemoryType, Kr as PERMISSION_MODE_ARGUMENT_HINT, Ks as ICommandProcessAdapter, Kt as IReversibleToolSafetyContext, L as toPromptFileReferenceRecords, La as IProviderConnectionRequest, Lc as IWorkspaceIdentity, Li as readProviderSettings, Ll as TExecutionAttachOutcome, Ln as TSandboxSettings, Lo as TMemoryCandidateStatus, Lr as applyStatusLineSettings, Ls as ICommandMCPOAuthLogoutResult, Lt as ISubagentOptions, M as parsePromptFileReferences, Ma as setCommandAutoCompactThreshold, Mc as WorkspaceSessionLogSource, Mi as resolveModelListSelection, Ml as ISpawnProcessTaskRequest, Mn as IContributionSource, Mo as IAutomaticMemoryConfig, Mr as isAppearanceSettingsPatch, Ms as ICommandHostAdapters, Mt as IToolCallHandoffPolicy, N as buildPromptWithFileReferences, Na as writeAutoCompactThresholdSetting, Nc as IRestrictedWorkspaceProjectAccess, Ni as IReadProviderSettingsOptions, Nl as createExecutionWorkspaceTaskSpawner, Nn as createWorkspaceProjectContributionSource, No as IMemoryCandidate, Nr as readAppearanceSettings, Ns as ICommandMCPActivationAdapter, Nt as IToolCallHandoffProvenance, O as IHookDefinitionSource, Oa as readAutoCompactThresholdSource, Oc as resolveReusableEmptySessionId, Oi as formatCommandHelpMessage, Ol as IBackgroundTaskSpawnerGroupRequest, On as SkillCommandSource, Oo as IMemoryWriter, Or as DEFAULT_APPEARANCE_SETTINGS, Os as ICommandEffortAdapter, Ot as substituteVariables, P as createPromptFileReferenceHistoryEntry, Pa as IProviderCommandModuleOptions, Pc as ITrustedWorkspaceProjectAccess, Pi as ProviderConfigError, Pl as createLineDetailPage, Pn as ILoadContextOptions, Po as IMemoryExtractionInput, Pr as DEFAULT_STATUS_LINE_COMMAND_SETTINGS, Ps as ICommandMCPActivationSummary, Pt as IInProcessSubagentRunnerDeps, Q as SystemCommandExecutor, Qa as ICommandModule, Qc as TWorkspaceProjectSettingsTarget, Qi as ISettingsDocumentStore, Ql as IEditCheckpointFileInspection, Qn as forkCommandEditCheckpoint, Qo as DEFAULT_GOAL_NO_PROGRESS_LIMIT, Qr as buildPermissionModeSubcommands, Qs as ICommandWorkspaceAdapter, Qt as TReversibleSideEffect, R as IExecutionResult$1, Ra as TProviderConnectionStage, Rc as IWorkspaceIdentityResolver, Ri as resolveEnvDefaultProvider, Rl as resolveExecutionAttach, Rn as TSettings, Ro as TMemoryPolicyMode, Rr as buildStatusLineCommandSubcommands, Rs as ICommandMCPOAuthRedirectPrompt, Rt as ISubagentParentContext, S as TExternalEventReceipt, Sa as TAutoCompactThreshold, Sc as createUserSessionStore, Si as formatCommandBackgroundTask, Sl as IAgentJobLogs, Sn as IProjectContributionPath, So as IDurableMemoryReader, Sr as PLUGIN_COMMAND_DESCRIPTION, Ss as IResolvedPromptFileReferences, St as retrieveAgentToolDeps, Su as IFrontmatterDecodeInput, T as createSubagentLogger, Ta as compactCommandContext, Tc as listUnreadableSessions, Ti as parseCommandBackgroundLogCursor, Tl as MONITOR_SHELL_TOOL, Tn as ISkillRootInspection, To as IMemoryRecaller, Tr as createShowPluginManagerIntent, Ts as EditCheckpointStore, Tt as ISkillPromptContext, U as createDefaultRemoteCommandPolicy, Ua as IProviderSetupPatch, Uc as IWorkspaceProjectStateStorage, Ui as IActiveModelChangeOptions, Ul as createExecutionOriginMetadata, Un as buildMemoryCommandSubcommands, Uo as MEMORY_INDEX_MAX_BYTES, Ur as IPermissionRuleGroup, Us as ICommandPermissionModeAdapter, Ut as getForkWorkerSuffix, V as IPromptHistoryOptions, Va as IProviderSettingsBuildOptions, Vc as IWorkspaceProjectReader, Vi as readMergedProviderSettingsFromSources, Vl as createBackgroundGroupExecutionEntryId, Vn as MEMORY_COMMAND_DESCRIPTION, Vo as IProjectMemorySummary, Vr as IPresetApplicationResult, Vs as ICommandOutputStyleRegistryAdapter, Vt as TSubagentSuffix, W as ISkillActivationHistoryData, Wa as TProviderSettingsDocument, Wc as IWorkspaceTrustCause, Wi as IActiveModelChangeResult, Wl as createMainThreadExecutionEntryId, Wn as createCommandMemoryStores, Wo as MEMORY_INDEX_MAX_LINES, Wr as IPermissionsCommandState, Ws as ICommandPermissionRulesAdapter, Wt as getSubagentSuffix, X as findUnknownModuleNames, Xa as upsertProviderProfile, Xc as TWorkspaceProjectAuthorityCandidate, Xi as createWorkspaceProjectSettingsStore, Xl as ICommandResult$1, Xn as REWIND_COMMAND_DESCRIPTION, Xo as createGoalStatusTool, Xr as TPermissionRuleKind, Xs as ICommandSettingsAdapter, Xt as TReversibleRollbackLayer, Y as executeSkill, Ya as setCurrentProvider, Yc as TWorkspaceProjectAccess, Yi as resolveProviderSettingsWriteTarget, Yl as ISessionUsageRecord, Yn as REWIND_COMMAND_ARGUMENT_HINT, Yo as GOAL_SIGNAL_TOOL_NAME, Yr as RUNTIME_RULE_SOURCE, Ys as ICommandSandboxStatus, Yt as TReversibleExecutionIsolation, Z as selectCommandModules, Za as validateProviderProfile, Zc as TWorkspaceProjectMutationDecision, Zi as createNodeHostSettingsStore, Zl as IOrgPolicy, Zn as buildRewindCommandSubcommands, Zo as DEFAULT_GOAL_MAX_ITERATIONS, Zr as VALID_PERMISSION_MODES, Zs as ICommandSettingsDocument, Zt as TReversibleSafetyStatus, _ as TInteractiveSessionOptions, _a as probeProviderProfile, _c as IInteractiveSessionStore$1, _i as BACKGROUND_COMMAND_DESCRIPTION, _l as TAutoCompactThresholdSource, _n as IBundleSkill, _o as ICommandHostSessionAccess, _r as formatCommandSessionReplayValidationReport, _s as IPromptFileReferenceHistoryData, _t as TMarketplaceSource, _u as TEffortSelection, a as SessionRenameUnavailableError, aa as IProjectSettingsPath, ac as TRemoteControlStatus, ai as readCommandPermissionMode, al as ICommandSessionHistory, an as AgentExecutor, ao as ICommandHostAdapterAccess, ar as CLEAR_COMMAND_DESCRIPTION, as as IContextReferenceAddResult, at as IHostBundlePluginLoaderOptions, au as IEditCheckpointSummary, b as IExternalEventSource, ba as DEFAULT_AUTO_COMPACT_THRESHOLD, bc as createProjectSessionStore, bi as cancelCommandBackgroundTask, bl as IAgentJobGroups, bn as TEnabledPlugins, bo as ICommandHostUserInteraction, br as validateCommandSessionReplayLog, bs as IPromptFileReferenceToken, bt as CommandRegistry, bu as resolveModelEffort, c as TRestoredScheduleDisposition, ca as TSettingsSource, cc as IAdvisorSetResult, ci as retryCommandPermissionDenial, cl as ICommandSessionPermissions, cn as TSessionFactory, co as ICommandHostCatalog, cr as ICommandSessionInfo, cs as IContextReferenceRemoveResult, ct as loadHostBundlePluginsFromScopes, cu as ICapabilityDescriptor, d as generateSessionName, da as INodeHostSettingsSource, dc as ICommandAdvisorAdapter, di as LANGUAGE_COMMAND_DESCRIPTION, dl as ICommandHostNoCapability, dn as IBundlePluginHookIssue, do as ICommandHostContextReferences, dr as RESUME_COMMAND_DESCRIPTION, ds as createContextReferenceItem, dt as NodeHostPluginSettingsStore, du as IAgentDefinition, ea as TSettingsScope, ec as IHandoffStaysBehind, ei as formatInvalidPermissionModeMessage, el as TWorkspaceProjectStateDirectories, en as wrapReversibleExecutionTools, eo as DuplicateSystemCommandSemanticRoleError, er as listCommandEditCheckpointBranches, es as IGoalSignal, et as BundlePluginInstaller, eu as IEditCheckpointInspection, f as IInteractiveSessionShutdownOptions, fa as createNodeHostSettingsSource, fc as formatAdvisorSpec, fi as RECOMMENDED_RESPONSE_LANGUAGES, fl as ICommandProductVocabulary, fn as IBundlePluginInspection, fo as ICommandHostContextWindow, fr as VALIDATE_SESSION_COMMAND_DESCRIPTION, fs as listActiveContextReferences, ft as IKnownMarketplaceEntry, fu as IProviderErrorGuidance, g as restoreSessionRecordIntoSession, ga as checkSettingsDocument, gc as IInteractiveSessionRecord$1, gi as parseLanguageArgument, gl as IUnknownCommandModuleName, gn as IBundlePluginSkip, go as ICommandHostPresetApplication, gr as createShowSessionPickerIntent, gs as IPromptFileReferenceDiagnostic, gt as TKnownMarketplacesRegistry, gu as TEffortDisposition, h as ISessionRecordRestoreResult, ha as checkNodeHostSettingsFile, hc as IHostToolResultSpillStore, hi as formatLanguageUsageMessage, hl as IModelReapplyOptions, hn as IBundlePluginMcpServer, ho as ICommandHostPlan, hr as createSessionRenameHostAction, hs as upsertContextReference, ht as IMarketplacePluginEntry, hu as IModelEffortResolution, i as IInteractiveRuntime, ia as writeSettings, ic as IWorkspaceMoveRequest, ii as parsePermissionModeArgument, il as ICommandSessionContextWindow, in as TProviderFactory, io as TSystemCommandSemanticRole, ir as switchCommandEditCheckpointBranch, is as isGoalCancelVerb, it as MarketplaceClient, iu as IEditCheckpointRestoreResult, j as resolvePromptFileReferences, ja as resetAutoCompactThresholdSetting, jc as WorkspaceSessionLogSink, ji as buildModelListSnapshot, jl as ISpawnAgentTaskRequest, jn as inspectSkillSources, jo as ISemanticMemoryQueryResult, jr as applyAppearanceSettings, js as ICommandHandoffAdapter, jt as TSessionResponseFormat, k as TSettingsMergeRule, ka as readCommandContextState, kc as resolveSessionIdByIdOrName, ki as buildProviderProfilesSnapshot, kl as ICreateExecutionWorkspaceTaskSpawnerOptions, kn as TSkillSkipReason, ko as IPerTurnRecallConfig, kr as IAppearanceSettings, ks as ICommandExternalEventGrant, kt as ILivePromptTracePort, l as restoredScheduleDisposition, la as createWorkspaceProjectSettingsSources, lc as IAdvisorSpec, li as writeCommandPermissionMode, ll as ICommandSessionPreset, ln as describeBundleContribution, lo as ICommandHostCheckpoints, lr as RENAME_COMMAND_DESCRIPTION, ls as IContextReferenceUpsertResult, lt as BundlePluginLoader, lu as DEFAULT_AGENT_DEFINED_IN, ma as TSettingsCheck, mc as resolveStartupAdvisorSpec, mi as buildLanguageCommandSubcommands, ml as ICommandSkillListEntry, mn as IBundlePluginMcpFault, mo as ICommandHostMemory, mr as createSessionExitHostAction, ms as toContextReferenceRecords, mt as IMarketplaceManifest, mu as IModelEffortInputs, na as readSettings, nc as IPermissionRuleLayer, ni as isPermissionMode, nl as TWorkspaceTrustState, nn as IPromptProvider, no as ISystemCommandSemanticRoles, nr as restoreCommandEditCheckpoint, ns as TGoalDecision, nt as IInstalledPluginRecord, nu as IEditCheckpointManifest, o as persistSessionRename, oa as IWorkspaceProjectSettingsSource, oc as TSandboxCommandMode, oi as readCommandPermissionsState, ol as ICommandSessionIdentity, on as IAgentExecutorOptions, oo as ICommandHostAgentJobs, or as COST_COMMAND_DESCRIPTION, os as IContextReferenceClearResult, ot as createHostBundlePluginLoader, ou as IEditCheckpointTurnInput, p as InteractiveSession, pa as THostSettingsScope, pc as parseAdvisorSpec, pi as TRecommendedResponseLanguage, pl as ICommandSessionReplayValidationReport, pn as IBundlePluginManifest, po as ICommandHostGoal, pr as clearConversationHistory, ps as removeContextReference, pt as IMarketplaceClientOptions, pu as EFFORT_LEVEL_LABELS, q as ISkillExecutionCallbacks, qa as deleteProviderProfile, qc as IWorkspaceTrustStoreSnapshot, qi as applyProviderConfiguration, ql as IBackgroundJobOrchestratorOptions, qn as listCommandUsedMemoryReferences, qo as buildGoalContinuationPrompt, qr as PERMISSION_MODE_COMMAND_DESCRIPTION, qs as ICommandRemoteControlAdapter, qt as IReversibleToolSafetyInput, r as createInteractiveRuntime, ra as updateModelInSettings, rc as IPermissionRuleRemoval, ri as listCommandSessionAllowedTools, rl as IOutputStylePrompt, rn as PromptExecutor, ro as TSystemCommandLifecycle, rr as rollbackCommandEditCheckpoint, rs as extractGoalSignal, rt as TInstalledPluginsRegistry, ru as IEditCheckpointRecorder, s as PeerMessageIngress, sa as TProjectSettingsScope, sc as ADVISOR_OFF, si as resolvePermissionModeAdapter, sl as ICommandSessionModel, sn as IAgentSession, so as ICommandHostBackgroundTasks, sr as EXIT_COMMAND_DESCRIPTION, ss as IContextReferenceInventoryLimits, st as loadHostBundlePluginInspectionFromScopes, su as TEditCheckpointFileRestoreAction, t as IInteractiveRuntimeOptions, ta as deleteSettings, tc as ILinkedDeviceSummary, ti as groupPermissionRulesBySource, tl as TWorkspaceProjectStateNamespace, tn as IPromptExecutorOptions, to as ISystemCommand, tr as listCommandEditCheckpoints, ts as IGoalStartOptions, tt as IBundlePluginInstallerOptions, tu as IEditCheckpointInspectionPlan, u as IGenerateSessionNameOptions, ua as readSettingsSourceText, uc as IAdvisorStatus, ui as LANGUAGE_COMMAND_ARGUMENT_HINT, ul as ICommandSessionRuntime, un as IBundlePluginFeatures, uo as ICommandHostContext, ur as RENAME_COMMAND_USAGE, us as clearContextReferences, ut as IPluginSettings, uu as DEFAULT_AGENT_TYPE, v as ExternalEventGrantHistory, va as testProviderProfileCommand, vc as createNodeHostSessionStore, vi as BACKGROUND_COMMAND_USAGE, vl as IPresetApplicationOptions, vn as ILoadedBundlePlugin, vo as ICommandHostSetupState, vr as parseSessionNameArgument, vs as IPromptFileReferenceLimits, vt as BuiltinCommandSource, vu as TEffortSource, w as createExternalEventGrantHistory, wa as clearCommandContextReferences, wc as listResumableSessionSummaries, wi as listCommandBackgroundTasks, wl as IAgentJobSchedules, wn as ISkillRootDescriptor, wo as IMemoryCurationQueue, wr as buildPluginCommandSubcommands, ws as wrapEditCheckpointTools, wt as IAgentToolDeps, wu as TFrontmatterProfile, x as IExternalEventSourceOptions, xa as ICompactContextResult, xc as createUserPromptHistoryFile, xi as closeCommandBackgroundTask, xl as IAgentJobHostContext, xn as IContributionDescriptor, xo as ICommandHostWorkspace, xr as PLUGIN_COMMAND_ARGUMENT_HINT, xs as IResolvedPromptFileReference, xt as createAgentTool, xu as IFrontmatterDecodeFailure, y as ExternalEventIngress, ya as AUTO_COMPACT_THRESHOLD_SETTINGS_KEY, yc as createNodeToolResultSpillStore, yi as buildBackgroundCommandSubcommands, yl as IAgentJobDispatch, yn as TBundlePluginSkipReason, yo as ICommandHostTerminalHandoff, yr as readCommandSessionInfo, ys as IPromptFileReferenceResolveOptions, yt as createBuiltinCommandModule, yu as parseModelEffort, z as TInteractivePermissionHandler, za as ILegacyProviderSettings, zc as IWorkspaceProjectAuthority, zi as mergeProviders, zl as createExecutionWorkspaceSnapshot, zn as createSystemCommands, zo as IAppendMemoryInput, zr as isStatusLineCommandSettingsPatch, zs as ICommandMCPOAuthStatus, zt as createSubagentSession } from "./createInteractiveRuntime-20Gv8UI1.cjs";
+import { IAIProvider, IActionRequest, IChatOptions, IDestroyResult, IEventService, IFileSystem, IFileSystemAsync, IGroupChatOrchestrationSpec, IHandoffOrchestrationSpec, IHierarchicalOrchestrationSpec, IHistoryEntry, IModelFallbackNotice, IModelRef, IOrchestrationDelegation, IOrchestrationRunResult, IOrchestrationStepResult, IParallelOrchestrationSpec, IProviderDefinition, IProviderDefinitionConfig, IProviderRequest, IRawProviderResponse, ISequentialOrchestrationSpec, ITerminalOutput as ITerminalOutput$2, IToolSchema, IToolWithEventService, IUniversalObjectValue, IUserInteraction, TActionResponse, TPermissionMode, TProviderCredentialResolver, TRoleModelMap, TToolArgs, TUniversalMessage, TUniversalValue } from "@robota-sdk/agent-core";
+import { IAgentDriver, ICommandInfo, IDiffLine, IExecutionResult, IInteractionChannel, IInteractiveSession, IInteractiveSessionEvents, IInteractiveSessionStore, IPlanArtifact, ISessionChangeRefusal, ISessionCommands, ISessionDeleteRefusal, ISessionEvents, ISessionGoal, ISessionIdentity, ISessionLoopState, ISessionTurnSubmission, ITerminalHandoff, InteractionEvent, TInteractiveEventName, TPlanStepStatus, TSessionBindingRole, TSessionChangeRefusalCode, TSessionDeleteRefusalCode } from "@robota-sdk/agent-interface-session";
+import { ICommandResult } from "@robota-sdk/agent-interface-command";
+import { IBackgroundTaskManager, IBackgroundTaskRunner as IBackgroundTaskRunner$1, ISubagentManager } from "@robota-sdk/agent-executor";
+import { TBackgroundPrimitive } from "@robota-sdk/agent-interface-execution";
+import { Session } from "@robota-sdk/agent-session";
+import { ISandboxClient, createZodFunctionTool } from "@robota-sdk/agent-tools";
+import { ITransportCompletionRecord, ITransportEntry, ITransportFailureRecord, ITransportLifecycleRegistryView, ITransportRegistryView, ITransportRunnerAdapter, ITransportSavedConfig, ITransportSettingsCapability, ITransportSettingsRepository, TBoundConfigurableTransport, TBoundTransportAdapter, TTransportAdapter } from "@robota-sdk/agent-interface-transport";
+import "@robota-sdk/agent-roundtable";
+//#region src/frontmatter/frontmatter-json.d.ts
+type TFrontmatterJsonResult = {
+  readonly ok: true;
+  readonly frontmatter: IUniversalObjectValue;
+  readonly body: string;
+} | IFrontmatterDecodeFailure;
+/** Decode every YAML field for content equality; no profile normalization or instruction activation. */
+declare function decodeFrontmatterJson(source: string, content: string): TFrontmatterJsonResult | undefined;
+//#endregion
+//#region src/frontmatter/frontmatter-decoder.d.ts
+declare function decodeFrontmatter<P extends TFrontmatterProfile>(input: IFrontmatterDecodeInput<P>): TFrontmatterDecodeResult<P>;
+//#endregion
+//#region src/transport-host/headless/headless-output-format.d.ts
+/**
+ * Leaf module for the output-format vocabulary (issue #2052: the ONE owner of the type and the
+ * runtime constant together).
+ *
+ * Split out of `headless-runner.ts` so `headless-output.ts` can depend on {@link TOutputFormat}
+ * without importing back from `headless-runner.ts`, which previously created an import cycle
+ * between the two.
+ */
+declare const OUTPUT_FORMATS: readonly ["text", "json", "stream-json"];
+type TOutputFormat = (typeof OUTPUT_FORMATS)[number];
+//#endregion
+//#region src/transport-host/headless/headless-session.d.ts
+/** Session roles required by the headless runner and transport. */
+interface IHeadlessSession extends ISessionTurnSubmission, ISessionEvents, ISessionCommands, ISessionGoal, ISessionIdentity {}
+//#endregion
+//#region src/transport-host/headless/headless-runner.d.ts
+/** GOAL-001: options for an autonomous headless goal run. */
+interface IHeadlessGoalOptions {
+  maxIterations?: number;
+}
+interface IHeadlessRunnerOptions {
+  session: IHeadlessSession;
+  outputFormat: TOutputFormat;
+  /** Optional startup resolution projected into ordinary print results. */
+  effortResolution?: IModelEffortResolution;
+  providerErrorGuidance?: IProviderErrorGuidance;
+}
+declare function createHeadlessRunner(options: IHeadlessRunnerOptions): {
+  run: (prompt: string) => Promise<number>;
+  runGoal: (objective: string, goalOptions?: IHeadlessGoalOptions) => Promise<number>;
+};
+//#endregion
+//#region src/command-api/org-policy/org-policy-parse-error.d.ts
+/**
+ * Issue #2023: an org policy file that EXISTS and cannot be understood is an error condition, never
+ * silently equated with a missing one.
+ *
+ * The loader returned `null` for both, and every enforcement site reads `null` as "no policy
+ * configured" — `orgPolicy?.allowedProviders && …` does not fire when the policy is absent. So a
+ * corrupted file removed provider allowlisting, blocked commands and the plaintext-key requirement
+ * at once, with no signal, and produced behaviour identical to having deployed no policy at all.
+ * An administrator could not tell those apart.
+ *
+ * This mirrors `SettingsParseError` (CLI-069) and the trusted-device store, which answer the same
+ * question the same way one and two files over. The sanctioned-degradation comment it replaces was
+ * not wrong to care about startup — a MISSING policy still returns `null` and still does not throw,
+ * which is the common case. What changes is the case where an administrator deployed a file and it
+ * cannot be read.
+ */
+declare class OrgPolicyParseError extends Error {
+  readonly filePath: string;
+  constructor(filePath: string, reason: string);
+}
+//#endregion
+//#region src/command-api/org-policy/org-policy-loader.d.ts
+/**
+ * Read the organization policy, or `null` when none is deployed.
+ *
+ * **`null` means "no policy file", and nothing else** (issue #2023). Every enforcement site spells
+ * its guard `orgPolicy?.<field> && <violation>`, so `null` is read as "no restrictions" — which is
+ * correct for an administrator who deployed no policy and catastrophic for one whose policy file was
+ * truncated by a partial write or mangled by a sync tool. Returning `null` for both made those two
+ * indistinguishable, and the second silently removed provider allowlisting, blocked commands and the
+ * plaintext-key requirement together.
+ *
+ * A file that EXISTS and cannot be understood therefore throws. That answers the concern the
+ * sanctioned-degradation comment here used to state — "malformed org-policy.json must not crash CLI
+ * startup" — rather than deleting it: a **missing** file is the common case and still returns `null`
+ * without throwing. What throws is a file an administrator put there that cannot be read, which is
+ * their error to see.
+ *
+ * `settings-io.ts` (CLI-069) and the trusted-device store answer the same question the same way, one
+ * and two files over. This loader was the one that did not.
+ */
+declare function loadOrgPolicy(policyPath: string): IOrgPolicy | null;
+declare function formatOrgPolicyViolationMessage(reason: string, adminContact: string | undefined): string;
+declare function isApiKeyPlaintext(apiKey: string | undefined): boolean;
+//#endregion
+//#region src/workspace-trust/workspace-authority.d.ts
+declare function assertWorkspaceProjectAuthority(candidate: TWorkspaceProjectAuthorityCandidate): IWorkspaceProjectAuthority;
+declare function getWorkspaceProjectReader(authority: IWorkspaceProjectAuthority): IWorkspaceProjectReader;
+declare function getWorkspaceProjectIdentity(authority: IWorkspaceProjectAuthority): IWorkspaceIdentity;
+//#endregion
+//#region src/workspace-trust/project-state-storage.d.ts
+declare function getWorkspaceProjectStateStorage(authority: IWorkspaceProjectAuthority, namespace: TWorkspaceProjectStateNamespace): IWorkspaceProjectStateStorage;
+declare function assertWorkspaceProjectStateStorage(candidate: TWorkspaceProjectAuthorityCandidate): IWorkspaceProjectStateStorage;
+//#endregion
+//#region src/workspace-trust/project-settings-writer.d.ts
+declare function createWorkspaceProjectSettingsWriter(authority: IWorkspaceProjectAuthority, decision: TWorkspaceProjectSettingsWriteDecision): IWorkspaceProjectSettingsWriter;
+declare function assertWorkspaceProjectSettingsWriter(candidate: TWorkspaceProjectAuthorityCandidate): IWorkspaceProjectSettingsWriter;
+//#endregion
+//#region src/workspace-trust/project-mutation.d.ts
+declare function createWorkspaceProjectMutation(authority: IWorkspaceProjectAuthority, decision: TWorkspaceProjectMutationDecision): IWorkspaceProjectMutation;
+declare function assertWorkspaceProjectMutation(candidate: TWorkspaceProjectAuthorityCandidate): IWorkspaceProjectMutation;
+/** Internal same-grant check for adapters that combine reads/state with project mutation. */
+declare function assertWorkspaceProjectMutationForAuthority(mutation: IWorkspaceProjectMutation, authority: IWorkspaceProjectAuthority): IWorkspaceProjectMutation;
+//#endregion
+//#region src/workspace-trust/project-relative-writer.d.ts
+/**
+ * Whether a project write on `platform` can be proven to stay under the trusted root. The proof
+ * walks descriptor-relative paths through `/proc/self/fd`, which only Linux provides; elsewhere every
+ * project mutation is refused, so a host keeps state it must write somewhere other than the project.
+ */
+declare function supportsWorkspaceProjectMutation(platform?: NodeJS.Platform): boolean;
+//#endregion
+//#region src/workspace-trust/project-reader.d.ts
+declare function assertWorkspaceProjectReader(candidate: TWorkspaceProjectAuthorityCandidate): IWorkspaceProjectReader;
+//#endregion
+//#region src/workspace-trust/pretrust-contribution-inspector.d.ts
+type TPreTrustProjectPathKind = TWorkspaceContributionKind | 'absent' | 'unavailable';
+interface IPreTrustProjectPathInspection {
+  readonly relativePath: string;
+  readonly kind: TPreTrustProjectPathKind;
+}
+/**
+ * Inspect only metadata for owner-declared project paths before trust is granted. The same
+ * identity-revalidating, no-follow path walk used by trusted readers is called without exposing
+ * their content-reading authority. A replaced root or unsafe ancestor yields no metadata claim.
+ */
+declare function inspectPreTrustProjectPaths(identity: IWorkspaceIdentity, relativePaths: readonly string[]): readonly IPreTrustProjectPathInspection[];
+//#endregion
+//#region src/workspace-trust/workspace-authority-required-error.d.ts
+/** Fail-closed response for project APIs without an accepted runtime authority. */
+declare class WorkspaceAuthorityRequiredError extends Error {
+  readonly name: string;
+  readonly code = "WORKSPACE_AUTHORITY_REQUIRED";
+  constructor(message?: string, cause?: Error);
+}
+//#endregion
+//#region src/workspace-trust/workspace-trust-service.d.ts
+interface IWorkspaceTrustServiceOptions {
+  readonly identityResolver: IWorkspaceIdentityResolver;
+  readonly store: IWorkspaceTrustStore;
+  readonly projectStateDirectories?: TWorkspaceProjectStateDirectories;
+}
+declare function createRestrictedWorkspaceProjectAccess(trustState: IRestrictedWorkspaceProjectAccess['trustState'], displayPath?: string, cause?: Error, identity?: IWorkspaceIdentity): IRestrictedWorkspaceProjectAccess;
+declare class WorkspaceTrustService {
+  private readonly options;
+  private readonly issuerGenerations;
+  private readonly projectStateDirectories;
+  constructor(options: IWorkspaceTrustServiceOptions);
+  private identityKey;
+  private recordGeneration;
+  inspect(cwd: string): Promise<TWorkspaceProjectAccess>;
+  /** The trusted branch: re-resolve the identity so a moved or replaced worktree cannot keep authority. */
+  private mintTrustedAccess;
+  grant(cwd: string): Promise<TWorkspaceProjectAccess>;
+  revoke(cwd: string): Promise<TWorkspaceProjectAccess>;
+}
+//#endregion
+//#region src/workspace-trust/node-host-workspace-trust.d.ts
+/** Resolve a Git worktree to a replacement-safe host identity. */
+declare function createNodeWorkspaceIdentityResolver(): IWorkspaceIdentityResolver;
+/** Create the owner-only, replacement-safe persistent grant store used by the Node host. */
+declare function createNodeWorkspaceTrustStore(filePath: string): IWorkspaceTrustStore;
+/** Compose the default Node resolver, caller-selected persistent store, and authority service. */
+declare function createNodeWorkspaceTrustService(filePath: string, projectStateDirectories?: TWorkspaceProjectStateDirectories): WorkspaceTrustService;
+//#endregion
+//#region src/checkpoints/edit-checkpoints-unavailable-error.d.ts
+/**
+ * Why a session has no edit checkpoints. A host that names its own commands (a trust command, say)
+ * maps the reason to that guidance; the messages below name none.
+ */
+type TEditCheckpointsUnavailableReason = 'host-cannot-write-project' | 'restricted-workspace' | 'no-checkpoint-store';
+/** Thrown by a checkpoint operation on a session that has no checkpoint store. */
+declare class EditCheckpointsUnavailableError extends WorkspaceAuthorityRequiredError {
+  readonly reason: TEditCheckpointsUnavailableReason;
+  readonly name: string;
+  constructor(reason: TEditCheckpointsUnavailableReason);
+}
+//#endregion
+//#region src/command-api/provider/provider-profile-names.d.ts
+interface IProviderProfileNameSuggestionInput {
+  type: string;
+}
+interface IProviderProfileNameSuggestionOptions {
+  existingProfileNames?: readonly string[];
+}
+declare function suggestProviderProfileName(input: IProviderProfileNameSuggestionInput, options?: IProviderProfileNameSuggestionOptions): string;
+declare function sanitizeProviderProfileName(value: string | undefined): string | undefined;
+//#endregion
+//#region src/contributions/node-host-contribution-source.d.ts
+/** Explicit root-bounded adapter for host-owned contribution content. */
+declare function createNodeHostContributionSource(root: string): IContributionSource;
+//#endregion
+//#region src/contributions/initial-contribution-sources.d.ts
+/** Default host-owned contribution roots. Project content is intentionally absent. */
+declare function createDefaultUserContributionSources(userHome: string): readonly IContributionSource[];
+/** Compose the initial contribution sources from one explicit trusted-or-restricted decision. */
+declare function createContributionSourcesForProjectAccess(projectAccess: TWorkspaceProjectAccess, userHome: string): readonly IContributionSource[];
+//#endregion
+//#region src/transport-host/headless/HeadlessInteractionChannel.d.ts
+interface IHeadlessInteractionChannelOptions {
+  cwd: string;
+  livePromptTrace?: ILivePromptTracePort;
+  provider: IAIProvider;
+  providerErrorGuidance?: IProviderErrorGuidance;
+  promptFileReferenceTag?: string;
+  modelCommandToolPrefix?: string;
+  subagentHookEnvironmentNames?: ICreateSessionOptions['subagentHookEnvironmentNames'];
+  observerFailureWarningCode?: ICreateSessionOptions['observerFailureWarningCode'];
+  commandHookShell?: string;
+  /** Resolved organization policy enforced by the interactive session. */
+  orgPolicy?: IOrgPolicy;
+  projectAccess?: TWorkspaceProjectAccess;
+  projectSettingsPaths?: readonly IProjectSettingsPath[];
+  userSettingsSources?: readonly INodeHostSettingsSource[];
+  environment?: Readonly<Record<string, string | undefined>>;
+  baselinePermissionAllow?: readonly string[];
+  /** Host-selected task-context root; absent means the framework scans no task directory. */
+  taskContext?: IResolvedConfig['taskContext'];
+  contributionSources?: readonly IContributionSource[];
+  skillRoots?: readonly ISkillRootDescriptor[];
+  outputFormat: TOutputFormat;
+  /**
+   * CLI-076: the resolved model id (the same value the CLI header displays). Forwarded verbatim to the
+   * session so an explicit `--model` override actually reaches the provider chat call. Absent ⇒ the
+   * session resolves the model from config (no silent substitution of the requested model).
+   */
+  model?: string;
+  /** CLI-1988: resolved provider-neutral response style. */
+  outputStyle?: IOutputStylePrompt;
+  /** ARCH-013: resolved preset effort, threaded to the session's `effort` seam. */
+  effort?: ICreateSessionOptions['effort'];
+  /** Provider generation options resolved by the print/goal preset. */
+  temperature?: number;
+  maxOutputTokens?: number;
+  /** Response language and preset prompt seed, distinct from a replacing system prompt. */
+  language?: string;
+  presetSystemPrompt?: string;
+  /** Structured response policy, including JSON schema requests. */
+  responseFormat?: ICreateSessionOptions['responseFormat'];
+  /** FLOW-008: startup source/effective metadata projected into headless results. */
+  effortResolution?: IModelEffortResolution;
+  permissionMode?: TPermissionMode;
+  maxTurns?: number;
+  sessionStore?: IInteractiveSessionStore;
+  disableSessionLoops?: boolean;
+  resolveDefaultLoopPrompt?: () => string;
+  /** Continue/resume an existing session by id (print-mode parity with TUI). */
+  resumeSessionId?: string;
+  /** Fork the resumed session into a new independent session instead of appending. */
+  forkSession?: boolean;
+  sessionName?: string;
+  bare?: boolean;
+  /** See `IInteractiveSessionOptions.skipConfiguredHooks`. */
+  skipConfiguredHooks?: boolean;
+  allowedTools?: readonly string[];
+  deniedTools?: readonly string[];
+  appendSystemPrompt?: string;
+  systemPrompt?: string;
+  /** Name reported to the underlying agent config (resolved by the CLI, e.g. preset agentName). */
+  agentName?: string;
+  /** Active preset id selected at startup (PRESET-011 runtime state). Defaults to 'default'. */
+  activePresetId?: string;
+  /** Preset persona block composed as a `source: 'persona'` system-prompt section (priority 5). */
+  persona?: string;
+  /** Preset execution capability: activate agent runtime + subagent/background dispatch. */
+  enableParallelSubagents?: boolean;
+  /** Preset execution capability: run a post-task self-verification step. */
+  selfVerification?: boolean;
+  backgroundTaskRunners?: IBackgroundTaskRunner$1[];
+  subagentRunnerFactory?: TSubagentRunnerFactory;
+  /**
+   * ARCH-005: subagent definitions contributed by the composition root (the capability packs
+   * `assembleProduct` merged). Forwarded to the session's `agentDefinitions` seam; absent ⇒ unchanged.
+   */
+  agentDefinitions?: readonly IAgentDefinition[];
+  /** Ordered host-owned relative directories for discovered agent definitions. */
+  agentDefinitionRoots?: readonly string[];
+  pluginDirectories?: {
+    readonly user?: string;
+    readonly project?: string;
+  };
+  /**
+   * ARCH-006: tools contributed by the composition root (the capability packs `assembleProduct` merged)
+   * and, when the profile hands the packs the whole tool surface, the suppressed framework default tier
+   * (`defaultTools: []`). Forwarded to the session's tool-composition seam; absent ⇒ unchanged.
+   */
+  additionalTools?: IToolWithEventService[];
+  defaultTools?: readonly IToolWithEventService[];
+  /** The sandbox the shell tools run under, so the session can let a confined command skip the prompt. */
+  sandboxClient?: ISandboxClient;
+  commandModules?: readonly ICommandModule[];
+  commandHostAdapters?: ICommandHostAdapters;
+  /** Host-owned shell adapter used only when a skill explicitly requests shell interpolation. */
+  shellExec: TShellExecFn;
+  /**
+   * SELFHOST-008 P6: optional durable-memory store injected by the surface (agent-cli). Forwarded into
+   * `buildRuntimeSession`; absent ⇒ memory OFF (today's behavior). Enablement/policy is surface-owned.
+   */
+  memoryStore?: IMemoryStore;
+  /** SELFHOST-008 P6: optional automatic post-turn capture policy (absent ⇒ capture OFF). */
+  automaticMemory?: IAutomaticMemoryConfig;
+  /** SELFHOST-008 P6: optional per-turn recall policy (absent ⇒ recall OFF, startup-only injection). */
+  recallMemory?: IPerTurnRecallConfig;
+  /** The run's edit checkpoint store, so a print run's edits can be rewound when it is resumed. */
+  editCheckpointStore?: EditCheckpointStore;
+}
+declare class HeadlessInteractionChannel {
+  private readonly opts;
+  private exitCode;
+  constructor(options: IHeadlessInteractionChannelOptions);
+  run(prompt: string): Promise<void>;
+  /**
+   * GOAL-001: run an autonomous goal to completion (or a stop condition) in headless mode.
+   * Mirrors {@link run} but drives the framework goal loop instead of a single prompt.
+   */
+  runGoal(objective: string, options?: {
+    maxIterations?: number;
+  }): Promise<void>;
+  private createSession;
+  getExitCode(): number;
+}
+//#endregion
+//#region src/transport-host/headless/headless-transport.d.ts
+interface IHeadlessTransportOptions {
+  /** Output format: 'text', 'json', or 'stream-json'. */
+  outputFormat: TOutputFormat;
+  /** The prompt to execute. */
+  prompt: string;
+}
+interface IHeadlessTransport extends ITransportRunnerAdapter<IInteractiveSession> {
+  attach(session: IHeadlessSession): void;
+  getExitCode(): number;
+}
+declare function createHeadlessTransport(options: IHeadlessTransportOptions): IHeadlessTransport;
+//#endregion
+//#region src/transport-host/programmatic/ProgrammaticInteractionChannel.d.ts
+declare class ProgrammaticInteractionChannel implements IInteractionChannel {
+  /** Full structured event stream pushed by the framework, in order. */
+  readonly events: InteractionEvent[];
+  availableCommands: ICommandInfo[];
+  busy: boolean;
+  started: boolean;
+  stopped: boolean;
+  private submitHandler;
+  private readonly userActionResponses;
+  onSubmit(handler: (text: string) => Promise<void>): void;
+  write(event: InteractionEvent): void;
+  /**
+   * CMD-004 unified ask. Resolves from the pre-supplied queue (FIFO); an empty queue resolves
+   * `{ type: 'cancelled' }` so a programmatic run never blocks on an un-answered question.
+   */
+  askUser(_request: IActionRequest): Promise<TActionResponse>;
+  setAvailableCommands(commands: ICommandInfo[]): void;
+  setBusy(busy: boolean): void;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  /** Push a user submission into the framework (the programmatic "user types and presses enter"). */
+  submit(text: string): Promise<void>;
+  /** Pre-answer the next `askUser` (CMD-004 unified ask). */
+  queueUserAction(response: TActionResponse): void;
+}
+//#endregion
+//#region src/transport-host/programmatic/createProgrammaticAgent.d.ts
+interface ICreateProgrammaticAgentOptions {
+  /** Provider that answers the agent loop (e.g. a real provider, or the scripted provider in tests). */
+  provider: IAIProvider;
+  /** Working directory for session creation. */
+  cwd: string;
+  /** Trusted-or-restricted project decision made by the host. Absence is Restricted. */
+  projectAccess?: TWorkspaceProjectAccess;
+  /** Explicit user settings layers for the underlying interactive session. */
+  userSettingsSources?: readonly INodeHostSettingsSource[];
+  environment?: Readonly<Record<string, string | undefined>>;
+  /** Slash-command modules to register (defaults to none). */
+  commandModules?: readonly ICommandModule[];
+  /** Optional session store for persistence. */
+  sessionStore?: IInteractiveSessionStore;
+  /** Permission mode for tool execution (e.g. `'bypassPermissions'` for unattended driving). */
+  permissionMode?: TPermissionMode;
+}
+/**
+ * Construct an in-process {@link IAgentDriver} bound to a real `InteractiveSession`. The returned
+ * driver's accessors are the shared `read*` helpers applied to the captured event stream.
+ */
+declare function createProgrammaticAgent(options: ICreateProgrammaticAgentOptions): IAgentDriver;
+//#endregion
+//#region src/transport-host/transport-registry.d.ts
+declare class TransportRegistry {
+  private readonly entries;
+  private readonly settings;
+  private generation;
+  private state;
+  private startOperation;
+  private stopOperation;
+  private preemptionStopOperation;
+  private startingTransport;
+  private preemptionStopFailure;
+  /**
+   * TRANS-010 (issue #2480): settings storage is an injected repository. A string is accepted as the
+   * path of a settings file and wrapped in the file repository, so the existing shell and tests keep
+   * their call shape.
+   */
+  constructor(settings: string | ITransportSettingsRepository);
+  /** The lifecycle/shape agreement every entry must satisfy, on the way in and on a replace. */
+  private assertRegisterableShape;
+  register(transport: TBoundTransportAdapter): void;
+  /**
+   * Swap the adapter registered under `transport.name` for a new instance of the same name.
+   *
+   * Narrower than an unregister: the name must ALREADY be registered and the count cannot change, so
+   * `stopAll` keeps its promise to reach everything. An entry is a claim about WHICH instance is
+   * live, and reconnect makes it false (issue #2043).
+   *
+   * Returns nothing and stops nothing: every caller that abandons an adapter already stops it on the
+   * path that abandoned it, and a registry that stopped it here would do so at a moment the caller
+   * did not choose.
+   */
+  replace(transport: TBoundTransportAdapter): void;
+  getAll(): ITransportEntry[];
+  getEnabled(): TBoundTransportAdapter[];
+  setEnabled(name: string, enabled: boolean): Promise<void>;
+  setOptions(name: string, options: Record<string, TUniversalValue>): Promise<void>;
+  /**
+   * TRANS-002 (issue #2480): hand the persisted options to a transport BEFORE it starts. Non-empty
+   * options a transport cannot receive (`configure` absent) or refuses (`validateOptions` false) are
+   * a typed configuration error rather than a silent ignore — the former "read, displayed, never
+   * applied" state.
+   */
+  private deliverOptions;
+  startAll(): Promise<void>;
+  waitForCompletion(): Promise<ITransportCompletionRecord[]>;
+  waitForFailure(): Promise<ITransportFailureRecord | undefined>;
+  stopAll(): Promise<IDestroyResult>;
+  private performStop;
+  private performStart;
+  private requireConfigurable;
+}
+//#endregion
+//#region src/transport-host/bind-transport-adapter.d.ts
+/** Bind the exact session port outside the registry while preserving configure-before-attach. */
+declare function bindTransportAdapter<TSession, TAdapter extends TTransportAdapter<TSession>>(adapter: TAdapter, session: TSession): TAdapter extends ITransportSettingsCapability ? TBoundConfigurableTransport : TBoundTransportAdapter;
+//#endregion
+//#region src/transport-host/transport-settings-repository.d.ts
+/** Reads/writes the `transports` section of one settings file. */
+declare function createFileTransportSettingsRepository(settingsPath: string): ITransportSettingsRepository;
+/** Holds transport settings in memory — tests, and hosts with no settings file. */
+declare function createMemoryTransportSettingsRepository(initial?: Record<string, ITransportSavedConfig>): ITransportSettingsRepository;
+//#endregion
+//#region src/assembly/context-capacity-hint.d.ts
+/**
+ * NEUT-005 wave 2 — surface-derived context-capacity hint.
+ *
+ * The zero-dependency `agent-core` layer emits a product-neutral hard-capacity notice and exposes
+ * the `IAgentConfig.contextCapacityHint` seam (a surface tier injects its own concrete remediation
+ * wording). This framework tier owns command composition, so it can derive that wording from the
+ * surface's OWN registered command set rather than hardcoding product vocabulary in a neutral core:
+ * when a `compact` command is composed into the session, the notice can point users at it; when no
+ * such command exists, no product wording is emitted and the neutral core default stands.
+ */
+/**
+ * Derive the concrete remediation hint for the hard-capacity notice from the composed command set.
+ * Returns `undefined` when no context-reduction command is registered, leaving the neutral core
+ * default (`DEFAULT_CONTEXT_CAPACITY_HINT`) in force.
+ */
+declare function deriveContextCapacityHint(contextReductionCommandName: string | undefined): string | undefined;
+//#endregion
+//#region src/interactive/session-loop-stop-verb.d.ts
+/**
+ * #3288: whether a `/loop` invocation's arguments are the `stop <id>` verb.
+ *
+ * `InteractiveSession.executeCommand`'s mid-turn control-action bypass (so `/loop stop <id>` can
+ * reach a loop while its own turn is still running, mirroring `isGoalCancelVerb`) and the `/loop`
+ * command module's own routing both need the identical answer — one parses it, the other imports
+ * it, so the two can never drift apart.
+ */
+declare function isLoopStopVerb(args: string): boolean;
+//#endregion
+//#region src/interactive/interactive-session-fork-record.d.ts
+/**
+ * A moved conversation's copy under a name no other record in `sessionStore` holds (issue #3081).
+ * The copy often lands in the same store as its source — every Restricted move, and a move within
+ * one worktree — and a name lookup matches the first record, so a shared name would make
+ * `--resume <name>` pick either one.
+ */
+declare function withUniqueSessionName(record: IInteractiveSessionRecord$1, sessionStore: IInteractiveSessionStore$1): IInteractiveSessionRecord$1;
+//#endregion
+//#region src/interactive/interactive-session-terminal-handoff.d.ts
+declare class SessionTerminalHandoffGate {
+  private readonly handoff;
+  /** Guards handoff exclusivity (one handoff at a time). */
+  private active;
+  constructor(handoff: ITerminalHandoff | undefined);
+  /**
+   * Whether the active transport can hand the real terminal to a child process. False when no
+   * handoff capability was injected or its `canHandoffTerminal` is false (e.g. headless).
+   */
+  canHandoffTerminal(): boolean;
+  /**
+   * Suspend the display, run `fn` (which spawns a child with inherited stdio), then restore. The
+   * framework enforces exclusivity and fast-fails when no interactive terminal is available instead
+   * of hanging; the transport implements the underlying suspend/resume; the caller's `fn` spawns
+   * whatever child it wants — the framework stays platform-neutral and never spawns a shell.
+   */
+  runWithTerminal<T>(fn: () => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/plan/plan-controller.d.ts
+/** An approval decision: flip to `acceptEdits`. */
+type TPlanApproveDecision = {
+  action: 'approve';
+  nextMode: TPermissionMode;
+  plan: IPlanArtifact;
+};
+/** A revert decision: return the mode to `plan`. */
+type TPlanRevertDecision = {
+  action: 'revert';
+  nextMode: TPermissionMode;
+  plan: IPlanArtifact;
+};
+/** A no-mode-change decision (e.g. presenting the plan for review). */
+type TPlanContinueDecision = {
+  action: 'continue';
+  plan: IPlanArtifact;
+};
+/** The controller's decision after a plan-phase transition. */
+type TPlanDecision = TPlanApproveDecision | TPlanRevertDecision | TPlanContinueDecision;
+/** Injected seams so the controller stays deterministic and testable. */
+interface IPlanControllerDeps {
+  now: () => string;
+  createId: () => string;
+}
+declare class PlanController {
+  private readonly deps;
+  private plan;
+  constructor(deps?: IPlanControllerDeps);
+  getState(): IPlanArtifact | null;
+  /**
+   * Begin drafting a plan (phase `planning`). Throws on an empty objective. Step descriptions are
+   * seeded as `pending` steps with generated ids. Returns the seeded artifact.
+   */
+  start(objective: string, stepDescriptions?: readonly string[]): IPlanArtifact;
+  /** Restore a persisted plan on resume. */
+  restore(plan: IPlanArtifact): void;
+  /** Present the drafted plan for review (`planning` → `awaiting-approval`). */
+  requestApproval(): TPlanContinueDecision;
+  /**
+   * Approve the plan (`awaiting-approval` → `executing`). Returns the decision to flip the mode to
+   * `acceptEdits`; the controller does NOT apply it. Throws unless awaiting approval.
+   */
+  approve(): TPlanApproveDecision;
+  /**
+   * Revert to planning, returning the mode back to `plan`. Intentionally has NO phase guard — it is
+   * the escape hatch usable from ANY phase (reject while awaiting approval, bail mid-execution, or
+   * re-open a completed plan for another cycle). The mode flip is always the safe direction (`→ plan`,
+   * which re-blocks mutation), so an any-phase revert can never widen permissions.
+   */
+  revert(): TPlanRevertDecision;
+  /** Finish the plan (`executing` → `completed`), reverting the mode to `plan` for the next cycle. */
+  complete(): TPlanRevertDecision;
+  /** Update one step's status (todo tracking). Throws on an unknown step id (surfaces caller bugs). */
+  markStep(stepId: string, status: TPlanStepStatus): IPlanArtifact;
+  private requirePlan;
+}
+//#endregion
+//#region src/query.d.ts
+interface ICreateQueryOptions {
+  /** AI provider instance (required). */
+  provider: IAIProvider;
+  /** Working directory. Defaults to process.cwd(). */
+  cwd?: string;
+  /** Host-owned initial project decision. Absence produces an observable Restricted query. */
+  projectAccess?: TWorkspaceProjectAccess;
+  /** Explicit user settings layers for this query's session. */
+  userSettingsSources?: readonly INodeHostSettingsSource[];
+  /**
+   * Permission mode. Defaults to `'default'`: with no `permissionHandler`, anything that would ask is
+   * denied (issue #3081). Pass `'bypassPermissions'` explicitly for unattended driving.
+   */
+  permissionMode?: TPermissionMode;
+  /**
+   * Model to request. Without it the query uses the model from `userSettingsSources`, or Anthropic's
+   * default when none is set — so pass it with any other provider.
+   */
+  model?: string;
+  /** Maximum agentic turns per query. */
+  maxTurns?: number;
+  /**
+   * Tools that run without asking (e.g. your own `additionalTools`). A call that every mode asks
+   * about still asks.
+   */
+  allowedTools?: readonly string[];
+  /** Tools the model is never offered. Denied wins over allowed. */
+  deniedTools?: readonly string[];
+  /** Permission handler callback. */
+  permissionHandler?: TInteractivePermissionHandler;
+  /** Streaming text callback. */
+  onTextDelta?: (delta: string) => void;
+  /** Additional tools registered alongside the default CLI tools. */
+  additionalTools?: IToolWithEventService[];
+  /** Request structured output from the provider. */
+  responseFormat?: {
+    type: 'text' | 'json_object';
+  };
+}
+/**
+ * Callable query surface plus its immutable initial project-access decision. Calls share one session
+ * and run one at a time, each answered by its own turn.
+ */
+type TQueryFunction = ((prompt: string) => Promise<string>) & {
+  readonly projectAccess: TWorkspaceProjectAccess;
+  /** Shut the query's session down; the running call and every later one reject. */
+  shutdown(): Promise<void>;
+};
+/**
+ * Create a prompt-only query function bound to a provider.
+ *
+ * ```typescript
+ * import { createQuery } from '@robota-sdk/agent-framework';
+ * import { AnthropicProvider } from '@robota-sdk/agent-provider-anthropic';
+ *
+ * const query = createQuery({ provider: new AnthropicProvider({ apiKey: '...' }) });
+ * const answer = await query('List all TypeScript files');
+ * ```
+ */
+declare function createQuery(options: ICreateQueryOptions): TQueryFunction;
+//#endregion
+//#region src/advisor/advisor-controller.d.ts
+/** A resolved advisor: the provider instance to ask and where it sends what it is given. */
+interface IAdvisorTarget {
+  readonly provider: IAIProvider;
+  readonly model: string;
+  /**
+   * Where the conversation goes: the provider type together with the endpoint it talks to. Consent
+   * is keyed on it, and it decides whether history leaves for somewhere the main model does not
+   * already send it — two endpoints of one provider type are two destinations.
+   */
+  readonly destination: string;
+  /** Defaults to the model's known window. */
+  readonly contextWindow?: number;
+}
+/** Host-supplied: build the provider a spec names. Throws when the profile does not exist. */
+type TAdvisorTargetResolver = (spec: IAdvisorSpec) => IAdvisorTarget;
+/** Per-destination consent to send conversation history there, persisted by the host. */
+interface IAdvisorConsentStore {
+  has(destination: string): boolean;
+  grant(destination: string): void;
+}
+interface IAdvisorControllerOptions {
+  /** The advisor configured when the session starts; absent means no Advisor tool this session. */
+  readonly spec?: IAdvisorSpec;
+  readonly resolveTarget: TAdvisorTargetResolver;
+  /** Optional host credential resolution; ordinary synchronous SDK callers remain unchanged. */
+  readonly resolveTargetAsync?: (spec: IAdvisorSpec) => Promise<IAdvisorTarget>;
+  /** Validate an asynchronously resolved target's settings without constructing its provider. */
+  readonly validateTarget?: (spec: IAdvisorSpec) => void;
+  readonly consent: IAdvisorConsentStore;
+  /** The organization's provider allowlist (profile names). */
+  readonly allowedProfiles?: readonly string[];
+  /** The kill switch: no tool, and nothing can turn the advisor on. */
+  readonly killSwitch?: boolean;
+  readonly maxCallsPerTurn?: number;
+  readonly maxCallsPerSession?: number;
+}
+type TAdvisorOutcome = 'answered' | 'repeated' | 'declined' | 'disabled' | 'limit';
+interface IAdvisorConsultation {
+  readonly outcome: TAdvisorOutcome;
+  /** What the main model receives as the tool result. */
+  readonly text: string;
+}
+/** One consultation, as the calling session sees it. */
+interface IAdvisorConsultRequest {
+  readonly question?: string;
+  /** The calling session's conversation, ending in the Advisor call itself. */
+  readonly history: readonly TUniversalMessage[];
+  readonly systemPrompt: string;
+  /**
+   * Where the main model sends the conversation now (`<type>@<host>`). Unknown means every advisor
+   * destination counts as a different one.
+   */
+  readonly mainDestination?: string;
+  readonly sessionId: string;
+  /** Identifies the turn the call belongs to; the per-turn limit and answer reuse are per turn. */
+  readonly turnId: string;
+  readonly ask?: IUserInteraction['ask'];
+  readonly signal?: AbortSignal;
+  /** Where the advisor's token usage is recorded: the same place the session records turn usage. */
+  readonly recordUsage?: (entries: readonly IHistoryEntry[]) => void;
+}
+declare class AdvisorController {
+  private readonly options;
+  private spec;
+  private enabled;
+  private readonly registered;
+  private readonly killSwitch;
+  private readonly maxCallsPerTurn;
+  private readonly maxCallsPerSession;
+  private sessionCalls;
+  private cachedTarget;
+  private readonly turns;
+  private readonly pendingConsent;
+  /** Destinations the user refused this session: not asked again until the next session. */
+  private readonly deniedConsent;
+  constructor(options: IAdvisorControllerOptions);
+  /** Whether the Advisor tool belongs in this session's tool list. Fixed for the session's life. */
+  isRegistered(): boolean;
+  status(): IAdvisorStatus;
+  /** The name the transcript shows on the Advisor tool line. */
+  displayLabel(): string;
+  /** `/advisor <spec>` or `/advisor off`. Changes the target only, never the tool. */
+  set(value: string): IAdvisorSetResult;
+  consult(request: IAdvisorConsultRequest): Promise<IAdvisorConsultation>;
+  private attempt;
+  private isAllowed;
+  private targetFor;
+  private targetForAsync;
+  private resolveQuietly;
+  private hasConsent;
+  private turnState;
+  private recordUsage;
+}
+//#endregion
+//#region src/advisor/advisor-tool.d.ts
+declare const ADVISOR_TOOL_NAME = "Advisor";
+/** The unbound tool a host adds to a session's tools when the advisor is configured at start. */
+declare function createAdvisorTool(controller: AdvisorController): IToolWithEventService;
+//#endregion
+//#region src/advisor/provider-destination.d.ts
+/**
+ * `<type>@<host>`: the configured base URL's host, else the type's default base URL or endpoint. A
+ * default port (80, 443) is left out, so one endpoint always has one name.
+ */
+declare function describeProviderDestination(config: {
+  readonly name: string;
+  readonly baseURL?: string;
+}, providerDefinitions: readonly IProviderDefinition[]): string;
+/** Record where `provider` sends requests; called where the provider is built from its settings. */
+declare function rememberProviderDestination(provider: IAIProvider, destination: string): void;
+/** Where `provider` sends requests, when that was recorded; otherwise unknown. */
+declare function providerDestinationOf(provider: IAIProvider): string | undefined;
+//#endregion
+//#region src/user-local/storage.d.ts
+declare const USER_LOCAL_STORAGE_CATEGORIES: readonly ["preferences", "view-state", "memory-projections", "task-associations", "workflow-metadata", "inspection-index"];
+type TUserLocalStorageCategory = (typeof USER_LOCAL_STORAGE_CATEGORIES)[number];
+interface IUserLocalStorageCategoryDefinition {
+  readonly category: TUserLocalStorageCategory;
+  readonly purpose: string;
+  readonly mayExecuteCommands: false;
+}
+interface IUserLocalStorageItemSummary {
+  readonly root: string;
+  readonly category: TUserLocalStorageCategory;
+  readonly key: string;
+  readonly summary: string;
+  readonly source: string;
+  readonly scope: string;
+  readonly storageLocation: string;
+  readonly createdAt?: string;
+  readonly lastUsedAt?: string;
+  readonly enabled: boolean;
+  readonly deleteAvailable: boolean;
+  readonly disableAvailable: boolean;
+}
+interface IUserLocalStorageCategoryProjection {
+  readonly category: TUserLocalStorageCategory;
+  readonly purpose: string;
+  readonly mayExecuteCommands: false;
+  readonly storageLocation: string;
+  readonly itemCount: number;
+  readonly items: readonly IUserLocalStorageItemSummary[];
+}
+interface IUserLocalStorageInspection {
+  readonly root: string;
+  readonly activeRepositoryRoot: string;
+  readonly categories: readonly IUserLocalStorageCategoryProjection[];
+  readonly generatedAt: string;
+}
+interface IResolveUserLocalStorageRootOptions {
+  readonly activeRepositoryRoot: string;
+  readonly storageRoot: string;
+  readonly fsAsync?: IFileSystemAsync;
+}
+interface IInspectUserLocalStorageOptions extends IResolveUserLocalStorageRootOptions {
+  readonly now?: () => Date;
+  readonly createDirectories?: boolean;
+}
+declare const USER_LOCAL_STORAGE_CATEGORY_DEFINITIONS: readonly IUserLocalStorageCategoryDefinition[];
+declare function resolveUserLocalStorageRoot(options: IResolveUserLocalStorageRootOptions): Promise<string>;
+declare function inspectUserLocalStorage(options: IInspectUserLocalStorageOptions): Promise<IUserLocalStorageInspection>;
+//#endregion
+//#region src/user-local/memory-types.d.ts
+declare const USER_LOCAL_MEMORY_CATEGORIES: readonly ["view-preference", "last-visible-cwd", "background-selection", "task-association", "display-preference", "inspection-choice"];
+type TUserLocalMemoryCategory = (typeof USER_LOCAL_MEMORY_CATEGORIES)[number];
+type TUserLocalMemoryCommandExecutionEffect = 'none';
+interface IUserLocalMemoryItemProjection {
+  readonly root: string;
+  readonly category: TUserLocalMemoryCategory;
+  readonly key: string;
+  readonly summary: string;
+  readonly valueSummary: string;
+  readonly source: string;
+  readonly scope: string;
+  readonly storageLocation: string;
+  readonly createdAt: string;
+  readonly lastUsedAt: string;
+  readonly enabled: boolean;
+  readonly displayNavigationRule: string;
+  readonly commandExecutionEffect: TUserLocalMemoryCommandExecutionEffect;
+  readonly deleteAvailable: true;
+  readonly disableAvailable: true;
+}
+interface IUserLocalMemoryListProjection {
+  readonly root: string;
+  readonly activeRepositoryRoot: string;
+  readonly items: readonly IUserLocalMemoryItemProjection[];
+}
+interface IUserLocalMemorySetOptions extends IResolveUserLocalStorageRootOptions {
+  readonly category: TUserLocalMemoryCategory;
+  readonly key: string;
+  readonly value: string;
+  readonly summary: string;
+  readonly source: string;
+  readonly scope?: string;
+  readonly now?: () => Date;
+}
+interface IUserLocalMemoryItemOptions extends IResolveUserLocalStorageRootOptions {
+  readonly category: TUserLocalMemoryCategory;
+  readonly key: string;
+  readonly now?: () => Date;
+}
+interface IUserLocalMemoryListOptions extends IResolveUserLocalStorageRootOptions {
+  readonly now?: () => Date;
+}
+interface IUserLocalMemoryDeleteResult {
+  readonly category: TUserLocalMemoryCategory;
+  readonly key: string;
+  readonly deleted: boolean;
+}
+//#endregion
+//#region src/user-local/memory.d.ts
+declare function setUserLocalMemoryItem(options: IUserLocalMemorySetOptions): Promise<IUserLocalMemoryItemProjection>;
+declare function listUserLocalMemoryItems(options: IUserLocalMemoryListOptions): Promise<IUserLocalMemoryListProjection>;
+declare function inspectUserLocalMemoryItem(options: IUserLocalMemoryItemOptions): Promise<IUserLocalMemoryItemProjection>;
+declare function disableUserLocalMemoryItem(options: IUserLocalMemoryItemOptions): Promise<IUserLocalMemoryItemProjection>;
+declare function deleteUserLocalMemoryItem(options: IUserLocalMemoryItemOptions): Promise<IUserLocalMemoryDeleteResult>;
+declare function readEnabledUserLocalMemoryItem(options: IUserLocalMemoryItemOptions): Promise<IUserLocalMemoryItemProjection | null>;
+//#endregion
+//#region src/memory/file-system-memory-store.d.ts
+declare class WorkspaceMemoryStore implements IMemoryStore {
+  private readonly project;
+  private readonly pending;
+  private readonly retrieval;
+  constructor(storage: IWorkspaceProjectStateStorage, now?: () => Date);
+  loadStartupMemory(): Promise<IStartupMemory>;
+  list(): Promise<IProjectMemorySummary>;
+  readTopic(topic: string): Promise<string>;
+  append(input: IAppendMemoryInput): Promise<IAppendMemoryResult>;
+  replaceTopic(input: IAppendMemoryInput): Promise<{
+    topic: string;
+    topicPath: string;
+    indexPath: string;
+  }>;
+  forgetTopic(topic: string): Promise<{
+    topic: string;
+    topicPath: string;
+    indexPath: string;
+  }>;
+  private purgePendingTopic;
+  recall(query: string, budget: IMemoryBudget): Promise<IMemoryRetrievalResult>;
+  getPending(id: string): Promise<IMemoryPendingRecord | undefined>;
+  listPending(status?: TMemoryCandidateStatus): Promise<IMemoryPendingRecord[]>;
+  markPending(id: string, status: TMemoryCandidateStatus, reason: string): Promise<IMemoryPendingRecord>;
+  upsertPending(candidate: IMemoryCandidate, status: TMemoryCandidateStatus, reason: string): Promise<void>;
+}
+/** Create the memory port adapter for an accepted workspace `memory` state facet. */
+declare function createWorkspaceMemoryStore(storage: IWorkspaceProjectStateStorage, now?: () => Date): IMemoryStore;
+//#endregion
+//#region src/memory/memory-approval.d.ts
+interface IApprovedMemoryCandidate {
+  record: IMemoryPendingRecord;
+  saved: IAppendMemoryResult;
+}
+/**
+ * The one approval path for a queued memory candidate. Only a `pending` candidate can be approved, and
+ * its text is checked for sensitive content again, so a skipped, rejected or already-saved record — or
+ * one that a stricter filter now flags — never reaches durable memory.
+ */
+declare function approvePendingMemoryCandidate(store: IMemoryStore, id: string): Promise<IApprovedMemoryCandidate>;
+//#endregion
+//#region src/memory/semantic-memory-store.d.ts
+declare class SemanticMemoryStore implements IMemoryStore {
+  private readonly base;
+  private readonly adapter;
+  private mutations;
+  constructor(base: IMemoryStore, adapter: ISemanticMemoryAdapter);
+  loadStartupMemory(): Promise<IStartupMemory>;
+  list(): Promise<IProjectMemorySummary>;
+  readTopic(topic: string): Promise<string>;
+  /**
+   * Durable base write first (authoritative), then a guarded semantic index — but only when the base actually wrote a
+   * new entry (not a dedup). An index failure is a declared degradation: the durable write is kept, the vector write is
+   * skipped (re-indexable later).
+   */
+  append(input: IAppendMemoryInput): Promise<IAppendMemoryResult>;
+  private mutate;
+  replaceTopic(input: IAppendMemoryInput): Promise<IMemoryTopicMutationResult>;
+  forgetTopic(topic: string): Promise<IMemoryTopicMutationResult>;
+  recall(query: string, budget: IMemoryBudget): Promise<IMemoryRetrievalResult>;
+  getPending(id: string): Promise<IMemoryPendingRecord | undefined>;
+  listPending(status?: TMemoryCandidateStatus): Promise<IMemoryPendingRecord[]>;
+  markPending(id: string, status: TMemoryCandidateStatus, reason: string): Promise<IMemoryPendingRecord>;
+  upsertPending(candidate: IMemoryCandidate, status: TMemoryCandidateStatus, reason: string): Promise<void>;
+}
+/**
+ * Compose a base `IMemoryStore` with a semantic adapter into a semantic-upgraded store (mirrors
+ * `createFileSystemMemoryStore`). The surface supplies the concrete `ISemanticMemoryAdapter`.
+ */
+declare function createSemanticMemoryStore(base: IMemoryStore, adapter: ISemanticMemoryAdapter): IMemoryStore;
+//#endregion
+//#region src/memory/memory-candidate-extractor.d.ts
+interface IMemoryCandidateExtractor {
+  extract(input: IMemoryExtractionInput): IMemoryCandidate[];
+}
+/** A memory-cue trigger: the first capture group of `pattern` becomes the candidate text. */
+interface IMemoryExtractorTrigger {
+  pattern: RegExp;
+  confidence: number;
+}
+/**
+ * NEUT-007: extractor POLICY — trigger phrases and classification vocabulary are
+ * locale/domain policy, injectable by the composition root. The library holds no
+ * baked-in locale/domain heuristics beyond the documented default below.
+ */
+interface IMemoryExtractorPolicy {
+  /** Memory-cue triggers, evaluated in order against the user message. */
+  triggers: readonly IMemoryExtractorTrigger[];
+  /** Vocabulary classifying a candidate as project-scoped memory. */
+  projectTerms: RegExp;
+  /** Vocabulary classifying a candidate as user-preference memory. */
+  preferenceTerms: RegExp;
+}
+/**
+ * The DOCUMENTED default policy: bilingual (English/Korean) memory cues plus a
+ * software-project vocabulary. Composition roots supply their own
+ * `IMemoryExtractorPolicy` to replace it (other locales, other domains).
+ */
+declare const DEFAULT_MEMORY_EXTRACTOR_POLICY: IMemoryExtractorPolicy;
+declare class RegexMemoryCandidateExtractor implements IMemoryCandidateExtractor {
+  private readonly policy;
+  constructor(policy?: IMemoryExtractorPolicy);
+  extract(input: IMemoryExtractionInput): IMemoryCandidate[];
+}
+//#endregion
+//#region src/self-hosting/self-hosting-verification.d.ts
+type TSelfHostingVerificationPhase = 'checkpoint' | 'edit' | 'handoff' | 'verify' | 'recover';
+type TSelfHostingLoopState = 'idle' | 'checkpointed' | 'editing' | 'verifying' | 'passed' | 'failed' | 'rolled_back' | 'cancelled';
+type TSelfHostingLoopEvent = 'checkpoint_created' | 'edits_started' | 'edits_applied' | 'verify_passed' | 'verify_failed' | 'rollback_completed' | 'cancelled';
+/**
+ * Repo-process command templates injected by the composition root (NEUT-001).
+ *
+ * The library ships NO default commands: which package manager, verification
+ * commands, or CI-like gate a repository uses is the host project's policy.
+ * Placeholders: `{scope}` in `packageVerify` templates is replaced with each
+ * package scope; `{baseRef}` in the `repoVerify` template is replaced with the
+ * plan's base ref.
+ */
+interface ISelfHostingCommandTemplates {
+  /** Per-scope verification commands, applied to every package scope in order. */
+  packageVerify: readonly {
+    name: string;
+    template: string;
+  }[];
+  /** Optional repo-wide verification gate appended after the per-scope steps. */
+  repoVerify?: {
+    description: string;
+    template: string;
+  };
+}
+interface ISelfHostingVerificationPlanInput {
+  changedFiles: readonly string[];
+  packageScopes?: readonly string[];
+  /** Base git ref to verify against. Required — the library has no repo-specific default. */
+  baseRef: string;
+  /** Verification command templates. Required — the library has no repo-specific default. */
+  commandTemplates: ISelfHostingCommandTemplates;
+}
+interface ISelfHostingVerificationStep {
+  id: string;
+  phase: TSelfHostingVerificationPhase;
+  description: string;
+  required: boolean;
+  command?: string;
+}
+interface ISelfHostingVerificationPlan {
+  changedFiles: readonly string[];
+  packageScopes: readonly string[];
+  baseRef: string;
+  steps: readonly ISelfHostingVerificationStep[];
+}
+declare function planSelfHostingVerification(input: ISelfHostingVerificationPlanInput): ISelfHostingVerificationPlan;
+declare function transitionSelfHostingLoop(state: TSelfHostingLoopState, event: TSelfHostingLoopEvent): TSelfHostingLoopState;
+//#endregion
+//#region src/evals/eval-types.d.ts
+/**
+ * A metric scores one run's SSOT result. A `boolean` is a direct pass/fail; a `number` is a score in `[0, 1]`
+ * where higher is better (compared against the definition threshold). Required assertions must score 1. A numeric score outside `[0, 1]` is
+ * clamped by the runner. Pure — no IO, no provider.
+ */
+interface IMetric {
+  readonly name: string;
+  /** A required assertion must score 1 in every case, independently of the aggregate threshold. */
+  readonly required?: boolean;
+  score(result: IExecutionResult$1, evalCase?: IEvalCase): number | boolean;
+}
+/** One eval case: the prompt driven through the agent, plus an optional expected reference for a metric to use. */
+interface IEvalCase {
+  readonly input: string;
+  readonly expected?: string;
+}
+/**
+ * An eval definition: a dataset of cases scored by metrics against a pass threshold.
+ * `threshold` is the aggregate mean-score bar in `[0, 1]` (default `1`). Because a `boolean` score normalizes to
+ * `1`/`0`, for boolean metrics the aggregate IS the pass rate (e.g. One-Shot CI Pass Rate ≥ 0.8).
+ */
+interface IEvalDefinition {
+  readonly name?: string;
+  readonly cases: readonly IEvalCase[];
+  readonly metrics: readonly IMetric[];
+  readonly threshold?: number;
+}
+/** One metric's outcome for one case: the raw score and its `[0, 1]`-normalized value. */
+interface IEvalMetricScore {
+  readonly metric: string;
+  readonly score: number | boolean;
+  readonly normalized: number;
+}
+/** One case's outcome: each metric's score plus the case's mean normalized score. */
+interface IEvalCaseResult {
+  readonly input: string;
+  readonly scores: readonly IEvalMetricScore[];
+  readonly caseScore: number;
+}
+/**
+ * The eval report: per-case results, the aggregate `overallScore` (mean of every case×metric normalized score),
+ * the resolved `threshold`, and the overall `passed` verdict (all runs completed, aggregate threshold met and every required assertion passes). This verdict is what
+ * the `agent eval` CI gate (P2) maps to a process exit code.
+ */
+interface IEvalReport {
+  readonly name?: string;
+  readonly results: readonly IEvalCaseResult[];
+  readonly overallScore: number;
+  readonly threshold: number;
+  readonly passed: boolean;
+}
+/**
+ * The injected run function: produce a run result for one case input. The library defines NO provider and NO
+ * agent config — the caller supplies this (the default is built from `createAgentRuntime().createSession()`,
+ * capturing the terminal `complete`-event `IExecutionResult`; see `createSessionRunFn`).
+ */
+type TEvalRunFn = (input: string) => Promise<IExecutionResult$1>;
+//#endregion
+//#region src/evals/runner.d.ts
+/**
+ * Validate + normalize an eval definition. Throws on an empty case/metric set or an out-of-range threshold;
+ * returns the definition with `threshold` defaulted to `1`. Exposed so a caller can fail fast before a run.
+ */
+declare function defineEval(def: IEvalDefinition): IEvalDefinition;
+/**
+ * Run every case through `runFn`, score each run-result with each metric, and aggregate to a report.
+ *
+ * Cases run sequentially (deterministic; a shared provider is not hammered in parallel). `overallScore` is the
+ * mean of every case×metric normalized score. Every run must complete and required assertions must pass; the CI
+ * gate maps to an exit code.
+ */
+declare function runEval(def: IEvalDefinition, runFn: TEvalRunFn): Promise<IEvalReport>;
+//#endregion
+//#region src/runtime/session-runtime.d.ts
+interface IAgentRuntimeConfig {
+  cwd: string;
+  provider: IAIProvider;
+  /** Host-owned initial project decision. Absence produces an observable Restricted runtime. */
+  projectAccess?: TWorkspaceProjectAccess;
+  /** Explicit user settings layers for sessions created by this runtime. */
+  userSettingsSources?: readonly INodeHostSettingsSource[];
+  commandModules?: readonly ICommandModule[];
+  commandHostAdapters?: ICommandHostAdapters;
+  backgroundTaskRunners?: IBackgroundTaskRunner$1[];
+  subagentRunnerFactory?: TSubagentRunnerFactory;
+  /** Runtime default; explicit undefined disables persistence for sessions that omit an override. */
+  sessionStore?: IInteractiveSessionStore$1 | undefined;
+  transportRegistry?: ITransportRegistryView;
+  reloadPluginCommandSource?: (registry: CommandRegistry) => void;
+  orgPolicy?: IOrgPolicy;
+  /** REMOTE-006: optional remote-command policy. Absent → allow (local == remote); provide one only to restrict. */
+  remoteCommandPolicy?: IRemoteCommandPolicy;
+}
+/** Session-specific options for IAgentRuntime.createSession(). Runtime fields (cwd, provider, etc.) are inherited automatically. */
+interface IHeadlessSessionOptions {
+  permissionMode?: TPermissionMode;
+  maxTurns?: number;
+  /** Omitted inherits the runtime store; explicit undefined disables persistence for this session. */
+  sessionStore?: IInteractiveSessionStore$1 | undefined;
+  sessionName?: string;
+  bare?: boolean;
+  allowedTools?: string[];
+  /** Denied tool names — added to permissions.deny. denied > allowed. */
+  deniedTools?: string[];
+  /** Override the model from config. When set, takes precedence over config.provider.model. */
+  model?: string;
+  appendSystemPrompt?: string;
+  /** Replace the entire system prompt. Takes precedence over the default builder. */
+  systemPrompt?: string;
+  shellExec?: TShellExecFn;
+  agentName?: string;
+  /** Additional tools registered alongside the default CLI tools. */
+  additionalTools?: IToolWithEventService[];
+  /** Resume an existing persisted session by ID. Requires sessionStore to be configured. */
+  resumeSessionId?: string;
+  /** Request structured output from the provider for this session (issue #2056: incl. `json_schema`). */
+  responseFormat?: TSessionResponseFormat;
+}
+interface IAgentRuntime {
+  readonly cwd: string;
+  readonly provider: IAIProvider;
+  readonly projectAccess: TWorkspaceProjectAccess;
+  readonly commandModules: readonly ICommandModule[];
+  readonly commandHostAdapters: ICommandHostAdapters;
+  readonly backgroundTaskRunners: IBackgroundTaskRunner$1[];
+  readonly subagentRunnerFactory: TSubagentRunnerFactory | undefined;
+  readonly sessionStore: IInteractiveSessionStore$1 | undefined;
+  readonly transportRegistry: ITransportRegistryView | undefined;
+  readonly reloadPluginCommandSource: (registry: CommandRegistry) => void;
+  createSession(opts: IHeadlessSessionOptions): InteractiveSession;
+}
+declare function createAgentRuntime(config: IAgentRuntimeConfig): IAgentRuntime;
+//#endregion
+//#region src/evals/session-run-fn.d.ts
+/**
+ * Build a default `runFn` bound to an agent runtime. Each invocation runs one case in its own session, captures
+ * that session's terminal `complete`/`interrupted` `IExecutionResult` (an `error` event rejects), and shuts the
+ * session down before returning.
+ */
+declare function createSessionRunFn(runtime: IAgentRuntime, options?: IHeadlessSessionOptions): TEvalRunFn;
+//#endregion
+//#region src/evals/metric-helpers.d.ts
+/**
+ * The run response equals the expected string. Two forms:
+ *   - `exactMatch('foo')` — a fixed expected applied to every case (homogeneous).
+ *   - `exactMatch()` — reads each case's `evalCase.expected` (per-case; makes `parseEvalCases`' field live).
+ * `trim` (default true) trims both sides before comparing.
+ */
+declare function exactMatch(expected?: string, options?: {
+  trim?: boolean;
+}): IMetric;
+/** The run response contains `substring`. */
+declare function includesText(substring: string): IMetric;
+/** The run response matches `pattern`. */
+declare function regexMatch(pattern: RegExp): IMetric;
+/** The run response parses as JSON (a format probe — no domain schema opinion). */
+declare function responseIsJson(): IMetric;
+/** The run's tool trajectory includes a call to the named tool. */
+declare function usedTool(name: string): IMetric;
+//#endregion
+//#region src/evals/dataset.d.ts
+/**
+ * Parse a consumer-supplied dataset into `IEvalCase[]`.
+ *   - `'json'`  — a JSON array of `{ input, expected? }` rows.
+ *   - `'jsonl'` — one JSON `{ input, expected? }` object per non-blank line.
+ * Throws on malformed input (a broken corpus is a loud failure, not a silent skip).
+ */
+declare function parseEvalCases(text: string, format: 'json' | 'jsonl'): IEvalCase[];
+//#endregion
+//#region src/evals/format.d.ts
+/** A compact human/CI-readable report: a per-case line each + an overall `PASS`/`FAIL` line against the threshold. */
+declare function formatEvalReport(report: IEvalReport): string;
+//#endregion
+//#region src/agents/built-in-agents.d.ts
+/**
+ * All built-in agent definitions shipped with the SDK.
+ * Order matters: general-purpose is the default fallback.
+ */
+declare const BUILT_IN_AGENTS: IAgentDefinition[];
+//#endregion
+//#region src/tools/command-execution-tool.d.ts
+type TModelCommandDescriptor$1 = Pick<ICapabilityDescriptor, 'name' | 'description' | 'argumentHint'>;
+interface ICommandExecutionToolDeps {
+  isModelInvocable: (command: string) => boolean;
+  execute: (command: string, args: string) => Promise<ICommandResult$1 | null>;
+  commandNames?: readonly string[];
+  commandDescriptors?: readonly TModelCommandDescriptor$1[];
+}
+declare function createCommandExecutionTool(deps: ICommandExecutionToolDeps): ReturnType<typeof createZodFunctionTool>;
+//#endregion
+//#region src/tools/model-command-tool-projection.d.ts
+declare const MODEL_COMMAND_TOOL_PREFIX: "command_";
+declare const PROVIDER_SAFE_TOOL_NAME_PATTERN: RegExp;
+type TModelCommandDescriptor = Pick<ICapabilityDescriptor, 'name' | 'description' | 'argumentHint' | 'requiresPermission'>;
+interface IProjectedModelCommandTool {
+  readonly commandName: string;
+  readonly toolName: string;
+  readonly description: string;
+  readonly descriptor: TModelCommandDescriptor;
+  /** Mirrors the source command's requiresPermission flag. false = auto-approved. */
+  readonly requiresPermission: boolean;
+}
+interface IModelCommandToolProjection {
+  readonly commandTools: readonly IProjectedModelCommandTool[];
+  readonly toolNameToCommandName: ReadonlyMap<string, string>;
+  readonly commandNameToToolName: ReadonlyMap<string, string>;
+}
+interface IProjectedCommandExecutionToolsDeps {
+  isModelInvocable: (command: string) => boolean;
+  execute: (command: string, args: string) => Promise<ICommandResult$1 | null>;
+  commandDescriptors: readonly TModelCommandDescriptor[];
+  toolNamePrefix?: string;
+}
+declare function normalizeModelCommandName(command: string): string;
+declare function createProviderSafeModelCommandToolName(commandName: string, prefix?: string): string;
+declare function createModelCommandToolProjection(commandDescriptors: readonly TModelCommandDescriptor[], toolNamePrefix?: string): IModelCommandToolProjection;
+declare function formatProjectedModelCommandToolPromptDescription(projection: IProjectedModelCommandTool): string;
+declare function createProjectedCommandExecutionTools(deps: IProjectedCommandExecutionToolsDeps): Array<ReturnType<typeof createZodFunctionTool>>;
+//#endregion
+//#region src/tools/background-process-tool.d.ts
+interface IBackgroundProcessToolDeps {
+  backgroundTaskManager: IBackgroundTaskManager;
+  cwd?: string;
+  parentSessionId?: string;
+  metadata?: Record<string, TBackgroundPrimitive>;
+}
+declare function createBackgroundProcessTool(deps: IBackgroundProcessToolDeps): ReturnType<typeof createZodFunctionTool>;
+//#endregion
+//#region src/orchestration/shared.d.ts
+/**
+ * Neutral run context threaded into each spawned subagent request. Shared by
+ * every orchestration primitive (`sequential`/`parallel`/`handoff`/…).
+ */
+interface IOrchestrationRunContext {
+  /** The parent session id the run belongs to. */
+  parentSessionId: string;
+  /** The working directory for spawned subagents. */
+  cwd: string;
+  /** Depth of this orchestration in the hierarchy (0 = root). */
+  depth?: number;
+}
+//#endregion
+//#region src/orchestration/sequential.d.ts
+/**
+ * Neutral run context threaded into each spawned subagent request.
+ * Alias of the shared {@link IOrchestrationRunContext}, kept as the
+ * sequential-specific public name for back-compat.
+ */
+type ISequentialRunContext = IOrchestrationRunContext;
+/**
+ * Dependencies for the `sequential` orchestration mechanism.
+ *
+ * The `manager` is the `agent-executor` `ISubagentManager` — the port surface
+ * over `ISubagentRunner`. At the composition root it is built over the real
+ * runner (`createInProcessSubagentRunner` in-process, or the child-process
+ * runner from `agent-subagent-runner` injected at the `agent-cli` root). The
+ * framework NEVER depends on `agent-subagent-runner` (that would be a cycle);
+ * it composes only over the injected `ISubagentManager`.
+ */
+interface ISequentialOrchestratorDeps {
+  /** The subagent manager (over `ISubagentRunner`) that runs each step. */
+  manager: ISubagentManager;
+  /** Run context threaded into each spawned subagent request. */
+  context: IOrchestrationRunContext;
+  /** Optional event service; when present, lifecycle events are emitted. */
+  events?: IEventService;
+}
+/**
+ * Run a `sequential` orchestration: execute each step in order over the injected
+ * `ISubagentManager`, threading each step's output into the next (when
+ * `threadOutput` is not disabled), and emitting neutral lifecycle events over the
+ * event-service. Returns the per-step results plus the final aggregate output
+ * (the last step's output).
+ */
+declare function runSequential(spec: ISequentialOrchestrationSpec, deps: ISequentialOrchestratorDeps): Promise<IOrchestrationRunResult>;
+//#endregion
+//#region src/orchestration/parallel.d.ts
+/**
+ * Dependencies for the `parallel` orchestration mechanism. Same shape as the
+ * sequential deps — the injected `ISubagentManager` (over `ISubagentRunner`)
+ * runs each step; the framework never depends on `agent-subagent-runner`.
+ */
+interface IParallelOrchestratorDeps {
+  /** The subagent manager (over `ISubagentRunner`) that runs each step. */
+  manager: ISubagentManager;
+  /** Run context threaded into each spawned subagent request. */
+  context: IOrchestrationRunContext;
+  /** Optional event service; when present, lifecycle events are emitted. */
+  events?: IEventService;
+}
+/**
+ * Run a `parallel` orchestration: execute the steps concurrently over the
+ * injected `ISubagentManager` under a bounded concurrency pool
+ * (`maxConcurrency`; unbounded when omitted or `<= 0`), then aggregate. Each
+ * step runs with only its own prompt (no threading). Results are returned in
+ * original step order regardless of completion order; the aggregate output is
+ * every step's output joined in order (blank-line separated). Emits neutral
+ * lifecycle events over the event-service; step events interleave by nature.
+ */
+declare function runParallel(spec: IParallelOrchestrationSpec, deps: IParallelOrchestratorDeps): Promise<IOrchestrationRunResult>;
+//#endregion
+//#region src/orchestration/handoff.d.ts
+/**
+ * A neutral handoff policy: given the current step's output and id, return the
+ * id of the step to transfer control to, or `null` to stop. This is the ONLY
+ * injected policy — keeping WHICH step receives control a caller decision means
+ * the primitive itself carries no app-domain routing logic (library-neutral).
+ */
+type ResolveHandoff = (output: string, currentStepId: string) => string | null;
+/**
+ * Dependencies for the `handoff` orchestration mechanism. Adds the neutral
+ * `resolveHandoff` policy to the shared manager/context/events surface.
+ */
+interface IHandoffOrchestratorDeps {
+  /** The subagent manager (over `ISubagentRunner`) that runs each step. */
+  manager: ISubagentManager;
+  /** Run context threaded into each spawned subagent request. */
+  context: IOrchestrationRunContext;
+  /** Optional event service; when present, lifecycle events are emitted. */
+  events?: IEventService;
+  /** Caller-supplied policy resolving the next step to transfer control to (or `null` to stop). */
+  resolveHandoff: ResolveHandoff;
+}
+/**
+ * Run a `handoff` orchestration: control starts at `entryStepId`; after each
+ * step the injected `resolveHandoff` policy decides which step (if any) receives
+ * control next, transferring loop ownership. The receiving step is threaded the
+ * previous step's output. A `maxHandoffs` bound (default: step count) guards a
+ * policy that never terminates. Returns the per-step results in execution order
+ * plus the final control-holder's output. Emits neutral lifecycle events.
+ */
+declare function runHandoff(spec: IHandoffOrchestrationSpec, deps: IHandoffOrchestratorDeps): Promise<IOrchestrationRunResult>;
+//#endregion
+//#region src/orchestration/hierarchical.d.ts
+/**
+ * A neutral delegation policy: given the manager step's latest output and the
+ * current round, return the worker delegations to run next, or an empty
+ * array / `null` to finish. Keeping WHICH workers run a caller decision means
+ * the primitive itself carries no app-domain routing (library-neutral).
+ */
+type PlanDelegation = (managerOutput: string, round: number) => IOrchestrationDelegation[] | null;
+/**
+ * Dependencies for the `hierarchical` orchestration mechanism. Adds the neutral
+ * `planDelegation` policy to the shared manager/context/events surface.
+ */
+interface IHierarchicalOrchestratorDeps {
+  /** The subagent manager (over `ISubagentRunner`) that runs each step. */
+  manager: ISubagentManager;
+  /** Run context threaded into each spawned subagent request. */
+  context: IOrchestrationRunContext;
+  /** Optional event service; when present, lifecycle events are emitted. */
+  events?: IEventService;
+  /** Caller-supplied policy turning the manager's output into worker delegations (or `null` to stop). */
+  planDelegation: PlanDelegation;
+}
+/**
+ * Run a `hierarchical` (manager-delegation) orchestration: the manager step runs
+ * (threaded the previous round's aggregated worker output), the injected
+ * `planDelegation` policy turns its output into worker delegations, those workers
+ * run, and their aggregated output feeds the manager's next round — until the
+ * policy returns an empty/`null` plan (the manager is done) or `maxRounds` is
+ * exceeded. Returns the per-step results in execution order plus the manager's
+ * final output. Emits neutral lifecycle events over the event-service.
+ */
+declare function runHierarchical(spec: IHierarchicalOrchestrationSpec, deps: IHierarchicalOrchestratorDeps): Promise<IOrchestrationRunResult>;
+//#endregion
+//#region src/orchestration/group-chat-roundtable.d.ts
+/**
+ * The neutral turn-selection policy the facade wraps into a `TurnSelector` (SELFHOST-001 P3 —
+ * moved here, unchanged, from `group-chat.ts`; re-exported there for the existing public path).
+ */
+type SelectNextStep = (history: IOrchestrationStepResult[], lastStepId: string) => string | null;
+//#endregion
+//#region src/orchestration/group-chat.d.ts
+/**
+ * Dependencies for the `group-chat` orchestration mechanism. Adds the neutral
+ * `selectNextStep` policy to the shared manager/context/events surface.
+ */
+interface IGroupChatOrchestratorDeps {
+  /** The subagent manager (over `ISubagentRunner`) that runs each step. */
+  manager: ISubagentManager;
+  /** Run context threaded into each spawned subagent request. */
+  context: IOrchestrationRunContext;
+  /** Optional event service; when present, lifecycle events are emitted. */
+  events?: IEventService;
+  /** Caller-supplied policy selecting the next step to take a turn (or `null` to end). */
+  selectNextStep: SelectNextStep;
+}
+/**
+ * Run a `group-chat` (turn-taking) orchestration: starting at `firstStepId` (or
+ * the first step), each selected step takes a turn — threaded the prior turns'
+ * outputs — then the injected `selectNextStep` policy picks who goes next, `null`
+ * ending the run. A `maxTurns` bound (default: step count) guards a policy that
+ * never ends; exceeding it fails the run. Returns the per-step results in turn
+ * order plus the last turn's output. Emits neutral lifecycle events.
+ *
+ * A facade over `@robota-sdk/agent-roundtable`'s `Roundtable`: the core owns the only turn loop
+ * here (see `group-chat-roundtable.ts`) — this function itself holds no transcript, turn counter or
+ * `while` loop, only the STARTED/COMPLETED/FAILED lifecycle around one `Roundtable` run.
+ */
+declare function runGroupChat(spec: IGroupChatOrchestrationSpec, deps: IGroupChatOrchestratorDeps): Promise<IOrchestrationRunResult>;
+//#endregion
+//#region src/context/task-context.d.ts
+type TTaskFileStatus = 'todo' | 'in-progress' | 'blocked' | 'completed' | 'unknown';
+interface ITaskContextFile {
+  path: string;
+  relativePath: string;
+  title: string;
+  status: TTaskFileStatus;
+  branch?: string;
+  scope?: string;
+  objective?: string;
+  openItems: readonly string[];
+}
+interface ITaskSelectionOptions {
+  currentBranch?: string;
+  maxTasks?: number;
+  /**
+   * NEUT-004: host-selected task-file scan directory relative to cwd; absence disables the scan.
+   */
+  dir?: string;
+}
+declare function readCurrentGitBranchFromNodeHost(cwd: string, fs?: IFileSystem): string | undefined;
+declare function discoverTaskFiles(reader: IWorkspaceProjectReader, dir: string): string[];
+declare function parseTaskFile(taskPath: string, reader: IWorkspaceProjectReader): ITaskContextFile;
+declare function selectRelevantTasks(tasks: readonly ITaskContextFile[], options?: ITaskSelectionOptions): ITaskContextFile[];
+declare function formatTaskContext(tasks: readonly ITaskContextFile[]): string;
+declare function loadTaskContext(reader: IWorkspaceProjectReader, options?: ITaskSelectionOptions): string;
+//#endregion
+//#region src/interaction/input-parser.d.ts
+type TParsedInput = {
+  type: 'slash-command';
+  name: string;
+  args: string[];
+} | {
+  type: 'user-message';
+  text: string;
+};
+/** Return true if text starts with '/' followed by a non-whitespace character. */
+declare function isSlashCommand(text: string): boolean;
+/** Tokenise '/name arg1 arg2' → { name, args }. */
+declare function tokeniseSlashCommand(text: string): {
+  name: string;
+  args: string[];
+};
+/** Parse raw user input into a structured command or message. */
+declare function parseInput(text: string): TParsedInput;
+//#endregion
+//#region src/permissions/permission-prompt.d.ts
+/**
+ * Issue #2351: the permission pattern a "don't ask again" answer for this invocation grants — the
+ * scope the enforcer remembers, so every prompt surface prints the same words.
+ *
+ * The rule is owned by agent-session; this is the framework's OWN facade over it rather than a
+ * pass-through re-export of the owner's binding. `agent-ui-terminal`'s permission prompt reads it
+ * and depends on this package alone, never on agent-session, and `sdk-public-surface` refuses the
+ * public graph passing through the owner directly.
+ */
+declare function consentScopeFor(toolName: string, toolArgs: TToolArgs): string;
+declare function promptForApproval(terminal: ITerminalOutput$2, toolName: string, toolArgs: TToolArgs): Promise<TPermissionResultValue$1>;
+//#endregion
+//#region src/config/settings-inspection.d.ts
+type TSettingsLayerState = 'absent' | 'ok' | 'empty' | 'unreadable' | 'invalid-json' | 'schema-invalid';
+interface ISettingsSchemaIssue {
+  readonly path: string;
+  readonly code: string;
+}
+/** Structured cause of a non-`ok`, non-`absent` layer state. Never carries file content. */
+interface ISettingsLayerCause {
+  readonly state: Exclude<TSettingsLayerState, 'absent' | 'ok'>;
+  /** `unreadable`: the errno code of the failed read (`EACCES`, `EISDIR`, …) when the error had one. */
+  readonly errno?: string;
+  /** `invalid-json`: the byte offset the parser reported, when it reported one. */
+  readonly offset?: number;
+  /** `schema-invalid`: the failing paths and issue codes. */
+  readonly issues?: readonly ISettingsSchemaIssue[];
+}
+interface ISettingsLayerInspection {
+  readonly source: TSettingsSource;
+  readonly displayName: string;
+  readonly kind: TSettingsSource['kind'];
+  readonly scope: TSettingsSource['scope'];
+  readonly state: TSettingsLayerState;
+  readonly cause?: ISettingsLayerCause;
+  /** The schema-validated document of an `ok` layer, before `$ENV:` resolution. */
+  readonly settings?: TSettings;
+}
+interface ISettingsKeyProvenance {
+  readonly key: string;
+  readonly rule: TSettingsMergeRule;
+  /** Display names of the layers that declared the key, in precedence order (lowest first). */
+  readonly contributors: readonly string[];
+}
+interface ISettingsInspection {
+  readonly layers: readonly ISettingsLayerInspection[];
+  /**
+   * The merge of every `ok` layer with the loader's own `mergeSettings`. When `partial` is true a
+   * present layer is broken and session start will refuse the configuration; this view then shows
+   * what the healthy layers alone would produce, and says so.
+   */
+  readonly merged: TEnvResolvedSettings;
+  readonly partial: boolean;
+  readonly provenance: readonly ISettingsKeyProvenance[];
+  /** Effective settings-layer definitions only, in merge order. No hook commands or prompts. */
+  readonly hookSources: readonly IHookDefinitionSource[];
+}
+/** Read-only inspection of every settings layer plus the merged view and its provenance. */
+declare function inspectSettingsLayers(sources: readonly TSettingsSource[]): ISettingsInspection;
+//#endregion
+//#region src/config/permission-rule-layers.d.ts
+declare function readPermissionRuleLayers(sources: readonly TSettingsSource[]): IPermissionRuleLayer[];
+/**
+ * #3282 §4a: remove one declared pattern from whichever writable `stores` entry matches the
+ * removal's `scope` — the same settings document `/permissions` would read the rule from. Returns
+ * `false` (writes nothing) when no store matches the scope, or the pattern is not actually present.
+ */
+declare function removePermissionRule(stores: readonly ISettingsDocumentStore[], removal: IPermissionRuleRemoval): boolean;
+declare function createSettingsPermissionRulesAdapter(sources: readonly TSettingsSource[], stores?: readonly ISettingsDocumentStore[]): ICommandPermissionRulesAdapter;
+//#endregion
+//#region src/config/settings-parse-error.d.ts
+/**
+ * CLI-069: an EXISTING settings file that fails to parse is an error condition,
+ * never silently equated with a missing file (forbidden-fallback class). Thrown
+ * by the settings readers; session start propagates it (fail fast, exit 1),
+ * reporting consumers (e.g. diagnose) catch it and present it as a finding.
+ */
+declare class SettingsParseError extends Error {
+  readonly filePath: string;
+  constructor(filePath: string, parseMessage: string);
+}
+//#endregion
+//#region src/config/no-current-provider-profile-error.d.ts
+/**
+ * CONFIG-002: `updateModelInSettings` writes the active model into
+ * `providers[currentProvider]`. When the settings file names no active profile there is nothing
+ * the canonical loader would accept, so the writer refuses instead of emitting the legacy flat
+ * `provider` shape that `loadConfig()` rejects.
+ */
+declare class NoCurrentProviderProfileError extends Error {
+  readonly filePath: string;
+  constructor(filePath: string);
+}
+//#endregion
+//#region src/config/reset-user-config.d.ts
+interface IResetUserConfigResult {
+  deleted: boolean;
+  path: string;
+}
+declare function resetUserConfig(path: string): IResetUserConfigResult;
+//#endregion
+//#region src/git/git-branch.d.ts
+/** Explicit host-filesystem Git metadata adapter. This does not establish project trust. */
+declare function resolveGitBranchFromNodeHost(cwd: string): string | undefined;
+//#endregion
+//#region src/git/git-process.d.ts
+declare const GIT_DEFAULT_TIMEOUT_MS = 120000;
+declare const GIT_MAX_OUTPUT_BYTES: number;
+/**
+ * Variables that redirect a git child to ANOTHER repository. Git exports them into hooks, so a
+ * `/git` run started from inside a hook (or from any process that inherited one) would otherwise
+ * operate on the wrong tree. Identity and configuration variables are deliberately NOT here — the
+ * user's `GIT_CONFIG_GLOBAL`, `GIT_AUTHOR_*`, `GPG_TTY`, `SSH_AUTH_SOCK` … are what make the commit
+ * theirs.
+ */
+declare const GIT_ENV_DENYLIST: readonly string[];
+interface IGitProcessRunOptions {
+  cwd: string;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+/**
+ * `not-found` covers every spawn failure — ENOENT, EACCES, ENOTDIR, … — with the code in `detail`;
+ * the other three are the run's own bounds.
+ */
+type TGitProcessFailureReason = 'not-found' | 'timeout' | 'aborted' | 'output-too-large';
+type TGitProcessOutcome = {
+  kind: 'exited';
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+} | {
+  kind: 'failed';
+  reason: TGitProcessFailureReason;
+  detail: string;
+};
+interface IGitProcessPort {
+  run(args: readonly string[], options: IGitProcessRunOptions): Promise<TGitProcessOutcome>;
+}
+interface ICreateGitProcessOptions {
+  /** The executable to run; `git` on PATH by default. */
+  executable?: string;
+  /** The environment to derive the child's from; the live process environment by default. */
+  env?: NodeJS.ProcessEnv;
+}
+/**
+ * The child's environment: `source` minus the repository-redirecting variables, with the locale
+ * forced to `C`. `isNotAGitRepositoryFailure` (and every other place this module's callers pattern-
+ * match git's stderr text) depends on that text being English; git translates it under the host's
+ * own `LANG`/`LC_ALL` otherwise, which would silently break that match on a non-English host (#3282
+ * §4c review).
+ */
+declare function gitEnvironment(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** The production port: argv-only `execFile`, stdin closed, output capped, timeout bounded. */
+declare function createGitProcess(options?: ICreateGitProcessOptions): IGitProcessPort;
+/**
+ * The reason a run did not produce a usable answer, for the verbs where a non-zero exit IS a failure.
+ * `undefined` when the child exited 0.
+ */
+declare function gitFailureMessage(verb: string, outcome: TGitProcessOutcome): string | undefined;
+//#endregion
+//#region src/git/git-status.d.ts
+declare const GIT_STATUS_ARGS: readonly string[];
+interface IGitStatusSummary {
+  /** `branch.head`; `(detached)` when detached; `undefined` when git printed no branch header. */
+  branch: string | undefined;
+  /** `branch.oid` is `(initial)` on an unborn branch. */
+  unborn: boolean;
+  staged: readonly string[];
+  unstaged: readonly string[];
+  untracked: readonly string[];
+  conflicted: readonly string[];
+}
+/** One porcelain-v2 record, kept close to the wire so a consumer can classify it its own way (the
+ *  `/git status` text summary below, and the Project panel's plain-word-per-file view). */
+type TRawGitStatusRecordKind = 'ordinary' | 'renamed' | 'unmerged' | 'untracked';
+interface IRawGitStatusRecord {
+  kind: TRawGitStatusRecordKind;
+  /** The X (index) and Y (worktree) status letters; `'??'` for an untracked record (git gives none). */
+  xy: string;
+  /** The current path — the post-rename name for a `renamed` record. */
+  path: string;
+  /** Only on a `renamed` record — the record's own SECOND NUL-terminated field. */
+  origPath?: string;
+}
+interface IParsedGitStatus {
+  branch: string | undefined;
+  unborn: boolean;
+  records: readonly IRawGitStatusRecord[];
+}
+/** The porcelain-v2 stdout, parsed into the branch header and every path record — the shared step
+ *  both `parseStatusPorcelainV2` (the `/git status` text summary) and the Project panel's per-file
+ *  status reader build on, so the two never classify a record differently. */
+declare function parseStatusRecords(stdout: string): IParsedGitStatus;
+declare function parseStatusPorcelainV2(stdout: string): IGitStatusSummary;
+declare function formatGitStatus(summary: IGitStatusSummary): string;
+declare function executeGitStatus(port: IGitProcessPort, cwd: string): Promise<ICommandResult>;
+//#endregion
+//#region src/git/git-diff.d.ts
+declare const GIT_DIFF_USAGE = "Usage: /git diff [--staged | <rev> | <a>..<b>] [-- <path> ...] — other git flags are not accepted here.";
+type TGitDiffTarget = {
+  kind: 'worktree';
+} | {
+  kind: 'staged';
+} | {
+  kind: 'revision';
+  revision: string;
+} | {
+  kind: 'range';
+  from: string;
+  to: string;
+};
+interface IGitDiffArgs {
+  target: TGitDiffTarget;
+  paths: readonly string[];
+}
+type TParseGitDiffArgs = {
+  ok: true;
+  args: IGitDiffArgs;
+} | {
+  ok: false;
+  message: string;
+};
+declare function parseGitDiffArgs(tokens: readonly string[]): TParseGitDiffArgs;
+/** The `diff` argv for a parsed target, `--end-of-options` before revisions and `--` before paths. */
+declare function gitDiffArgv(args: IGitDiffArgs): readonly string[];
+declare function executeGitDiff(port: IGitProcessPort, cwd: string, args: string): Promise<ICommandResult>;
+//#endregion
+//#region src/git/project-status-read.d.ts
+/** Never a raw XY code — the #3277 "usable by anyone" principle applies to this panel too. */
+type TProjectFileStatus = 'Added' | 'Modified' | 'Deleted' | 'Renamed' | 'Copied' | 'Untracked' | 'Conflicted';
+interface IProjectGitStatusFile {
+  path: string;
+  status: TProjectFileStatus;
+  /** For a rename/copy, the record's own prior path. */
+  renamedFrom?: string;
+  /** Lines added/removed since HEAD (or the empty tree on an unborn branch). Absent for Untracked and
+   *  Conflicted — no single baseline to diff against — and for a binary file (git counts it as `-`). */
+  added?: number;
+  removed?: number;
+}
+type TProjectGitStatusResult = {
+  ok: true;
+  repository: true;
+  branch: string | undefined;
+  unborn: boolean;
+  files: readonly IProjectGitStatusFile[];
+  /** True when `files` stopped at {@link MAX_STATUS_FILES} — there were more. */
+  truncated: boolean;
+} | {
+  ok: true;
+  repository: false;
+} | {
+  ok: false;
+  message: string;
+};
+/** Bounds the panel's file list — #3282 §4c "bound every output: file count, diff lines and bytes". */
+declare const MAX_STATUS_FILES = 200;
+/** Whether a failed git run means "this folder is not a git repository" (vs. a real git failure). */
+declare function isNotAGitRepositoryFailure(stderr: string): boolean;
+/** The Project panel's git status: `/git status`'s own record parser, turned into the panel's shape. */
+declare function readProjectGitStatus(port: IGitProcessPort, cwd: string): Promise<TProjectGitStatusResult>;
+//#endregion
+//#region src/git/project-diff-read.d.ts
+type TProjectGitDiffResult = {
+  ok: true;
+  diffLines: readonly IDiffLine[];
+  truncated: boolean;
+} | {
+  ok: false;
+  code: 'not_a_repository';
+  message: string;
+} | {
+  ok: false;
+  code: 'outside_workspace';
+  message: string;
+} | {
+  ok: false;
+  code: 'git_failed';
+  message: string;
+};
+/** Matches `MAX_WRITE_DIFF_LINES` in `interactive-session-streaming.ts` — the ONE diff-line cap a
+ *  surface already renders correctly (DiffLines has no fold of its own; a builder caps its output). */
+declare const MAX_PROJECT_DIFF_LINES = 500;
+/** Parses `git diff`'s unified-diff body into `IDiffLine[]`. A binary file's one-line notice becomes
+ *  a single `hunk` line; anything before the first `@@` hunk header (the `diff --git`/`index`/`---`/
+ *  `+++` preamble) is not itself a line of the change and is skipped. */
+declare function parseUnifiedDiffLines(diffText: string): IDiffLine[];
+/**
+ * The Project panel's one-file diff. `requestedPath` is workspace-relative, exactly as
+ * {@link readProjectGitStatus} reported it — resolved against `cwd` and checked with `isPathInside`
+ * before anything else runs.
+ */
+declare function readProjectGitDiff(port: IGitProcessPort, cwd: string, requestedPath: string, fs?: IFileSystemAsync): Promise<TProjectGitDiffResult>;
+//#endregion
+//#region src/utils/semver-compare.d.ts
+declare function compareSemverVersions(left: string, right: string): number;
+declare function isNewerSemverVersion(candidate: string, current: string): boolean;
+//#endregion
+//#region src/utils/trim-char.d.ts
+/** Remove every trailing character in `chars`. Equivalent to `value.replace(/[chars]+$/, '')`. */
+declare function trimTrailingChars(value: string, chars: string): string;
+//#endregion
+//#region src/utils/read-package-version.d.ts
+declare function readPackageVersion(importMetaUrl: string): string;
+//#endregion
+//#region src/runtime/stateless-runtime.d.ts
+interface IStatelessRuntimeConfig {
+  provider: IAIProvider;
+  /** Working directory. Defaults to process.cwd(). Not used for file I/O in stateless mode. */
+  cwd?: string;
+}
+declare function createStatelessRuntime(config: IStatelessRuntimeConfig): IAgentRuntime;
+//#endregion
+//#region src/runtime/session-slot.d.ts
+interface ISessionSlotOptions {
+  /** Bound on shutting the replaced session down; defaults to {@link RUNTIME_SHUTDOWN_TIMEOUT_MS}. */
+  shutdownTimeoutMs?: number;
+}
+/**
+ * A stable {@link IInteractiveSession} that forwards every member to the current session. `moveTo`
+ * makes another session current and leaves the previous one running, for a host that keeps several
+ * sessions live; `replace` does the same and shuts the previous one down. Either way listeners move
+ * to the next session and only this slot's listeners receive `session_switched`.
+ */
+declare class SessionSlot<TSession extends IInteractiveSession = InteractiveSession> implements IInteractiveSession {
+  private currentSession;
+  private readonly listeners;
+  private readonly shutdownTimeoutMs;
+  constructor(initial: TSession, options?: ISessionSlotOptions);
+  /** The session every call reaches now. Read it at call time; it changes on `moveTo` and `replace`. */
+  get current(): TSession;
+  /**
+   * Make `next` the current session and leave the previous one running: another slot, or nobody,
+   * may still be on it. Listeners registered on this slot move to `next`, then this slot's listeners
+   * — and no one else's — receive `session_switched`.
+   */
+  moveTo(next: TSession): void;
+  /**
+   * Make `next` the current session and shut the previous one down. Listeners registered on the slot
+   * move to it before the old session shuts down (bounded), so no event of the new session is
+   * missed; `session_switched` follows once the old one is gone.
+   */
+  replace(next: TSession, message?: string): Promise<void>;
+  /** Move the listeners onto `next` and make it current; `undefined` when it already is. */
+  private swap;
+  private emitSwitched;
+  on<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
+  off<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
+  get isInitialized(): boolean;
+  shutdown: IInteractiveSession['shutdown'];
+  submit: IInteractiveSession['submit'];
+  abort: IInteractiveSession['abort'];
+  cancelQueue: IInteractiveSession['cancelQueue'];
+  setGoal: IInteractiveSession['setGoal'];
+  getGoalState: IInteractiveSession['getGoalState'];
+  cancelGoal: IInteractiveSession['cancelGoal'];
+  isExecuting: IInteractiveSession['isExecuting'];
+  getPendingPrompt: IInteractiveSession['getPendingPrompt'];
+  getPendingCount: IInteractiveSession['getPendingCount'];
+  getActiveDriverId: IInteractiveSession['getActiveDriverId'];
+  getMessages: IInteractiveSession['getMessages'];
+  getFullHistory: IInteractiveSession['getFullHistory'];
+  getMessagesDisplay: IInteractiveSession['getMessagesDisplay'];
+  getContextState: IInteractiveSession['getContextState'];
+  getSession: IInteractiveSession['getSession'];
+  getCwd: IInteractiveSession['getCwd'];
+  executeCommand: IInteractiveSession['executeCommand'];
+  listCommands: IInteractiveSession['listCommands'];
+  listSkills: IInteractiveSession['listSkills'];
+  getStatusSnapshot: IInteractiveSession['getStatusSnapshot'];
+  listModels: IInteractiveSession['listModels'];
+  listRuntimeTools: IInteractiveSession['listRuntimeTools'];
+  invokeRuntimeTool: IInteractiveSession['invokeRuntimeTool'];
+  readToolAppView: IInteractiveSession['readToolAppView'];
+  resolvePermission: IInteractiveSession['resolvePermission'];
+  resolveAsk: IInteractiveSession['resolveAsk'];
+  listBackgroundTasks: IInteractiveSession['listBackgroundTasks'];
+  getBackgroundTask: IInteractiveSession['getBackgroundTask'];
+  cancelBackgroundTask: IInteractiveSession['cancelBackgroundTask'];
+  closeBackgroundTask: IInteractiveSession['closeBackgroundTask'];
+  sendBackgroundTask: IInteractiveSession['sendBackgroundTask'];
+  readBackgroundTaskLog: IInteractiveSession['readBackgroundTaskLog'];
+  listBackgroundJobGroups: IInteractiveSession['listBackgroundJobGroups'];
+  getBackgroundJobGroup: IInteractiveSession['getBackgroundJobGroup'];
+  createBackgroundJobGroup: IInteractiveSession['createBackgroundJobGroup'];
+  waitBackgroundJobGroup: IInteractiveSession['waitBackgroundJobGroup'];
+  getExecutionWorkspaceSnapshot: IInteractiveSession['getExecutionWorkspaceSnapshot'];
+  readExecutionWorkspaceDetail: IInteractiveSession['readExecutionWorkspaceDetail'];
+  stopWaitingSelfPacedLoop: IInteractiveSession['stopWaitingSelfPacedLoop'];
+  listAgentDefinitions: IInteractiveSession['listAgentDefinitions'];
+  getDefaultAgentType: IInteractiveSession['getDefaultAgentType'];
+  setDefaultAgentType: IInteractiveSession['setDefaultAgentType'];
+  listAgentJobs: IInteractiveSession['listAgentJobs'];
+  spawnAgentJob: IInteractiveSession['spawnAgentJob'];
+  sendAgentJob: IInteractiveSession['sendAgentJob'];
+  cancelAgentJob: IInteractiveSession['cancelAgentJob'];
+  closeAgentJob: IInteractiveSession['closeAgentJob'];
+}
+//#endregion
+//#region src/runtime/session-pool.d.ts
+/** The primary included. */
+declare const SESSION_POOL_MAX_LIVE = 4;
+/** How long a session nobody is bound to stays live once idle. */
+declare const SESSION_POOL_IDLE_GRACE_MS = 300000;
+/** A binding's role, as the session contracts define it. */
+type TSessionPoolRole = TSessionBindingRole;
+/** The members of a session the default busy rule reads; the last two are InteractiveSession's own. */
+type TPoolBusySession = Pick<IInteractiveSession, 'isExecuting' | 'getPendingPrompt' | 'getPendingCount' | 'listBackgroundTasks'> & {
+  /** `needs-input` while a permission or ask prompt waits for an answer. */
+  getLocalActivityStatus?(): 'working' | 'needs-input' | 'idle' | undefined;
+  listSelfPacedLoops?(): readonly ISessionLoopState[];
+};
+/**
+ * Whether closing this session now would lose work: a running turn, a prompt waiting for an answer,
+ * queued messages, a live background task, or a self-paced loop that has not ended.
+ */
+declare function isSessionBusy(session: TPoolBusySession, nowMs?: number): boolean;
+interface ISessionPoolOptions<TSession> {
+  /** The session the host started with. Every binding starts on it; only `shutdownAll` closes it. */
+  primary: TSession;
+  /** Build a session, resuming `resumeSessionId` when given, or a fresh one. */
+  build(resumeSessionId?: string): TSession;
+  /** Live sessions at most, the primary and sessions still starting included. */
+  maxLive?: number;
+  /** How long a session nobody is bound to stays live once idle. */
+  idleGraceMs?: number;
+  /** Whether closing `session` now would lose work; defaults to {@link isSessionBusy}. */
+  isBusy?(session: TSession): boolean;
+  /** Shut `session` down, bounded; defaults to {@link shutdownSessionBounded}. */
+  shutdown?(session: TSession, message: string): Promise<void>;
+}
+/**
+ * A session held for one client between `acquire` and the binding's `moveTo`: while held it is not
+ * closed. Hand it to `moveTo`, or `cancel` it when the client does not move after all.
+ */
+interface ISessionLease<TSession> {
+  readonly session: TSession;
+  cancel(): void;
+}
+/** One client's place in the pool. */
+interface ISessionPoolBinding<TSession extends IInteractiveSession> {
+  readonly role: TSessionPoolRole;
+  /** The client's session; it follows this binding's moves and no one else's. */
+  readonly slot: SessionSlot<TSession>;
+  /** Move this binding onto the leased session. Its slot's listeners hear `session_switched`. */
+  moveTo(lease: ISessionLease<TSession>): void;
+  /** This binding drives, and no other driver is on its session. */
+  isLastDriver(): boolean;
+  /** The client has gone. Idempotent. */
+  release(): void;
+}
+/** A live session and who is on it. */
+interface ISessionPoolEntry<TSession> {
+  readonly sessionId: string;
+  readonly session: TSession;
+  /** Bindings on it, drivers and observers. */
+  readonly clients: number;
+  readonly drivers: number;
+}
+declare class SessionPool<TSession extends IInteractiveSession> {
+  private readonly options;
+  private readonly entries;
+  private readonly primaryEntry;
+  /** Builds in flight, by the session id asked for (a fresh build under a key of its own). */
+  private readonly building;
+  /** Shutdowns in flight, by session id; an acquire of that id waits for it. */
+  private readonly closing;
+  private readonly leases;
+  private readonly maxLive;
+  private readonly idleGraceMs;
+  private readonly isBusy;
+  private readonly shutdownSession;
+  private clock;
+  private freshBuilds;
+  private drained;
+  constructor(options: ISessionPoolOptions<TSession>);
+  /** A binding for one client, on the primary session. */
+  bind(role: TSessionPoolRole): ISessionPoolBinding<TSession>;
+  /**
+   * Hold session `sessionId` for a client, or a fresh session when no id is given. A live instance
+   * is reused, a build already under way for that id is shared, and an instance still closing is
+   * waited for. Refused with `limit` when the pool is full and no session can be closed, with
+   * `start_failed` when the session cannot start, and with `stopping` once the pool is shut down.
+   */
+  acquire(sessionId?: string): Promise<ISessionLease<TSession>>;
+  /** The live sessions that have named themselves, and who is on each. */
+  listLive(): ISessionPoolEntry<TSession>[];
+  /** Shut every session down in parallel, each bounded, the primary included. Idempotent. */
+  shutdownAll(message?: string): Promise<void>;
+  private assertOpen;
+  private register;
+  private entryId;
+  /** The primary must be matched by its id, never built twice, so an acquire waits for its name. */
+  private namePrimary;
+  private findLive;
+  private lease;
+  private join;
+  private leave;
+  private touch;
+  /** Start the idle grace of a session nobody is on or about to be on. */
+  private settle;
+  private clearGrace;
+  private busy;
+  /** Close the oldest idle session nobody is on when the pool is full; refuse when none can go. */
+  private makeRoom;
+  private close;
+  private trackClosing;
+  private shutdownQuietly;
+  private startBuild;
+  private finishBuild;
+}
+//#endregion
+//#region src/runtime/runtime-host.d.ts
+/** Normalized, explicitly discriminated input for every `InteractiveSession` construction path. */
+type SessionRecipe = TInteractiveSessionOptions;
+/** Build a runtime `InteractiveSession` from a normalized recipe. The single construction seam. */
+declare function buildRuntimeSession(recipe: SessionRecipe): InteractiveSession;
+interface IRuntimeHostOptions {
+  /** The resolved session-build options — the consumer resolves settings/preset/args and passes them in. */
+  session: SessionRecipe;
+  /** The transport registry (e.g. the loopback WS sidecar); the host owns its start/stop lifecycle. */
+  transportRegistry?: ITransportLifecycleRegistryView;
+  /** Bind each raw adapter to the host's session slot before registration/start. */
+  bindTransports?: (session: SessionSlot) => void;
+  /**
+   * Keep several sessions live, one per client that switched (#3189). The host's session becomes
+   * the pool's primary, and further sessions are built from this recipe. Absent, the host holds one
+   * session.
+   */
+  pool?: IRuntimeHostPoolOptions;
+}
+interface IRuntimeHostPoolOptions {
+  /** Live sessions at most, the primary included. */
+  maxLive?: number;
+  /** How long a session no client is on stays live once idle. */
+  idleGraceMs?: number;
+}
+interface IRuntimeHostHandle {
+  /**
+   * The live runtime session every presentation drives, behind a slot: whoever holds it reaches the
+   * current session, including after the host switches to another one (#3189).
+   */
+  readonly session: SessionSlot;
+  /** The live sessions when started with `pool`; its primary is the one `session` starts on. */
+  readonly pool?: SessionPool<InteractiveSession>;
+  /** Stop the transports and shut the session down (bounded) — every pooled one; idempotent. */
+  shutdown(message?: string): Promise<void>;
+  /** Return the complete ordered runner aggregate, including registry-owned abandonment on stop. */
+  waitForCompletion(): Promise<ITransportCompletionRecord[]>;
+  /** Report only the first real failed runner outcome; normal stop abandonment is not a failure. */
+  waitForFailure(): Promise<ITransportFailureRecord | undefined>;
+}
+/**
+ * Build the runtime session and start its transports. Returns a handle the caller renders over (TUI) or simply
+ * keeps alive (headless `--serve`). The caller owns the process-lifetime wait; `shutdown()` tears it down.
+ */
+declare function startRuntimeHost(opts: IRuntimeHostOptions): Promise<IRuntimeHostHandle>;
+//#endregion
+//#region src/runtime/session-change-refusal.d.ts
+declare class SessionChangeRefusal extends Error implements ISessionChangeRefusal {
+  readonly code: TSessionChangeRefusalCode;
+  readonly name: "SessionChangeRefusal";
+  constructor(code: TSessionChangeRefusalCode, message: string);
+}
+/** #3289 §1 — a session delete the host declined, with a code the client can branch on. */
+declare class SessionDeleteRefusal extends Error implements ISessionDeleteRefusal {
+  readonly code: TSessionDeleteRefusalCode;
+  readonly name: "SessionDeleteRefusal";
+  constructor(code: TSessionDeleteRefusalCode, message: string);
+}
+//#endregion
+//#region src/routing/role-model-routing.d.ts
+/** Resolve the PRIMARY model for a role (first of its fallback chain); `undefined` if the role is unmapped. */
+declare function resolveRoleModel(map: TRoleModelMap, roleKey: string): IModelRef | undefined;
+/** The full ordered fallback chain for a role (primary first, then fallbacks); empty if unmapped. */
+declare function resolveRoleFallbackChain(map: TRoleModelMap, roleKey: string): IModelRef[];
+/**
+ * Walk a role's fallback chain, trying each `IModelRef` in order until one succeeds. `run(ref)` performs
+ * the actual execution against the given provider+model over the DIP; on a thrown error it advances to
+ * the next fallback (an alternate provider AND model). Throws the LAST error if the whole chain is
+ * exhausted, or immediately if the chain is empty.
+ *
+ * `shouldRetry(err)` gates advancing to the next fallback (default: retry ALL errors). A caller that
+ * only wants provider/transient failures to fall back — not auth/4xx/config errors that will fail
+ * identically on every provider — should pass a predicate; a non-retryable error then rethrows
+ * immediately instead of burning the chain and masking the root cause.
+ */
+declare function runWithRoleFallback<T>(chain: IModelRef[], run: (ref: IModelRef) => Promise<T>, shouldRetry?: (err: unknown) => boolean): Promise<T>;
+//#endregion
+//#region src/routing/fallback-provider.d.ts
+/** One model a request may move to, and how to reach it. */
+interface IFallbackModelTarget {
+  /** The provider (vendor) and model this entry answers on. */
+  ref: IModelRef;
+  /** Build the provider for this entry. A throw means it cannot be reached, and the chain moves on. */
+  create: () => IAIProvider;
+  /** Optional host resolution for credentials held outside settings. */
+  createAsync?: () => Promise<IAIProvider>;
+}
+interface IFallbackProviderOptions {
+  /** Context window of a model, or `undefined` when unknown. Defaults to the registered metadata. */
+  contextWindowOf?: (model: string) => number | undefined;
+  /** Told once per entry that could not be built. */
+  onUnreachable?: (target: IFallbackModelTarget, error: unknown) => void;
+  /** Told of every move, beside the request's own `onModelFallback`; for a host with no turn view. */
+  onFallback?: (notice: IModelFallbackNotice) => void;
+  /**
+   * The chain as the user wrote it, kept so a host that swaps the primary can read it again for the
+   * new one rather than drop it.
+   */
+  entries?: readonly string[];
+}
+declare class FallbackProvider implements IAIProvider {
+  private readonly primary;
+  private readonly fallbacks;
+  private readonly options;
+  readonly name: string;
+  readonly version: string;
+  private readonly built;
+  /** Chain position each recent run moved to; a run not listed is on the primary. */
+  private readonly runPositions;
+  private readonly contextWindowOf;
+  capabilityTable?: IAIProvider['capabilityTable'];
+  effortTable?: IAIProvider['effortTable'];
+  endpointIsVendorDefault?: IAIProvider['endpointIsVendorDefault'];
+  canPropagateTraceContext?: IAIProvider['canPropagateTraceContext'];
+  configureNativeWebTools?: IAIProvider['configureNativeWebTools'];
+  getCapabilities?: IAIProvider['getCapabilities'];
+  constructor(primary: IAIProvider, fallbacks: readonly IFallbackModelTarget[], options?: IFallbackProviderOptions);
+  /** The models a request may move to, in order. */
+  get chain(): readonly IModelRef[];
+  /** The options this chain was built with, to build the same chain over another primary. */
+  get chainOptions(): Readonly<IFallbackProviderOptions>;
+  resolveModelRoute(model: string, executionId?: string): IModelRef;
+  chat(messages: TUniversalMessage[], options?: IChatOptions): Promise<TUniversalMessage>;
+  generateResponse(payload: IProviderRequest): Promise<IRawProviderResponse>;
+  supportsTools(): boolean;
+  validateConfig(): boolean;
+  dispose(): Promise<void>;
+  close(): Promise<void>;
+  private startPosition;
+  private refAt;
+  /**
+   * The chain positions this request may use: from where its run stands, skipping any model whose
+   * context window is smaller than the requested one's when the request asks for that.
+   */
+  private candidatePositions;
+  /** Only a window known to be at least as large counts; an unknown one on either side proves nothing. */
+  private keepsContextWindow;
+  private providerAt;
+  private remember;
+  /**
+   * The request for another model: the same conversation, tools and settings, on that model. What
+   * belongs to the primary's vendor stays behind — a hosted tool it was required to offer, its vendor
+   * option blocks and an effort resolution made against its table — and a trace context goes only
+   * where it can be carried. A hosted tool the request WITHHELD stays withheld: the next model must
+   * not offer what the caller refused.
+   */
+  private fallbackOptions;
+}
+//#endregion
+//#region src/routing/model-fallback-chain.d.ts
+/** A request moves along at most this many models after the primary. */
+declare const MAX_FALLBACK_MODELS = 3;
+/** The settings key holding the chain. */
+declare const FALLBACK_MODEL_SETTINGS_KEY = "fallbackModel";
+interface IModelFallbackPrimary {
+  /** The settings profile the primary comes from; absent for a legacy or environment config. */
+  profile?: string;
+  /** The primary's resolved config, on the model the session runs. */
+  config: IProviderDefinitionConfig;
+}
+interface IResolveModelFallbackChainInput {
+  /** The entries as written, flag or settings. */
+  entries: readonly string[];
+  /** Merged provider settings. */
+  settings: TProviderSettingsDocument;
+  primary: IModelFallbackPrimary;
+  providerDefinitions: readonly IProviderDefinition[];
+  /** Host-selected environment for lazy profile credential resolution. */
+  environment?: Readonly<Record<string, string | undefined>>;
+  resolveCredential?: TProviderCredentialResolver;
+  /** The organization's provider allowlist, by profile name. */
+  allowedProviders?: readonly string[];
+}
+interface IModelFallbackChain {
+  targets: IFallbackModelTarget[];
+  /** Why entries were left out, one line each, for the user. */
+  notices: string[];
+}
+/** Split a comma-separated `--fallback-model` value into its entries. */
+declare function parseFallbackModelList(value: string | undefined): string[] | undefined;
+/** The chain written in settings, or `undefined` when none is. */
+declare function readFallbackModelSetting(settings: TProviderSettingsDocument): string[] | undefined;
+/**
+ * The entries to use: the flag's when it is given, the settings' otherwise. The flag replaces the
+ * settings rather than adding to them, so one run can try a different chain.
+ */
+declare function selectFallbackModelEntries(flag: readonly string[] | undefined, settings: TProviderSettingsDocument): readonly string[];
+/**
+ * Read the chain: entries in order, the primary and repeats removed, entries the organization does
+ * not allow dropped, and at most {@link MAX_FALLBACK_MODELS} kept. Every drop is announced.
+ */
+declare function resolveModelFallbackChain(input: IResolveModelFallbackChainInput): IModelFallbackChain;
+interface IApplyModelFallbackInput extends IResolveModelFallbackChainInput {
+  /** The primary provider. */
+  provider: IAIProvider;
+  /** How the decorator reports; `entries` is filled in from `entries` above. */
+  providerOptions?: Omit<IFallbackProviderOptions, 'entries'>;
+}
+/**
+ * Put the chain in front of `provider`: a {@link FallbackProvider} whenever the user wrote a chain,
+ * even one whose every entry was dropped for this primary, because the chain belongs to the session
+ * and a later primary may keep entries this one could not. The notices say what was dropped.
+ */
+declare function applyModelFallback(input: IApplyModelFallbackInput): {
+  provider: IAIProvider;
+  notices: string[];
+};
+/** The note shown when a turn moved to another model. */
+declare function describeModelFallback(notice: IModelFallbackNotice): string;
+//#endregion
+export { ADVISOR_OFF, ADVISOR_TOOL_NAME, APPEARANCE_SETTINGS_KEYS, AUTO_COMPACT_THRESHOLD_SETTINGS_KEY, AdvisorController, AgentExecutor, BACKGROUND_COMMAND_DESCRIPTION, BACKGROUND_COMMAND_USAGE, BUILT_IN_AGENTS, BackgroundJobOrchestrator, BuiltinCommandSource, BundlePluginInstaller, BundlePluginLoader, CLEAR_COMMAND_DESCRIPTION, COST_COMMAND_DESCRIPTION, CommandRegistry, DEFAULT_AGENT_DEFINED_IN, DEFAULT_AGENT_TYPE, DEFAULT_APPEARANCE_SETTINGS, DEFAULT_AUTO_COMPACT_THRESHOLD, DEFAULT_GOAL_MAX_ITERATIONS, DEFAULT_GOAL_NO_PROGRESS_LIMIT, DEFAULT_MEMORY_EXTRACTOR_POLICY, DEFAULT_STATUS_LINE_COMMAND_SETTINGS, DuplicateSystemCommandSemanticRoleError, EFFORT_LEVEL_LABELS, EXECUTION_ORIGIN_METADATA_KEYS, EXIT_COMMAND_DESCRIPTION, EditCheckpointStore, EditCheckpointsUnavailableError, ExternalEventGrantHistory, ExternalEventIngress, FALLBACK_MODEL_SETTINGS_KEY, FallbackProvider, GIT_DEFAULT_TIMEOUT_MS, GIT_DIFF_USAGE, GIT_ENV_DENYLIST, GIT_MAX_OUTPUT_BYTES, GIT_STATUS_ARGS, GOAL_SIGNAL_TOOL_NAME, GoalController, HELP_COMMAND_DESCRIPTION, HeadlessInteractionChannel, type IActiveModelChangeOptions, type IActiveModelChangeResult, type IAdvisorConsentStore, type IAdvisorControllerOptions, type IAdvisorSetResult, type IAdvisorSpec, type IAdvisorStatus, type IAdvisorTarget, type IAgentDefinition, type IAgentExecutorOptions, type IAgentJobDispatch, type IAgentJobGroups, type IAgentJobHostContext, type IAgentJobLogs, type IAgentJobMonitors, type IAgentJobSchedules, type IAgentRuntime, type IAgentRuntimeConfig, type IAgentSession, type IAgentToolDeps, type IAppearanceSettings, type IAppendMemoryInput, type IAppendMemoryResult, type IApplyModelFallbackInput, type IApprovedMemoryCandidate, type IAutomaticMemoryConfig, type IBackgroundJobOrchestratorOptions, type IBackgroundProcessToolDeps, type IBackgroundTaskRunner, type IBackgroundTaskSpawnerGroupRequest, type IBundlePluginFeatures, type IBundlePluginHookIssue, type IBundlePluginInspection, type IBundlePluginInstallerOptions, type IBundlePluginManifest, type IBundlePluginMcpFault, type IBundlePluginMcpServer, type IBundlePluginSkip, type IBundleSkill, type ICommandAdvisorAdapter, type ICommandCostBudget, type ICommandCostBudgetAdapter, type ICommandEffortAdapter, type ICommandExecutionToolDeps, type ICommandExternalEventGrant, type ICommandExternalEventsAdapter, type ICommandHandoffAdapter, type ICommandHostAdapterAccess, type ICommandHostAdapters, type ICommandHostAgentJobs, type ICommandHostBackgroundTasks, type ICommandHostCatalog, type ICommandHostCheckpoints, type ICommandHostContext, type ICommandHostContextReferences, type ICommandHostContextWindow, type ICommandHostGoal, type ICommandHostMemory, type ICommandHostNoCapability, type ICommandHostPlan, type ICommandHostPresetApplication, type ICommandHostSessionAccess, type ICommandHostSetupState, type ICommandHostTerminalHandoff, type ICommandHostUserInteraction, type ICommandHostWorkspace, type ICommandMCPActivationAdapter, type ICommandMCPActivationSummary, type ICommandMCPOAuthLoginRequest, type ICommandMCPOAuthLoginResult, type ICommandMCPOAuthLogoutResult, type ICommandMCPOAuthRedirectPrompt, type ICommandMCPOAuthStatus, type ICommandMCPSourceProblem, type ICommandModule, type ICommandOutputStyleRegistryAdapter, type ICommandOutputStyleSummary, type ICommandPermissionModeAdapter, type ICommandPermissionRulesAdapter, type ICommandPickerAdapter, type ICommandProcessAdapter, type ICommandProductVocabulary, type ICommandRemoteControlAdapter, type ICommandSandboxAdapter, type ICommandSandboxStatus, type ICommandSessionContextWindow, type ICommandSessionHistory, type ICommandSessionIdentity, type ICommandSessionInfo, type ICommandSessionModel, type ICommandSessionPermissions, type ICommandSessionPreset, type ICommandSessionReplayValidationReport, type ICommandSessionRuntime, type ICommandSettingsAdapter, type ICommandSettingsDocument, type ICommandSkillListEntry, type ICommandWorkspaceAdapter, type ICompactContextResult, type IContextReferenceAddResult, type IContextReferenceClearResult, type IContextReferenceInventoryLimits, type IContextReferenceRemoveResult, type IContextReferenceUpsertResult, type IContributionDescriptor, type IContributionSource, type ICreateExecutionWorkspaceTaskSpawnerOptions, type ICreateGitProcessOptions, type ICreateProgrammaticAgentOptions, type ICreateQueryOptions, type ICreateSessionOptions, type IDurableMemoryReader, type IEditCheckpointFileInspection, type IEditCheckpointFileRecord, type IEditCheckpointInspection, type IEditCheckpointInspectionPlan, type IEditCheckpointManifest, type IEditCheckpointRecorder, type IEditCheckpointRestoreResult, type IEditCheckpointSummary, type IEditCheckpointTurnInput, type IEvalCase, type IEvalCaseResult, type IEvalDefinition, type IEvalMetricScore, type IEvalReport, type IExecutionWorkspaceTaskSpawner, type IExternalEventSource, type IExternalEventSourceOptions, type IFallbackModelTarget, type IFallbackProviderOptions, type IForkExecutionOptions, type IGenerateSessionNameOptions, type IGitDiffArgs, type IGitProcessPort, type IGitProcessRunOptions, type IGitStatusSummary, type IGoalSignal, type IGoalStartOptions, type IGroupChatOrchestratorDeps, type IHandoffOrchestratorDeps, type IHandoffProgress, type IHandoffStaysBehind, type IHeadlessInteractionChannelOptions, type IHeadlessRunnerOptions, type IHeadlessSession, type IHeadlessSessionOptions, type IHeadlessTransport, type IHeadlessTransportOptions, type IHierarchicalOrchestratorDeps, type IHostBundlePluginLoaderOptions, type IHostToolResultSpillStore, type IInProcessSubagentRunnerDeps, type IInspectUserLocalStorageOptions, type IInstalledPluginRecord, type IInteractiveRuntime, type IInteractiveRuntimeOptions, type IInteractiveSessionShutdownOptions, type IKnownMarketplaceEntry, type ILegacyProviderSettings, type ILinkedDeviceSummary, type ILivePromptTracePort, type ILoadContextOptions, type ILoadedBundlePlugin, type IMarketplaceClientOptions, type IMarketplaceManifest, type IMarketplacePluginEntry, type IMemoryBudget, type IMemoryCandidate, type IMemoryCandidateExtractor, type IMemoryCurationQueue, type IMemoryExtractorPolicy, type IMemoryExtractorTrigger, type IMemoryPendingRecord, type IMemoryRecaller, type IMemoryStore, type IMemoryWriter, type IMetric, type IModelCommandToolProjection, type IModelEffortInputs, type IModelEffortResolution, type IModelFallbackChain, type IModelFallbackPrimary, type IModelListSelection, type IModelReapplyOptions, type INodeHostSettingsSource, type IOrchestrationRunContext, type IOrgPolicy, type IOutputStylePrompt, type IParallelOrchestratorDeps, type IParsedGitStatus, type IPerTurnRecallConfig, type IPermissionRuleGroup, type IPermissionRuleLayer, type IPermissionRuleRemoval, type IPermissionsCommandState, type IPlanControllerDeps, type IPluginSettings, type IPreTrustProjectPathInspection, type IPresetApplicationOptions, type IPresetApplicationResult, type IProjectContributionPath, type IProjectGitStatusFile, type IProjectMemorySummary, type IProjectSettingsPath, type IProjectedCommandExecutionToolsDeps, type IProjectedModelCommandTool, type IPromptExecutorOptions, type IPromptFileReferenceDiagnostic, type IPromptFileReferenceHistoryData, type IPromptFileReferenceLimits, type IPromptFileReferenceResolveOptions, type IPromptFileReferenceToken, type IPromptHistoryOptions, type IPromptProvider, type IProviderCommandModuleOptions, type IProviderCommandSettingsAdapter, type IProviderConnectionHost, type IProviderConnectionRequest, type IProviderErrorGuidance, type IProviderProfileNameSuggestionInput, type IProviderProfileNameSuggestionOptions, type IProviderProfileSettings, type IProviderSettingsBuildOptions, type IProviderSetupInput, type IProviderSetupPatch, type IProviderSwitchOptions, type IRawGitStatusRecord, type IReadProviderSettingsOptions, type IRemoteCommandPolicy, type IResetUserConfigResult, type IResolveExecutionAttachInput, type IResolveModelFallbackChainInput, type IResolveUserLocalStorageRootOptions, type IResolvedConfig, type IResolvedPromptFileReference, type IResolvedPromptFileReferences, type IRestrictedWorkspaceProjectAccess, type IReversibleExecutionOptions, type IReversibleToolSafetyContext, type IReversibleToolSafetyInput, type IReversibleToolSafetyReport, type IRuntimeHostHandle, type IRuntimeHostOptions, type IRuntimeHostPoolOptions, type ISelfHostingCommandTemplates, type ISelfHostingVerificationPlan, type ISelfHostingVerificationPlanInput, type ISelfHostingVerificationStep, type ISemanticMemoryAdapter, type ISemanticMemoryQueryResult, type ISequentialOrchestratorDeps, type ISequentialRunContext, type ISessionLease, type ISessionPoolBinding, type ISessionPoolEntry, type ISessionPoolOptions, type ISessionRecordRestoreResult, type ISessionSlotOptions, type ISessionUsageRecord, type ISettingsDocumentStore, type ISettingsInspection, type ISettingsKeyProvenance, type ISettingsLayerCause, type ISettingsLayerInspection, type ISettingsSchemaIssue, type ISkillActivationHistoryData, type ISkillExecutionCallbacks, type ISkillExecutionResult, type ISkillPromptContext, type ISkillRootDescriptor, type ISkillRootInspection, type ISkillSourceInspection, type ISkillSourceSkip, type ISpawnAgentTaskRequest, type ISpawnProcessTaskRequest, type IStartupMemory, type IStatelessRuntimeConfig, type ISubagentOptions, type ISubagentParentContext, type ISubagentPromptOptions, type ISystemCommand, type ISystemCommandSemanticRoles, type ITaskContextFile, type ITaskSelectionOptions, type IToolCallHandoffPolicy, type IToolCallHandoffProvenance, type ITrustedWorkspaceProjectAccess, type IUnknownCommandModuleName, type IUserLocalMemoryDeleteResult, type IUserLocalMemoryItemOptions, type IUserLocalMemoryItemProjection, type IUserLocalMemoryListOptions, type IUserLocalMemoryListProjection, type IUserLocalMemorySetOptions, type IUserLocalStorageCategoryDefinition, type IUserLocalStorageCategoryProjection, type IUserLocalStorageInspection, type IUserLocalStorageItemSummary, type IWorkspaceAncestorTextEntry, type IWorkspaceDirectoryEntry, type IWorkspaceIdentity, type IWorkspaceIdentityResolver, type IWorkspaceMoveRequest, type IWorkspaceProjectAuthority, type IWorkspaceProjectMutation, type IWorkspaceProjectReader, type IWorkspaceProjectSettingsSource, type IWorkspaceProjectSettingsWriter, type IWorkspaceProjectStateStorage, type IWorkspaceTrustCause, type IWorkspaceTrustGrant, type IWorkspaceTrustServiceOptions, type IWorkspaceTrustStore, type IWorkspaceTrustStoreSnapshot, InteractiveSession, LANGUAGE_COMMAND_ARGUMENT_HINT, LANGUAGE_COMMAND_DESCRIPTION, MAX_FALLBACK_MODELS, MAX_PROJECT_DIFF_LINES, MAX_STATUS_FILES, MEMORY_COMMAND_ARGUMENT_HINT, MEMORY_COMMAND_DESCRIPTION, MEMORY_COMMAND_USAGE, MEMORY_INDEX_MAX_BYTES, MEMORY_INDEX_MAX_LINES, MODEL_COMMAND_TOOL_PREFIX, MONITOR_SHELL_TOOL, MarketplaceClient, MonitorCommandRefusedError, NoCurrentProviderProfileError, NodeHostPluginSettingsStore, OUTPUT_FORMATS, OrgPolicyParseError, PERMISSIONS_COMMAND_DESCRIPTION, PERMISSION_MODE_ARGUMENT_HINT, PERMISSION_MODE_COMMAND_DESCRIPTION, PERMISSION_MODE_LABELS, PLUGIN_COMMAND_ARGUMENT_HINT, PLUGIN_COMMAND_DESCRIPTION, PROVIDER_SAFE_TOOL_NAME_PATTERN, PeerMessageIngress, PlanController, type PlanDelegation, PluginCommandSource, ProgrammaticInteractionChannel, ProjectMemoryStore, PromptExecutor, ProviderConfigError, RECOMMENDED_RESPONSE_LANGUAGES, RELOAD_PLUGINS_COMMAND_DESCRIPTION, RENAME_COMMAND_DESCRIPTION, RENAME_COMMAND_USAGE, RESUME_COMMAND_DESCRIPTION, REWIND_COMMAND_ARGUMENT_HINT, REWIND_COMMAND_DESCRIPTION, RUNTIME_RULE_SOURCE, RegexMemoryCandidateExtractor, type ResolveHandoff, SESSION_POOL_IDLE_GRACE_MS, SESSION_POOL_MAX_LIVE, STATUSLINE_COMMAND_ARGUMENT_HINT, STATUSLINE_COMMAND_DESCRIPTION, type SelectNextStep, SemanticMemoryStore, SessionChangeRefusal, SessionDeleteRefusal, SessionPool, SessionRenameUnavailableError, SessionSlot, SessionTerminalHandoffGate, SettingsParseError, SkillCommandSource, SystemCommandExecutor, type TAdvisorTargetResolver, type TAppearanceSettingsPatch, type TAutoCompactThreshold, type TAutoCompactThresholdSource, type TBundlePluginSkipReason, type TCommandModuleSessionRequirement, type TEditCheckpointFileRestoreAction, type TEditCheckpointsUnavailableReason, type TEffortDisposition, type TEffortSelection, type TEffortSource, type TEnabledPlugins, type TEvalRunFn, type TExecutionAttachOutcome, type TExternalEventReceipt, type TExternalEventSettlement, type TFrontmatterJsonResult, type TGitDiffTarget, type TGitProcessFailureReason, type TGitProcessOutcome, type TGoalDecision, type THostSettingsScope, type TInstalledPluginsRegistry, type TInteractiveSessionOptions, type TKnownMarketplacesRegistry, type TMarketplaceSource, type TMemoryCandidateStatus, type TMemoryPolicyMode, type TOutputFormat, type TParseGitDiffArgs, type TParsedInput, type TPermissionRuleKind, type TPlanDecision, type TPoolBusySession, type TProjectFileStatus, type TProjectGitDiffResult, type TProjectGitStatusResult, type TProjectSettingsScope, type TPromptFileReferenceDiagnosticCode, type TProviderConnectionStage, type TProviderFactory, type TProviderSettingsDocument, type TQueryFunction, type TRawGitStatusRecordKind, type TRecommendedResponseLanguage, type TRemoteControlStatus, type TRestoredScheduleDisposition, type TReversibleExecutionIsolation, type TReversibleRollbackLayer, type TReversibleSafetyStatus, type TReversibleSideEffect, type TSandboxCommandMode, type TSandboxSettings, type TSelfHostingLoopEvent, type TSelfHostingLoopState, type TSelfHostingVerificationPhase, type TSessionFactory, type TSessionPoolRole, type TSessionResponseFormat, type TSettings, type TSettingsCheck, type TSettingsData, type TSettingsLayerState, type TSettingsMergeRule, type TSettingsScope, type TSettingsSource, type TShellExecFn, type TSkillSkipReason, type TSubagentRunnerFactory, type TSubagentSuffix, type TSystemCommandLifecycle, type TSystemCommandSemanticRole, type TTaskFileStatus, type TUserLocalMemoryCategory, type TUserLocalMemoryCommandExecutionEffect, type TUserLocalStorageCategory, type TWorkspaceContributionKind, type TWorkspaceProjectAccess, type TWorkspaceProjectAuthorityCandidate, type TWorkspaceProjectMutationDecision, type TWorkspaceProjectSettingsTarget, type TWorkspaceProjectSettingsWriteDecision, type TWorkspaceProjectStateDirectories, type TWorkspaceProjectStateNamespace, type TWorkspaceTrustState, TransportRegistry, USER_LOCAL_MEMORY_CATEGORIES, USER_LOCAL_STORAGE_CATEGORIES, USER_LOCAL_STORAGE_CATEGORY_DEFINITIONS, VALIDATE_SESSION_COMMAND_DESCRIPTION, VALID_PERMISSION_MODES, WorkspaceAuthorityRequiredError, WorkspaceMemoryStore, WorkspaceProjectSessionStore, WorkspaceSessionLogSink, WorkspaceSessionLogSource, WorkspaceTrustService, addCommandContextReference, applyActiveModelChange, applyAppearanceSettings, applyModelFallback, applyPresetToSession, applyProviderConfiguration, applyProviderSwitch, applyStatusLineSettings, approvePendingMemoryCandidate, assembleSubagentPrompt, assertWorkspaceProjectAuthority, assertWorkspaceProjectMutation, assertWorkspaceProjectMutationForAuthority, assertWorkspaceProjectReader, assertWorkspaceProjectSettingsWriter, assertWorkspaceProjectStateStorage, bindTransportAdapter, buildBackgroundCommandSubcommands, buildGoalContinuationPrompt, buildGoalStartPrompt, buildLanguageCommandSubcommands, buildMemoryCommandSubcommands, buildModelListSnapshot, buildPermissionModeSubcommands, buildPluginCommandSubcommands, buildPromptWithFileReferences, buildProviderProfile, buildProviderProfilesSnapshot, buildProviderSetupPatch, buildRewindCommandSubcommands, buildRuntimeSession, buildStatusLineCommandSubcommands, cancelCommandBackgroundTask, checkNodeHostSettingsFile, checkSettingsDocument, clearCommandContextReferences, clearContextReferences, clearConversationHistory, closeCommandBackgroundTask, compactCommandContext, compareSemverVersions, consentScopeFor, createAdvisorTool, createAgentRuntime, createAgentTool, createBackgroundGroupExecutionEntryId, createBackgroundProcessTool, createBackgroundTaskExecutionEntryId, createBuiltinCommandModule, createCommandExecutionTool, createCommandMemoryStores, createContextReferenceItem, createContributionSourcesForProjectAccess, createDefaultRemoteCommandPolicy, createDefaultUserContributionSources, createExecutionOriginMetadata, createExecutionWorkspaceSnapshot, createExecutionWorkspaceTaskSpawner, createExternalEventGrantHistory, createFileTransportSettingsRepository, createGitProcess, createGoalStatusTool, createHeadlessRunner, createHeadlessTransport, createHostBundlePluginLoader, createInProcessSubagentRunner, createInteractiveRuntime, createLineDetailPage, createMainThreadDetailPage, createMainThreadExecutionEntryId, createMemoryTransportSettingsRepository, createModelCommandToolProjection, createNodeHostContributionSource, createNodeHostSessionStore, createNodeHostSettingsSource, createNodeHostSettingsStore, createNodeToolResultSpillStore, createNodeWorkspaceIdentityResolver, createNodeWorkspaceTrustService, createNodeWorkspaceTrustStore, createProgrammaticAgent, createProjectSessionStore, createProjectedCommandExecutionTools, createPromptFileReferenceHistoryEntry, createProviderFromSettings, createProviderSafeModelCommandToolName, createQuery, createRestrictedWorkspaceProjectAccess, createSemanticMemoryStore, createSessionExitHostAction, createSessionRenameHostAction, createSessionRunFn, createSettingsPermissionRulesAdapter, createShowPluginManagerIntent, createShowSessionPickerIntent, createSkillCommand, createSkillExecutionPort, createStatelessRuntime, createSubagentLogger, createSubagentSession, createSystemCommands, createUserPromptHistoryFile, createUserSessionStore, createWorkspaceMemoryStore, createWorkspaceProjectContributionSource, createWorkspaceProjectMutation, createWorkspaceProjectSettingsSources, createWorkspaceProjectSettingsStore, createWorkspaceProjectSettingsWriter, decodeFrontmatter, decodeFrontmatterJson, defineEval, deleteProviderProfile, deleteSettings, deleteUserLocalMemoryItem, deriveContextCapacityHint, describeBundleContribution, describeModelFallback, describeProviderDestination, disableUserLocalMemoryItem, discoverTaskFiles, evaluateReversibleToolSafety, exactMatch, executeGitDiff, executeGitStatus, executeSkill, extractGoalSignal, findUnknownModuleNames, forkCommandEditCheckpoint, formatAdvisorSpec, formatCommandBackgroundTask, formatCommandBackgroundTaskList, formatCommandHelpMessage, formatCommandPermissionsMessage, formatCommandSessionReplayValidationReport, formatEvalReport, formatGitStatus, formatInvalidPermissionModeMessage, formatLanguageUsageMessage, formatOrgPolicyViolationMessage, formatProjectedModelCommandToolPromptDescription, formatPromptFileReferenceDiagnostics, formatTaskContext, generateSessionName, getForkWorkerSuffix, getSubagentSuffix, getWorkspaceProjectIdentity, getWorkspaceProjectReader, getWorkspaceProjectStateStorage, gitDiffArgv, gitEnvironment, gitFailureMessage, groupPermissionRulesBySource, hasBlockingPromptFileReferenceDiagnostics, hasSensitiveCommandMemoryContent, includesText, inspectCommandEditCheckpoint, inspectPreTrustProjectPaths, inspectSettingsLayers, inspectSkillSources, inspectUserLocalMemoryItem, inspectUserLocalStorage, isApiKeyPlaintext, isAppearanceSettingsPatch, isCommandMemoryType, isGoalCancelVerb, isLoopStopVerb, isMemoryType, isNewerSemverVersion, isNotAGitRepositoryFailure, isPermissionMode, isSafeSessionId, isSessionBusy, isSlashCommand, isStatusLineCommandSettingsPatch, listActiveContextReferences, listCommandBackgroundTasks, listCommandContextReferences, listCommandEditCheckpointBranches, listCommandEditCheckpoints, listCommandSessionAllowedTools, listCommandUsedMemoryReferences, listFrameworkProjectContributionPaths, listResumableSessionSummaries, listUnreadableSessions, listUnreadableSessionsForWorkspace, listUserLocalMemoryItems, loadHostBundlePluginInspectionFromScopes, loadHostBundlePluginsFromScopes, loadOrgPolicy, loadTaskContext, mergeProviderPatch, mergeProviders, mergeSettings, normalizeModelCommandName, parseAdvisorSpec, parseCommandBackgroundLogCursor, parseEvalCases, parseExecutionWorkspaceEntryId, parseFallbackModelList, parseGitDiffArgs, parseInput, parseLanguageArgument, parseModelEffort, parsePermissionModeArgument, parsePromptFileReferences, parseSessionNameArgument, parseStatusPorcelainV2, parseStatusRecords, parseTaskFile, parseUnifiedDiffLines, persistSessionRename, planSelfHostingVerification, preprocessShellCommands, probeProviderProfile, promptForApproval, providerDestinationOf, readAppearanceSettings, readAutoCompactThreshold, readAutoCompactThresholdSource, readCommandBackgroundTaskLog, readCommandContextState, readCommandPermissionMode, readCommandPermissionsState, readCommandSessionInfo, readCurrentGitBranchFromNodeHost, readEnabledUserLocalMemoryItem, readFallbackModelSetting, readMergedProviderSettings, readMergedProviderSettingsFromSources, readPackageVersion, readPermissionRuleLayers, readProjectGitDiff, readProjectGitStatus, readProviderSettings, readSettings, readSettingsSourceText, readStatusLineSettings, recordCommandMemoryEvent, regexMatch, rememberProviderDestination, removeCommandContextReference, removeContextReference, removePermissionRule, resetAutoCompactThresholdSetting, resetUserConfig, resolveActiveProvider, resolveEnvDefaultProvider, resolveExecutionAttach, resolveGitBranchFromNodeHost, resolveLatestSessionId, resolveModelEffort, resolveModelFallbackChain, resolveModelListSelection, resolvePermissionModeAdapter, resolvePluginCommandAdapter, resolvePromptFileReferencePaths, resolvePromptFileReferences, resolveProviderSettingsWriteTarget, resolveReusableEmptySessionId, resolveRoleFallbackChain, resolveRoleModel, resolveSessionIdByIdOrName, resolveStartupAdvisorSpec, resolveSubagentLogDir, resolveUserLocalStorageRoot, responseIsJson, restoreCommandEditCheckpoint, restoreSessionRecordIntoSession, restoredScheduleDisposition, retrieveAgentToolDeps, retryCommandPermissionDenial, rollbackCommandEditCheckpoint, runEval, runGroupChat, runHandoff, runHierarchical, runParallel, runSequential, runWithRoleFallback, sandboxApprovalFor, sanitizeProviderProfileName, selectCommandModules, selectFallbackModelEntries, selectRelevantTasks, setCommandAutoCompactThreshold, setCurrentProvider, setUserLocalMemoryItem, startRuntimeHost, storeAgentToolDeps, substituteVariables, suggestProviderProfileName, summarizeBackgroundJobGroup, supportsWorkspaceProjectMutation, switchCommandEditCheckpointBranch, testProviderProfileCommand, toContextReferenceRecords, toPromptFileReferenceRecords, tokeniseSlashCommand, transitionSelfHostingLoop, trimTrailingChars, updateModelInSettings, upsertContextReference, upsertProviderProfile, usedTool, validateCommandSessionReplayLog, validateProviderProfile, withUniqueSessionName, wrapEditCheckpointTools, wrapReversibleExecutionTools, writeAutoCompactThresholdSetting, writeCommandPermissionMode, writeSettings };
+//# sourceMappingURL=index.d.cts.map