agent-afk 5.308.5 → 5.308.7

package/dist/agent/afk-mode-gate.d.ts

@@ -12,5 +12,6 @@ export interface AfkModeGateOptions {
     }) => Promise<ElicitationResult>;
     sessionId?: string;
     traceWriter?: TraceSink;
+    daemonTaskId?: string;
 }
 export declare function createAfkModeGate(getMode: () => PermissionMode, cwd?: string, getCwd?: () => string | undefined, opts?: AfkModeGateOptions): HookHandler;

package/dist/agent/background-registry.d.ts

@@ -48,6 +48,5 @@ export declare class BackgroundAgentRegistry extends EventEmitter<BackgroundRegi
     getTouchedFiles(jobId: string): readonly string[] | undefined;
     private nextJobId;
     private markTerminal;
-    private statusFromResult;
     private snapshot;
 }

package/dist/agent/background-registry.mark-terminal.d.ts

@@ -0,0 +1,29 @@
+import type { BgJobLogWriter, BgJobMeta } from './bg-job-log.js';
+import type { SubagentResult, SubagentStatus } from './subagent.js';
+import type { TraceSink } from './trace/index.js';
+import type { BackgroundJobStatus } from './background-registry.types.js';
+export interface MarkTerminalJob {
+    jobId: string;
+    subagentId: string;
+    status: BackgroundJobStatus;
+    startedAt: number;
+    endedAt?: number;
+    result?: SubagentResult;
+    provenance: 'user' | 'model';
+    parentSessionId?: string;
+    cancelSource?: 'explicit' | 'cascade';
+    modelCancelReason?: string;
+    transcriptTail: string;
+    touchedFiles: string[];
+    handle: {
+        teardown(): Promise<void>;
+        cancel(): Promise<void>;
+    };
+    settle: (r: SubagentResult) => void;
+    onCleanup?: () => Promise<void>;
+    onSettled?: () => void;
+}
+export declare function statusFromResult(s: SubagentStatus): BackgroundJobStatus;
+export declare function appendTranscript(job: MarkTerminalJob, chunk: string): void;
+export declare function recordTouched(job: MarkTerminalJob, rawInput: unknown): void;
+export declare function markTerminalImpl(job: MarkTerminalJob, result: SubagentResult, emit: (job: MarkTerminalJob) => void, evict: (jobId: string) => void, traceWriter: TraceSink | undefined, writer?: BgJobLogWriter, openMeta?: BgJobMeta): Promise<void>;

package/dist/agent/daemon/gates.d.ts

@@ -1,5 +1,5 @@
 export declare const DEFAULT_SESSIONSTART_COOLDOWN_MS: number;
-export type SessionStartSkipReason = 'cooldown' | 'overlap' | 'budget-over' | 'telemetry-unwritable';
+export type SessionStartSkipReason = 'cooldown' | 'overlap' | 'budget-over' | 'telemetry-unwritable' | 'expired' | 'not-yet';
 export interface GateDecision {
     fire: boolean;
     skipReason?: SessionStartSkipReason;

package/dist/agent/daemon/schedule-store.d.ts

@@ -12,6 +12,8 @@ export interface ScheduledTaskConfig {
     notifyChat?: number | string;
     maxAttempts?: number;
     retryDelayMs?: number;
+    runAt?: string;
+    expiresAt?: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -20,8 +22,10 @@ export declare function saveSchedules(configs: ScheduledTaskConfig[], path?: str
 export declare function addSchedule(config: Omit<ScheduledTaskConfig, 'id' | 'createdAt' | 'updatedAt'>, path?: string): ScheduledTaskConfig;
 export declare function removeSchedule(id: string, path?: string): boolean;
 export declare function getSchedule(id: string, path?: string): ScheduledTaskConfig | undefined;
-export type SchedulePatch = Partial<Omit<ScheduledTaskConfig, 'id' | 'createdAt' | 'updatedAt' | 'cwd'>> & {
+export type SchedulePatch = Partial<Omit<ScheduledTaskConfig, 'id' | 'createdAt' | 'updatedAt' | 'cwd' | 'runAt' | 'expiresAt'>> & {
     cwd?: string | null;
+    runAt?: string | null;
+    expiresAt?: string | null;
 };
 export declare function updateSchedule(id: string, patch: SchedulePatch, path?: string): ScheduledTaskConfig | undefined;
 export declare function toggleScheduleEnabled(id: string, enabled: boolean, path?: string): ScheduledTaskConfig | undefined;

package/dist/agent/daemon/scheduler.d.ts

@@ -28,7 +28,7 @@ export interface SchedulerOptions {
     retrySleep?: (ms: number, signal: AbortSignal) => Promise<void>;
 }
 export type TelemetryTrigger = 'cron' | 'sessionstart' | 'pull';
-type TelemetryStatus = 'success' | 'error' | 'skipped';
+type TelemetryStatus = 'success' | 'error' | 'skipped' | 'blocked';
 export interface TelemetryRecord {
     taskId: string;
     command: string;
@@ -43,6 +43,7 @@ export interface TelemetryRecord {
     name?: string;
     doneUnverified?: boolean;
     attempts?: number;
+    gateBlocks?: number;
 }
 export interface TaskCompletionDetails {
     responseText?: string;

package/dist/agent/daemon/scheduler.execute-agent-task.d.ts

@@ -29,7 +29,9 @@ export interface AgentTaskContext {
     queueDir: string;
     idleDetector: IdleDetector;
     now: () => number;
-    spawnSession: (task: ScheduledTask, trigger: TelemetryTrigger) => Promise<{
+    spawnSession: (task: ScheduledTask, trigger: TelemetryTrigger, gateBlockCounter?: {
+        count: number;
+    }) => Promise<{
         session: AgentSession;
         memoryStore: MemoryStore;
         stateStore: StateStore;

package/dist/agent/daemon/scheduler.overlap-guard.d.ts

@@ -6,6 +6,8 @@ export declare function makeOverlapSkipRecord(task: ScheduledTask, trigger: Tele
 export declare function makeBudgetSkipRecord(task: ScheduledTask, trigger: TelemetryTrigger, nowMs: number, skip: BudgetGateSkip): TelemetryRecord;
 export declare function makeTelemetryUnwritableSkipRecord(task: ScheduledTask, nowMs: number, errorDescription: string): TelemetryRecord;
 export declare function makeSessionStartSkipRecord(task: ScheduledTask, decision: GateDecision, nowMs: number): TelemetryRecord;
+export declare function makeExpiredSkipRecord(task: ScheduledTask, trigger: TelemetryTrigger, nowMs: number): TelemetryRecord;
+export declare function makeNotYetSkipRecord(task: ScheduledTask, trigger: TelemetryTrigger, nowMs: number): TelemetryRecord;
 export declare class OverlapAlertLatch {
     private readonly alerted;
     shouldAlert(taskId: string): boolean;

package/dist/agent/daemon/scheduler.runat-gate.d.ts

@@ -0,0 +1,13 @@
+import type { ScheduledTask } from './triggers.js';
+import type { TelemetryRecord, TelemetryTrigger } from './scheduler.js';
+export type RunAtGateResult = {
+    kind: 'pass';
+} | {
+    kind: 'not-yet';
+    record: TelemetryRecord;
+} | {
+    kind: 'expired';
+    record: TelemetryRecord;
+};
+export declare function evaluateRunAtGate(task: ScheduledTask, trigger: TelemetryTrigger, nowMs: number): RunAtGateResult;
+export declare function applyAutoDisable(taskId: string, unregister: (id: string) => void): void;

package/dist/agent/daemon/session-spawn.d.ts

@@ -9,6 +9,9 @@ export interface DaemonSpawnOptions {
     sessionFactory?: (config: AgentConfig, ownedTraceWriter?: TraceWriter) => AgentSession;
     trigger?: 'cron' | 'sessionstart' | 'pull';
     taskCwd?: string;
+    gateBlockCounter?: {
+        count: number;
+    };
 }
 export declare function daemonTraceLabel(taskId: string): string;
 export declare function _resetDaemonDefaultCwdCache(): void;

package/dist/agent/daemon/triggers.d.ts

@@ -6,6 +6,8 @@ export interface ScheduledTask {
     executor?: TaskExecutor;
     trigger: TriggerMode;
     cronExpression?: string;
+    runAt?: string;
+    expiresAt?: string;
     debounceMs?: number;
     notifyOn?: 'failure' | 'always' | 'never';
     notifyChat?: number | string;

package/dist/agent/default-hook-registry.d.ts

@@ -22,4 +22,5 @@ export declare function createDefaultHookRegistry(onSubagentComplete?: (info: Su
     traceWriter?: TraceSink;
     afkPromptForApproval?: boolean;
     getTranscriptPath?: () => string | null;
+    daemonTaskId?: string;
 }, getCwd?: () => string | undefined): DefaultHookRegistryResult;

package/dist/agent/providers/openai-compatible/index.d.ts

@@ -1,35 +1,6 @@
 import type { ModelProvider, ProviderQuery, ProviderQueryArgs, ProviderCompleteArgs } from '../../provider.js';
-import type { HookRegistry } from '../../hooks.js';
-import type { SubagentExecutor } from '../../tools/subagent-executor.js';
-import type { SkillExecutor } from '../../tools/skill-executor.js';
-import type { ComposeExecutor } from '../../tools/compose-executor.js';
-import type { ToolPermissionConfig } from '../../tools/permissions.js';
-import type { CanUseTool } from '../../types/sdk-types.js';
-import type { ToolDispatcher } from '../anthropic-direct/tool-dispatcher.js';
-import { MemoryStore } from '../../memory/index.js';
-import { WorkspaceStore } from '../../workspace/index.js';
-import { StateStore } from '../../state/state-store.js';
-import { type ChildSessionOptions } from './index.child-session.js';
-export interface OpenAICompatibleProviderOptions extends ChildSessionOptions {
-    baseURL?: string;
-    defaultHeaders?: Record<string, string>;
-    hookRegistry?: HookRegistry;
-    permissions?: ToolPermissionConfig;
-    canUseTool?: CanUseTool;
-    subagentExecutor?: SubagentExecutor;
-    skillExecutor?: SkillExecutor;
-    composeExecutor?: ComposeExecutor;
-    memoryStore?: MemoryStore;
-    workspaceStore?: WorkspaceStore;
-    stateStore?: StateStore;
-    surface?: string;
-    readOnlyMemory?: boolean;
-    readOnlyBash?: boolean;
-    tools?: ToolDispatcher;
-    mcpManager?: import('../../mcp/index.js').McpManager;
-    customTools?: import('../../tools/custom-tool.js').CustomToolDef[];
-    fastModeController?: import('../../fast-mode.js').FastModeController;
-}
+import { type OpenAICompatibleProviderOptions } from './index.options.js';
+export type { OpenAICompatibleProviderOptions } from './index.options.js';
 export declare class OpenAICompatibleProvider implements ModelProvider {
     readonly name = "openai-compatible";
     private readonly providerOpts;

package/dist/agent/providers/openai-compatible/index.options.d.ts

@@ -0,0 +1,31 @@
+import type { HookRegistry } from '../../hooks.js';
+import type { SubagentExecutor } from '../../tools/subagent-executor.js';
+import type { SkillExecutor } from '../../tools/skill-executor.js';
+import type { ComposeExecutor } from '../../tools/compose-executor.js';
+import type { ToolPermissionConfig } from '../../tools/permissions.js';
+import type { CanUseTool } from '../../types/sdk-types.js';
+import type { ToolDispatcher } from '../anthropic-direct/tool-dispatcher.js';
+import { MemoryStore } from '../../memory/index.js';
+import { WorkspaceStore } from '../../workspace/index.js';
+import { StateStore } from '../../state/state-store.js';
+import type { ChildSessionOptions } from './index.child-session.js';
+export interface OpenAICompatibleProviderOptions extends ChildSessionOptions {
+    baseURL?: string;
+    defaultHeaders?: Record<string, string>;
+    hookRegistry?: HookRegistry;
+    permissions?: ToolPermissionConfig;
+    canUseTool?: CanUseTool;
+    subagentExecutor?: SubagentExecutor;
+    skillExecutor?: SkillExecutor;
+    composeExecutor?: ComposeExecutor;
+    memoryStore?: MemoryStore;
+    workspaceStore?: WorkspaceStore;
+    stateStore?: StateStore;
+    surface?: string;
+    readOnlyMemory?: boolean;
+    readOnlyBash?: boolean;
+    tools?: ToolDispatcher;
+    mcpManager?: import('../../mcp/index.js').McpManager;
+    customTools?: import('../../tools/custom-tool.js').CustomToolDef[];
+    fastModeController?: import('../../fast-mode.js').FastModeController;
+}

package/dist/agent/providers/shared/transient-retry.d.ts

@@ -16,5 +16,6 @@ export interface TransientRetryOpts {
     onExhausted?: (info: RetryInfo) => void;
     sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
 }
+export declare function isTransientOauthOrg403(err: unknown): boolean;
 export declare function isTransientError(err: unknown): boolean;
 export declare function withTransientRetry<T>(attempt: () => Promise<T>, opts?: TransientRetryOpts): Promise<T>;

package/dist/agent/providers/xai/oauth-http.d.ts

@@ -20,4 +20,5 @@ export declare function safeText(res: Response): Promise<string>;
 export declare function clearOidcCache(): void;
 export declare function discoverXaiOidc(deps?: OAuthHttpDeps): Promise<XaiOidcDiscovery>;
 export declare function discoverXaiOidcCached(deps?: OAuthHttpDeps): Promise<XaiOidcDiscovery>;
+export declare function postOAuthForm(url: string, params: Record<string, string>, errPrefix: string, fetchFn?: FetchFn): Promise<Record<string, unknown>>;
 export declare function tokenResponseToBundle(json: Record<string, unknown>, nowSeconds?: () => number, fallbackRefresh?: string): XaiTokenBundle | null;

package/dist/agent/risk-classifier.d.ts

@@ -2,5 +2,6 @@ export type RiskLevel = 'safe' | 'medium' | 'high';
 export interface RiskContext {
     cwd: string;
     workspaceRoot?: string;
+    daemonTaskId?: string;
 }
 export declare function classifyRisk(toolName: string, input: unknown, ctx: RiskContext): RiskLevel;

package/dist/agent/subagent.abort-wiring.d.ts

@@ -0,0 +1 @@
+export declare function wireParentAbortSignal(parentSignal: AbortSignal, rootController: AbortController): void;

package/dist/agent/subagent.drain.d.ts

@@ -0,0 +1,11 @@
+import type { AbortOrigin } from './trace/index.js';
+import type { AbortGraph } from './abort-graph.js';
+import { SUBAGENT_DRAIN_TIMEOUT_MS } from './subagent/constants.js';
+export interface DrainHandle {
+    cancel(): Promise<void>;
+}
+export declare function abortAllAndDrainImpl(active: ReadonlyMap<string, DrainHandle>, abortGraph: AbortGraph, rootId: string, reason: unknown, origin: AbortOrigin, timeoutMs: number, rearm: boolean, doRearm: () => void): Promise<{
+    drained: number;
+    timedOut: boolean;
+}>;
+export { SUBAGENT_DRAIN_TIMEOUT_MS };

package/dist/agent/tools/compose-executor.context.d.ts

@@ -0,0 +1,29 @@
+import type { AgentModelInput, IAgentSession } from '../types.js';
+import type { Surface } from '../awareness/types.js';
+import type { WorkspaceStore } from '../workspace/index.js';
+import type { TraceSink } from '../trace/index.js';
+import type { ReadScopeInputs } from '../subagent-read-scope.js';
+import type { AgentRegistry } from '../agents/index.js';
+import type { InboundAttachmentReader } from '../content/attachment-registry.js';
+export interface ComposeExecutorContext {
+    parentSession: Pick<IAgentSession, 'sessionId' | 'abortSignal'> & import('../subagent/fork-types.js').JournalParent;
+    defaultModel?: AgentModelInput;
+    defaultSubagentModel: AgentModelInput;
+    apiKey?: string;
+    resolveApiKeyForModel?: (model: string) => string | undefined;
+    baseUrl?: string;
+    openaiBaseUrl?: string;
+    systemPrompt: string;
+    cwd?: string;
+    traceWriter?: TraceSink;
+    surface?: Surface;
+    depth?: number;
+    maxDepth?: number;
+    getReadScopeInputs?: () => ReadScopeInputs;
+    workspaceStore?: WorkspaceStore;
+    agentRegistry?: AgentRegistry;
+    delegationBudget?: import('./delegation-budget.js').DelegationBudget;
+    inboundAttachmentRegistry?: InboundAttachmentReader;
+    onSubagentSucceeded?: (usage: import('../subagent/result.js').SubagentTrace['usage'], costUsd: number | undefined) => void;
+    credentialModel?: AgentModelInput;
+}

package/dist/agent/tools/compose-executor.d.ts

@@ -1,36 +1,10 @@
-import { type ReadScopeInputs } from '../subagent-read-scope.js';
-import type { AgentModelInput, IAgentSession } from '../types.js';
-import type { Surface } from '../awareness/types.js';
-import type { WorkspaceStore } from '../workspace/index.js';
 import type { TraceSink } from '../trace/index.js';
 import type { ToolCall, ToolResult } from './types.js';
+import { type ComposeExecutorContext } from './compose-executor.context.js';
+export type { ComposeExecutorContext } from './compose-executor.context.js';
 import { cleanupComposeSpills } from './compose-executor.format.js';
 export { cleanupComposeSpills };
-import type { InboundAttachmentReader } from '../content/attachment-registry.js';
-import type { AgentRegistry } from '../agents/index.js';
 import type { DetachableToolRegistry } from './detach-registry.js';
-export interface ComposeExecutorContext {
-    parentSession: Pick<IAgentSession, 'sessionId' | 'abortSignal'> & import('../subagent/fork-types.js').JournalParent;
-    defaultModel?: AgentModelInput;
-    defaultSubagentModel: AgentModelInput;
-    apiKey?: string;
-    resolveApiKeyForModel?: (model: string) => string | undefined;
-    baseUrl?: string;
-    openaiBaseUrl?: string;
-    systemPrompt: string;
-    cwd?: string;
-    traceWriter?: TraceSink;
-    surface?: Surface;
-    depth?: number;
-    maxDepth?: number;
-    getReadScopeInputs?: () => ReadScopeInputs;
-    workspaceStore?: WorkspaceStore;
-    agentRegistry?: AgentRegistry;
-    delegationBudget?: import('./delegation-budget.js').DelegationBudget;
-    inboundAttachmentRegistry?: InboundAttachmentReader;
-    onSubagentSucceeded?: (usage: import('../subagent/result.js').SubagentTrace['usage'], costUsd: number | undefined) => void;
-    credentialModel?: AgentModelInput;
-}
 export declare class ComposeExecutor {
     private readonly ctx;
     private currentCwd;

package/dist/agent/tools/compose-executor.wave-manifest.d.ts

@@ -0,0 +1,14 @@
+import type { ComposeInput } from './compose-input-parse.js';
+import type { AgentModelInput } from '../types.js';
+import type { AgentRegistry } from '../agents/index.js';
+export interface BuildComposeWaveManifestArgs {
+    parsed: ComposeInput;
+    dagNodeCount: number;
+    depth: number | undefined;
+    currentCwd: string | undefined;
+    defaultModel: AgentModelInput | undefined;
+    defaultSubagentModel: AgentModelInput;
+    parentSessionId: string | undefined;
+    agentRegistry: AgentRegistry | undefined;
+}
+export declare function buildComposeWaveManifest(args: BuildComposeWaveManifestArgs): string | undefined;

package/dist/agent/tools/subagent-executor.d.ts

@@ -1,6 +1,6 @@
 import type { TraceSink } from '../trace/index.js';
 import type { AnthropicToolDef, ToolCall, ToolResult } from './types.js';
-import { type AgentExecutionMode } from './subagent/input-parse.js';
+import type { AgentExecutionMode } from './subagent/input-parse.js';
 import { buildSubagentsLite } from './subagent-executor.lite-snapshot.js';
 import type { SubagentExecutorContext, SubagentControl } from './subagent-executor/types.js';
 import type { QueuedNoteClaim, PromotedSubagentInfo } from './subagent-executor/types.js';
@@ -11,7 +11,7 @@ export type { PromotedSubagentInfo } from './subagent/foreground-promotion.js';
 export declare class SubagentExecutor implements SubagentControl {
     private readonly ctx;
     private currentCwd;
-    private isolationCounter;
+    private readonly isolationCounterRef;
     constructor(ctx: SubagentExecutorContext);
     setCwd(cwd: string): void;
     setTraceWriter(writer: TraceSink | undefined): void;

package/dist/agent/tools/subagent-executor.execute-once.d.ts

@@ -0,0 +1,22 @@
+import type { ToolCall, ToolResult } from './types.js';
+import { type BuildChildConfigArgs } from './subagent/child-config.js';
+import { type PromotionTrigger } from './subagent/foreground-promotion.js';
+import type { StreamCutProbe } from '../subagent/stream-cut-retry.js';
+import { WaveManifestTracker } from './subagent-executor.wave-manifest.js';
+import type { SubagentExecutorContext } from './subagent-executor/types.js';
+export interface ExecuteOnceArgs {
+    ctx: SubagentExecutorContext;
+    currentCwd: string | undefined;
+    isolationCounterRef: {
+        value: number;
+    };
+    waveTracker: WaveManifestTracker;
+    promotionTriggers: Map<string, PromotionTrigger>;
+    activeForegroundHandles: Map<string, {
+        cancel: () => Promise<void>;
+    }>;
+    getCancelGeneration: () => number;
+    inheritedChildConfigArgs: () => Partial<BuildChildConfigArgs>;
+    updateCurrentWaveUnit: (callId: string, status: 'running' | 'done' | 'failed', error?: string, cwd?: string) => void;
+}
+export declare function executeOnce(call: ToolCall, args: ExecuteOnceArgs, probe?: StreamCutProbe, retryCancelGeneration?: number): Promise<ToolResult>;

package/dist/agent/tools/subagent-executor.execute-once.helpers.d.ts

@@ -0,0 +1,103 @@
+import { SubagentManager } from '../subagent.js';
+import type { AgentInput } from './subagent/input-parse.js';
+import type { StreamCutProbe } from '../subagent/stream-cut-retry.js';
+import { type InboundAttachmentReader } from '../content/attachment-registry.js';
+import type { SpawnReceipt } from './delegation-budget.js';
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import type { RegisteredAgent } from '../agents/index.js';
+import type { SubagentExecutorContext } from './subagent-executor/types.js';
+import type { TraceOrigin, TraceActor } from '../session/session-identity.js';
+import type { AgentConfig } from '../types/config-types.js';
+import type { ToolResult } from './types.js';
+import type { TraceSink } from '../trace/index.js';
+export interface IsolationWorktreeResult {
+    teardown: {
+        repoRoot: string;
+        worktreePath: string;
+    };
+}
+export interface SetupIsolationWorktreeArgs {
+    parsed: AgentInput;
+    currentCwd: string | undefined;
+    isolationCounterRef: {
+        value: number;
+    };
+    childConfig: AgentConfig;
+    childWriteCapable: boolean;
+    probe: StreamCutProbe | undefined;
+    budgetReceipt: SpawnReceipt | undefined;
+}
+export declare function setupIsolationWorktree(args: SetupIsolationWorktreeArgs): Promise<IsolationWorktreeResult | {
+    skipped: true;
+} | {
+    error: ToolResult;
+}>;
+export interface ForkAndCheckCancelArgs {
+    ctx: SubagentExecutorContext;
+    parsed: AgentInput;
+    childConfig: AgentConfig;
+    namedAgent: RegisteredAgent | undefined;
+    nestedAgentAllowlist: string[] | undefined;
+    isolationTeardown: {
+        repoRoot: string;
+        worktreePath: string;
+    } | undefined;
+    getCancelGeneration: () => number;
+    retryCancelGeneration: number | undefined;
+    budgetReceipt: SpawnReceipt | undefined;
+    childManager: {
+        teardownAll: () => Promise<void>;
+    } | undefined;
+    identity: {
+        origin?: TraceOrigin;
+        actor?: TraceActor;
+    };
+    depth: number;
+    updateCurrentWaveUnit: (callId: string, status: 'running' | 'done' | 'failed', error?: string, cwd?: string) => void;
+    callId: string;
+}
+export type ForkResult = {
+    handle: Awaited<ReturnType<SubagentManager['forkSubagent']>>;
+    cancelled: false;
+} | {
+    cancelled: true;
+    result: ToolResult;
+} | {
+    forkError: true;
+    result: ToolResult;
+};
+export declare function forkAndCheckCancel(args: ForkAndCheckCancelArgs): Promise<ForkResult>;
+export interface ResolveChildPromptArgs {
+    parsed: AgentInput;
+    childScopeInputs: {
+        parentReadRoots: string[] | undefined;
+        parentCwd: string | undefined;
+    };
+    currentCwd: string | undefined;
+    sessionId: string | undefined;
+    attachmentRegistry?: InboundAttachmentReader;
+}
+export type ResolveChildPromptResult = {
+    prompt: string | ContentBlockParam[];
+    error?: never;
+} | {
+    error: ToolResult;
+    prompt?: never;
+};
+export declare function resolveChildPrompt(args: ResolveChildPromptArgs): Promise<ResolveChildPromptResult>;
+export interface RunBackgroundDispatchArgs {
+    handle: Awaited<ReturnType<SubagentManager['forkSubagent']>>;
+    ctx: SubagentExecutorContext;
+    parsed: AgentInput;
+    childConfig: AgentConfig;
+    waveId: string | undefined;
+    callId: string;
+    budgetRelease: (() => void) | undefined;
+    isolationTeardown: {
+        repoRoot: string;
+        worktreePath: string;
+    } | undefined;
+    traceWriter: TraceSink | undefined;
+}
+export declare function runBackgroundDispatch(args: RunBackgroundDispatchArgs): Promise<ToolResult>;
+export declare function checkNestedScope(nestedScope: readonly string[], requestedType: string | undefined): ToolResult | undefined;

package/dist/cli/commands/config-command.env.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerEnvSubcommands(envCmd: Command): void;

package/dist/cli/commands/interactive/bootstrap-session-builder.d.ts

@@ -53,3 +53,12 @@ export declare function buildSharedDeps(a: {
     initialPermissionMode: PermissionMode | undefined;
     explicitProvider?: string;
 }): BuildAgentSessionDeps;
+import { MemoryStore } from '../../../agent/memory/index.js';
+import { StateStore } from '../../../agent/state/state-store.js';
+import { WorkspaceStore } from '../../../agent/workspace/workspace-store.js';
+export interface BootstrapSharedStores {
+    sharedWorkspaceStore: WorkspaceStore | undefined;
+    sharedMemoryStore: MemoryStore;
+    sharedStateStore: StateStore;
+}
+export declare function createBootstrapSharedStores(): BootstrapSharedStores;

package/dist/cli/commands/marketplace.subcommands.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from 'commander';
+import ora from 'ora';
+import { type InstallFromMarketplaceDeps } from '../../agent/marketplaces/resolve.js';
+import { type UpdateMarketplaceDeps, type UpdateMarketplaceOutcome } from '../../agent/marketplaces/update.js';
+export interface MarketplaceSubDeps extends InstallFromMarketplaceDeps, UpdateMarketplaceDeps {
+    logger?: Pick<Console, 'log' | 'error'>;
+    cacheDir: string;
+    indexPath: string;
+}
+export declare function registerMarketplaceInstallPlugin(market: Command, moduleDeps: MarketplaceSubDeps): void;
+export declare function registerMarketplaceRemove(market: Command, moduleDeps: MarketplaceSubDeps, logger: Pick<Console, 'log' | 'error'>): void;
+export declare function formatOutcome(o: UpdateMarketplaceOutcome): string;
+export declare function printOutcome(o: UpdateMarketplaceOutcome, spinner: ReturnType<typeof ora>): void;
+export declare function registerMarketplaceUpdate(market: Command, moduleDeps: MarketplaceSubDeps, logger: Pick<Console, 'log' | 'error'>): void;

package/dist/cli/config/json-tier-parse.interactive.d.ts

@@ -0,0 +1,4 @@
+import type { CliConfig, ConfigFileSchema } from './types.js';
+type InteractiveConfig = NonNullable<CliConfig['interactive']>;
+export declare function parseInteractiveBlock(raw: ConfigFileSchema['interactive'], configPath: string): InteractiveConfig | undefined;
+export {};

package/dist/cli/config/json-tier-parse.telegram.d.ts

@@ -0,0 +1,4 @@
+import type { CliConfig, ConfigFileSchema } from './types.js';
+type TelegramConfig = NonNullable<CliConfig['telegram']>;
+export declare function parseTelegramBlock(raw: ConfigFileSchema['telegram']): TelegramConfig | undefined;
+export {};

package/dist/cli/markdown-stream-buffer.d.ts

@@ -16,20 +16,13 @@ export interface ParsePipelineCallbacks {
     onScheduleRepaint(): void;
 }
 export declare function runParsePipeline(buffer: string, chunk: string, callbacks: ParsePipelineCallbacks): string;
-export interface LogUpdateFunction {
-    (str: string): void;
-    clear: () => void;
-}
 export interface RepaintParams {
     flushing: boolean;
     overlayComposer: OverlayComposerLike | null | undefined;
     compositor: CompositorLike | null;
-    logUpdate: LogUpdateFunction | null;
     renderPending(): string;
-    initLogUpdate(): Promise<LogUpdateFunction | null>;
-    onLogUpdateReady(fn: LogUpdateFunction | null): void;
 }
-export declare function executeRepaint(p: RepaintParams): Promise<void>;
+export declare function executeRepaint(p: RepaintParams): void;
 export interface CompositorLike {
     setOverlay(str: string): void;
 }
@@ -37,7 +30,5 @@ export interface OverlayComposerLike {
     markDirty(slot: string): void;
     flush(): void;
 }
-export declare function clearOverlay(overlayComposer: OverlayComposerLike | null | undefined, compositor: CompositorLike | null, logUpdate: {
-    clear(): void;
-} | null): void;
+export declare function clearOverlay(overlayComposer: OverlayComposerLike | null | undefined, compositor: CompositorLike | null): void;
 export declare function syncPendingOverlay(overlayComposer: OverlayComposerLike | null | undefined, compositor: CompositorLike | null, renderPending: () => string): void;

package/dist/cli/markdown-stream-format.d.ts

@@ -9,10 +9,6 @@ export declare function hasMarkdownContent(text: string): boolean;
 export declare function isInOpenCodeFence(text: string): boolean;
 export declare function isInOpenTable(text: string): boolean;
 export declare function findBlockBoundary(text: string): number;
-export declare function initLogUpdateModule(): Promise<{
-    (str: string): void;
-    clear: () => void;
-} | null>;
 export interface OverlayRoutingParams {
     indented: string;
     overlayComposer: {
@@ -22,10 +18,6 @@ export interface OverlayRoutingParams {
     compositor: {
         setOverlay(str: string): void;
     } | null;
-    logUpdate: {
-        (str: string): void;
-        clear: () => void;
-    } | null;
 }
 export declare function routeOverlayOutput(params: OverlayRoutingParams): boolean;
 export declare function accumulateCommitted(current: string, trimmed: string): string;

package/dist/cli/markdown-stream.d.ts

@@ -17,7 +17,6 @@ export declare class StreamingMarkdownRenderer {
     private committed;
     private throttleTimer;
     private lastPaintTime;
-    private logUpdate;
     private isTTY;
     private flushing;
     private compositor;
@@ -27,7 +26,6 @@ export declare class StreamingMarkdownRenderer {
     private inputState;
     private smoke;
     constructor(opts?: StreamingMarkdownRendererOptions);
-    private initLogUpdate;
     private commitBlock;
     private scheduleRepaint;
     renderPending(): string;

package/dist/cli/slash/commands/info.mcp.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../types.js';
+export declare const mcpCmd: SlashCommand;