@wrongstack/core 0.284.0 → 0.285.0

package/dist/index.d.ts

@@ -1,2873 +1,109 @@
-import { d as TaskGraph, T as TaskType, a as TaskPriority, e as TaskNode } from './task-graph-CH3acNQ7.js';
-export { C as CriticalPathResult, S as SerializableTaskGraph, f as SerializableTaskGraphNodes, g as SerializedTaskGraph, h as TaskAssignment, i as TaskDependency, j as TaskEdge, k as TaskFilter, c as TaskProgress, l as TaskSort, b as TaskStatus, m as computeTaskProgress, n as deserializeTaskGraph, o as findCriticalPath, s as serializeTaskGraph, t as topologicalSort } from './task-graph-CH3acNQ7.js';
-import { W as WorktreeManager } from './worktree-manager-DzwxKE35.js';
-export { A as AllocateOpts, M as MergeOpts, a as MergeResult, b as WorktreeHandle, c as WorktreeManagerOptions, R as WorktreeRunResult, d as WorktreeStatus, e as assertSafePath } from './worktree-manager-DzwxKE35.js';
-import { E as EventBus, B as BrainArbiter, c as MemoryStore, a as EventName, L as Listener } from './events-Bgnh43r9.js';
-export { e as BrainDecision, f as BrainDecisionOption, g as BrainDecisionQueue, h as BrainDecisionRequest, i as BrainDecisionSource, j as BrainFallback, k as BrainRisk, D as DefaultBrainArbiter, l as DefaultBrainArbiterOptions, m as EventLogger, n as EventMap, H as HumanEscalatingBrainArbiter, o as MEMORY_TYPE_LABELS, p as MemoryClearedPayload, q as MemoryConsolidatedPayload, b as MemoryEntry, r as MemoryForgottenPayload, s as MemoryPriority, d as MemoryRelevanceContext, t as MemoryRememberedPayload, M as MemoryScope, u as MemoryType, O as ObservableBrainArbiter, v as ScopedEventBus, S as ScoredEntry, w as formatHumanPrompt } from './events-Bgnh43r9.js';
-import { TaskStore } from './tasking/index.js';
-export { DefaultTaskStore, TaskTracker, TaskTrackerChange, TaskTrackerListener, TaskTrackerOptions, TaskTransition } from './tasking/index.js';
-import { D as DefaultLogger } from './mcp-servers-DEV4s6Ks.js';
-export { C as ContextManagerAction, a as ContextManagerInput, b as ContextManagerResult, c as ContextManagerToolOptions, d as DefaultLoggerOptions, L as LogFormat, e as allServers, f as awsServer, g as blockServer, h as braveSearchServer, i as context7Server, j as contextManagerTool, k as createContextManagerTool, l as everArtServer, m as filesystemServer, n as githubServer, o as googleMapsServer, p as miniMaxVisionServer, q as playwrightServer, s as sentinelServer, r as slackServer, t as sshManagerServer, z as zaiVisionServer } from './mcp-servers-DEV4s6Ks.js';
-import { D as DefaultPathResolver } from './path-resolver-CMS5307d.js';
-import { D as DefaultSecretVault } from './secret-vault-DxohkUBc.js';
-export { A as AutoApprovePermissionPolicy, a as DefaultPermissionPolicy, b as DefaultSecretScrubber, P as PermissionPolicyOptions, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, m as migratePlaintextSecrets, r as rewriteConfigEncrypted } from './secret-vault-DxohkUBc.js';
-import { j as Config, q as TokenSavingTier, r as HookInput, s as HookOutcome, H as HookEvent, C as ConfiguredHook, M as ModelsRegistry, f as HookMatcher, I as InProcessHook, g as HookRegistrationOptions, n as ConfigStore } from './config-MRqn1V-u.js';
-export { A as AdaptiveConcurrencyConfig, t as AnyHookOutcome, u as AutonomyConfig, v as CONTEXT_WINDOW_MODES, w as CircuitBreakerRuntimeConfig, l as ConfigLoader, x as ContextConfig, o as ContextWindowAggressiveOn, y as ContextWindowConfigLike, z as ContextWindowMode, B as ContextWindowModeId, p as ContextWindowPolicy, D as ContextWindowThresholds, E as CustomModelDefinition, G as DEFAULT_CONTEXT_WINDOW_MODE_ID, J as DEFAULT_TUI_THINKING_WORD, K as ExecDangerConfig, L as ExecToolConfig, N as FeaturesConfig, F as FleetConfig, O as FleetSupervisorConfig, i as HookEntry, Q as HookFailurePolicy, U as HookInvocationContext, V as HqClientConfig, h as HttpHook, X as IndexingConfig, Y as InputHistoryConfig, Z as LaunchConfig, _ as LogConfig, $ as LoopDetectionConfig, a0 as MAX_TUI_THINKING_WORD_LENGTH, b as MCPServerConfig, a as ModelMatrixEntry, a1 as ModelRuntimeCacheConfig, k as ModelRuntimeConfig, a2 as ModelRuntimeParametersConfig, a3 as ModelRuntimeReasoningConfig, e as ModelsDevModel, c as ModelsDevPayload, a4 as ModelsDevProvider, a5 as PluginConfig, a6 as PreToolUseOutcome, a7 as PreToolUseStage, a8 as ProviderApiKey, P as ProviderConfig, R as ResolvedModel, d as ResolvedProvider, a9 as SessionLoggingConfig, S as ShellHook, aa as SkillsConfig, ab as SyncCategory, m as SyncConfig, ac as ToolDescriptionMode, ad as ToolDescriptionModeConfig, T as ToolResultRenderMode, ae as ToolResultRenderModeConfig, af as ToolsConfig, W as WireFamily, ag as formatContextWindowModeList, ah as getContextWindowMode, ai as isContextWindowModeId, aj as listContextWindowModes, ak as normalizeTokenSavingTier, al as normalizeTuiThinkingWord, am as resolveContextWindowPolicy } from './config-MRqn1V-u.js';
-import { W as WstackPaths } from './wstack-paths-C3K40Qst.js';
-export { a as WstackPathOptions, p as projectHash, b as projectSlug, r as resolveWstackPaths, w as wstackGlobalRoot } from './wstack-paths-C3K40Qst.js';
-import { n as SlashCommand, P as PluginAPI, o as PluginPipelines, p as ToolRegistryView, q as ProviderRegistryView, r as MCPRegistryView, s as SlashCommandRegistryView, t as SessionWriterView, u as MetricsSinkView, v as PluginLLM, w as PluginCapabilities, x as PluginDependency, y as Plugin } from './multi-agent-coordinator-4RCRZKjN.js';
-export { z as AGENT_TOOL_PRESETS, A as Agent, E as AgentBudgetTier, G as AgentCapability, h as AgentDefinition, a as AgentFactory, H as AgentFactoryResult, g as AgentPhase, I as AgentRunnerOptions, m as AwaitAnyResult, J as BudgetExceededError, K as BudgetKind, L as BudgetLimits, N as BudgetNegotiationMode, O as BudgetThresholdDecision, Q as BudgetThresholdHandler, R as BudgetThresholdSignal, U as BudgetUsage, V as CoordinatorEvents, C as CoordinatorStatus, W as DECISION_TIMEOUT_MS, X as DEFAULT_DISPATCH_ROLE, b as DefaultMultiAgentCoordinator, Y as DispatchCandidate, D as DispatchClassifier, Z as DispatchMethod, _ as DispatchOptions, $ as DispatchResult, c as DoneCondition, F as FleetBus, a0 as FleetEvent, a1 as FleetHandler, j as FleetUsage, k as FleetUsageAggregator, a2 as HEAVY_BUDGET, a3 as LIGHT_BUDGET, a4 as MEDIUM_BUDGET, M as MultiAgentConfig, a5 as MultiAgentCoordinator, a6 as MultiAgentCoordinatorOptions, a7 as PluginLLMOptions, a8 as PluginLLMResult, a9 as SpawnResult, aa as SubagentBudget, i as SubagentConfig, ab as SubagentContext, ac as SubagentError, ad as SubagentErrorKind, ae as SubagentPartialResult, af as SubagentRunContext, ag as SubagentRunOutcome, S as SubagentRunner, ah as SubagentSpawnLineage, ai as SubagentStructuredReport, aj as SubagentUsageSnapshot, ak as TIMEOUT_PREEMPT_FRACTION, al as TaskDelegation, l as TaskResult, T as TaskSpec, am as dispatchAgent, an as makeAgentSubagentRunner, ao as makeLLMClassifier, ap as scoreAgents, aq as withDisabledToolFiltering } from './multi-agent-coordinator-4RCRZKjN.js';
-export { A as ACP_AGENTS, a as AGENTS_BY_PHASE, b as AGENT_CATALOG, c as ALL_AGENT_DEFINITIONS, d as ALL_FLEET_AGENTS, e as AUDIT_LOG_AGENT, f as AutoExtendCeiling, g as AutoExtendPolicy, B as BUG_HUNTER_AGENT, h as BugFinding, C as CollabBudgetConfig, i as CollabBudgetOverrides, j as CollabBudgetWarningPayload, k as CollabDebugReport, l as CollabSession, m as CollabSessionOptions, n as CreateDelegateToolOptions, o as CriticConcern, p as CriticEvaluation, D as DEFAULT_DIRECTOR_PREAMBLE, q as DEFAULT_SUBAGENT_BASELINE, r as DelegateHost, s as Director, t as DirectorAlert, u as DirectorAlertLevel, v as DirectorCancelCollabPayload, w as DirectorPromptParts, x as DirectorSessionFactory, y as DirectorSessionFactoryOptions, F as FLEET_ROSTER, z as FLEET_ROSTER_BUDGETS, E as FLEET_ROSTER_WITHACP, G as FleetCostCapError, H as FleetManager, I as FleetManagerOptions, J as FleetRosterBudget, K as FleetSpawnBudgetError, L as FleetTokenCapError, M as FleetWorktreePolicy, N as ICoordinator, O as IFleetManager, P as InMemoryAgentBridge, Q as InMemoryBridgeTransport, R as LargeAnswerStore, S as NULL_FLEET_BUS, T as REFACTOR_PLANNER_AGENT, U as RefactorPhase, V as RefactorPlan, W as SECURITY_SCANNER_AGENT, X as SharedFileEntry, Y as SharedFileSnapshot, Z as SubagentPromptParts, _ as TaskResultNotification, $ as WorktreeIntegrationError, a0 as WorktreeIsolationDecision, a1 as WorktreeTaskRunnerOptions, a2 as WorktreeTaskStateUpdate, a3 as applyRosterBudget, a4 as attachAutoExtend, a5 as composeDirectorPrompt, a6 as composeSubagentPrompt, a7 as createDelegateTool, a8 as createMessage, a9 as getAgentDefinition, aa as makeAskResultTool, ab as makeAskTool, ac as makeAssignTool, ad as makeAwaitTasksTool, ae as makeCollabDebugTool, af as makeDirectorSessionFactory, ag as makeFleetEmitTool, ah as makeFleetHealthTool, ah as makeFleetSessionTool, ah as makeFleetTool, ah as makeFleetUsageTool, ai as makeKanbanQueueTool, aj as makeQualityGateTool, ak as makeRollUpTool, al as makeSpawnTool, am as makeTerminateAllTool, an as makeTerminateTool, ao as makeWorkCompleteTool, ap as resolveSubagentWorktreeDecision, aq as rosterSummaryFromConfigs, ar as subagentNeedsWorktree, as as wrapSubagentRunnerWithWorktrees } from './null-fleet-bus-CFoNVQEK.js';
-export { AcquireOptions, AcquireResult, AdaptiveConcurrencyController, AdaptiveConcurrencyState, AgentMonitorOptions, AgentMonitorService, AgentTimelineEntry, AgentVirtualSession, ApplyResult, ApprovalDecision, AutonomousBrain, AutonomousBrainOptions, AutonomousCoordinator, AutonomousCoordinatorOptions, AutonomousDecisionRequest, AutonomousDecisionType, BUILD_AGENTS, BrainInterventionInput, BrainMonitor, BrainMonitorOptions, ChangeFile, ChangeManager, ChangeManagerOptions, ChangeNode, ChangeProposal, ChangeStatus, ConsensusOptions, ConsensusProtocol, ConsensusResult, CoordinatorEvent, CoordinatorStats, DAGEdgeEvent, DAGEdgeHandler, DAGNode, DAGNodeStatus, DEFAULT_MAX_FLEET_SPAWNS, DEFAULT_QUALITY_CHECKS, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DecisionNode, DecisionPrompt, DefaultMailbox, DepWatchEntry, DepWatcherBridgeOptions, DependencyWatcherConfig, DownAlertInput, EscalationDecision, FactCategory, FactNode, FleetStatusToolOptions, FleetSupervisor, FleetSupervisorActions, FleetSupervisorOptions, FleetSupervisorSource, GoalNode, GoalPriority, GoalStatus, GraphSubscription, HARD_MAX_SPAWN_DEPTH, KNOWLEDGE_AGENTS, KnowledgeGraph, LLMProvider, LiveLockResult, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MATRIX_PHASE_KEYS, MAX_SUBAGENT_STRUCTURED_REPORT_CHARS, META_AGENTS, MailToolsOptions, MailboxActionInput, MailboxActionResult, MailboxBridgeLock, MailboxHealthEvent, MailboxHealthWatchdog, MailboxHealthWatchdogOptions, MailboxHooksOptions, MailboxMessageAction, MailboxResolver, MailboxToolOptions, MatrixKeyKind, ModelMatrixResolution, ModelMatrixResolutionSource, ModelReference, NodeFilter, NodeType, OutdatedNotifyMessage, PLANNING_AGENTS, PackageAuthorEntry, PackageAuthorLog, PackageAuthorTrackerOptions, PackageOutdatedEntry, PackageOutdatedResult, PackageOutdatedWatcherOptions, PrioritizationDecision, QualityCheck, QualityGateChecks, QualityGateResult, QuorumRule, REVIEW_AGENTS, RecoveryAlertInput, ResolvedModelTarget, ResolvedSubagentModelTarget, RollbackResult, RunnablesHandler, SUBAGENT_STRUCTURED_REPORT_META_KEY, SpawnDecision, SupervisedSubagent, SupervisorLogEntry, TaskAuctionOptions, TaskAuctioneer, TaskBid, TaskDAG, VERIFY_AGENTS, VoteNode, VoteRecord, VoteValue, VoterConfig, WatchdogConfig, acquireOrJoin, actionToAckInput, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, createAgentMonitorService, createMailboxHooks, detectEcosystem, detectEcosystem as detectPackageEcosystem, finalize, formatSubagentStructuredReport, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, isValidMatrixKey, mailboxSessionTag, makeDependencyWatcherConfig, makeFleetStatusTool, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeSubagentResultTool, matrixKeyKind, normalizeSubagentStructuredReport, phaseForRole, readLiveLock, readSubagentStructuredReport, recordPackageAction, release, resolveImplementationModelTarget, resolveMailboxIdentity, resolveMaxSpawnDepth, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveSubagentModelTarget, roleNeedsIndependentReviewModel, sameModelReference, startPackageOutdatedWatcher, updatePackageOutdatedStatus, validateWatchdogOptions } from './coordination/index.js';
-export { D as DEFAULT_HQ_REDACTION_POLICY, G as GlobalMailbox, H as HQ_PROTOCOL_VERSION, a as HqAgentMessagePayload, b as HqAgentStatusPayload, c as HqAlertMessage, d as HqBrainEventKind, e as HqBrainEventPayload, f as HqBrowserEventMessage, g as HqBrowserMessage, h as HqBrowserSnapshotMessage, i as HqClientCapability, j as HqClientCommandAckMessage, k as HqClientCommandPollMessage, l as HqClientEventMessage, m as HqClientHeartbeatPayload, n as HqClientHelloMessage, o as HqClientHelloPayload, p as HqClientIdentity, q as HqClientKind, r as HqClientMessage, s as HqClientRecord, t as HqEventEnvelope, u as HqEventPayloadResult, v as HqEventType, w as HqFleetEventPayload, x as HqFleetSnapshotPayload, y as HqFleetSummary, z as HqGitSnapshotPayload, A as HqMachineRecord, B as HqMailboxAgentStatus, C as HqMailboxAgentSummary, E as HqMailboxEventAction, F as HqMailboxEventPayload, I as HqMailboxMappingOptions, J as HqMailboxMessageSummary, K as HqMailboxMessageType, L as HqMailboxPriority, M as HqMailboxSnapshotOptions, N as HqMailboxSnapshotPayload, O as HqMailboxSummary, P as HqParseResult, Q as HqPathPolicy, R as HqProjectIdentity, S as HqProjectRecord, T as HqProjectStatus, U as HqProtocolVersion, V as HqPublishEventOptions, W as HqPublisher, X as HqPublisherCommandHandler, Y as HqPublisherCommandResult, Z as HqPublisherOptions, _ as HqQueuedCommand, $ as HqRedactionPolicy, a0 as HqServerCommandBatchMessage, a1 as HqServerMessage, a2 as HqSessionAgentLiveStatus, a3 as HqSessionAgentSummary, a4 as HqSessionEndedPayload, a5 as HqSessionLiveStatus, a6 as HqSessionSnapshotPayload, a7 as HqSessionStartedPayload, a8 as HqSessionStatus, a9 as HqSessionStatusPayload, aa as HqSessionSummary, ab as HqSnapshot, ac as HqSocketFactory, ad as HqSocketLike, ae as HqSubagentSummary, af as HqToolArgsPolicy, ag as HqToolCompletedPayload, ah as HqToolStartedPayload, ai as HqTranscriptAppendPayload, aj as HqTranscriptEntry, ak as HqTranscriptRole, al as HqUsagePayload, am as HqWelcomePayload, an as HqWorklistCounts, ao as HqWorklistSnapshotPayload, ap as HqWorkspaceKind, aq as HqWorktreeEventKind, ar as HqWorktreeEventPayload, as as createHqEventEnvelope, at as createMailboxEventPayload, au as createMailboxSnapshotPayload, av as createMailboxSnapshotPayloadFromMailbox, aw as mapMailboxAgentToHqSummary, ax as mapMailboxMessageToHqSummary, ay as parseHqEventPayload, az as parseHqFrame, aA as resolveProjectDir } from './global-mailbox-sZwyI6CS.js';
-export { A as AgentEntry, a as AgentLiveStatus, S as SessionLiveStatus, b as SessionRegistry, c as SessionRegistryEntry, g as getSessionRegistry, h as hasSessionRegistry } from './session-registry-Dvg7i_IA.js';
-import { b as Mailbox, M as MailboxMessage } from './mailbox-types-BGZWrYTJ.js';
-export { g as AgentHeartbeatInput, A as AgentRegistrationInput, h as ClientHeartbeatInput, C as ClientRegistrationInput, k as ClientSource, i as ClientStatus, f as MailboxAckBatchInput, e as MailboxAckInput, a as MailboxAgentStatus, l as MailboxMessageType, d as MailboxQuery, c as MailboxSendInput, m as MailboxTaskContext, P as PurgeOptions, j as PurgeResult, R as ReadReceipts, n as RegisteredAgent, o as normalizeRecipient } from './mailbox-types-BGZWrYTJ.js';
-import { d as Context, A as TodoItem, g as Tool, P as Provider, i as ContentBlock, c as Request, e as Response, s as TextBlock, M as Message, J as JSONSchema } from './tool-BNlnIJvo.js';
-export { E as AgentError, C as CacheStats, q as CacheTtl, r as Capabilities, G as CompletedWorkEvidence, H as CompletedWorkSource, I as ConfigError, K as ContextEvidenceState, L as ContextFileEvidence, N as ContextInit, O as ContextIntentEvidence, Q as ContextRepeatedReadEvidence, u as ConversationState, V as ERROR_CODES, X as ErrorCode, Y as ErrorSeverity, Z as ErrorSubsystem, _ as FetchError, $ as FileSnapshot, F as ForkedSession, a0 as FsError, a1 as ImageBlock, a2 as JsonSchemaSpec, a3 as MessageRole, a4 as ParseError, f as Permission, a5 as PluginError, h as ProviderError, a6 as ProviderErrorBody, a7 as ProviderErrorKind, a8 as ReadonlyConversationState, a as ReasoningConfig, p as ReasoningEffort, R as ReasoningRequest, a9 as RequestCacheControl, aa as ResponseFormat, ab as ResumeFileStatus, ac as ResumeFileValidationEntry, ad as ResumeValidation, x as ResumedSession, n as RiskTier, ae as RunEnv, t as RunOptions, af as SafetySetting, ag as SddError, y as SessionData, ah as SessionError, S as SessionEvent, v as SessionForkOptions, j as SessionMetadata, k as SessionStore, z as SessionSummary, b as SessionWriter, ai as SideEffect, aj as SideEffectRisk, ak as StateChange, al as StateChangeHandler, am as StopReason, an as StreamEvent, ao as StreamHangError, ap as ThinkingBlock, T as TokenCounter, aq as ToolCallContext, ar as ToolError, l as ToolErrorCategory, as as ToolErrorInfo, at as ToolEvidenceStatus, au as ToolFinalEvent, av as ToolIconId, o as ToolOutputMetadata, m as ToolProgressEvent, D as ToolResultBlock, aw as ToolStreamEvent, B as ToolUseBlock, ax as ToolValidationError, U as Usage, W as WorkspaceCheckpointRef, w as WorkspaceMaterializationResult, ay as WrongStackError, az as classifyProviderError, aA as effectiveInputTokens, aB as extractRunEnv, aC as isAgentError, aD as isConfigError, aE as isFetchError, aF as isFsError, aG as isImageBlock, aH as isParseError, aI as isPluginError, aJ as isRetryableKind, aK as isSddError, aL as isSessionError, aM as isTextBlock, aN as isToolError, aO as isToolResultBlock, aP as isToolUseBlock, aQ as isToolValidationError, aR as isWrongStackError, aS as toWrongStackError, aT as wrapAsState } from './tool-BNlnIJvo.js';
-import { j as AgentExtension, S as SystemPromptContributor, b as ToolRegistry, P as ProviderRegistry, A as AgentPipelines, R as ResolvedLoopDetectionConfig, c as ToolExecutorLike, E as ExtensionRegistry, T as ToolCallPipelinePayload } from './index--Gm41aBJ.js';
-export { k as AfterIterationHook, l as AfterRunHook, m as AfterToolExecutionHook, d as AgentInit, e as AgentInput, B as BeforeIterationHook, n as BeforeRunHook, o as BeforeToolExecutionHook, D as DEFAULT_MAX_ITERATIONS, H as HookRunEnv, p as HookRunner, q as HookRunnerOptions, O as OnErrorHook, r as PreToolUseResult, s as PromptResult, t as ProviderFactory, u as ProviderRunnerWrapper, f as RunResult, a as ToolWrapper, U as UserInputPayload, v as createDefaultPipelines } from './index--Gm41aBJ.js';
-import { L as Logger } from './logger-B63L5bTg.js';
-export { a as LogLevel } from './logger-B63L5bTg.js';
-import { A as AttachmentStore, b as AttachmentRef, a as AddAttachmentInput } from './session-reader-7Esxrkpw.js';
-export { c as Attachment, d as AttachmentKind, e as AttachmentMeta, D as DefaultSessionReader, f as DefaultSessionReaderOptions, S as SessionReader } from './session-reader-7Esxrkpw.js';
-import { T as Tracer, M as MetricsSink, H as HealthRegistry } from './observability-D-HZN_mF.js';
-export { A as AggregateHealth, a as HealthCheck, b as HealthCheckResult, c as HealthStatus, d as MetricLabels, e as MetricSeries, f as MetricsSnapshot, S as Span } from './observability-D-HZN_mF.js';
-import { R as RetryPolicy, E as ErrorHandler } from './retry-policy-CQ7KwXJa.js';
-import { M as ModeStore } from './mode-CZlO9iU1.js';
-export { D as DEFAULT_MODES, b as Mode, a as ModeConfig, c as ModeManifest } from './mode-CZlO9iU1.js';
-import { S as SkillLoader } from './skill-DHniprNl.js';
-export { b as SkillEntry, a as SkillManifest } from './skill-DHniprNl.js';
-import { S as SystemPromptBuilder, c as ModelCapabilities, B as BuildContext, d as SystemPromptRegions, C as Container, a as Renderer, b as Middleware, H as HookRegistry } from './pipeline-DGDyIohT.js';
-export { e as BindOptions, D as Decorator, F as Factory, M as MiddlewareHandler, N as NextFn, P as Pipeline, f as PipelineOptions, T as Token, g as flattenSystemPromptRegions, h as hookMatcherMatches } from './pipeline-DGDyIohT.js';
-export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorOptions, d as CompactorStrategy, D as DefaultDesignKitLoader, e as DefaultErrorHandler, f as DefaultPromptLoader, g as DefaultRetryPolicy, h as DefaultSkillLoader, i as DesignKitLoaderOptions, j as DesignOverrides, k as DoneCheckResult, l as DoneConditionChecker, H as HybridCompactor, I as IntelligentCompactor, m as IntelligentCompactorOptions, P as PersistedActiveKit, n as PromptLoaderOptions, S as SelectiveCompactor, o as SelectiveCompactorOptions, p as SkillLoaderOptions, q as StrategyCompactorOptions, T as ToolExecutor, _ as _resetDesignKitLoaderMemo, r as _resetDesignRulesCache, s as activateDesign, t as applyTokenOverrides, u as buildGoalPreamble, v as clearActiveKit, w as clearPersistedActiveKit, x as createStrategyCompactor, y as designProjectDir, z as detectFrontendFile, B as detectFrontendIntent, E as getDesignKitLoader, F as getDesignState, G as installDesignStudioMiddleware, J as loadActiveKit, K as loadProjectDesignRules, L as makeAutonomyPromptContributor, M as makeDesignDetectToolCallMiddleware, N as makeDesignDetectUserInputMiddleware, O as makeDesignStudioRequestMiddleware, Q as makeDesignVerifyToolCallMiddleware, R as recordKitChoice, U as recordOverrides, V as renderPrompt, W as resolveBundledDesignKitsDir, X as setActiveKit, Y as setDesignOverrides } from './tool-executor-CckSCM5E.js';
-export { DefaultProviderRunner, DesignVerifyReport, DesignViolation, MaterializeResult, colorToHex, isColorToken, materializeTokens, oklchToHex, parseOklch, runDesignVerify, verifyFiles } from './defaults/index.js';
-export { f as DESIGN_STACKS, d as DesignKitEntry, b as DesignKitLoader, c as DesignKitManifest, e as DesignKitTokens, D as DesignStack, a as DesignStudioState, g as DesignTokenSet, E as EternalAutonomyEngine, h as EternalAutonomyOptions, i as EternalEngineState, I as IterationStage, P as ParallelEngineState, j as ParallelEternalEngine, k as ParallelEternalOptions, l as ParallelIterationStage, m as isDesignStack } from './parallel-eternal-engine-HUrtePLd.js';
-export { C as CODEX_MODELS, a as CodexModelMeta, D as DefaultModeStore, b as DefaultModelsRegistry, c as DefaultModelsRegistryOptions, L as LLMSelector, d as LLMSelectorOptions, M as ModeLoaderOptions, P as ProviderModelDescriptor, e as classifyFamily, f as codexModelMeta, g as describeCatalogModel, l as loadProjectModes, h as loadUserModes, r as resolveProviderModelList } from './provider-model-resolve-o2hHLs79.js';
-export { DefaultHealthRegistry, InMemoryMetricsSink, MetricsServerHandle, MetricsServerOptions, NoopMetricsSink, NoopTracer, OTelTracer, OtlpMetricsExporterHandle, OtlpMetricsExporterOptions, OtlpTraceExporterHandle, OtlpTraceExporterOptions, PROMETHEUS_CONTENT_TYPE, buildOtlpMetricsRequest, buildOtlpTracesRequest, renderPrometheus, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, wireMetricsToEvents } from './observability/index.js';
-export { A as AbandonedSession, a as AttachmentStoreOptions, C as ConfigLoaderOptions, b as ConfigMigration, c as ConfigMigrationError, d as ConfigSource, D as DEFAULT_CONFIG_MIGRATIONS, e as DefaultAttachmentStore, f as DefaultConfigLoader, g as DefaultConfigStore, h as DefaultMemoryStore, i as DefaultSessionStore, F as FileMemoryBackend, j as FileMemoryBackendOptions, M as MemoryBackend, k as MemoryStoreOptions, l as MigrationContext, m as MigrationResult, P as PersistedQueueItem, n as PlanFile, o as PlanItem, p as PlanTemplate, Q as QueueStore, R as RecoveryLock, q as RecoveryLockOptions, S as SessionAnalyzer, r as SessionStoreOptions, T as TodosCheckpointFile, s as addPlanItem, t as attachPlanCheckpoint, u as attachTodosCheckpoint, v as clearPlan, w as deriveTodosFromPlanItem, x as emptyPlan, y as formatPlan, z as formatPlanTemplates, B as getPlanTemplate, E as listPlanTemplates, G as loadPlan, H as loadTodosCheckpoint, I as mutatePlan, J as parseEntries, K as removePlanItem, L as runConfigMigrations, N as savePlan, O as saveTodosCheckpoint, U as setPlanItemStatus } from './todos-checkpoint-FY7PjmMx.js';
-export { a as DirectorStateCheckpoint, D as DirectorStateSnapshot, b as DirectorSubagentState, c as DirectorTaskState, l as loadDirectorState } from './director-state-CMS_bMs4.js';
-export { A as AuditLevel, C as CORE_RECONSTRUCT_EVENTS, a as STANDARD_AUDIT_EVENTS, S as SessionEventBridge, b as SessionEventBridgeOptions, c as SessionSamplingOptions, T as ToolProgressSamplingOptions, d as createSessionEventBridge, r as resolveAuditLevel, e as resolveSessionLoggingConfig } from './session-event-bridge-D_z_mBwk.js';
-export { AutonomyBrainOptions, BrainAutoRisk, ModelRuntimeMiddlewareOptions, ResolvedModelRuntime, TieredBrainArbiterOptions, applyModelRuntime, createAutonomyBrain, createTieredBrainArbiter, formatDecisionSummary, mergeModelRuntime, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest } from './execution/index.js';
-import { estimateMessageTokens } from './utils/index.js';
-export { AtomicWriteOptions, BuildChildEnvOptions, COMPLETED_WORK_LEDGER_MARKER, CoercionResult, CompactToolDefinitionForWireOptions, CompactWireToolDefinition, CompileFail, CompileResult, DEFAULT_TOOL_DESCRIPTION_MODE, DEFAULT_TOOL_RESULT_RENDER_MODE, DeepMergeOptions, FORBIDDEN_PROTO_KEYS, FileLockOptions, JsonObject, JsonPath, JsonPathSegment, MessageRepairReport, MessageRepairResult, NewlineStyle, OutputLineGuard, RecordCompletedWorkInput, RecordToolOutputEvidenceInput, RequestTokenBreakdown, SafeParseResult, ToolDescriptionRegistryLike, ToolOutputSerializerOptions, ToolResultRenderModeRegistryLike, ToolWireDefinitionLike, UnifiedDiffOptions, ValidationError, ValidationResult, applyToolDescriptionModeToTool, applyToolDescriptionModes, applyToolResultRenderModes, assertNever, assertNotPrivateHost, atomicWrite, buildChildEnv, buildCompletedWorkLedgerBlock, buildContextEvidenceDigest, coerceAgainstSchema, color, compactSchemaDescriptions, compactToolDefinitionForWire, compileGlob, compileUserRegex, completePartialObject, computeMessageTokens, createContextEvidenceState, createToolOutputSerializer, deepMerge, detectNewlineStyle, ensureDir, escapeGlobSubject, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, expandIPv6, formatCompletedWorkLedger, formatTodosList, getCalibrationState, getJsonPath, getTermSize, getToolDescriptionMode, getToolResultRenderMode, hasOpenTodos, isInteractive, isJsonObject, isPathSubjectKey, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isStdinTTY, isStdoutTTY, isUlid, jsonObjectFileExists, markAssistantReferencedEvidence, matchAny, matchGlob, mergeCustomModelDefs, mergeModelsPayload, normalizePathSubject, normalizeToLf, normalizeToolDescriptionMode, normalizeToolResultRenderMode, onResize, readJsonObjectFile, recordActualUsage, recordCompletedWorkEvidence, recordToolOutputEvidence, recordUserIntentEvidence, removeJsonPath, removeJsonPathInFile, repairToolUseAdjacency, repeatedReadPressure, resetCalibration, resolveToolDescriptionMode, resolveToolResultRenderMode, safeParse, safeStringify, sanitizeJsonString, sanitizeNodeOptions, sessionScopedPath, setJsonPath, setJsonPathInFile, setOutputLineGuard, setRawMode, setToolDescriptionMode, setToolResultRenderMode, simplifyToolDescription, sleep, slugify, stripAnsi, stripCodeFences, subjectForToolInput, syncCompletedWorkLedgerBlock, toStyle, truncate, ulid, unifiedDiff, updateJsonObjectFile, validateAgainstSchema, withFileLock, writeErr, writeJsonObjectFile, writeOut } from './utils/index.js';
-export { ConversationTurn, ENHANCER_SYSTEM_PROMPT, EnhanceResult, EnhanceUserPromptOptions, enhanceUserPrompt, gatedEnhancerReasoning, normalizedEqual, recentTextTurns, shouldEnhance } from './execution/prompt-enhancer.js';
-export { AgentMonitorEventBridgeOptions, BrainTelemetryBridgeOptions, CostTelemetryBridgeOptions, CreateGlobalMailboxOptions, CreateHqPublisherOptions, EnsureHqFirstRunAuthResult, FleetTelemetryBridgeOptions, HQ_AUTH_FILE_VERSION, HQ_COMMAND_TYPES, HqAbortCommand, HqAgentEventPublisher, HqAlert, HqAlertEngine, HqAlertRuleConfig, HqAlertSeverity, HqAuthFile, HqBroadcastCommand, HqBrowserToken, HqBtwCommand, HqCommand, HqCommandAuditEntry, HqCommandAuditLog, HqCommandType, HqEventLog, HqEventLogOptions, HqPersistence, HqPublisherEnvConfig, HqQueueCommand, HqRedactOptions, HqRedactionResult, HqRunCommandCommand, HqRuntimeFile, HqSnapshotStore, HqSnapshotStoreOptions, HqSpawnCommand, HqSteerCommand, HqTimeseriesSample, HqTimeseriesStore, HqTimeseriesStoreOptions, HqToken, SessionTelemetryBridgeOptions, ToolTelemetryBridgeOptions, WorktreeTelemetryBridgeOptions, buildTranscriptFromEvents, createGlobalMailbox, createHqPersistence, createHqPublisherFromEnv, defaultHqDataDir, discoverLocalHqEndpoint, emptyHqAuthFile, ensureHqFirstRunAuthFile, hqAuthFilePath, hqRuntimeFilePath, mapSessionEventToEntries, mergeToolResults, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, readHqAuthFile, readHqRuntimeFileSync, redactHqEvent, redactHqValue, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, scrubAndTruncateHqPreview, startAgentMonitorEventBridge, startBrainTelemetryBridge, startCostTelemetryBridge, startFleetTelemetryBridge, startSessionTelemetryBridge, startToolTelemetryBridge, startWorktreeTelemetryBridge, summarizeHqToolArgs, toAlertMessage, tokenHasCapability, validateHqCommand, watchHqAuthFile, writeHqAuthFile, writeHqRuntimeFile } from './hq/index.js';
-export { RunController, RunControllerOptions, TOKENS } from './kernel/index.js';
-import { P as PermissionPolicy } from './permission-ByDKXEcG.js';
-export { a as PermissionDecision, T as TrustPolicy } from './permission-ByDKXEcG.js';
-export { H as HttpDispatcher, a as HttpsAgentAsDispatcher } from './dispatcher-types.d-BBeXBQgS.js';
-import { DefaultPromptStore, PromptUsageStore, ReplayLogStore } from './storage/index.js';
-export { ALL_SYNC_CATEGORIES, AgentStatusTracker, AgentStatusTrackerOptions, Annotation, AnnotationsStore, AnnotationsStoreOptions, AuditEntry, CheckpointGitResult, CloudSync, CompletedWorkCheckpointFile, ConsolidationOp, DefaultSessionRewinder, FleetNotifier, FleetNotifierOptions, GraphMemoryBackend, GraphMemoryBackendOptions, INPUT_HISTORY_DEFAULT_MAX, InputHistoryStore, MemoryConsolidatorOptions, PromptStore, PromptUsage, ProviderConfigSnapshot, RecoveryPlan, ReplayEntry, ReplayLogStoreOptions, SessionCheckpointCas, SessionCheckpointCasOptions, SessionMemoryConsolidator, SessionRecovery, SessionRewinderOptions, StaleSession, SyncResult, TaskFile, ToolAuditLog, ToolAuditLogOptions, VerifyResult, WatchProviderConfigOptions, emptyTaskFile, generateSessionId, loadCompletedWorkCheckpoint, loadTasks, migratePromptEntry, mutateTasks, promptChecksum, sanitizeModel, saveCompletedWorkCheckpoint, saveTasks, watchProviderConfig } from './storage/index.js';
-import { P as PromptLoader } from './prompt-DLd35n4Q.js';
-export { B as BUILTIN_PROMPT_CATEGORIES, d as BuiltinPromptCategory, e as PROMPT_CATEGORY_LABELS, f as PromptCategory, c as PromptCategoryCount, a as PromptEntry, g as PromptManifest, h as PromptManifestRef, b as PromptSearchOptions, i as PromptSource, j as PromptVariable, k as isBuiltinCategory } from './prompt-DLd35n4Q.js';
-import { SkillRegistryAdapter } from './skills/index.js';
-export { DEFAULT_SKILLS_SH_URL, DownloadResult, ExtractedSkillDraft, FOREIGN_SKILL_TOOLS, ForeignSkillTool, InstallResult, InstalledSkillEntry, ManifestData, ParsedRef, ParsedSkillFrontmatter, RegistrySearchOptions, RegistrySearchResult, RegistrySkillSummary, ResolvedForeignTools, SKILL_LIMITS, SkillInstaller, SkillInstallerOptions, SkillManifestStore, SkillNameValidation, SkillSecurityTier, SkillSkeletonOptions, UpdateResult, bodyLineAdvisory, createSkillsShAdapter, downloadGitHubTarball, extractSkillFromPrompt, generateSkillSkeleton, githubDirectAdapter, isValidSkillNameFormat, openInEditor, parseSkillFrontmatter, parseSkillRef, resolveForeignToolIds, resolveForeignToolIdsWithWarnings, securityScoreToTier, stripFrontmatter, validateSkillName, validateSkillNameAvailable, writeSkeletonSkill } from './skills/index.js';
-import { PromptRegistryManifest, RegistryDiff, PromptManifestData, InstalledPromptEntry } from './types/index.js';
-export { AutonomyStage, DEFAULT_SPEC_TEMPLATE, DistributiveOmit, MALFORMED_ARG_MARKERS, ManifestValidation, PromptRegistryRef, SpecAnalysis, SpecApiEndpoint, SpecRequirement, SpecSection, SpecSectionType, SpecStatus, SpecTemplate, SpecValidationResult, Specification, diffRegistry, validateRegistryManifest } from './types/index.js';
-import { P as ProviderRunner, R as RunProviderOptions$1 } from './provider-runner-ChL-kVg6.js';
-export { D as DANGEROUS_FOR_SUBAGENTS, T as ToolCapabilities, a as ToolCapability, W as WIDE_SUBAGENT_CAPABILITIES, g as getDangerousCapabilities, h as hasCapability, b as hasDangerousCapabilityForSubagents } from './index-CbyuOE5y.js';
-export { G as GoalFile, J as JournalEntry, M as MAX_JOURNAL_ENTRIES, a as MAX_PROGRESS_HISTORY, P as ProgressSnapshot, b as appendJournal, e as emptyGoal, f as formatGoal, g as goalFilePath, l as loadGoal, p as parseProgressFromText, r as recordProgress, s as saveGoal, c as setProgress, d as summarizeUsage } from './goal-store-Datpp-ar.js';
-import { MCPRegistryHandle } from './tools/index.js';
-export { createMcpControlTool } from './tools/index.js';
-export { a as CompactReport, C as Compactor } from './compactor-DQLL4HTo.js';
-export { D as DEFAULT_AUTONOMY_CONFIG, a as DEFAULT_CIRCUIT_BREAKER_CONFIG, b as DEFAULT_CONTEXT_CONFIG, c as DEFAULT_SESSION_LOGGING_CONFIG, d as DEFAULT_SESSION_PRUNE_DAYS, e as DEFAULT_TOOLS_CONFIG } from './default-config-B79_gJYv.js';
-export { C as CheckpointInfo, R as RewindResult, a as RewindResultExtended, S as SessionRewinder } from './session-rewinder-C9HnMkhP.js';
-export { I as InputReader, P as PromptOption } from './input-reader-E-ffP2ee.js';
-export { S as SecretScrubber } from './secret-scrubber-3MHDDAtm.js';
-export { R as RotatableSecretVault, S as SecretVault, e as encryptedPrefixForVersion, n as noOpVault, p as parseEncryptedVersion } from './secret-vault-BAKpgFw_.js';
+export { type AutoPhaseOptions, AutoPhasePlanner, type AutoPhasePlannerOptions, type AutoPhasePlanResult, AutoPhaseRunner, type AutoPhaseRunnerOptions, type Checkpoint, CheckpointManager, type CheckpointManagerOptions, createAutoPhaseFromTaskGraph, PHASE_EVENT_NAMES, type PhaseEventMap, type PhaseEventName, type PhaseExecutionContext, type PhaseFilter, type PhaseGraph, PhaseGraphBuilder, type PhaseGraphBuilderOptions, type PhaseNode, PhaseOrchestrator, type PhaseOrchestratorOptions, type PhaseProgress, type PhaseSort, type PhaseStatus, PhaseStore, type PhaseStoreOptions, type PhaseTemplate, } from './autophase/index.js';
+export { type BootConfigOptions, type BootConfigResult, bootConfig, flagsToConfigPatch, } from './boot.js';
+export { allServers } from './infrastructure/mcp-servers.js';
+export { type AgentFactory, type AgentFactoryResult, type AgentRunnerOptions, makeAgentSubagentRunner, } from './coordination/agent-subagent-runner.js';
+export { AGENT_CATALOG, AGENTS_BY_PHASE, type AgentDefinition, type AgentPhase, ALL_AGENT_DEFINITIONS, getAgentDefinition, } from './coordination/agents/index.js';
+export { type BrainArbiter, type BrainDecision, type BrainDecisionOption, BrainDecisionQueue, type BrainDecisionRequest, type BrainDecisionSource, type BrainFallback, type BrainRisk, DefaultBrainArbiter, type DefaultBrainArbiterOptions, formatHumanPrompt, HumanEscalatingBrainArbiter, ObservableBrainArbiter, } from './coordination/brain.js';
+export { type BrainInterventionInput, BrainMonitor, type BrainMonitorOptions, } from './coordination/brain-monitor.js';
+export { type CollabBusState, CollaborationBus, type ConsumedInjectionInfo, } from './coordination/collab-bus.js';
+export { assessCommitSafety, type CommitSafetyOptions, type CommitSafetyReport, type ForeignFile, } from './coordination/commit-safety.js';
+export { DEPENDENCY_FILE_PATTERNS, type DependencyWatcherConfig, type DepWatchEntry, makeDependencyWatcherConfig, } from './coordination/dep-watcher.js';
+export { attachDepWatcherBridge, type DepWatcherBridgeOptions, } from './coordination/dep-watcher-bridge.js';
+export { Director, FleetCostCapError, FleetSpawnBudgetError, FleetTokenCapError, type TaskResultNotification, } from './coordination/director.js';
+export { DEFAULT_MAX_FLEET_SPAWNS, HARD_MAX_SPAWN_DEPTH, resolveMaxSpawnDepth, } from './coordination/spawn-budget.js';
+export { type DirectorSessionFactory, type DirectorSessionFactoryOptions, makeDirectorSessionFactory, } from './coordination/director-session.js';
+export { makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeFleetEmitTool, makeFleetTool, makeKanbanQueueTool, makeQualityGateTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, } from './coordination/director-tools.js';
+export { formatSubagentStructuredReport, MAX_SUBAGENT_STRUCTURED_REPORT_CHARS, makeSubagentResultTool, normalizeSubagentStructuredReport, readSubagentStructuredReport, SUBAGENT_STRUCTURED_REPORT_META_KEY, } from './coordination/subagent-result-tool.js';
+export { DEFAULT_DISPATCH_ROLE, type DispatchCandidate, type DispatchClassifier, type DispatchMethod, type DispatchOptions, type DispatchResult, dispatchAgent, makeLLMClassifier, scoreAgents, } from './coordination/dispatcher.js';
+export { compactLog, type FileAuthorEntry, type FileAuthorLog, type FileAuthorTrackerOptions, getFileHistory, getFilesByAgent, getFullLog, getLastAuthor, recordFileAction, } from './coordination/file-author-tracker.js';
+export { ACP_AGENTS, ALL_FLEET_AGENTS, applyRosterBudget, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, type FleetRosterBudget, } from './coordination/fleet.js';
+export { FleetBus, type FleetEvent, type FleetHandler, type FleetUsage, FleetUsageAggregator, type SubagentUsageSnapshot, } from './coordination/fleet-bus.js';
+export { FleetManager, type FleetManagerOptions, } from './coordination/fleet-manager.js';
+export { type FleetStatusToolOptions, makeFleetStatusTool, } from './coordination/fleet-status-tool.js';
+export { FleetSupervisor, type FleetSupervisorActions, type FleetSupervisorOptions, type FleetSupervisorSource, type SupervisedSubagent, type SupervisorLogEntry, } from './coordination/fleet-supervisor.js';
+export { GlobalMailbox, resolveProjectDir } from './coordination/global-mailbox.js';
+export { SessionRegistry, getSessionRegistry, hasSessionRegistry, type SessionRegistryEntry, type SessionLiveStatus, } from './session-registry.js';
+export * from './coordination/index.js';
+export { type MailToolsOptions, makeMailInboxTool, makeMailSendTool, } from './coordination/mail-tools.js';
+export { DefaultMailbox } from './coordination/mailbox.js';
+export { type MailboxResolver, type MailboxToolOptions, mailboxSessionTag, makeMailboxTool, resolveMailboxIdentity, } from './coordination/mailbox-tool.js';
+export type { AgentHeartbeatInput, AgentRegistrationInput, Mailbox, MailboxAckInput, MailboxAgentStatus, MailboxMessage, MailboxMessageType, MailboxQuery, MailboxSendInput, MailboxTaskContext, ReadReceipts, RegisteredAgent, } from './coordination/mailbox-types.js';
+export { normalizeRecipient } from './coordination/mailbox-types.js';
+export { isValidMatrixKey, MATRIX_PHASE_KEYS, type MatrixKeyKind, type ModelMatrixResolution, type ModelMatrixResolutionSource, type ModelReference, matrixKeyKind, phaseForRole, type ResolvedModelTarget, type ResolvedSubagentModelTarget, resolveImplementationModelTarget, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveSubagentModelTarget, roleNeedsIndependentReviewModel, sameModelReference, } from './coordination/model-matrix.js';
+export { NULL_FLEET_BUS } from './coordination/null-fleet-bus.js';
+export { detectEcosystem as detectPackageEcosystem, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, type PackageAuthorEntry, type PackageAuthorLog, type PackageAuthorTrackerOptions, recordPackageAction, updatePackageOutdatedStatus, } from './coordination/package-author-tracker.js';
+export { type OutdatedNotifyMessage, type PackageOutdatedEntry, type PackageOutdatedResult, type PackageOutdatedWatcherOptions, startPackageOutdatedWatcher, } from './coordination/package-outdated-watcher.js';
+export { assignNickname, type NicknameAssignment, nicknameKeyFromDisplay, } from './coordination/subagent-nicknames.js';
+export { startTechStackConsumer, type TechStackConsumerOptions, } from './coordination/techstack-mailbox-consumer.js';
+export { type FleetWorktreePolicy, resolveSubagentWorktreeDecision, subagentNeedsWorktree, WorktreeIntegrationError, type WorktreeIsolationDecision, type WorktreeTaskRunnerOptions, type WorktreeTaskStateUpdate, wrapSubagentRunnerWithWorktrees, } from './coordination/worktree-task-runner.js';
+export { Agent, type AgentInit, type AgentInput, type AgentPipelines, createDefaultPipelines, DEFAULT_MAX_ITERATIONS, type RunResult, type ToolCallPipelinePayload, type UserInputPayload, } from './core/agent.js';
+export { buildBtwBlock, consumeBtwNotes, pendingBtwCount, setBtwNote, } from './core/btw.js';
+export { Context, type ContextInit, type RunOptions, type TodoItem } from './core/context.js';
+export { type ContinuationInput, type ContinuationSource, detectContinueIntent, type ResolvedContinuation, resolveContinuation, } from './core/continue-intent.js';
+export { type ContinueDirective, makeContinueToNextIterationTool, parseContinueDirective, } from './core/continue-to-next-iteration.js';
+export { ConversationState, type ReadonlyConversationState, type StateChange, type StateChangeHandler, wrapAsState, } from './core/conversation-state.js';
+export { createFallbackModelExtension, effectiveFallbackChain, type FallbackModelDeps, fallbackProfileChain, formatModelRef, normalizeModelRef, parseModelRef, smartDefaultFallbackChain, } from './core/fallback-model.js';
+export { InputBuilder, type InputBuilderEvent, type InputBuilderOptions, } from './core/input-builder.js';
+export { type InstructionBundle, type InstructionBundlePaths, loadInstructionBundle, mergeInstructionBundle, type SystemInstructionBundle, } from './core/instruction-bundle.js';
+export { buildMailboxBlock, buildMailboxBtwAwarenessBlock, createMailboxChecker, injectPendingMailboxMessages, type MailboxLoopOptions, } from './core/mailbox-loop.js';
+export { runProviderWithRetry } from './core/provider-runner.js';
+export { buildQueuedMessagesBlock, consumeQueuedMessagesUpdate, peekQueuedMessages, setQueuedMessagesSnapshot, } from './core/queued-messages.js';
+export { extractRunEnv, type RunEnv } from './core/run-env.js';
+export { DefaultSystemPromptBuilder, type DefaultSystemPromptBuilderOptions, LAYER_1_IDENTITY, } from './core/system-prompt-builder.js';
+export * from './defaults/index.js';
+export { AutoCompactionMiddleware, type CompactorOptions, type CompactorStrategy, createStrategyCompactor, HybridCompactor, IntelligentCompactor, type IntelligentCompactorOptions, SelectiveCompactor, type SelectiveCompactorOptions, type StrategyCompactorOptions, } from './defaults/index.js';
+export { type AutonomyBrainOptions, type BrainAutoRisk, createAutonomyBrain, createTieredBrainArbiter, formatDecisionSummary, type TieredBrainArbiterOptions, } from './execution/autonomy-brain.js';
+export { buildLosslessDigest, buildSmartDigest, type ContentScore, type EliseResult, eliseOldToolResults, estimateMessages, extractText, findPreserveStart, hasTextContent, scoreMessage, } from './execution/compaction-core.js';
+export { applyModelRuntime, type ModelRuntimeMiddlewareOptions, mergeModelRuntime, type ResolvedModelRuntime, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest, } from './execution/model-runtime.js';
+export { type ConversationTurn, ENHANCER_SYSTEM_PROMPT, type EnhanceResult, type EnhanceUserPromptOptions, enhanceUserPrompt, gatedEnhancerReasoning, normalizedEqual, recentTextTurns, shouldEnhance, } from './execution/prompt-enhancer.js';
+export { type AfterIterationHook, type AfterRunHook, type AfterToolExecutionHook, type AgentExtension, type BeforeIterationHook, type BeforeRunHook, type BeforeToolExecutionHook, ExtensionRegistry, type OnErrorHook, type ProviderRunnerWrapper, } from './extension/index.js';
+export { countShellHooks, HookRegistry, type HookRunEnv, HookRunner, type HookRunnerOptions, hookMatcherMatches, type PreToolUseResult, type PromptResult, runShellHook, type ShellHookSpec, shellHooksEqual, } from './hooks/index.js';
+export * from './hq/index.js';
+export * from './kernel/index.js';
+export { attachMailboxChecker } from './mailbox-attach.js';
+export { type CollabPauseMiddlewareOptions, collabInjectMiddleware, collabPauseMiddleware, type InjectedToolResult as CollabInjectedToolResult, } from './middleware/collab-pause.js';
+export { DefaultPluginAPI, definePlugin, type PluginAPIInit } from './plugin/api.js';
+export { KERNEL_API_VERSION, type LoadPluginsOptions, loadPlugins, unloadPlugins, } from './plugin/loader.js';
+export type { ChimeraReviewNeededPayload, ResolvedChimeraConfig, } from './plugins/chimera-plugin.js';
+export { CHIMERA_REVIEW_PROMPT, createChimeraPlugin, resolveChimeraConfig, } from './plugins/chimera-plugin.js';
+export { createGitPlugin } from './plugins/git-plugin.js';
+export { createObservabilityPlugin } from './plugins/observability-plugin.js';
+export { createPlanPlugin } from './plugins/plan-plugin.js';
+export { createPromptsPlugin } from './plugins/prompts-plugin.js';
+export { createSecurityPlugin } from './plugins/security-plugin.js';
+export { createSkillsPlugin } from './plugins/skills-plugin.js';
+export { createSyncPlugin } from './plugins/sync-plugin.js';
+export * from './prompts/index.js';
+export { type ProviderFactory, ProviderRegistry } from './registry/provider-registry.js';
+export { type SlashCommand, SlashCommandRegistry, } from './registry/slash-command-registry.js';
+export type { ToolWrapper } from './registry/tool-registry.js';
+export { ToolRegistry } from './registry/tool-registry.js';
+export { hashRequest, stableStringify, } from './replay/hash.js';
+export { type ReplayMode, ReplayProviderRunner, type ReplayProviderRunnerOptions, } from './replay/replay-provider-runner.js';
+export { DANGEROUS_FOR_SUBAGENTS, getDangerousCapabilities, hasCapability, hasDangerousCapabilityForSubagents, ToolCapabilities, type ToolCapability, WIDE_SUBAGENT_CAPABILITIES, } from './security/capabilities.js';
+export { DefaultSecretScrubber } from './security/secret-scrubber.js';
+export * from './skills/index.js';
+export * from './storage/index.js';
+export { type AuditLevel, createSessionEventBridge, resolveAuditLevel, resolveSessionLoggingConfig, type SessionEventBridge, type SessionEventBridgeOptions, type SessionSamplingOptions, type ToolProgressSamplingOptions, } from './storage/session-event-bridge.js';
+export { createMcpControlTool, type MCPRegistryHandle } from './tools/mcp-control.js';
+export { createMcpUseTool } from './tools/mcp-use.js';
+export type { Compactor, CompactReport } from './types/compactor.js';
+export { CONTEXT_WINDOW_MODES, type ContextWindowAggressiveOn, type ContextWindowConfigLike, type ContextWindowMode, type ContextWindowModeId, type ContextWindowPolicy, type ContextWindowThresholds, DEFAULT_CONTEXT_WINDOW_MODE_ID, formatContextWindowModeList, getContextWindowMode, isContextWindowModeId, listContextWindowModes, resolveContextWindowPolicy, } from './types/context-window.js';
+export { DEFAULT_SESSION_PRUNE_DAYS } from './types/default-config.js';
+export * from './types/index.js';
+export type { Logger, LogLevel } from './types/logger.js';
+export type { ModelsDevModel, ModelsDevPayload, ModelsDevProvider, ModelsRegistry, ResolvedModel, ResolvedProvider, WireFamily, } from './types/models-registry.js';
+export type { ProviderRunner, RunProviderOptions } from './types/provider-runner.js';
+export type { SecretScrubber } from './types/secret-scrubber.js';
+export type { RotatableSecretVault, SecretVault } from './types/secret-vault.js';
+export { encryptedPrefixForVersion, noOpVault, parseEncryptedVersion, } from './types/secret-vault.js';
+export type { CacheStats, TokenCounter } from './types/token-counter.js';
 export { expectDefined } from './utils/expect-defined.js';
-export { toErrorMessage } from './utils/error.js';
-export { T as TaskItem, c as computeTaskItemProgress, f as formatTaskList, a as formatTaskProgress } from './task-format-GX0B1mMC.js';
-import './path-resolver-CPRj4bFY.js';
-import 'node:events';
-import './selector-D8O6B_Rm.js';
-import 'node:https';
-import 'undici';
-
-type PhaseStatus = 'pending' | 'ready' | 'running' | 'paused' | 'completed' | 'failed' | 'skipped';
-interface PhaseNode {
-    id: string;
-    /** Phase name, e.g. "Discovery", "Design", "Implementation", "Testing". */
-    name: string;
-    description: string;
-    status: PhaseStatus;
-    /** Task graph for this phase. */
-    taskGraph: TaskGraph;
-    /** Previous phase IDs; this phase cannot start until they complete. */
-    dependsOn: string[];
-    /** Next phase IDs. */
-    nextPhases: string[];
-    /** Whether this phase can run in parallel before the previous phase finishes. */
-    parallelizable: boolean;
-    /** Phase priority. */
-    priority: 'critical' | 'high' | 'medium' | 'low';
-    /** Estimated duration in hours. */
-    estimateHours: number;
-    /** Actual duration in milliseconds. */
-    actualDurationMs?: number | undefined;
-    /** Start time. */
-    startedAt?: number | undefined;
-    /** Completion time. */
-    completedAt?: number | undefined;
-    /** Agents assigned to this phase. */
-    assignedAgents: string[];
-    /** Phase metadata. */
-    metadata?: Record<string, unknown> | undefined;
-    createdAt: number;
-    updatedAt: number;
-}
-interface PhaseGraph {
-    id: string;
-    /** Project title. */
-    title: string;
-    description: string;
-    phases: Map<string, PhaseNode>;
-    /** Starting phase IDs. */
-    rootPhaseIds: string[];
-    /** Active phase IDs with running status. */
-    activePhaseIds: string[];
-    /** Completed phase IDs. */
-    completedPhaseIds: string[];
-    /** Failed phase IDs. */
-    failedPhaseIds: string[];
-    /** Whether autonomous mode is active. */
-    autonomous: boolean;
-    /** Stop when all phases complete. */
-    stopOnComplete: boolean;
-    createdAt: number;
-    updatedAt: number;
-    startedAt?: number | undefined;
-    completedAt?: number | undefined;
-}
-interface PhaseProgress {
-    totalPhases: number;
-    pending: number;
-    ready: number;
-    running: number;
-    paused: number;
-    completed: number;
-    failed: number;
-    skipped: number;
-    percentComplete: number;
-    totalTasks: number;
-    completedTasks: number;
-    failedTasks: number;
-    estimatedHours: number;
-    actualHours: number;
-}
-interface PhaseEventMap {
-    'phase.statusChange': {
-        phaseId: string;
-        from: PhaseStatus;
-        to: PhaseStatus;
-    };
-    'phase.started': {
-        phaseId: string;
-        name: string;
-    };
-    'phase.completed': {
-        phaseId: string;
-        name: string;
-        durationMs: number;
-    };
-    'phase.failed': {
-        phaseId: string;
-        name: string;
-        error?: string | undefined;
-    };
-    /** A task began executing — carries the worker agent so boards can show who is on it. */
-    'phase.taskStarted': {
-        phaseId: string;
-        taskId: string;
-        taskTitle: string;
-        agentId?: string | undefined;
-        agentName?: string | undefined;
-    };
-    'phase.taskCompleted': {
-        phaseId: string;
-        taskId: string;
-        taskTitle: string;
-    };
-    'phase.taskFailed': {
-        phaseId: string;
-        taskId: string;
-        taskTitle: string;
-        error: string;
-    };
-    'phase.taskRetrying': {
-        phaseId: string;
-        taskId: string;
-        taskTitle: string;
-        attempt: number;
-        maxRetries: number;
-    };
-    /** A task timed out — exceeded `taskTimeoutMs`. */
-    'phase.taskTimedOut': {
-        phaseId: string;
-        taskId: string;
-        taskTitle: string;
-        timeoutMs: number;
-    };
-    'phase.allTasksDone': {
-        phaseId: string;
-        completed: number;
-        failed: number;
-    };
-    'phase.verifying': {
-        phaseId: string;
-        name: string;
-        attempt: number;
-    };
-    'phase.verifyFailed': {
-        phaseId: string;
-        name: string;
-        attempt: number;
-        error?: string | undefined;
-    };
-    'phase.repairing': {
-        phaseId: string;
-        name: string;
-        attempt: number;
-    };
-    'phase.conflictResolving': {
-        phaseId: string;
-        name: string;
-        files: string[];
-    };
-    'phase.conflictResolved': {
-        phaseId: string;
-        name: string;
-    };
-    'graph.completed': {
-        graphId: string;
-        durationMs: number;
-    };
-    'graph.failed': {
-        graphId: string;
-        failedPhaseId: string;
-        error: string;
-    };
-    'autonomous.tick': {
-        activePhases: string[];
-        queuedPhases: string[];
-    };
-    'agent.assigned': {
-        phaseId: string;
-        agentId: string;
-    };
-    'agent.released': {
-        phaseId: string;
-        agentId: string;
-    };
-    /** A task was moved between phases from an interactive board. */
-    'phase.taskMoved': {
-        taskId: string;
-        fromPhaseId: string;
-        toPhaseId: string;
-    };
-    /** A task was (re)assigned to a specific agent from an interactive board. */
-    'phase.taskAssigned': {
-        phaseId: string;
-        taskId: string;
-        agentId?: string | undefined;
-        agentName?: string | undefined;
-    };
-    /** A task was added to a phase from an interactive board. */
-    'phase.taskAdded': {
-        phaseId: string;
-        taskId: string;
-        taskTitle: string;
-    };
-}
-type PhaseEventName = keyof PhaseEventMap;
-/**
- * All phase event names as a const array. Consumers (TUI, WebUI) should
- * import this rather than hardcoding string literals, so the compiler
- * catches drift when events are added or renamed.
- */
-declare const PHASE_EVENT_NAMES: readonly PhaseEventName[];
-interface PhaseExecutionContext {
-    /**
-     * Execute a task through an AI agent. `env` points to the phase git
-     * worktree when available, so the agent runs in an isolated working directory.
-     */
-    executeTask: (task: TaskNode, phaseId: string, env?: {
-        cwd?: string | undefined;
-        branch?: string | undefined;
-    }) => Promise<unknown>;
-    /**
-     * Optional verification gate. Called after all tasks in a phase finish,
-     * but before the phase is marked "completed" and its worktree is merged
-     * back to the base branch. `env` points to the phase worktree when available;
-     * verification should run in that isolated directory, such as typecheck/test.
-     * If `ok:false` is returned, merge is blocked and `repairPhase` is attempted when available.
-     *
-     * If undefined, the gate is skipped for backward compatibility.
-     */
-    verifyPhase?: ((phase: PhaseNode, env?: {
-        cwd?: string | undefined;
-        branch?: string | undefined;
-    }) => Promise<{
-        ok: boolean;
-        output?: string | undefined;
-    }>) | undefined;
-    /**
-     * Optional repair pass. When `verifyPhase` fails, it is called with the
-     * captured error output. It should try to fix the code in the worktree
-     * for example, through a repair subagent. Its return value is ignored;
-     * the orchestrator reruns `verifyPhase` afterward. It is never called when `verifyPhase` is undefined.
-     */
-    repairPhase?: ((phase: PhaseNode, failure: string, attempt: number, env?: {
-        cwd?: string | undefined;
-        branch?: string | undefined;
-    }) => Promise<void>) | undefined;
-    /**
-     * Optional merge-conflict resolver. Called when a phase worktree conflicts
-     * during squash-merge into the base branch. `info.cwd` points to the base
-     * working tree where conflict markers exist; the resolver should clean those
-     * markers and return `true`. On success the merge is committed; otherwise
-     * the merge is aborted and the worktree is kept in `needs-review`.
-     * If undefined, conflicts keep the old parked-for-review behavior.
-     */
-    resolveConflict?: ((phase: PhaseNode, info: {
-        conflictFiles: string[];
-        cwd: string;
-    }) => Promise<boolean>) | undefined;
-    /** Optional global Brain arbiter for the policy, decision, and escalation layer. */
-    brain?: BrainArbiter | undefined;
-    /** Called when a phase completes. */
-    onPhaseComplete?: ((phase: PhaseNode) => void) | undefined;
-    /** Called when a phase fails. */
-    onPhaseFail?: ((phase: PhaseNode, error: Error) => void) | undefined;
-    /** Called on every tick in autonomous mode. */
-    onTick?: ((ctx: {
-        activePhases: PhaseNode[];
-        readyPhases: PhaseNode[];
-    }) => void) | undefined;
-}
-interface AutoPhaseOptions {
-    /** Maximum number of parallel phases. */
-    maxConcurrentPhases?: number | undefined;
-    /** Maximum number of parallel tasks within a phase. */
-    maxConcurrentTasks?: number | undefined;
-    /** Retry count for failed tasks. */
-    maxRetries?: number | undefined;
-    /**
-     * Maximum number of repair attempts after the verification gate fails.
-     * Total verification runs = maxVerifyAttempts + 1: the first run plus one
-     * rerun after each repair. Defaults to 2. Has no effect without `verifyPhase`.
-     */
-    maxVerifyAttempts?: number | undefined;
-    /** Autonomous mode: automatically advance as phases complete. */
-    autonomous?: boolean | undefined;
-    /** Delay between phases in milliseconds. */
-    phaseDelayMs?: number | undefined;
-    /** Stop when a phase fails. */
-    stopOnFailure?: boolean | undefined;
-    /**
-     * Per-task timeout in milliseconds. A single task exceeding this
-     * is marked failed and `phase.taskTimedOut` is emitted.
-     * Defaults to 600_000 (10 min). Set to 0 to disable.
-     */
-    taskTimeoutMs?: number | undefined;
-    /** Event bus */
-    events?: EventBus | undefined;
-    /**
-     * Optional git-worktree manager. When provided, each phase runs in its own
-     * isolated worktree and branch, then is squash-merged back into the base
-     * branch in order. Without it, behavior is unchanged and uses the shared working tree.
-     */
-    worktrees?: WorktreeManager | undefined;
-}
-interface PhaseFilter {
-    status?: PhaseStatus[] | undefined;
-    priority?: PhaseNode['priority'][] | undefined;
-}
-interface PhaseSort {
-    field: 'priority' | 'createdAt' | 'startedAt' | 'completedAt';
-    direction: 'asc' | 'desc';
-}
-interface PhaseTemplate {
-    name: string;
-    description: string;
-    priority: PhaseNode['priority'];
-    estimateHours: number;
-    parallelizable: boolean;
-    /** Task templates to create automatically. */
-    taskTemplates?: Array<{
-        title: string;
-        description: string;
-        type: TaskType;
-        priority: TaskPriority;
-        estimateHours: number;
-        tags?: string[] | undefined;
-    }>;
-}
-
-interface AutoPhaseRunnerOptions extends AutoPhaseOptions {
-    /** Project title. */
-    title: string;
-    description?: string | undefined;
-    /** Phase templates. */
-    phases: PhaseTemplate[];
-    /** Function that executes a task. */
-    executeTask: PhaseExecutionContext['executeTask'];
-    /** Optional verification gate. */
-    verifyPhase?: PhaseExecutionContext['verifyPhase'] | undefined;
-    /** Optional repair pass after verification failure. */
-    repairPhase?: PhaseExecutionContext['repairPhase'] | undefined;
-    /** Optional resolver for worktree merge conflicts. */
-    resolveConflict?: PhaseExecutionContext['resolveConflict'] | undefined;
-    /** Optional Brain arbiter. */
-    brain?: PhaseExecutionContext['brain'] | undefined;
-    /** Called when a phase completes. */
-    onPhaseComplete?: ((phase: PhaseNode) => void) | undefined;
-    /** Called when a phase fails. */
-    onPhaseFail?: (phase: PhaseNode, error: Error) => void;
-    /** Called on every orchestrator tick. */
-    onTick?: (ctx: {
-        activePhases: PhaseNode[];
-        readyPhases: PhaseNode[];
-    }) => void;
-    /** Called when progress changes. */
-    onProgress?: ((progress: PhaseProgress) => void) | undefined;
-    /** Safety net that stops a phase graph if cleanup is bypassed. Default: 24h. */
-    maxRunDurationMs?: number | undefined;
-    /** Called when the graph completes. */
-    onComplete?: ((graph: PhaseGraph) => void) | undefined;
-    /** Called when the graph fails. */
-    onFail?: (graph: PhaseGraph, failedPhase: PhaseNode, error: Error) => void;
-}
-/**
- * AutoPhaseRunner - high-level API for managing the whole autonomous phase flow from one entry point.
- *
- * Usage:
- *   const runner = new AutoPhaseRunner({
- *     title: 'Auth Refactor',
- *     phases: [...],
- *     executeTask: async (task, phaseId) => { ... },
- *     onProgress: (p) => console.log(`${p.percentComplete}% done`),
- *   });
- *   await runner.start();
- */
-declare class AutoPhaseRunner {
-    private graph;
-    private orchestrator;
-    private opts;
-    private progressInterval;
-    private maxRunTimer;
-    private readonly graphCompletedHandler;
-    private readonly graphFailedHandler;
-    /** Stores the unsubscribe function returned by EventBus.on() */
-    private unsubscribeCompleted;
-    private unsubscribeFailed;
-    constructor(opts: AutoPhaseRunnerOptions);
-    start(): Promise<PhaseGraph>;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-    getProgress(): PhaseProgress | null;
-    getGraph(): PhaseGraph | null;
-    isRunning(): boolean;
-    isPaused(): boolean;
-    assignAgent(phaseId: string, agentId: string): void;
-    releaseAgent(phaseId: string, agentId: string): void;
-    private cleanup;
-}
-/**
- * Quick-start helper: create an AutoPhaseRunner from an existing TaskGraph.
- */
-declare function createAutoPhaseFromTaskGraph(taskGraph: TaskGraph, options: Omit<AutoPhaseRunnerOptions, 'phases' | 'title'> & {
-    title?: string | undefined;
-    tasksPerPhase?: number | undefined;
-}): Promise<AutoPhaseRunner>;
-
-interface PhaseOrchestratorOptions extends AutoPhaseOptions {
-    graph: PhaseGraph;
-    ctx: PhaseExecutionContext;
-}
-/**
- * PhaseOrchestrator - dependency-aware engine for running phases autonomously.
- *
- * Features:
- * - Automatically starts the next phase as each phase completes in autonomous mode
- * - Supports parallel phases with parallelizable=true
- * - Assigns and releases agents
- * - Integrates with the event bus
- * - Supports pause and resume
- */
-declare class PhaseOrchestrator {
-    private graph;
-    private ctx;
-    private opts;
-    private events;
-    private stopped;
-    private paused;
-    private runningPhases;
-    private tickInterval;
-    private trackerCache;
-    private taskRetryCounts;
-    private readonly worktrees?;
-    /** Per-phase worktree handles, keyed by phase id. */
-    private readonly phaseWorktrees;
-    /** Serializes all merges back to the base branch (one at a time). */
-    private mergeQueue;
-    /** Per-phase merge promise, so a phase merges only after its deps do. */
-    private readonly phaseMergePromise;
-    constructor(opts: PhaseOrchestratorOptions);
-    /**
-     * Start the full phase flow.
-     * In autonomous mode, starts root phases and automatically starts the next phase when they finish.
-     */
-    start(): Promise<void>;
-    /**
-     * Make a (possibly resumed) graph runnable. A graph loaded from disk after an
-     * interrupted run can carry transient state from the dead process: phases left
-     * `running` and tasks left `in_progress`. The scheduler only starts `pending`
-     * phases (getReadyPhases) and only runs `pending` tasks (getExecutableTasks),
-     * so without this a resumed phase/task would stall forever. Reset that
-     * transient state to `pending`; terminal phases (completed/failed/skipped) and
-     * already-completed tasks are untouched, so completed work is never re-run.
-     * For a freshly built graph this is a no-op.
-     */
-    private normalizeForResume;
-    /** Wait for all pending phase merges, dependency-ordered and globally serialized. */
-    private drainMerges;
-    /** Pause: active phases continue, but no new phase starts. */
-    pause(): void;
-    /** Resume: new phases may start again. */
-    resume(): void;
-    /** Stop completely, including active phases. */
-    stop(): void;
-    private tick;
-    private startPhase;
-    /**
-     * Run the verification gate for a phase whose tasks all succeeded. Verifies in
-     * the phase's worktree; on failure, runs the repair pass and re-verifies, up to
-     * `maxVerifyAttempts` repairs. Returns the final verdict. When no `verifyPhase`
-     * callback is wired the gate is a no-op and always passes.
-     */
-    private runVerifyGate;
-    /** Worktree env (cwd/branch) for a phase, or undefined if it runs on the shared tree. */
-    private worktreeEnv;
-    /** Shared failure bookkeeping for a phase whose tasks ran but the phase failed. */
-    private failPhaseAfterTasks;
-    /**
-     * A phase whose tasks all succeeded was marked `completed` and queued for
-     * merge, but the merge back into the base branch failed. Its work is NOT
-     * integrated, so correct the graph: move the phase out of `completedPhaseIds`
-     * into `failedPhaseIds` and flip its status to `failed`. Without this the
-     * persisted graph (and the board) would claim the phase succeeded while a
-     * `phase.failed` event fired — an inconsistency that hides un-merged work.
-     * Idempotent: safe to call more than once for the same phase.
-     */
-    private markPhaseMergeFailed;
-    /** Trim long verifier output so it fits cleanly in an event/error message. */
-    private truncate;
-    /**
-     * Commit the phase's worktree changes, then enqueue the merge back into the
-     * base branch. Merges run dependency-ordered (a phase merges only after its
-     * `dependsOn` phases) and globally serialized (one at a time) to avoid
-     * concurrent writes to the base tree.
-     */
-    private commitAndEnqueueMerge;
-    /**
-     * Squash-merge one phase. When a `resolveConflict` callback is wired, a merge
-     * conflict is handed to it (a resolver subagent) before giving up; only if
-     * that fails does the worktree fall to needs-review and the run continues.
-     */
-    private mergeOne;
-    private shouldAttemptConflictResolution;
-    private setIntegrationMetadata;
-    /** A failed phase keeps its worktree on disk for inspection (no merge). */
-    private keepWorktreeForReview;
-    private executePhaseTasks;
-    private executeSingleTask;
-    private markTaskCompleted;
-    private markTaskFailed;
-    private getReadyPhases;
-    private getActivePhases;
-    private getExecutableTasks;
-    private getTrackerForPhase;
-    private getFailedTaskCount;
-    private getCompletedTaskCount;
-    private updatePhaseStatus;
-    private isComplete;
-    private onGraphComplete;
-    private onGraphFailed;
-    getProgress(): PhaseProgress;
-    getGraph(): PhaseGraph;
-    isRunning(): boolean;
-    isPaused(): boolean;
-    assignAgent(phaseId: string, agentId: string): void;
-    releaseAgent(phaseId: string, agentId: string): void;
-    /** Find the phase whose task graph currently holds `taskId`. */
-    findPhaseOfTask(taskId: string): PhaseNode | undefined;
-    /**
-     * Move a task to another phase's task graph. Edges that referenced the task
-     * are dropped (cross-phase dependencies are not modeled). No-op when the task
-     * or target phase is missing, or it is already in the target phase.
-     */
-    moveTask(taskId: string, toPhaseId: string): boolean;
-    /** (Re)assign a task to a specific agent (or clear with agentName/agentId omitted). */
-    setTaskAssignee(taskId: string, agentId?: string, agentName?: string): boolean;
-    /** Add a new task to a phase. Returns the created task id, or null if the phase is missing. */
-    addTask(phaseId: string, spec: {
-        title: string;
-        description?: string | undefined;
-        type?: TaskNode['type'] | undefined;
-        priority?: TaskNode['priority'] | undefined;
-    }): string | null;
-    /**
-     * Requeue a task to `pending` (clearing its retry counter) and nudge a
-     * terminal/paused phase back to `ready` so the loop re-runs it. Backs both the
-     * board's "retry" and "start" affordances.
-     */
-    requeueTask(taskId: string): boolean;
-    private emit;
-    private createNoopEventBus;
-    private waitWhilePaused;
-    private delay;
-}
-
-interface PhaseGraphBuilderOptions {
-    title: string;
-    description?: string | undefined;
-    /** Ordered phase templates. */
-    phases: PhaseTemplate[];
-    /** Autonomous mode. */
-    autonomous?: boolean | undefined;
-    /** Stop on failure. */
-    stopOnFailure?: boolean | undefined;
-    /** Optional external TaskStore. */
-    externalTaskStore?: TaskStore | undefined;
-}
-/**
- * PhaseGraphBuilder - builds project phases and a task graph for each phase.
- *
- * Usage:
- *   const builder = new PhaseGraphBuilder({
- *     title: 'Auth System Refactor',
- *     phases: [
- *       { name: 'Discovery', description: '...', priority: 'high', estimateHours: 2, parallelizable: false },
- *       { name: 'Design', description: '...', priority: 'critical', estimateHours: 4, parallelizable: false },
- *       { name: 'Implementation', description: '...', priority: 'critical', estimateHours: 12, parallelizable: false },
- *       { name: 'Testing', description: '...', priority: 'high', estimateHours: 6, parallelizable: true },
- *       { name: 'Deployment', description: '...', priority: 'medium', estimateHours: 2, parallelizable: false },
- *     ]
- *   });
- *   const graph = await builder.build();
- */
-declare class PhaseGraphBuilder {
-    private readonly opts;
-    constructor(opts: PhaseGraphBuilderOptions);
-    build(): Promise<PhaseGraph>;
-    /**
-     * Create phases from an existing TaskGraph.
-     * Groups tasks into phases using topological sort so dependencies
-     * stay in the same phase wherever possible.
-     */
-    static fromTaskGraph(taskGraph: TaskGraph, options: Omit<PhaseGraphBuilderOptions, 'phases'> & {
-        /** Number of tasks per phase. Defaults to 5. */
-        tasksPerPhase?: number | undefined;
-    }): Promise<PhaseGraph>;
-}
-
-/**
- * AutoPhasePlanner - converts a goal into phases using a real LLM call,
- * producing a large task list with todos under each phase.
- *
- * Similar to SDD's spec-to-task flow, but different: the output is directly
- * `PhaseTemplate[]`; each phase carries `taskTemplates`, so
- * `PhaseGraphBuilder` produces a populated `PhaseGraph` and `PhaseOrchestrator`
- * runs each task through a real agent execution.
- *
- * The planner is not tied to a specific LLM: callers provide a `runOnce(prompt)` function
- * (a subagent run in the CLI, or a deterministic stub in tests).
- */
-
-interface AutoPhasePlannerOptions {
-    /**
-     * One-shot LLM call: receives a prompt and returns the model text output.
-     * In the CLI this wraps subagent.run; in tests it can be a deterministic stub.
-     */
-    runOnce: (prompt: string) => Promise<string>;
-    /** Goal or project title. */
-    goal: string;
-    /** Optional project context such as package.json or directory structure. */
-    projectContext?: string | undefined;
-    /** Requested minimum phase count. Defaults to 3. */
-    minPhases?: number | undefined;
-    /** Requested maximum phase count. Defaults to 8. */
-    maxPhases?: number | undefined;
-    /** Target todo count per phase. Defaults to 6. */
-    todosPerPhase?: number | undefined;
-    /**
-     * Maximum total tasks across all phases. When set, plans exceeding
-     * this limit will have `budgetExceeded: true` and `warnings` will
-     * describe the overage. Defaults to 0 (no limit).
-     */
-    maxTotalTasks?: number | undefined;
-}
-interface AutoPhasePlanResult {
-    /** Phase templates passed to PhaseGraphBuilder. */
-    phases: PhaseTemplate[];
-    /** Raw model output for debugging and logs. */
-    raw: string;
-    /** True when JSON could not be parsed; `phases` is empty in that case. */
-    parseFailed: boolean;
-    /** Validation warnings collected during coercion (e.g. invalid priority defaults). */
-    warnings: string[];
-    /**
-     * Rough cost estimate (in tokens) for executing this plan.
-     * Based on estimated task count × average per-task LLM round-trip.
-     */
-    estimatedCostTokens?: number | undefined;
-    /** True when the plan exceeds `maxTotalTasks` budget. */
-    budgetExceeded?: boolean | undefined;
-}
-/**
- * AutoPhasePlanner drives the model through `plan()` and produces `PhaseTemplate[]`.
- */
-declare class AutoPhasePlanner {
-    private readonly opts;
-    constructor(opts: AutoPhasePlannerOptions);
-    /** Convert the goal into a phase-and-todo plan. */
-    plan(): Promise<AutoPhasePlanResult>;
-    /** Instruction prompt for the plan the model should produce. */
-    buildPrompt(): string;
-    /** Extract JSON from raw output, validate it, and convert it to PhaseTemplate[].
-     *  Returns `{ phases, warnings }` where warnings describe coerced defaults. */
-    parse(raw: string): {
-        phases: PhaseTemplate[];
-        warnings: string[];
-    };
-    private coercePhase;
-    private coerceTask;
-}
-
-interface PhaseStoreOptions {
-    baseDir: string;
-}
-/**
- * PhaseStore - persistence layer for saving and loading PhaseGraph objects on disk.
- */
-declare class PhaseStore {
-    readonly baseDir: string;
-    constructor(opts: PhaseStoreOptions);
-    save(graph: PhaseGraph): Promise<void>;
-    load(graphId: string): Promise<PhaseGraph | null>;
-    delete(graphId: string): Promise<void>;
-    list(): Promise<Array<{
-        id: string;
-        title: string;
-        updatedAt: number;
-        status: string;
-    }>>;
-    private getFilePath;
-    private serializeGraph;
-    private serializePhase;
-    private serializeTaskGraph;
-    private serializeTaskNode;
-    private deserializeGraph;
-    private deserializePhase;
-    private deserializeTaskGraph;
-}
-
-interface Checkpoint {
-    id: string;
-    graphId: string;
-    phaseId: string;
-    phaseStatus: PhaseNode['status'];
-    taskStatuses: Array<{
-        taskId: string;
-        status: string;
-        title: string;
-    }>;
-    timestamp: number;
-    label?: string | undefined;
-}
-interface CheckpointManagerOptions {
-    store: PhaseStore;
-    maxCheckpoints?: number | undefined;
-    /** Max age in ms before a checkpoint is eligible for TTL-based pruning. Default: 7 days. */
-    maxCheckpointAgeMs?: number | undefined;
-    baseDir?: string | undefined;
-}
-/**
- * CheckpointManager - saves and restores snapshots of the phase graph.
- *
- * Usage:
- *   const cm = new CheckpointManager({ store });
- *   await cm.saveCheckpoint(graph, 'Before risky refactor');
- *   // ... if something goes wrong ...
- *   const restored = await cm.restoreCheckpoint(checkpointId);
- */
-declare class CheckpointManager {
-    private store;
-    private maxCheckpoints;
-    private maxCheckpointAgeMs;
-    private checkpoints;
-    private baseDir;
-    constructor(opts: CheckpointManagerOptions);
-    initialize(): Promise<void>;
-    saveCheckpoint(graph: PhaseGraph, label?: string): Promise<Checkpoint>;
-    restoreCheckpoint(checkpointId: string): Promise<PhaseGraph | null>;
-    listCheckpoints(graphId?: string): Checkpoint[];
-    deleteCheckpoint(checkpointId: string): Promise<boolean>;
-    private saveToDisk;
-    private deleteFromDisk;
-    private loadFromDisk;
-    private pruneCheckpoints;
-}
-
-/**
- * Options for {@link bootConfig}. Both the CLI and the WebUI server boot the
- * same way; the only intentional differences are the label used in the
- * plaintext-secret migration notice and whether CLI flags are supplied.
- */
-interface BootConfigOptions {
-    /**
-     * Parsed CLI flags. `cwd` relocates path resolution; `provider`/`model`/
-     * `log-level`/`verbose`/`trace`/`yolo`/`no-features` are patched into the
-     * loaded config (see {@link flagsToConfigPatch}). Defaults to `{}` (the
-     * WebUI server passes no flags).
-     */
-    flags?: Record<string, string | boolean>;
-    /**
-     * Label shown in the `[<label>] Encrypted N plaintext secret(s) in FILE`
-     * stderr notice emitted when legacy plaintext secrets get auto-encrypted.
-     * The CLI passes `wstack`; the WebUI server passes `WebUI`. Default
-     * `wstack`.
-     */
-    appLabel?: string | undefined;
-    /**
-     * Load `~/.wrongstack/sync.json` and merge it into `config.sync` so the
-     * ConfigStore starts with the correct CloudSync state. Default `true`.
-     */
-    loadSyncConfig?: boolean | undefined;
-    /**
-     * Skip the provider/model identity validation during config load. When
-     * `true`, a missing provider or model in config does NOT throw — the
-     * boot caller is responsible for handling the missing-provider case
-     * (e.g. showing a setup screen). Used by `--webui` mode so the WebUI
-     * can boot without a configured provider and show the setup screen.
-     */
-    skipIdentityValidation?: boolean | undefined;
-}
-/**
- * Everything the boot phase resolves before DI-container wiring. Superset of
- * what the CLI and WebUI server each consumed previously, so both can pick the
- * fields they need from a single canonical result.
- */
-interface BootConfigResult {
-    cwd: string;
-    projectRoot: string;
-    userHome: string;
-    wpaths: WstackPaths;
-    pathResolver: DefaultPathResolver;
-    config: Config;
-    vault: DefaultSecretVault;
-    logger: DefaultLogger;
-    /** Convenience alias for `wpaths.globalConfig`. */
-    globalConfigPath: string;
-}
-/**
- * Canonical boot routine shared by `@wrongstack/cli` and `@wrongstack/webui`.
- * Resolves paths, creates the real AES-GCM secret vault, migrates any
- * plaintext secrets, loads + merges config (with CLI-flag overrides and an
- * optional sync overlay), and builds a logger.
- *
- * The per-package `bootConfig()` wrappers re-shape this result into their own
- * legacy return types for backward compatibility — keep this the single source
- * of boot behavior so the two consumers can't drift.
- */
-declare function bootConfig(options?: BootConfigOptions): Promise<BootConfigResult>;
-/**
- * Translate parsed CLI flags into a partial Config patch applied on top of the
- * file-loaded config. Explicit `--log-level` wins over `--verbose`/`--trace`.
- */
-declare function flagsToConfigPatch(flags: Record<string, string | boolean>): Partial<Config>;
-
-/**
- * CollaborationBus — kernel-level pause/resume signal for the
- * collaboration `controller` role (Phase 3 of idea #13 from IDEAS.md).
- *
- * The bus is a single-process singleton. The webui server (which hosts
- * the agent loop) creates one at boot, passes it to both the agent's
- * `toolCall` pipeline (as a middleware) and the `CollaborationWsHandler`
- * (which toggles it on client requests).
- *
- * Semantics:
- *   - `requestPause(by)` flips the bus into the "paused" state. The
- *     state has no timeout of its own — the *middleware* decides how
- *     long to wait before auto-resuming (default 60s).
- *   - `resume()` returns the bus to the running state. Idempotent:
- *     calling resume() when not paused is a no-op returning `false`.
- *   - `waitForResume(timeoutMs)` is what the middleware calls. It
- *     returns `true` if the bus was resumed in time, `false` if the
- *     timeout fired (in which case it also auto-resumes, so the agent
- *     loop is never permanently stuck).
- *   - `getState()` returns a snapshot for observability surfaces
- *     (UI badges, CLI `/collab status`).
- *
- * Why a separate bus object rather than putting state on RunController?
- *
- *   - The RunController is per-run; the bus is per-process. A single
- *     pause signal across the whole webui process is the right
- *     granularity (the webui hosts exactly one Agent.run at a time).
- *   - The bus can be unit-tested without spinning up an Agent. The
- *     middleware can be tested by injecting a fake bus.
- *   - Future multi-session webui (when the bus is upgraded to filter
- *     by sessionId) does not require touching the agent loop — the
- *     middleware already receives the sessionId in its payload.
- */
-type CollabBusState = {
-    paused: boolean;
-    pausedAt: string | null;
-    pausedBy: string | null;
-};
-declare class CollaborationBus {
-    private pausePromise;
-    private pauseResolve;
-    private pausedAtMs;
-    private pausedBy;
-    isPaused(): boolean;
-    getState(): CollabBusState;
-    /**
-     * Pause the agent loop. Idempotent: a second `requestPause` while
-     * already paused is a no-op (the original pause wins; we do not
-     * overwrite `pausedBy`). Returns true when the state actually
-     * transitioned, false when it was already paused.
-     */
-    requestPause(byParticipant: string): boolean;
-    /**
-     * Resume the agent loop. Returns true when the state actually
-     * transitioned from paused → running, false when it was already
-     * running (no-op).
-     */
-    resume(): boolean;
-    /**
-     * Block until the bus is resumed or the timeout fires. Returns:
-     *   - `true`  → bus was resumed in time
-     *   - `false` → timeout fired; bus was auto-resumed as a side effect
-     *
-     * When `timeoutMs` is `0` the wait is unbounded (the middleware must
-     * be paired with an external AbortSignal in that case — we don't
-     * expose one here to keep the API simple).
-     */
-    waitForResume(timeoutMs: number): Promise<boolean>;
-    private readonly injectionQueue;
-    private onConsumed?;
-    /**
-     * Register a listener fired when `collabInjectMiddleware` actually splices a
-     * queued injection into a tool call (Phase 4 feedback loop). The webui's
-     * CollaborationWebSocketHandler uses it to broadcast a
-     * `collab.injection.granted` with phase `'consumed'` so observers learn the
-     * injection was applied (and to which real tool). Last registration wins.
-     */
-    onInjectionConsumed(fn: (info: ConsumedInjectionInfo) => void): void;
-    /**
-     * Invoked by `collabInjectMiddleware` immediately after it replaces a tool
-     * call's result with a queued injection. No-op when no listener is set.
-     */
-    notifyInjectionConsumed(info: ConsumedInjectionInfo): void;
-    /**
-     * Queue a manual tool result. The next time the agent's toolCall
-     * pipeline sees a matching `toolUse.id`, the
-     * `collabInjectMiddleware` consumes this entry and replaces the
-     * real tool execution. Returns `false` if an injection for the
-     * same id is already queued (idempotent — first write wins).
-     */
-    injectToolResult(input: InjectedToolResult): boolean;
-    /**
-     * Pop an injection from the queue. Returns the payload (and
-     * removes it) if one is pending, or `null` when nothing matches.
-     * Called by the middleware on every tool call.
-     */
-    takeInjection(toolUseId: string): InjectedToolResult | null;
-    /** Inspect the queue size (for observability / tests). */
-    pendingInjectionCount(): number;
-}
-/**
- * Payload for a queued manual tool-call injection. The middleware
- * splices this into the toolCall pipeline as a synthetic result.
- */
-interface InjectedToolResult {
-    toolUseId: string;
-    /** Serialized content the model will see (string, JSON, etc.). */
-    content: unknown;
-    /** When true, the result is rendered as a tool error. */
-    isError: boolean;
-    /**
-     * Free-form context surfaced in the broadcast and the audit log,
-     * e.g. "controller: read returned the right file but with these
-     * contents" or "controller: skipped the destructive bash call".
-     */
-    reason: string;
-    /** Participant id of the controller who issued the injection. */
-    authorId: string;
-}
-/**
- * Emitted to `onInjectionConsumed` listeners when the middleware splices a
- * queued injection into a real tool call. Carries the resolved tool NAME
- * (unknown at queue time — the injection is keyed only by tool_use_id).
- */
-interface ConsumedInjectionInfo {
-    toolUseId: string;
-    toolName: string;
-    authorId: string;
-    reason: string;
-    isError: boolean;
-}
-
-/**
- * commit-safety — detect when a commit would sweep up work that this session
- * did NOT author.
- *
- * When several coding agents (or a separate wrongstack process, or a human)
- * edit the same worktree at once, a blanket `git add .` / commit-all captures
- * everyone's uncommitted changes — including half-finished work from another
- * agent. There is no way to un-bake that once it lands in a shared commit.
- *
- * This module reads the working tree and cross-references it against the
- * per-project {@link file-author-tracker} log (which records the sessionId that
- * created/edited each file). Dirty files whose latest author is a DIFFERENT
- * session are flagged as "foreign"; dirty files with no recorded author are
- * "unverified" (a concurrent non-wrongstack agent, a build/format step, or a
- * human). The result is a plain-text warning callers render before committing.
- *
- * Warn-only by design: this never blocks or rewrites what gets committed — it
- * surfaces the risk so the agent (or user) can scope the commit to its own
- * files or coordinate first.
- *
- * @module commit-safety
- */
-interface CommitSafetyOptions {
-    /** Directory to run git in (the agent's cwd is fine). */
-    cwd: string;
-    /** Project root, used to locate the file-author log. */
-    projectRoot: string;
-    /**
-     * The current session's id — the "self" key. Dirty files authored by a
-     * different sessionId are flagged as foreign. When omitted, every authored
-     * file counts as foreign (we cannot prove ownership).
-     */
-    sessionId?: string | undefined;
-    /**
-     * Directory holding the file-author log. Defaults to the resolved per-project
-     * dir (`~/.wrongstack/projects/<slug>`). Mainly an injection seam for tests.
-     */
-    storageDir?: string | undefined;
-    /** Abort signal for the git subprocesses. */
-    signal?: AbortSignal | undefined;
-}
-interface ForeignFile {
-    /** Repo-relative path. */
-    path: string;
-    /** Human-readable name of the agent that last authored it, if known. */
-    agentName?: string | undefined;
-    /** Session that last authored it, if known. */
-    sessionId?: string | undefined;
-}
-interface CommitSafetyReport {
-    /** Total uncommitted (staged + unstaged + untracked) paths. */
-    dirtyCount: number;
-    /** Dirty files whose latest recorded author is a DIFFERENT session. */
-    foreignFiles: ForeignFile[];
-    /** Dirty files with no recorded author for any session. */
-    unverifiedFiles: string[];
-    /** Branch names of OTHER active worktrees of this repo (excludes ours). */
-    otherWorktrees: string[];
-    /**
-     * Pre-formatted, plain-text (no ANSI) multi-line warning, or '' when there
-     * is nothing notable to surface. Callers may colorize/wrap as they see fit.
-     */
-    warning: string;
-}
-/**
- * Assess whether committing now risks capturing another agent's work.
- *
- * Best-effort: any git failure (not a repo, git missing, timeout) yields an
- * empty report rather than throwing — commit-safety must never break a commit.
- */
-declare function assessCommitSafety(opts: CommitSafetyOptions): Promise<CommitSafetyReport>;
-
-/**
- * file-author-tracker — JSON-based tracking of which agent created/edited files.
- *
- * Stores a per-project JSON log in the global project directory:
- *   ~/.wrongstack/projects/<slug-hash>/file-authors.json
- *
- * Each entry records: file path, action (create|edit), agent id/name,
- * timestamp, and optional session id.
- *
- * Used by the tech-stack agent and other coordination tools to know
- * who touched what, so warnings can be routed to the right agent.
- *
- * @module file-author-tracker
- */
-interface FileAuthorEntry {
-    /** Absolute or relative file path. */
-    filePath: string;
-    /** What happened to the file. */
-    action: 'create' | 'edit' | 'delete';
-    /** Agent id (e.g. 'leader', 'tech-stack', 'executor'). */
-    agentId: string;
-    /** Human-readable agent name. */
-    agentName?: string | undefined;
-    /** Session that performed the action. */
-    sessionId?: string | undefined;
-    /** ISO8601 timestamp. */
-    timestamp: string;
-    /** Optional commit hash if known. */
-    commitHash?: string | undefined;
-}
-interface FileAuthorLog {
-    /** Project root this log belongs to. */
-    projectRoot: string;
-    /** All entries, newest last. */
-    entries: FileAuthorEntry[];
-    /** Last time the log was compacted (old entries archived). */
-    lastCompactedAt?: string | undefined;
-}
-interface FileAuthorTrackerOptions {
-    /** Directory where the JSON log is stored. Usually the global project dir. */
-    storageDir: string;
-    /** Project root for reference. */
-    projectRoot: string;
-    /** Max entries before auto-compaction. Default: 5000. */
-    maxEntries?: number | undefined;
-}
-/**
- * Record that an agent created, edited, or deleted a file.
- */
-declare function recordFileAction(opts: FileAuthorTrackerOptions, entry: Omit<FileAuthorEntry, 'timestamp'>): Promise<void>;
-/**
- * Get the most recent author entry for a given file path.
- * Returns undefined if no entry exists.
- */
-declare function getLastAuthor(opts: Pick<FileAuthorTrackerOptions, 'storageDir' | 'projectRoot'>, filePath: string): Promise<FileAuthorEntry | undefined>;
-/**
- * Get all entries for a file, newest last.
- */
-declare function getFileHistory(opts: Pick<FileAuthorTrackerOptions, 'storageDir' | 'projectRoot'>, filePath: string): Promise<FileAuthorEntry[]>;
-/**
- * Get all files last touched by a specific agent.
- */
-declare function getFilesByAgent(opts: Pick<FileAuthorTrackerOptions, 'storageDir' | 'projectRoot'>, agentId: string): Promise<Map<string, FileAuthorEntry>>;
-/**
- * Return the full log (for debugging/auditing).
- */
-declare function getFullLog(opts: Pick<FileAuthorTrackerOptions, 'storageDir' | 'projectRoot'>): Promise<FileAuthorLog>;
-/**
- * Compact the log by archiving old entries to a separate file.
- * Keeps the most recent `keepCount` entries in the active log.
- */
-declare function compactLog(opts: Pick<FileAuthorTrackerOptions, 'storageDir' | 'projectRoot'>, keepCount?: number): Promise<{
-    archived: number;
-    kept: number;
-}>;
-
-/**
- * Subagent nickname pool — famous scientists, mathematicians, and computing pioneers.
- * Names are grouped by domain affinity so the nickname hints at the agent's role.
- */
-/** Result of a nickname assignment. */
-interface NicknameAssignment {
-    /**
-     * Canonical pool key (e.g. `von-neumann`). This — NOT the display string — is
-     * what callers must add to their `used` set and later remove on release.
-     * Deriving the key by parsing the display string is unsafe: multi-word names
-     * like "Von Neumann" would be truncated to "von" and never dedupe correctly.
-     */
-    key: string;
-    /** Human display string, e.g. `Von Neumann (Backend)`. */
-    display: string;
-}
-/**
- * Assign a unique nickname to a subagent based on its role.
- *
- * Returns both the canonical pool `key` (for the `used` set) and the formatted
- * `display` string (`Name (Role)`, e.g. `Einstein (Bug Hunter)`).
- *
- * @param role - The subagent's role id (e.g. 'bug-hunter', 'security-scanner')
- * @param used - Set of nickname KEYS already assigned in this fleet
- *               (so no two subagents share the same base name)
- */
-declare function assignNickname(role: string, used: ReadonlySet<string>): NicknameAssignment;
-/**
- * Resolve a previously-assigned display string back to its canonical pool key,
- * for release paths that only retained the formatted name (e.g. a manifest
- * entry). Strips the trailing ` (Role)` suffix, then matches the base name
- * against the pool. Returns `undefined` when the name is not a known nickname.
- *
- * Use this instead of `name.split(' ')[0]` — the latter mangles multi-word
- * names like "Von Neumann" and "Berners-Lee".
- */
-declare function nicknameKeyFromDisplay(display: string): string | undefined;
-
-/**
- * techstack-mailbox-consumer — Auto-spawns the tech-stack agent when
- * dep-watcher messages land in the mailbox.
- *
- * This module runs a lightweight polling loop that checks the mailbox
- * for unread `assign` messages directed at the `tech-stack` agent.
- * When found, it invokes the provided `onSpawn` callback to spawn a
- * tech-stack subagent, passing the manifest path as the task.
- *
- * The consumer also records file-author entries when it detects that
- * a manifest was edited, so the tech-stack agent knows who to warn.
- *
- * @module techstack-mailbox-consumer
- */
-
-interface TechStackConsumerOptions {
-    /** The mailbox to poll. */
-    mailbox: Mailbox;
-    /** Called when a tech-stack agent should be spawned. Receives the task description. */
-    onSpawn: (task: string, name: string) => Promise<{
-        subagentId: string;
-        taskId: string;
-    }>;
-    /** Agent id that the consumer watches for. Default: 'tech-stack'. */
-    targetAgent?: string | undefined;
-    /** Agent id that sends the completion ack. Default: 'tech-stack-consumer'. */
-    consumerAgentId?: string | undefined;
-    /** Polling interval in ms. Default: 5000. */
-    pollIntervalMs?: number | undefined;
-    /** File-author tracker config (for recording manifest edits). */
-    fileAuthorOpts?: FileAuthorTrackerOptions | undefined;
-    /** Current session id (for file-author entries). */
-    sessionId?: string | undefined;
-    /** Current agent id (for file-author entries). */
-    currentAgentId?: string | undefined;
-    /** Current agent name (for file-author entries). */
-    currentAgentName?: string | undefined;
-    /** Called on each poll cycle for logging. */
-    onLog?: ((msg: string) => void) | undefined;
-    /** Called when an error occurs. */
-    onError?: ((err: unknown) => void) | undefined;
-}
-/**
- * Start the mailbox consumer loop.
- *
- * Returns a dispose function that stops polling and cleans up.
- */
-declare function startTechStackConsumer(opts: TechStackConsumerOptions): () => void;
-
-/**
- * `/btw` — non-aborting mid-run steering ("by the way").
- *
- * Unlike `/steer` (which aborts the current iteration and prepends a heavy
- * STEERING preamble), `/btw` stashes a short note on the live `Context` and
- * lets the agent pick it up at the NEXT iteration boundary — between tool
- * batches — without tearing down in-flight work.
- *
- * Flow:
- *  1. The `/btw <text>` slash command calls `setBtwNote(ctx, text)` on the
- *     live run context. Multiple notes accumulate in order.
- *  2. At the top of each agent iteration (before the request is built),
- *     `Agent` drains the queue via `consumeBtwNotes(ctx)` and folds the
- *     notes into the conversation as a user-visible block.
- *
- * The notes live in `ctx.meta` so the slash command and the agent loop share
- * one source of truth, the same way `_autonomousContinue` is plumbed in
- * {@link ./continue-to-next-iteration.ts}.
- */
-
-/**
- * Stash a "by the way" note on the context. The agent surfaces it at the
- * start of its next iteration. Blank notes are ignored. Returns the number
- * of notes now pending.
- */
-declare function setBtwNote(ctx: Context, text: string): number;
-/** Number of notes currently waiting to be delivered. */
-declare function pendingBtwCount(ctx: Context): number;
-/**
- * Read and clear all pending notes in one call. Returns them in the order
- * they were added (empty array when none).
- */
-declare function consumeBtwNotes(ctx: Context): string[];
-/**
- * Format pending notes as the text the agent reads. Kept deliberately light
- * (no "I interrupted you" framing) so the model folds the note into its
- * current work rather than restarting.
- */
-declare function buildBtwBlock(notes: string[]): string;
-
-/**
- * Continue-intent detection + continuation resolution.
- *
- * ## Problem
- *
- * Users frequently type a bare "continue" (or "devam", "go on", "keep going")
- * to nudge the agent forward without supplying any new instruction. On its own
- * that word carries no information about *what* to continue — the model has to
- * re-derive "what was next" from history, which drifts as the context window is
- * compacted. Left unanchored, a run of "continue … continue … continue" turns
- * into an ever-vaguer manual loop: the model repeats work, declares completion
- * prematurely, or wanders.
- *
- * ## Approach
- *
- * A bare "continue" is not new information — it points at an *existing* goal.
- * So instead of asking the model to remember a hidden per-message marker, we
- * resolve the continuation against the state we already keep:
- *
- *   1. **Open todos** — the strongest, most durable anchor. Survives context
- *      compaction (todos are re-injected each turn) and goal.json persistence.
- *      "continue" = resume the next open todo.
- *   2. **Parsed `<nextsteps>` suggestions** — the menu surfaced after the last
- *      completed turn (already extracted and stored by the surface's
- *      suggestion store). "continue" = do suggestion #1.
- *   3. **Open continuation** — no explicit task is queued, but the user still
- *      wants work to proceed. We inject an instruction that tells the model to
- *      pick the single most valuable next step itself and carry it out — while
- *      explicitly forbidding fabricated busywork. This is what keeps "continue"
- *      from ever dead-ending.
- *
- * This module is pure and surface-agnostic: detection takes the raw string,
- * resolution takes already-collected data (todos + parsed suggestion strings).
- * The REPL and TUI wire it in at the point where a user message becomes an
- * agent run, *before* prompt refinement — a bare "continue" has nothing
- * meaningful to refine, and refining it would only add latency and drift.
- *
- * The three triggers of the same continuation machinery — the user typing
- * "continue", the model emitting the `[continue]` marker (see
- * {@link parseContinueDirective}), and an autonomy tick — all ultimately want
- * the same thing: advance the plan. This module is the manual-trigger path.
- */
-
-/**
- * True when `raw` is a bare "continue"-style nudge and nothing else.
- *
- * Strict by construction: the message must normalize to exactly one of
- * {@link CONTINUE_PHRASES}. Anything with additional substance ("continue but
- * skip tests", "go on to the next file and commit") normalizes to a string
- * outside the set and returns false, so it is handled as an ordinary message.
- */
-declare function detectContinueIntent(raw: string): boolean;
-/**
- * Where the resolved continuation came from:
- *   - `todo`       — resumed the next open todo (strongest anchor)
- *   - `suggestion` — took the top parsed `<nextsteps>` suggestion
- *   - `open`       — no explicit task queued; model self-determines the step
- */
-type ContinuationSource = 'todo' | 'suggestion' | 'open';
-interface ContinuationInput {
-    /** Live todo list (`ctx.todos`). */
-    todos?: readonly TodoItem[] | undefined;
-    /** Already-parsed `<nextsteps>` suggestion strings from the surface store. */
-    suggestions?: readonly string[] | undefined;
-}
-interface ResolvedContinuation {
-    source: ContinuationSource;
-    /**
-     * The concrete instruction injected as the next user turn in place of the
-     * bare "continue". Written for the model, not the human.
-     */
-    text: string;
-    /**
-     * Short one-line label for the surface to echo (dim) so the human sees what
-     * "continue" resolved to without the full injected paragraph.
-     */
-    label: string;
-}
-/**
- * Resolve what a bare "continue" should do, given the current run state.
- *
- * The ladder — first match wins:
- *   1. an open todo (in-progress preferred, else the first pending),
- *   2. the top stored suggestion,
- *   3. an open continuation that never dead-ends.
- *
- * Always returns a usable {@link ResolvedContinuation}; the `open` branch is
- * the guaranteed fallback so "continue" keeps work moving even with no todos
- * and no suggestions.
- */
-declare function resolveContinuation(input: ContinuationInput): ResolvedContinuation;
-
-/**
- * L1-E: Autonomous continue — model-driven self-iteration continuation.
- *
- * In autonomous mode the model can signal "keep going without waiting for
- * user input" by either:
- *
- *  1. **Tool call** — call `continue_to_next_iteration()` with no args.
- *     The tool returns `{ continue: true }` and sets
- *     `ctx.meta._autonomousContinue = true`. The agent loop detects this
- *     flag and re-runs the iteration instead of returning.
- *
- *  2. **Text marker** — include one of the below markers on its own line
- *     in the final text output (no tool call required):
- *
- *     - `[continue]`          — same as calling the tool; next iteration
- *     - `[next step]`        — synonym for `[continue]`
- *     - `[proceed]`          — synonym for `[continue]`
- *     - `[done]`             — stop iterating; return to caller
- *
- *     The parser matches `^\s*(?:\[continue\]|\[next step\]|\[proceed\]|\[done\])\s*$`
- *     so the marker must occupy its own line (possibly indented).
- *
- * Text markers are checked in `processResponse()` BEFORE the loop exit
- * condition, so the model can emit `[continue]` as part of its final text
- * block and the loop re-runs seamlessly.
- *
- * The `_autonomousContinue` flag lives in `ctx.meta` — it is cleared at
- * the start of each iteration so a stale flag from a prior run cannot
- * cause spurious continuation.
- *
- * @example
- * ```typescript
- * // Enable autonomous continuation on the Agent
- * const agent = new Agent({
- *   // ... other options
- *   autonomousContinue: true,   // enable text-marker parsing
- * });
- *
- * // The model can now end a response with:
- * //   [continue]
- * // and the agent will immediately start the next iteration without
- * // returning to the caller.
- * ```
- */
-
-/**
- * Directive emitted by the model to control the autonomous loop.
- *
- * `continue`  — halt the current agent.run() and signal to the outer
- *                runner (e.g. AutonomousRunner) that it should re-invoke
- *                agent.run() immediately with a fresh continuation prompt.
- *
- * `stop`      — halt and signal the outer runner to NOT continue.
- *                The agent.run() returns `{ status: 'done' }` as normal.
- *
- * `none`      — no directive present; outer runner uses its own
- *                `doneCondition` to decide.
- */
-type ContinueDirective = 'continue' | 'stop' | 'none';
-/**
- * Parse a `ContinueDirective` from raw assistant text.
- *
- * Matches markers on their own line (with optional leading/trailing
- * whitespace). Case-insensitive. Returns `'none'` when no marker found.
- *
- * The marker must be on its own line to avoid false positives — e.g.
- * "remember to use [continue] in your next email" does NOT trigger it.
- */
-declare function parseContinueDirective(text: string): ContinueDirective;
-/**
- * Built-in tool that lets the model explicitly request the next iteration.
- *
- * When called, the agent loop detects the flag and re-runs instead of
- * returning to the caller. This is the explicit counterpart to the
- * `[continue]` text marker.
- *
- * The tool has no side effects and returns `{ continue: true }`.
- */
-declare function makeContinueToNextIterationTool(): Tool;
-
-/**
- * Cross-provider fallback model extension.
- *
- * Lives in core so EVERY agent surface can reuse it: the CLI leader, the CLI
- * director/host subagent factory, and the runtime light subagent factory (used
- * by standalone SDD runs). It wraps the provider runner and, when the active
- * model 429s / overloads / stream-hangs, rotates through a fallback chain. The
- * chain is recomputed from live config every turn, so changes take effect
- * without a restart; an empty chain makes the wrapper a no-op.
- *
- * Moved here from `@wrongstack/cli` (it only ever depended on core types) so the
- * runtime light factory can wire fallbacks for SDD worker subagents.
- */
-
-interface FallbackModelDeps {
-    /** Returns the live config (re-read each turn so `/model` switches are honored). */
-    getConfig: () => Config;
-    /**
-     * Builds a credential-resolved Provider for a provider id (alias-resolved),
-     * WITHOUT persisting anything to config/configStore. Supplied by the boot
-     * path, which shares this with the `/model` switch logic. May be async — the
-     * subagent host resolves a provider's real context window asynchronously.
-     */
-    buildProvider: (providerId: string, modelId?: string | undefined) => Provider | Promise<Provider>;
-    /**
-     * Called after the active model changes (a fallback hop or the primary
-     * restore) so the host can refresh the auto-compaction / context-window
-     * denominator — important when a fallback crosses to a smaller-window model.
-     */
-    onModelSwitch?: (providerId: string, modelId: string) => void | Promise<void>;
-    events: EventBus;
-    /** Optional — warnings about un-buildable fallback providers. */
-    logger?: Logger | undefined;
-    /**
-     * Base cooldown after the configured primary fails with a fallback-worthy
-     * error. While active, `beforeRun` leaves the context on the working fallback
-     * instead of retrying the primary at the start of every turn. Default: 60s.
-     * Set 0 to preserve the legacy "probe primary every turn" behavior.
-     */
-    primaryCooldownMs?: number | undefined;
-    /**
-     * Maximum exponential cooldown for repeated failed primary probes. Default:
-     * 10 minutes. Ignored when `primaryCooldownMs` is 0.
-     */
-    primaryCooldownMaxMs?: number | undefined;
-    /** Test hook for deterministic cooldown assertions. */
-    now?: (() => number) | undefined;
-}
-interface ModelRef {
-    provider?: string | undefined;
-    model: string;
-}
-/** Parse a fallback entry: `model`, `provider/model`, or `provider model`. */
-declare function parseModelRef(ref: string): ModelRef;
-declare function formatModelRef(ref: ModelRef, defaultProvider?: string | undefined): string;
-declare function normalizeModelRef(ref: string, defaultProvider?: string | undefined): string;
-declare function fallbackProfileChain(config: Config, profileName: string | undefined): string[];
-/**
- * Derive a fallback chain from the configured providers when the user has not
- * set an explicit `fallbackModels` list. Picks declared models from every
- * keyed provider — same-provider alternatives first (same key, cheapest
- * failover), then cross-provider — excluding the active leader model. Returns
- * `[]` when nothing usable is configured (e.g. providers with no `models`
- * list), in which case the extension is a no-op.
- */
-declare function smartDefaultFallbackChain(config: Config): string[];
-/**
- * The effective fallback chain for a turn: the explicit `fallbackModels` list
- * when non-empty, otherwise the smart default (unless `fallbackAuto` is off).
- */
-declare function effectiveFallbackChain(config: Config): string[];
-/**
- * Build the cross-provider fallback extension. Always returns an extension —
- * the effective chain (`effectiveFallbackChain`) is recomputed every turn from
- * the live config, so a chain that is empty at boot but populated later (via
- * `/fallback add` or the smart default kicking in once a key is added) takes
- * effect WITHOUT a restart. An empty chain makes the wrapper a no-op (it just
- * rethrows the original error).
- *
- * Mechanism (see plan): wraps the provider runner. The inner runner already
- * applies the per-model retry policy (backoff, up to 5 tries for 429), so the
- * fallback only engages AFTER the active model's own retries are exhausted.
- * Because the wrapper resolves within a single provider call, it does not
- * consume the agent loop's `recoveryRetries` budget — chains longer than two
- * entries work. `beforeRun` keeps the last working fallback while the primary
- * is cooling down, then restores the configured primary for a half-open probe.
- */
-declare function createFallbackModelExtension(deps: FallbackModelDeps): AgentExtension;
-
-interface InputBuilderOptions {
-    store: AttachmentStore;
-    /**
-     * Pastes ≥ this many lines collapse to a `[pasted #N]` placeholder.
-     * Default: 8 lines.
-     */
-    pasteLineThreshold?: number | undefined;
-    /**
-     * Pastes ≥ this many characters collapse to a placeholder regardless of
-     * line count. Default: 2000 chars.
-     */
-    pasteCharThreshold?: number | undefined;
-}
-interface InputBuilderEvent {
-    /** Current display string (with placeholders, before submit). */
-    display: string;
-    refs: AttachmentRef[];
-}
-/**
- * UI-agnostic accumulator for user input. The frontend (CLI/TUI) feeds in:
- *   - typed text via `appendText()`
- *   - large pastes via `appendPaste()` → returns placeholder string
- *   - image paste via `appendImage()` → returns placeholder string
- *   - file refs (`@path`) via `appendFile()` → returns placeholder string
- *
- * On `submit()` the builder runs the display string through AttachmentStore.expand()
- * and returns the final ContentBlock[] ready for `agent.run()`.
- *
- * The builder does not know what a "line" or "key" is — that is the
- * frontend's job. It only operates on strings and byte payloads.
- */
-declare class InputBuilder {
-    private readonly store;
-    private readonly pasteLineThreshold;
-    private readonly pasteCharThreshold;
-    private display;
-    private readonly refs;
-    constructor(opts: InputBuilderOptions);
-    get text(): string;
-    get attachments(): AttachmentRef[];
-    get isEmpty(): boolean;
-    appendText(text: string): void;
-    /**
-     * Decide whether a chunk of pasted text is "big" enough to collapse.
-     * If yes, store it and append a placeholder. If no, inline it.
-     * Returns the placeholder string actually appended (or `null` if inlined).
-     */
-    appendPaste(text: string): Promise<string | null>;
-    /**
-     * Always collapses to `[image #N]` — images are never inlined.
-     * `dataBase64` is the raw base64 payload (no data: prefix).
-     */
-    appendImage(dataBase64: string, mediaType: string): Promise<string>;
-    appendFile(input: AddAttachmentInput): Promise<string>;
-    /**
-     * Register-only variant of `appendPaste`. Always stores the paste and
-     * returns the inline `[pasted #N, L lines]` token WITHOUT mutating
-     * `display` — the caller (TUI) owns its own editable buffer as the single
-     * source of truth, inserts the token there, and expands the buffer at
-     * submit. The collapse decision is the caller's (it gates this call); use
-     * `wouldCollapse()` for that.
-     */
-    registerPaste(text: string): Promise<string>;
-    /**
-     * Register-only variant of `appendImage` — see `registerPaste`. Returns a
-     * seq-keyed `[image #N, LABEL]` token; does not touch `display`.
-     */
-    registerImage(dataBase64: string, mediaType: string): Promise<string>;
-    /**
-     * Register-only variant of `appendFile` — see `registerPaste`. Returns a
-     * path-keyed `[file:<path>]` token (resolved by path at expand time); does
-     * not touch `display`. The path is read from `meta.filename` (falling back
-     * to `meta.label`).
-     */
-    registerFile(input: AddAttachmentInput): Promise<string>;
-    /**
-     * Whether `appendPaste(text)` would collapse the text to a placeholder
-     * (rather than inlining it). Lets a frontend decide where to route a paste
-     * — e.g. collapsed pastes become a pill, while inlined ones can be shown
-     * in the editable input row — without calling `appendPaste` first (which
-     * mutates the display buffer).
-     */
-    wouldCollapse(text: string): boolean;
-    /** Reset display and ref list. Does NOT clear the store itself. */
-    reset(): void;
-    /**
-     * Resolve the current display string into ContentBlock[]. Empty
-     * input returns an empty array — caller decides what to do.
-     */
-    submit(): Promise<ContentBlock[]>;
-    private shouldCollapse;
-}
-
-interface SystemInstructionBundle {
-    identity?: string | undefined;
-    leaderAfterTask?: string | undefined;
-}
-interface InstructionBundle {
-    version?: number | undefined;
-    system?: SystemInstructionBundle | undefined;
-    sections?: Record<string, string> | undefined;
-}
-interface InstructionBundlePaths {
-    /** Bundled instruction directory. Defaults to `<@wrongstack/core>/instructions`. */
-    bundledDir?: string | undefined;
-    /** User-global override directory, e.g. `~/.wrongstack/instructions`. */
-    globalDir?: string | undefined;
-    /** Project override directory, e.g. `<project>/.wrongstack/instructions`. */
-    projectDir?: string | undefined;
-    /** Extra override JSON files applied after projectDir, in order. */
-    files?: readonly string[] | undefined;
-}
-declare function loadInstructionBundle(paths: InstructionBundlePaths | undefined): Promise<InstructionBundle>;
-declare function mergeInstructionBundle(base: InstructionBundle, override: InstructionBundle): InstructionBundle;
-
-/**
- * mailbox-loop — Agent-loop integration for mailbox checking.
- *
- * Integrates the inter-agent mailbox into the agent's iteration cycle.
- * Before each LLM call, checks for unread messages from subagents and other
- * agents. ALL message types are injected inline so the leader sees and acts
- * on them even when mid-task — subagent results, asks, assigns, and
- * steer/btw are all folded into the conversation with a call to action.
- *
- * Uses the project-level GlobalMailbox for cross-session communication.
- *
- * @module mailbox-loop
- */
-
-interface MailboxLoopOptions {
-    mailbox: Mailbox;
-    /**
-     * The agent's globally unique mailbox identity (e.g. `leader@a1b2c3d4`,
-     * session-bound). Read receipts are recorded under this id, so two
-     * sessions whose leaders share a base name never consume each other's
-     * receipts. Pass a GETTER when the identity can change at runtime (an
-     * in-process session swap moves the leader onto a new session tag).
-     */
-    agentId: string | (() => string);
-    /**
-     * Additional addresses this agent also answers to — typically the bare
-     * base id (`leader`). Lets other agents (and humans) address "leader"
-     * without knowing the session tag; every live leader session receives it.
-     */
-    aliases?: string[] | undefined;
-    /** Optional delivery predicate applied before dedup/read receipts. */
-    include?: ((message: MailboxMessage) => boolean) | undefined;
-    /** Mark returned messages as read. Defaults to true for normal delivery. */
-    ack?: boolean | undefined;
-}
-declare function createMailboxChecker(opts: MailboxLoopOptions): () => Promise<MailboxMessage[]>;
-declare function buildMailboxBtwAwarenessBlock(messages: MailboxMessage[]): {
-    type: 'text';
-    text: string;
-};
-declare function buildMailboxBlock(messages: MailboxMessage[]): {
-    type: 'text';
-    text: string;
-};
-/** Result of an inject pass — signals an out-of-band control request. */
-interface MailboxInjectResult {
-    /** A fresh `control:interrupt` message asked this agent to stop. */
-    interrupt: boolean;
-    /** Operator-supplied reason for the interrupt, if any. */
-    interruptReason?: string | undefined;
-}
-declare function injectPendingMailboxMessages(checkMailbox: () => Promise<MailboxMessage[]>, foldFn: (block: {
-    type: 'text';
-    text: string;
-}) => void, a: {
-    events: {
-        emit: (type: string, payload: unknown) => void;
-    };
-    logger: {
-        debug?: (...args: unknown[]) => void;
-    };
-}): Promise<MailboxInjectResult>;
-
-interface RunProviderOptions {
-    provider: Provider;
-    request: Request;
-    signal: AbortSignal;
-    ctx: Context;
-    events: EventBus;
-    retry: RetryPolicy;
-    logger: Logger;
-    tracer?: Tracer | undefined;
-}
-/**
- * Call a provider with the retry policy applied. Emits `provider.retry`
- * before each retry and `provider.error` once when the retries are
- * exhausted. Streaming providers route through the streaming-response
- * builder so deltas reach the renderer.
- */
-declare function runProviderWithRetry(opts: RunProviderOptions): Promise<Response>;
-
-/**
- * Queue awareness — let the running agent *see* messages the user typed
- * while it was busy, without delivering them early.
- *
- * The TUI queues plain messages typed mid-run and replays them as real user
- * turns after the run finishes (the queue drainer in app.tsx). That keeps
- * turn-taking clean, but the model is blind to the backlog: a queued message
- * may invalidate the current approach, add a constraint, or just be a
- * "by the way" note the user expected the agent to notice.
- *
- * Unlike `/btw` (a consume-once note channel, {@link ./btw.ts}), this is a
- * SNAPSHOT channel: the host mirrors the queue's current contents onto the
- * live `Context` on every queue mutation (enqueue, /queue delete, /queue
- * clear, dequeue-for-delivery). At each iteration boundary the agent loop
- * asks "did the snapshot change since the model last saw it?" and, if so,
- * injects an informational block listing the pending messages. The queue
- * itself is untouched — every queued message still arrives later as its own
- * user turn.
- *
- * Deliberate quietness: when the queue transitions to empty (cleared by the
- * user, drained between runs, or dropped by steering/abort) the snapshot is
- * marked seen WITHOUT injecting a "queue is now empty" block. The empty
- * transition usually happens at run boundaries where such a notice is stale
- * noise; the cost is that a mid-run `/queue clear` isn't announced, which is
- * safe because the block's framing already tells the model the queue may
- * change and the authoritative messages arrive as future turns.
- */
-
-/**
- * Mirror the host's pending-message queue onto the context. Call on every
- * queue mutation with the FULL current queue (head first) — not a delta.
- * Blank entries are dropped; the head-most {@link MAX_ITEMS} are kept since
- * the head is what arrives first.
- */
-declare function setQueuedMessagesSnapshot(ctx: Context, texts: string[]): void;
-/** Current snapshot (previews), without affecting seen-state. */
-declare function peekQueuedMessages(ctx: Context): string[];
-/**
- * Called by the agent loop at each iteration boundary. Returns the queued
- * messages to surface when the snapshot changed since the model last saw it,
- * or `null` when there is nothing new to say. Marks the snapshot seen either
- * way, so the same state is never injected twice. An empty snapshot is
- * acknowledged silently (see module comment).
- */
-declare function consumeQueuedMessagesUpdate(ctx: Context): string[] | null;
-/**
- * Format the awareness block. Framing goals: (1) the model must NOT treat
- * the listed messages as instructions to execute now — they each arrive as
- * their own turn later; (2) it SHOULD let them influence in-flight decisions
- * (a queued message may invalidate the current approach or be a /btw-style
- * note); (3) the list is a full replacement of any earlier notice, so a
- * shrunken list implicitly communicates deletions.
- */
-declare function buildQueuedMessagesBlock(items: string[]): string;
-
-declare const LAYER_1_IDENTITY: string;
-interface DefaultSystemPromptBuilderOptions {
-    memoryStore?: MemoryStore | undefined;
-    skillLoader?: SkillLoader | undefined;
-    /**
-     * How skill bodies reach the prompt. `'eager'` (default) injects every
-     * discovered skill body; `'progressive'` injects only a name+trigger manifest
-     * and relies on the agent calling the `skill` tool to load a body on demand
-     * (the agentskills.io progressive-disclosure model).
-     */
-    skillMode?: 'eager' | 'progressive' | undefined;
-    /**
-     * In eager mode, cap the total chars of injected skill bodies (highest-priority
-     * skills first); the rest become a load-on-demand manifest. Bounds prompt
-     * cost when many skills are discovered. Default ~24k chars.
-     */
-    skillEagerMaxChars?: number | undefined;
-    modeStore?: ModeStore | undefined;
-    /** Pre-resolved active mode id — shown in environment block. */
-    modeId?: string | undefined;
-    /** Pre-resolved mode prompt — avoids redundant modeStore.getActiveMode() call. */
-    modePrompt?: string | undefined;
-    /** Model capabilities — object snapshot or lazy getter for live model switches. */
-    modelCapabilities?: ModelCapabilities | (() => ModelCapabilities | undefined) | undefined;
-    todayIso?: string | undefined;
-    /**
-     * Path to the session's plan JSON, or a getter that returns it. When
-     * set, the builder reads the file on every `build()` call and injects
-     * an "Active plan" block listing open items, so the LLM is anchored to
-     * the strategic roadmap every turn — not just at resume. The block is
-     * tagged `ephemeral` so a plan edit on turn N doesn't invalidate the
-     * provider's prefix cache for earlier turns.
-     *
-     * The function form lets callers bind the builder before the session
-     * id is known (e.g. DI containers that resolve the builder lazily) —
-     * the getter is called at build-time, after the session has been
-     * created.
-     */
-    planPath?: string | (() => string | undefined);
-    /**
-     * System prompt contributors — called on every `build()` to inject
-     * additional TextBlocks. Use `ExtensionRegistry.listSystemPromptContributors()`
-     * or pass a plain array. Contributors are called in order; a throwing
-     * contributor is caught and logged without aborting the build.
-     */
-    contributors?: readonly SystemPromptContributor[] | undefined;
-    /**
-     * Token-saving mode tier. Controls how aggressively the system prompt is
-     * compacted: skill bodies are omitted/trimmed, tool hints are shortened,
-     * and optional guidance sections (delegation, mailbox, context management)
-     * use minimal versions to reduce per-request tokens.
-     *
-     * - 'off'        — Full guidance (no reduction)
-     * - 'minimal'    — TIER1 tools, stripped guidance
-     * - 'light'     — TIER1 + memory tools, minimal patterns
-     * - 'medium'    — TIER1 + TIER2 tools, some guidance
-     * - 'aggressive' — Maximum reduction before tools become unusable
-     *
-     * Boolean values are accepted for backward compatibility:
-     * - `true`  → 'medium'
-     * - `false` → 'off'
-     */
-    tokenSavingMode?: TokenSavingTier | boolean | undefined;
-    /**
-     * File-backed instruction layers. Builtins are loaded first, then global
-     * overrides, then project overrides, then explicit files. This lets durable
-     * system instructions live outside TypeScript while keeping the builder API
-     * stable for embedded runtimes.
-     */
-    instructionPaths?: InstructionBundlePaths | undefined;
-    /**
-     * Last-mile in-memory overrides, applied after instructionPaths. Useful for
-     * tests, embedders, and plugin-provided prompt experiments.
-     */
-    instructionBundle?: InstructionBundle | undefined;
-}
-declare class DefaultSystemPromptBuilder implements SystemPromptBuilder {
-    private readonly opts;
-    /**
-     * Cached environment block, keyed by projectRoot. A single builder
-     * instance is normally reused across turns of the same agent run, but
-     * tests and library consumers may reuse it across runs with different
-     * roots; keying the cache prevents leaking the first call's project
-     * state into a later call against an unrelated project.
-     */
-    private envCacheByRoot;
-    private skillCache?;
-    /** Cached full skill bodies (after frontmatter), built once per session. */
-    private skillBodyCache?;
-    /** Tools from last build — used for memory relevance scoring. */
-    private _lastBuildTools?;
-    /** Cached rendered online agents string, keyed by content fingerprint. */
-    private _lastOnlineAgents?;
-    /** Cached full buildToolUsage output — keyed by tools array ref + agents fingerprint + tier. */
-    private _toolsUsageCache?;
-    private _instructionBundle?;
-    constructor(opts?: DefaultSystemPromptBuilderOptions);
-    /**
-     * Normalizes `tokenSavingMode` to a boolean for backward-compatible boolean checks.
-     * - `undefined` / `false` / `'off'` → false
-     * - `true` / any tier string other than `'off'` → true
-     *
-     * Note: invalid tier strings (e.g. "MINIMAL") are coerced to 'off'
-     * by `normalizeTokenSavingTier` via the `tier` getter, so isCompact
-     * correctly returns false for them — preventing isCompact/tier
-     * disagreement on bad input.
-     */
-    private get isCompact();
-    /** Exposes the normalized `TokenSavingTier` for tier-aware guidance decisions. */
-    private get tier();
-    /**
-     * Returns the max tool description length for the current tier.
-     * Per the design doc: off=80, minimal=40, light=50, medium=60, aggressive=70.
-     */
-    private toolDescLimit;
-    build(ctx: BuildContext): Promise<TextBlock[]>;
-    buildRegions(ctx: BuildContext): Promise<SystemPromptRegions>;
-    private instructions;
-    private instructionSection;
-    /**
-     * Cached plan content keyed by (planPath, mtimeMs). The plan is read
-     * once per system-prompt build; most turns don't change the plan, so
-     * this avoids a blocking fs.readFile + JSON.parse on every iteration.
-     * Cleared when the file's mtime changes (the `/plan` tool mutated it).
-     */
-    private _planCache?;
-    /**
-     * Reads the session-scoped plan sidecar (when configured) and produces
-     * a short "Active plan" block listing open items so the model is
-     * anchored to the strategic roadmap every turn. Reads on every `build()`
-     * so a plan edit (via `/plan` or the `plan` tool) reflects on the next
-     * turn without restarting the session.
-     */
-    private buildActivePlan;
-    private _formatPlan;
-    private buildToolUsage;
-    private renderToolSelectionBoundary;
-    /**
-     * Cheap content fingerprint of the online agents array. The mailbox
-     * rebuilds the array as a fresh object on every status check, so caching
-     * by reference always misses — this lets the renderOnlineAgents and
-     * buildToolUsage caches detect membership changes instead.
-     *
-     * O(n) over agent names with no per-element string concatenation. Uses
-     * FNV-1a over character codes so two different agent sets collide only
-     * if they produce the identical sequence of name characters — astronomically
-     * unlikely. A collision would produce a stale agent list in the prompt,
-     * a cosmetic issue, not a correctness bug.
-     */
-    private agentsFingerprint;
-    /**
-     * Render the online agents list, cached by content fingerprint. The agents
-     * list changes at join/leave pace (seconds to minutes), not every prompt
-     * build turn (hundreds of ms). The fingerprint detects membership changes
-     * without holding the array reference — the mailbox rebuilds the array as
-     * a fresh object on every status check, so reference equality always misses.
-     *
-     * Tier behaviour:
-     * - 'off' / 'medium' / 'aggressive' → full list with names, sessions, sources
-     * - 'minimal' / 'light' → count only (no list)
-     */
-    private renderOnlineAgents;
-    private buildEnvironment;
-    private modelCapabilities;
-    private buildMemoryAndSkills;
-    /**
-     * Build the progressive-disclosure manifest: list each skill's name + trigger
-     * only and instruct the agent to call the `skill` tool to load a body. No
-     * bodies are injected — the agent pulls them on demand (agentskills.io tier 2).
-     */
-    private buildProgressiveSkillManifest;
-    /** Build full skill bodies (token-saving OFF), bounded by an overall budget. */
-    private buildFullSkillBodies;
-    /**
-     * Build compact skill bodies for token-saving mode.
-     * Uses `readSaveBody` from the skill loader which tries `SKILL.save.md`
-     * first, then falls back to auto-compaction.
-     */
-    private buildCompactSkillBodies;
-    private buildMode;
-    private dirExists;
-    private gitStatus;
-    private detectLanguages;
-}
-
-/**
- * Token estimate for a message array (text + tool I/O). Re-exported from the
- * canonical `token-estimate` helper so compactors and the context-pressure
- * monitor share one number.
- */
-declare const estimateMessages: typeof estimateMessageTokens;
-/**
- * Shared, pure compaction primitives.
- *
- * Before this module the three compactors (`HybridCompactor`,
- * `IntelligentCompactor`, `SelectiveCompactor`) each carried their own copies
- * of message-token estimation, tool-result elision, text detection and digest
- * rendering — with subtle divergences (notably Selective lacked the
- * tool_use/tool_result pair preservation, so it could elide the result of a
- * tool call it was supposed to keep). These helpers are the single source of
- * truth. They operate on plain `Message[]` and never touch `Context`/state, so
- * each compactor keeps its own `ctx.state.replaceMessages(...)` plumbing.
- */
-/** Does this message carry any non-empty text? */
-declare function hasTextContent(m: Message): boolean;
-/**
- * Index where the preserved (recent) window starts. Walks back counting
- * user/assistant messages until `preserveK` are covered, then walks forward to
- * keep any tool_use/tool_result protocol pair intact — so a tool_result whose
- * tool_use is preserved is never elided.
- *
- * Instrumentation: emits `compaction.find_preserve_start.ended` with the
- * repair-loop block count so we can track whether protocol-pair repair is
- * scanning too much content.
- */
-declare function findPreserveStart(messages: readonly Message[], preserveK: number): number;
-interface EliseResult {
-    /** New message array, or the same reference when nothing changed. */
-    messages: Message[];
-    /** Estimated tokens reclaimed. */
-    saved: number;
-    changed: boolean;
-}
-/**
- * Elide oversized tool I/O that falls before the preserve window. Pure:
- * returns a fresh array (or the same reference when unchanged). Replaces the
- * duplicate copies that lived in all three compactors.
- */
-declare function eliseOldToolResults(messages: readonly Message[], opts: {
-    preserveK: number;
-    eliseThreshold: number;
-}): EliseResult;
-/**
- * Lossless textual digest of a message range. Every text block is kept verbatim
- * (across all roles, so prior `system` digests fold forward and nothing
- * accumulates as loss). `tool_use` / `tool_result` blocks are counted and
- * replaced with a marker rather than serialized — their payload is already
- * persisted in the session log. Empty/tool-only messages are skipped.
- */
-declare function buildLosslessDigest(messages: readonly Message[]): string;
-/** Importance score for a message — drives retention vs. summarization. */
-type ContentScore = 0 | 1 | 2 | 3 | 4 | 5;
-/**
- * Extract the plain text from a message (ignoring tool blocks).
- * Returns empty string if no text content exists.
- */
-declare function extractText(m: Message): string;
-/**
- * Score a message by content importance.
- *
- * CRITICAL (5): user corrections, explicit "no/wrong/stop", error messages,
- *   architecture decisions, security findings.
- * MEDIUM (3): normal exchanges, successful tool calls, file reads, edits.
- * LOW (1): large tool results (>3K chars), grep/file-list outputs, boilerplate.
- * NOISE (0): repeated identical failures (same tool, same error, 5th+ occurrence
- *   within the range), pure tool I/O with no text.
- */
-declare function scoreMessage(m: Message, context?: {
-    failureCounts?: Map<string, number>;
-}): ContentScore;
-/**
- * Build a content-aware digest of messages.
- *
- * Unlike `buildLosslessDigest` which preserves all text equally, this uses
- * `scoreMessage` to apply tiered treatment:
- * - Score 5 (critical): verbatim text
- * - Score 3 (medium):   first sentence only
- * - Score 1 (low):      one-line summary
- * - Score 0 (noise):    collapsed to count marker
- */
-declare function buildSmartDigest(messages: readonly Message[]): string;
-
-interface ShellHookSpec {
-    command: string;
-    timeoutMs?: number | undefined;
-}
-/**
- * Run a shell hook (Claude-compatible). The `HookInput` JSON is written to the
- * command's stdin. Resolution rules, in order:
- *   - exit code 2 → `{ decision: 'block', reason: <stderr or stdout> }`
- *   - stdout parses as a JSON object → returned verbatim as a `HookOutcome`
- *   - otherwise → no-op (`null`)
- *
- * The hook never throws into the agent loop: spawn errors and timeouts resolve
- * to `null` and are logged. Output is capped at 64 KiB.
- */
-declare function runShellHook(spec: ShellHookSpec, input: HookInput, logger?: Logger | undefined): Promise<HookOutcome | null>;
-
-/**
- * Helpers for comparing and counting shell-hook configurations.
- * Used by the hot-reload path: the `ConfigStore` watcher fires on every
- * `configStore.update` call (model, log level, anything), so we need a
- * cheap predicate to decide whether `config.hooks` actually changed before
- * re-running `replaceShellHooks`.
- *
- * Pure functions — no I/O, no logger, no side effects. Safe to import
- * from anywhere.
- */
-
-declare function shellHooksEqual(a: Partial<Record<HookEvent, ConfiguredHook[]>> | undefined, b: Partial<Record<HookEvent, ConfiguredHook[]>> | undefined): boolean;
-/** Count the total number of shell-hook entries across all events. */
-declare function countShellHooks(hooks: Partial<Record<HookEvent, ConfiguredHook[]>> | undefined): number;
-
-/**
- * Minimal interface exposing the Agent fields that the extracted
- * loop / tool-execution / response modules need. Each extracted
- * function takes this interface instead of the full Agent class,
- * keeping coupling explicit and testable.
- */
-interface AgentInternals {
-    readonly container: Container;
-    readonly tools: ToolRegistry;
-    readonly providers: ProviderRegistry;
-    readonly events: EventBus;
-    readonly pipelines: AgentPipelines;
-    readonly ctx: Context;
-    readonly maxIterations: number;
-    readonly executionStrategy: 'parallel' | 'sequential' | 'smart';
-    readonly perIterationOutputCapBytes: number;
-    readonly autoExtendLimit: boolean;
-    readonly loopDetection: ResolvedLoopDetectionConfig;
-    readonly toolExecutor: ToolExecutorLike;
-    readonly extensions: ExtensionRegistry;
-    readonly logger: Logger;
-    readonly retry: RetryPolicy;
-    readonly errorHandler: ErrorHandler;
-    readonly permission: PermissionPolicy;
-    readonly renderer: Renderer | undefined;
-    readonly tracer: Tracer | undefined;
-}
-
-/**
- * mailbox-attach — composition glue for the agent-loop mailbox checker.
- *
- * Lives at the src root (composition layer) because it constructs the
- * concrete GlobalMailbox from coordination/ and hands the resulting
- * checker to core/ — core/ itself may only depend on the Mailbox
- * interface (architecture Rule 3, see tests/architecture/
- * package-boundaries.test.ts).
- *
- * @module mailbox-attach
- */
-
-declare function attachMailboxChecker(a: AgentInternals, source?: 'cli' | 'webui'): () => Promise<MailboxMessage[]>;
-
-/**
- * collabPauseMiddleware — gates the agent's `toolCall` pipeline on
- * the collaboration pause signal.
- *
- * Position: must be installed as the *first* middleware in the
- * `toolCall` pipeline so it runs before permission checks, retries,
- * and the tool itself. That way the controller can halt an agent
- * regardless of what the model is about to do.
- *
- * Semantics:
- *   - When the bus is not paused: pass through (`next()`).
- *   - When the bus is paused: await `bus.waitForResume(timeoutMs)`.
- *     The default timeout is 60s — long enough for a human to think,
- *     short enough that a forgotten controller doesn't pin the agent
- *     forever. The auto-resume on timeout is logged below.
- *
- * Phase 3 of idea #13. Manual tool-call injection (a controller
- * "writing" a tool result) is *not* in scope for this middleware —
- * that requires splicing the injected result into the agent's
- * message stream and is a follow-up.
- */
-interface CollabPauseMiddlewareOptions {
-    /**
-     * How long to wait for a resume before auto-resuming the bus.
-     * Defaults to 60_000 ms. Set to 0 for an unbounded wait (the
-     * caller is then responsible for cancellation via the bus itself).
-     */
-    defaultTimeoutMs?: number | undefined;
-    /**
-     * Optional logger — receives a debug line on pause entry and on
-     * timeout-driven auto-resume. Matches the `Logger` token surface
-     * so the runtime can pass its existing logger.
-     */
-    logger?: {
-        debug?: ((msg: string) => void) | undefined;
-        warn?: ((msg: string) => void) | undefined;
-    };
-}
-declare function collabPauseMiddleware(bus: CollaborationBus, opts?: CollabPauseMiddlewareOptions): Middleware<ToolCallPipelinePayload>;
-/**
- * collabInjectMiddleware — Phase 4 of idea #13. Splices
- * controller-injected tool results into the toolCall pipeline.
- *
- * Position: should run AFTER `collabPauseMiddleware` so the
- * controller has a chance to pause + inject before the next tool
- * executes. Install order:
- *   - `pipeline.toolCall.prepend(collabInject)`
- *   - `pipeline.toolCall.prepend(collabPause)`  // runs first
- *
- * Semantics:
- *   - On every tool call, the middleware asks the bus for an
- *     injection matching `payload.toolUse.id`.
- *   - If one is queued, the payload's `result` is overwritten with
- *     a synthetic ToolResultBlock carrying the injected content +
- *     `is_error` flag. The real `next()` is NOT called; downstream
- *     middleware sees the controller's synthetic result.
- *   - The injection is consumed once and removed from the bus.
- *
- * Why this shape: the agent loop's existing `tool.executed` event still
- * fires (carrying the injected content), so the session log + observers see
- * a normal-looking call — just with the controller's intent in the result.
- */
-declare function collabInjectMiddleware(bus: CollaborationBus, opts?: {
-    logger?: {
-        debug?: ((msg: string) => void) | undefined;
-        warn?: ((msg: string) => void) | undefined;
-    };
-}): Middleware<ToolCallPipelinePayload>;
-
-declare class SlashCommandRegistry {
-    private readonly cmds;
-    /**
-     * Register a command.
-     *
-     * Trust tiers, by `owner` and `opts.official`:
-     *
-     *  - **Built-ins** (`owner === 'core'`) and **official plugins**
-     *    (`opts.official === true`, set by the host only for first-party plugins
-     *    loaded from the built-in factory list) claim the **bare** command name
-     *    (`/prompts`). They may override one another — last write wins — so an
-     *    official plugin can replace a built-in. Official plugins are *also*
-     *    reachable under their `owner:name` namespace.
-     *  - **External plugins** (any other `owner`) are isolated under the
-     *    `owner:name` namespace: invocable only as `/owner:cmd`, never by bare
-     *    name, and unable to shadow or override a built-in or official command.
-     *
-     * Officiality is supplied by the host based on the plugin's load source, not
-     * self-declared by the plugin — an external plugin cannot name itself into
-     * the official tier.
-     */
-    register(cmd: SlashCommand, owner?: string, opts?: {
-        official?: boolean | undefined;
-    }): void;
-    unregister(name: string): boolean;
-    /**
-     * Bulk-register multiple slash commands at once.
-     */
-    registerAll(cmds: SlashCommand[], owner?: string): void;
-    get(name: string): SlashCommand | undefined;
-    ownerOf(name: string): string | undefined;
-    list(): SlashCommand[];
-    listWithOwner(): Array<{
-        cmd: SlashCommand;
-        owner: string;
-        fullName: string;
-    }>;
-    /**
-     * Parse a slash command line. Accepts both:
-     *   `/cmd args`          → builtin command (owner=core)
-     *   `/pluginName:cmd args` → plugin command
-     * The command name is split at the first `:` if the prefix matches a known owner.
-     */
-    dispatch(line: string, ctx: Context): Promise<{
-        exit?: boolean | undefined;
-        message?: string | undefined;
-        runText?: string | undefined;
-        metadata?: Record<string, unknown>;
-    } | null>;
-}
-
-interface PluginAPIInit {
-    ownerName: string;
-    container: Container;
-    events: EventBus;
-    /**
-     * The agent's concrete pipelines. `DefaultPluginAPI` converts each to a
-     * `ReadonlyPipeline` before exposing them to the plugin — plugins can
-     * inspect and invoke pipelines but cannot mutate them.
-     */
-    pipelines: PluginPipelines;
-    toolRegistry: ToolRegistry;
-    providerRegistry: ProviderRegistry;
-    slashCommandRegistry?: SlashCommandRegistry | undefined;
-    mcpRegistry?: MCPRegistryView | undefined;
-    /**
-     * The agent's extension registry. Plugins register AgentExtension
-     * instances here to hook into agent lifecycle events.
-     */
-    extensions?: ExtensionRegistry | undefined;
-    /**
-     * The host's lifecycle hook registry. When provided, `api.registerHook`
-     * adds in-process hooks here. When absent, `registerHook` is a noop.
-     */
-    hookRegistry?: HookRegistry | undefined;
-    /**
-     * The active session writer. Plugins append custom events here.
-     * When not provided, a noop writer is used.
-     */
-    sessionWriter?: SessionWriterView | undefined;
-    /**
-     * The host's metrics sink. When set, the plugin gets a scoped view
-     * that auto-prefixes metric names with `plugin.<pluginName>.`.
-     * When not provided, a noop sink is used.
-     */
-    metricsSink?: MetricsSinkView | undefined;
-    /**
-     * The host's models registry (models.dev-backed catalog of providers,
-     * models, and per-token pricing). When provided, plugins that need
-     * model metadata (cost-tracker, billing reports) can query it instead
-     * of relying on bundled tables. Optional — minimal hosts/tests may
-     * omit it.
-     */
-    modelsRegistry?: ModelsRegistry | undefined;
-    /**
-     * The host's project-level mailbox. When provided, plugins that publish
-     * to other agents (todo-listener, session-recap) can call `api.mailbox.send`.
-     * When not provided, those plugins should gracefully no-op.
-     */
-    mailbox?: Mailbox | undefined;
-    /**
-     * LLM wiring for `api.llm`. When provided, `DefaultPluginAPI` exposes a
-     * `PluginLLM` that routes completions through the host's provider layer:
-     *
-     *  - `provider` — the host session's live default Provider instance
-     *  - `model`    — the host session's default model id
-     *  - `createProvider` — optional factory used when a plugin requests a
-     *    DIFFERENT provider by name (per-call `opts.provider` or the plugin's
-     *    `config.extensions[<name>].llm.provider`). The CLI host passes an
-     *    implementation backed by the provider registry + saved provider
-     *    configs; when absent, `DefaultPluginAPI` falls back to
-     *    `providerRegistry.create({ ...config.providers[name], type: name })`.
-     *
-     * Omit entirely on minimal hosts — `api.llm` stays undefined and plugins
-     * must guard.
-     */
-    llm?: {
-        provider: Provider;
-        model: string;
-        createProvider?: ((name: string, model?: string) => Provider) | undefined;
-    } | undefined;
-    config: Config;
-    /**
-     * The host's ConfigStore. Used to wire `api.onConfigChange()`.
-     * When not provided, `onConfigChange` is a noop.
-     */
-    configStore?: {
-        watch(cb: (next: unknown, prev: unknown) => void): () => void;
-    };
-    log: Logger;
-    /**
-     * Whether this plugin is first-party ("official"). Set by the host based on
-     * the plugin's load source (e.g. shipped in the built-in factory list), NOT
-     * self-declared by the plugin. Official plugins may register bare slash
-     * command names and override built-ins; external plugins are namespaced.
-     * Defaults to false.
-     */
-    official?: boolean | undefined;
-    /**
-     * Declared capabilities of the plugin. Used for capability-based
-     * authorization checks (e.g. tool mutation permissions).
-     */
-    capabilities?: PluginCapabilities | undefined;
-}
-declare class DefaultPluginAPI implements PluginAPI {
-    readonly container: Container;
-    readonly events: EventBus;
-    readonly pipelines: PluginPipelines;
-    readonly tools: ToolRegistryView;
-    readonly providers: ProviderRegistryView;
-    readonly mcp: MCPRegistryView;
-    readonly slashCommands: SlashCommandRegistryView;
-    readonly extensions: ExtensionRegistry;
-    readonly session: SessionWriterView;
-    readonly metrics: MetricsSinkView;
-    readonly config: Config;
-    readonly log: Logger;
-    readonly modelsRegistry: ModelsRegistry | undefined;
-    readonly mailbox: Mailbox | undefined;
-    readonly llm: PluginLLM | undefined;
-    private readonly configStore;
-    private readonly hookRegistry;
-    private readonly ownerName;
-    private readonly pluginCleanupFns;
-    constructor(init: PluginAPIInit);
-    onEvent<K extends EventName>(event: K, handler: Listener<K>): () => void;
-    onPattern(pattern: string, handler: (event: string, payload: unknown) => void): () => void;
-    emitCustom(event: string, payload: unknown): void;
-    onConfigChange(handler: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
-    /** Called by the plugin loader when uninstalling the plugin. */
-    drainCleanup(): void;
-    registerSystemPromptContributor(c: SystemPromptContributor): () => void;
-    registerHook(event: HookEvent, matcher: HookMatcher | undefined, hook: InProcessHook, options?: HookRegistrationOptions | undefined): () => void;
-}
-/**
- * Define a plugin with automatic `apiVersion` injection and optional
- * TypeScript type inference for the plugin options schema.
- *
- * The `options` generic is inferred from the `factory` function's second
- * parameter, so annotating it gives you fully-typed options throughout:
- *
- * @example
- * ```ts
- * import { definePlugin } from '@wrongstack/core';
- *
- * interface MyOptions {
- *   threshold: number;
- *   enabled: boolean;
- * }
- *
- * const myPlugin = definePlugin(
- *   {
- *     name: 'my-plugin',
- *     version: '0.1.0',
- *     description: 'My example plugin',
- *     capabilities: { tools: true },
- *     configSchema: {
- *       type: 'object',
- *       properties: {
- *         threshold: { type: 'number', default: 100 },
- *         enabled: { type: 'boolean', default: true },
- *       },
- *     },
- *     defaultConfig: { threshold: 100, enabled: true },
- *   },
- *   (api, options) => {
- *     // options.threshold is `number` here, not `unknown`
- *     api.tools.register({
- *       name: 'my-tool',
- *       description: `Threshold is ${options.threshold}`,
- *       // ...
- *     });
- *   },
- * );
- *
- * export default myPlugin;
- * ```
- *
- * Plugins that don't need typed options can omit the interface and let
- * TypeScript infer from `defaultConfig`, or omit `defaultConfig` entirely
- * (options will be `undefined` at runtime, accessible via `api.config`):
- *
- * @example
- * ```ts
- * const simplePlugin = definePlugin(
- *   { name: 'simple' },
- *   (api) => {
- *     api.tools.register({ name: 'ping', description: 'Ping the service' });
- *   },
- * );
- * ```
- *
- * The `apiVersion` is automatically set to the current `KERNEL_API_VERSION`
- * so plugins are always compatible with the kernel that loaded them.
- * Plugins that need to pin to a specific kernel version can override it
- * in the returned object before exporting.
- */
-declare function definePlugin<const TOptions extends Record<string, unknown> | undefined>(metadata: {
-    name: string;
-    version?: string | undefined;
-    description?: string | undefined;
-    capabilities?: PluginCapabilities | undefined;
-    configSchema?: JSONSchema | undefined;
-    defaultConfig?: TOptions | undefined;
-    dependsOn?: (string | PluginDependency)[] | undefined;
-    optionalDeps?: (string | PluginDependency)[] | undefined;
-    conflictsWith?: string[] | undefined;
-}, factory: (api: PluginAPI, options: TOptions) => void | Promise<void>): {
-    name: string;
-    version?: string | undefined;
-    description?: string | undefined;
-    apiVersion: string;
-    capabilities?: PluginCapabilities | undefined;
-    configSchema?: JSONSchema | undefined;
-    defaultConfig?: TOptions | undefined;
-    dependsOn?: (string | PluginDependency)[] | undefined;
-    optionalDeps?: (string | PluginDependency)[] | undefined;
-    conflictsWith?: string[] | undefined;
-    setup: (api: PluginAPI) => void | Promise<void>;
-};
-
-/**
- * Stable plugin API contract version. This is intentionally independent of
- * the package version: bump only when the surface visible to plugins
- * (PluginAPI, types/plugin) changes in a way that breaks existing setup
- * functions. Plugins declare `apiVersion: "^1.0"` to opt into this contract.
- *
- * 0.1.9: additive — `FleetSpawnBudgetError|FleetCostCapError` plus `FLEET_ROSTER` and the
- * pre-built fleet agent configs (Audit Log, Bug Hunter, Refactor Planner,
- * Security Scanner) now exported from `@wrongstack/core`.
- * 0.1.10: additive — extended-thinking stream events, core subpath
- * exports, tool output size chips on `tool.executed`. Plugin contract
- * unchanged otherwise; 0.1.x range still loads cleanly.
- *
- * Note: the package shipped as 0.2.0, but the *plugin contract* didn't
- * change in a breaking way — `SubagentError`, `subagent.tool_executed`,
- * `transcriptPath`, `planTool`, `delegate`, `runText`, and Director
- * sessionWriter are all additive to the surface. We deliberately keep
- * the kernel API at 0.1.10 so plugins pinning `apiVersion: "^0.1"`
- * keep loading. Bump to 1.0 when we stabilize and want the freedom to
- * remove deprecated surfaces.
- */
-declare const KERNEL_API_VERSION = "0.1.10";
-interface LoadPluginsOptions {
-    apiFactory: (plugin: Plugin) => PluginAPI;
-    log: Logger;
-    kernelApiVersion?: string | undefined;
-    /**
-     * Per-plugin options keyed by plugin name. When a plugin declares
-     * `configSchema`, the loader validates `pluginOptions[plugin.name]`
-     * against it before calling `setup`. Pass `Config.plugins` shaped
-     * `{ [name]: { options } }` or any flat record.
-     */
-    pluginOptions?: Record<string, unknown>;
-    /**
-     * When true, the loader throws a PluginError if a plugin calls an API
-     * method that contradicts its declared `capabilities` — instead of
-     * just logging a warning. Use in CI/strict deployments to enforce
-     * manifest honesty. Default: false (log-only, backward-compatible).
-     */
-    enforceCapabilities?: boolean | undefined;
-    /**
-     * Timeout in milliseconds for each plugin's `setup()` call. If the
-     * plugin's setup exceeds this deadline it is treated as a failure
-     * and the plugin is not loaded. Default: 30 000 ms.
-     */
-    setupTimeoutMs?: number | undefined;
-    /**
-     * Timeout in milliseconds for each plugin's `teardown()` call. If the
-     * plugin's teardown exceeds this deadline it is treated as a best-effort
-     * failure (logged but not propagated). Default: 10 000 ms.
-     */
-    teardownTimeoutMs?: number | undefined;
-}
-declare function loadPlugins(plugins: Plugin[], opts: LoadPluginsOptions): Promise<{
-    loaded: Plugin[];
-    failed: {
-        plugin: Plugin;
-        err: unknown;
-    }[];
-}>;
-/**
- * Tear down loaded plugins in reverse-dependency order. `teardown()` is
- * best-effort: errors are caught and logged so a single misbehaving plugin
- * can't abort the host shutdown sequence.
- *
- * Pass the result of a prior `loadPlugins(...)` call's `loaded` array, plus
- * the original `LoadPluginsOptions` so the same `apiFactory` (and the same
- * PluginAPI surface the plugin saw during `setup`) is used for `teardown`.
- */
-declare function unloadPlugins(loadedPlugins: Plugin[], opts: LoadPluginsOptions): Promise<void>;
-
-interface ChimeraConfig {
-    enabled?: boolean | undefined;
-    provider?: string | undefined;
-    model?: string | undefined;
-    maxFiles?: number | undefined;
-    /**
-     * @deprecated Removed. The subagent's `Request.maxTokens` now defaults to
-     * the provider's `capabilities.maxOutput`, so Chimera reports can run up
-     * to the selected model's native ceiling. Kept on the config interface as an `unknown` sink
-     * so old config files don't crash — but it's no longer read.
-     */
-    maxTokens?: unknown;
-}
-interface ResolvedChimeraConfig {
-    enabled: boolean;
-    provider: string;
-    model: string;
-    maxFiles: number;
-}
-declare function resolveChimeraConfig(cfg: ChimeraConfig, sessionProvider: string, sessionModel: string): ResolvedChimeraConfig;
-interface ChimeraReviewNeededPayload {
-    /** Resolved chimera config */
-    config: ResolvedChimeraConfig;
-    /** Project root for git operations */
-    cwd: string;
-    /** Changed files with their contents */
-    files: Array<{
-        path: string;
-        status: 'added' | 'modified';
-        content: string;
-    }>;
-}
-declare const CHIMERA_REVIEW_PROMPT: string;
-declare function createChimeraPlugin(): Plugin;
-
-/**
- * GitPlugin — built-in git helpers.
- *
- * Registers `/commit`, `/gitcheck` and `/push`. First-party ("official")
- * plugin, so the commands keep their bare names and `gc` / `gcstatus` aliases.
- * `/commit` generates an LLM commit message from the session provider when one
- * is available, falling back to diff heuristics. No configuration required.
- */
-declare function createGitPlugin(): Plugin;
-
-interface ObservabilityPluginOptions {
-    metricsSink?: MetricsSink | undefined;
-    healthRegistry?: HealthRegistry | undefined;
-}
-/**
- * ObservabilityPlugin — runtime metrics + health checks.
- *
- * Registers `/metrics` and `/health`. First-party ("official") plugin, so the
- * commands keep their bare names. Both require the host to have started the
- * metrics subsystem (`--metrics`); without it they report that and no-op.
- */
-declare function createObservabilityPlugin(opts?: ObservabilityPluginOptions): Plugin;
-
-interface PlanPluginOptions {
-    paths?: WstackPaths | undefined;
-}
-/**
- * PlanPlugin — strategic plan board (`/plan`), the higher-level counterpart to
- * `/todos`. First-party ("official") plugin, so the command keeps its bare
- * name. Plans persist to `<projectDir>/plan.json` (from the injected
- * `WstackPaths`); the live context is read off `ctx` at dispatch.
- */
-declare function createPlanPlugin(opts?: PlanPluginOptions): Plugin;
-
-interface PromptsPluginOptions {
-    store?: DefaultPromptStore | undefined;
-    loader?: PromptLoader | undefined;
-    usage?: PromptUsageStore | undefined;
-    paths?: WstackPaths | undefined;
-}
-/**
- * PromptsPlugin — built-in prompt library.
- *
- * Registers three slash commands:
- *   - `/prompts`     manage your library (list/view/add/edit/delete/favorite/extend)
- *   - `/prompt`      search the merged library (builtin + user + project) and insert
- *   - `/prompt-gen`  AI-guided authoring of a new high-quality prompt
- *
- * Active by default for all WrongStack sessions. The host injects a
- * `PromptLoader` (cross-layer read + copy-on-write) via `config.promptLoader`;
- * without one the commands degrade to the writable user store only.
- */
-declare function createPromptsPlugin(opts?: PromptsPluginOptions): Plugin;
-
-/**
- * SecurityPlugin — automated security scanning back-end.
- *
- * Exposes the LLM-powered `defaultOrchestrator` programmatically. The
- * synchronous TUI surface is owned by the CLI built-in
- * `packages/cli/src/slash-commands/security.ts` (`/security audit-deps |
- * scan | redact-test | help`), which intentionally does NOT invoke the
- * orchestrator — slash commands run on a sync surface and a full scan
- * takes minutes. To run a real scan, dispatch a subagent from the TUI
- * (`/security scan` prints the dispatch instructions).
- *
- * Do NOT register a `/security` slash command here — it would shadow the
- * CLI built-in and leave users staring at a silent prompt while an
- * LLM scan hangs in the background. The `createSecuritySlashCommand`
- * factory remains exported for programmatic/test use only.
- */
-declare function createSecurityPlugin(): Plugin;
-
-interface SkillsPluginOptions {
-    skillLoader?: SkillLoader | undefined;
-    /**
-     * Registry adapters. When unset the plugin wires the github-direct adapter
-     * (for `user/repo` installs) plus a skills.sh adapter pointed at
-     * `config.skills.registryUrl` (default {@link DEFAULT_SKILLS_SH_URL}).
-     */
-    registryAdapters?: SkillRegistryAdapter[] | undefined;
-}
-/**
- * SkillsPlugin — skill library + installer + authoring toolkit.
- *
- * Registers `/skill`, `/skill-gen`, `/skill-search`, `/skill-install`,
- * `/skill-import`, `/skill-update`, `/skill-uninstall`. First-party ("official")
- * plugin, so the commands keep their bare names. Needs a `SkillLoader` (injected
- * by the host via `config.skillLoader`); without one the commands report that
- * and no-op.
- */
-declare function createSkillsPlugin(opts?: SkillsPluginOptions): Plugin;
-
-interface SyncPluginOptions {
-    paths?: WstackPaths | undefined;
-    configStore?: ConfigStore | undefined;
-    /** Secret vault for encrypting the GitHub token before persisting to disk. */
-    vault?: {
-        encrypt(plaintext: string): string;
-        decrypt?(value: string): string;
-    };
-}
-/**
- * SyncPlugin — GitHub-backed cloud sync for WrongStack user data.
- *
- * Registers `/sync` slash command. Users can push/pull their prompts,
- * skills, settings, memory, and history to a private GitHub repo.
- * Active by default; configure once with `/sync enable owner/repo TOKEN`.
- */
-declare function createSyncPlugin(opts?: SyncPluginOptions): Plugin;
-
-/**
- * Fetch a JSON document. Injectable so the installer is testable without
- * network access. Defaults to the global `fetch`.
- */
-type JsonFetcher = (url: string) => Promise<unknown>;
-interface PromptPullResult {
-    manifest: PromptRegistryManifest;
-    diff: RegistryDiff;
-    /** Always true for the stub — pull never writes anything yet. */
-    dryRun: true;
-}
-interface PromptInstallerOptions {
-    fetcher?: JsonFetcher | undefined;
-}
-/**
- * PromptInstaller — registry sync GROUNDWORK (stub).
- *
- * `pull()` fetches and validates a remote manifest and computes the checksum
- * diff against the prompts the caller already has — but writes NOTHING. The
- * actual download/write is the documented extension point (`install`), left
- * unimplemented so the sync surface can land incrementally and be reviewed
- * before it can touch the user's prompt store.
- *
- * Mirrors `SkillInstaller`. For a GitHub-backed hub, the contract is a repo
- * with a top-level `registry.json` (a `PromptRegistryManifest`) plus
- * `prompts/<slug>.json` bodies — the same shape the bundled dataset emits.
- */
-declare class PromptInstaller {
-    private readonly fetcher;
-    constructor(opts?: PromptInstallerOptions);
-    /**
-     * Fetch + validate a manifest and report what a sync WOULD change. Read-only.
-     * @param manifestUrl URL to the registry's `registry.json`.
-     * @param local       The prompts the caller already has (slug + checksum).
-     */
-    pull(manifestUrl: string, local: {
-        slug: string;
-        checksum?: string | undefined;
-    }[]): Promise<PromptPullResult>;
-    /**
-     * EXTENSION POINT (not yet wired): download the prompt bodies for the given
-     * registry refs and write them into the user layer as `source:'synced'`,
-     * recording each in the installed-prompts manifest. Intentionally unimplemented
-     * — pulling real content over the network is gated behind a future change so
-     * the format/diff path can ship and be reviewed first.
-     */
-    install(): Promise<never>;
-}
-
-/**
- * Tracks prompts pulled from a remote registry, persisted to
- * `~/.wrongstack/installed-prompts.json`. Mirrors `SkillManifestStore`. The
- * manifest is the source of truth for "what have I synced and at what version",
- * enabling a future `pull --favorites` / update flow.
- */
-declare class PromptManifestStore {
-    private readonly manifestPath;
-    constructor(manifestPath: string);
-    load(): Promise<PromptManifestData>;
-    save(data: PromptManifestData): Promise<void>;
-    /** Upsert one entry keyed by slug. */
-    record(entry: InstalledPromptEntry): Promise<void>;
-    remove(slug: string): Promise<boolean>;
-    list(): Promise<InstalledPromptEntry[]>;
-}
-
-/**
- * Idea #2 from IDEAS.md — Deterministic Replay.
- *
- * The hash function is the foundation of replay: given a `Request`,
- * produce a stable identifier so a recorded `Response` can be looked
- * up later when we want to "re-run" the same agent loop without
- * burning API credits.
- *
- * Stability rules:
- *
- *   - All object keys are sorted recursively before stringification.
- *     Without this, two semantically identical requests that differ
- *     only in key insertion order would produce different hashes.
- *   - We hash ONLY the fields that affect the response: `model`,
- *     `system`, `messages`, `tools`, `maxTokens`, and the four
- *     sampling knobs (`temperature`, `topP`, `stopSequences`,
- *     `toolChoice`). Anything else on the `Request` (metadata,
- *     future extensions) is ignored so replay stays forward-compat.
- *   - We serialize to JSON. The `ContentBlock` and `Message` shapes
- *     are pure data; this works as long as no `undefined` values
- *     sneak in (those get dropped by `JSON.stringify`, which is
- *     fine — the structural diff is what matters).
- *
- * The SHA-256 output is hex-encoded and prefixed with the algorithm
- * tag so a future migration to a different hash (e.g. blake3) is
- * trivial to detect.
- */
-declare function stableStringify(value: unknown): string;
-declare function hashRequest(request: Request): string;
-
-/**
- * ReplayProviderRunner — idea #2 from IDEAS.md.
- *
- * A drop-in `ProviderRunner` that wraps an inner runner and either
- *   - records every (request, response) pair it observes (mode: 'record'),
- *   - serves a recorded response when the request hash matches (mode: 'replay'),
- *   - or does both: serve when present, record when not (mode: 'auto').
- *
- * Bind to `TOKENS.ProviderRunner` to completely replace the default
- * runner. Or use `AgentExtension.wrapProviderRunner` to chain in
- * alongside other extensions.
- *
- * Mode semantics:
- *   - 'record' is the production mode. Every real API call is
- *     persisted; the user can later `wstack replay <sessionId>` to
- *     re-run with frozen responses.
- *   - 'replay' is the debugging mode. The agent loop runs normally
- *     (same permissions, same tool dispatch) but every LLM call
- *     comes from the recorded log. If a request hash is not in the
- *     log, we throw — the user is expected to either rebuild the
- *     session or fall back to record mode.
- *   - 'auto' is the warm-start mode for development. The first time
- *     a particular request is seen, it's recorded; the next time
- *     the same request is made, the recorded response is served.
- *     This is the cheapest path to a deterministic test harness.
- */
-type ReplayMode = 'record' | 'replay' | 'auto';
-interface ReplayProviderRunnerOptions {
-    log: ReplayLogStore;
-    sessionId: string;
-    mode: ReplayMode;
-    /**
-     * Optional logger — receives a debug line on every replay hit
-     * ("served cached response for hash sha256:…") and a warn on
-     * every miss in 'replay' mode (the throw that follows is the
-     * real signal, but the warn helps when the throw is caught
-     * upstream).
-     */
-    logger?: {
-        debug?: ((msg: string) => void) | undefined;
-        warn?: ((msg: string) => void) | undefined;
-    } | undefined;
-}
-declare class ReplayProviderRunner implements ProviderRunner {
-    private readonly inner;
-    private readonly opts;
-    constructor(inner: ProviderRunner, opts: ReplayProviderRunnerOptions);
-    run(runOpts: RunProviderOptions$1): Promise<Response>;
-}
-
-/**
- * `mcp_use` — meta-tool for ephemeral MCP tool calls in token-saving mode.
- *
- * Instead of the 4-step manual cycle (list → activate → use → deactivate),
- * the model calls this single tool. It:
- *  1. Activates the server's tools in the registry
- *  2. Calls the requested tool with the provided input
- *  3. Returns the result
- *  4. Deactivates the server's tools
- *
- * The tool is registered only when features.lazyMcp is active so the model
- * always has a way to reach MCP tools without them being in the prompt.
- */
-interface CreateMcpUseToolOptions {
-    /** Live MCP registry handle (activate/deactivate/describe). */
-    registry: MCPRegistryHandle;
-    /** Tool registry — needed to resolve and call MCP tools by name. */
-    toolRegistry: ToolRegistry;
-}
-declare function createMcpUseTool(opts: CreateMcpUseToolOptions): Tool;
-
-declare function readBundledInstructionText(relativePath: string): string;
-declare function renderInstructionTemplate(template: string, values: Record<string, string>): string;
-
-export { AddAttachmentInput, AgentExtension, AgentPipelines, AttachmentRef, AttachmentStore, type AutoPhaseOptions, type AutoPhasePlanResult, AutoPhasePlanner, type AutoPhasePlannerOptions, AutoPhaseRunner, type AutoPhaseRunnerOptions, type BootConfigOptions, type BootConfigResult, BrainArbiter, BuildContext, CHIMERA_REVIEW_PROMPT, type Checkpoint, CheckpointManager, type CheckpointManagerOptions, type ChimeraReviewNeededPayload, type CollabBusState, type InjectedToolResult as CollabInjectedToolResult, type CollabPauseMiddlewareOptions, CollaborationBus, type CommitSafetyOptions, type CommitSafetyReport, Config, ConfigStore, ConfiguredHook, type ConsumedInjectionInfo, Container, ContentBlock, type ContentScore, Context, type ContinuationInput, type ContinuationSource, type ContinueDirective, DefaultLogger, DefaultPluginAPI, DefaultPromptStore, DefaultSecretVault, DefaultSystemPromptBuilder, type DefaultSystemPromptBuilderOptions, type EliseResult, EventBus, EventName, ExtensionRegistry, type FallbackModelDeps, type FileAuthorEntry, type FileAuthorLog, type FileAuthorTrackerOptions, type ForeignFile, HealthRegistry, HookEvent, HookInput, HookMatcher, HookOutcome, HookRegistrationOptions, HookRegistry, InProcessHook, InputBuilder, type InputBuilderEvent, type InputBuilderOptions, InstalledPromptEntry, type InstructionBundle, type InstructionBundlePaths, JSONSchema, type JsonFetcher, KERNEL_API_VERSION, LAYER_1_IDENTITY, Listener, type LoadPluginsOptions, Logger, MCPRegistryHandle, MCPRegistryView, Mailbox, type MailboxLoopOptions, MailboxMessage, MemoryStore, Message, MetricsSink, MetricsSinkView, Middleware, ModeStore, ModelCapabilities, ModelsRegistry, type NicknameAssignment, PHASE_EVENT_NAMES, PermissionPolicy, type PhaseEventMap, type PhaseEventName, type PhaseExecutionContext, type PhaseFilter, type PhaseGraph, PhaseGraphBuilder, type PhaseGraphBuilderOptions, type PhaseNode, PhaseOrchestrator, type PhaseOrchestratorOptions, type PhaseProgress, type PhaseSort, type PhaseStatus, PhaseStore, type PhaseStoreOptions, type PhaseTemplate, Plugin, PluginAPI, type PluginAPIInit, PluginCapabilities, PluginDependency, PluginLLM, PluginPipelines, PromptInstaller, type PromptInstallerOptions, PromptLoader, PromptManifestData, PromptManifestStore, type PromptPullResult, PromptRegistryManifest, PromptUsageStore, Provider, ProviderRegistry, ProviderRegistryView, ProviderRunner, RegistryDiff, Renderer, ReplayLogStore, type ReplayMode, ReplayProviderRunner, type ReplayProviderRunnerOptions, Request, type ResolvedChimeraConfig, type ResolvedContinuation, Response, RunProviderOptions$1 as RunProviderOptions, SessionWriterView, type ShellHookSpec, SkillLoader, SkillRegistryAdapter, SlashCommand, SlashCommandRegistry, SlashCommandRegistryView, type SystemInstructionBundle, SystemPromptBuilder, SystemPromptContributor, SystemPromptRegions, TaskGraph, TaskNode, TaskPriority, TaskStore, TaskType, type TechStackConsumerOptions, TextBlock, TodoItem, TokenSavingTier, Tool, ToolCallPipelinePayload, ToolRegistry, ToolRegistryView, Tracer, WorktreeManager, WstackPaths, assessCommitSafety, assignNickname, attachMailboxChecker, bootConfig, buildBtwBlock, buildLosslessDigest, buildMailboxBlock, buildMailboxBtwAwarenessBlock, buildQueuedMessagesBlock, buildSmartDigest, collabInjectMiddleware, collabPauseMiddleware, compactLog, consumeBtwNotes, consumeQueuedMessagesUpdate, countShellHooks, createAutoPhaseFromTaskGraph, createChimeraPlugin, createFallbackModelExtension, createGitPlugin, createMailboxChecker, createMcpUseTool, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSkillsPlugin, createSyncPlugin, definePlugin, detectContinueIntent, effectiveFallbackChain, eliseOldToolResults, estimateMessageTokens, estimateMessages, extractText, fallbackProfileChain, findPreserveStart, flagsToConfigPatch, formatModelRef, getFileHistory, getFilesByAgent, getFullLog, getLastAuthor, hasTextContent, hashRequest, injectPendingMailboxMessages, loadInstructionBundle, loadPlugins, makeContinueToNextIterationTool, mergeInstructionBundle, nicknameKeyFromDisplay, normalizeModelRef, parseContinueDirective, parseModelRef, peekQueuedMessages, pendingBtwCount, readBundledInstructionText, recordFileAction, renderInstructionTemplate, resolveChimeraConfig, resolveContinuation, runProviderWithRetry, runShellHook, scoreMessage, setBtwNote, setQueuedMessagesSnapshot, shellHooksEqual, smartDefaultFallbackChain, stableStringify, startTechStackConsumer, unloadPlugins };
+export * from './utils/index.js';
+export { readBundledInstructionText, renderInstructionTemplate, } from './utils/instruction-file.js';
+export { safeParse, safeStringify, sanitizeJsonString, stripCodeFences } from './utils/safe-json.js';
+export { getTermSize, isInteractive, isStdinTTY, isStdoutTTY, type OutputLineGuard, onResize, setOutputLineGuard, setRawMode, writeErr, writeOut, } from './utils/term.js';
+export { type AllocateOpts, assertSafePath, type MergeOpts, type MergeResult, type WorktreeHandle, WorktreeManager, type WorktreeManagerOptions, type WorktreeRunResult, type WorktreeStatus, } from './worktree/index.js';
+export { type TaskStore, type TaskTrackerOptions, type TaskTransition, type TaskTrackerChange, type TaskTrackerListener, TaskTracker, } from './tasking/task-tracker.js';
+export { DefaultTaskStore } from './tasking/task-store.js';
+//# sourceMappingURL=index.d.ts.map