agent-afk 5.328.2 → 5.330.0

package/dist/agent/agents/index.d.ts

@@ -1,4 +1,4 @@
 export type { AgentRegistry, RegisteredAgent, } from './types.js';
 export { resolveAgentToolAccess } from './resolve.js';
 export { loadAgentRegistry } from './registry.js';
-export { buildAgentToolDef } from './tool-def.js';
+export { buildAgentToolDef, buildAgentTypeListing } from './tool-def.js';

package/dist/agent/agents/tool-def.d.ts

@@ -1,3 +1,4 @@
 import type { AnthropicToolDef } from '../tools/types.js';
 import type { AgentRegistry } from './types.js';
 export declare function buildAgentToolDef(registry: AgentRegistry | undefined): AnthropicToolDef;
+export declare function buildAgentTypeListing(registry: AgentRegistry | undefined): string;

package/dist/agent/hooks.d.ts

@@ -28,6 +28,8 @@ export interface SubagentStartContext {
     event: 'SubagentStart';
     subagentId: string;
     parentSessionId?: string;
+    chainId?: string;
+    continuationIndex?: number;
 }
 export interface SubagentStopContext {
     event: 'SubagentStop';

package/dist/agent/providers/anthropic-direct/query/prompt-assembly.d.ts

@@ -12,6 +12,7 @@ export interface PromptAssemblyArgs {
     skillExecutor?: SkillExecutor;
     runtimeStateSource: RuntimeStateSource;
     userSystem: string | null;
+    agentTypeListing?: string;
 }
 export interface AssembledPrompt {
     stableSystemPrefix: StableSystemParts;

package/dist/agent/providers/anthropic-direct/query/system-prompt.d.ts

@@ -6,6 +6,7 @@ export interface StableSystemPromptInputs {
     hotMemory: string;
     goalPrompt?: string;
     manifest: string;
+    agentTypeListing?: string;
     userSystem: string | null;
 }
 export type StableSystemParts = StableSystemPromptInputs;

package/dist/agent/providers/openai-compatible/query/turn-driver.d.ts

@@ -2,7 +2,7 @@ import type { ProviderEvent, ProviderUserTurn } from '../../../provider.js';
 import { type IterationContext, type FinishTurnContext } from './turn-iteration.js';
 import type { AbortCoordinator } from '../../shared/abort-coordinator.js';
 import type { ToolDispatcher } from '../../anthropic-direct/tool-dispatcher.js';
-import type { TraceSink } from '../../../trace/index.js';
+import type { TraceSink } from '../../../trace/writer.js';
 import type { OpenAIMessage } from '../messages.js';
 import type { OpenAIJournalWiring } from './journal-wiring.js';
 import type { AgentConfig } from '../../../types/config-types.js';
@@ -28,4 +28,5 @@ export interface TurnDriverContext extends IterationContext, FinishTurnContext {
 }
 export declare function applyBeforeNextRound(priorTurns: OpenAIMessage[], steeringText: string | undefined, traceWriter: TraceSink | undefined, subagentId: string | undefined): void;
 export declare function applyAndSyncSteering(ctx: TurnDriverContext): void;
+export declare function injectRoundCapNotice(priorTurns: OpenAIMessage[], round: number, maxIterations: number, traceWriter: TraceSink | undefined): void;
 export declare function runTurnInner(ctx: TurnDriverContext, content: ProviderUserTurn['content'], controller: AbortController, turnStartTime: number, taskId: string): AsyncGenerator<ProviderEvent>;

package/dist/agent/providers/openai-compatible/system-prompt-wiring.d.ts

@@ -11,6 +11,7 @@ export interface SystemPromptWiringArgs {
     surface: string;
     getCurrentCwd: () => string;
     runtimeStateSource: RuntimeStateSource;
+    agentTypeListing?: string;
 }
 export interface SystemPromptWiringResult {
     initialSystemPrompt: string;

package/dist/agent/safe-destruct-detect.d.ts

@@ -1,5 +1,6 @@
 import type { HookContext, HookDecision } from './hooks.js';
 export declare const SAFE_DESTRUCT_DETECT_REASON_PREFIX = "safe-destruct observe-only: destructive-command attempt";
 export declare const SAFE_DESTRUCT_BLOCK_INJECT_CONTEXT: string;
+export declare const WORKTREE_SCOPED_BLOCK_IDS: ReadonlySet<string>;
 export declare function detectDestructiveCommands(command: string): string[];
-export declare function createSafeDestructDetect(): (context: HookContext) => HookDecision;
+export declare function createSafeDestructDetect(sessionCwd?: string): (context: HookContext) => HookDecision;

package/dist/agent/session/agent-session.lifecycle.d.ts

@@ -6,6 +6,7 @@ import type { SessionStateManager } from './session-state.js';
 import type { HookRegistry } from '../hooks.js';
 import type { ProviderQuery, ProviderEvent } from '../provider.js';
 import type { QueryInputStream } from './input-iterable.js';
+import type { OutputEvent } from '../types/session-types.js';
 export interface SessionRunnerSlots {
     getConfig: () => AgentConfig;
     getAbortController: () => AbortController;
@@ -53,6 +54,7 @@ export interface BuildInitPromiseOptions {
     shutdown: SessionShutdown;
     hookRegistry: HookRegistry | undefined;
     queueFrameworkContext: (text: string) => void;
+    pushSidebandEvent: (event: OutputEvent) => void;
     getRunner: () => TurnStreamRunner;
     stateManager: SessionStateManager;
 }

package/dist/agent/session/model-slots.utils.d.ts

@@ -1,4 +1,3 @@
-type SlotProvider = 'anthropic' | 'openai' | 'chatgpt-oauth' | 'xai' | 'xai-oauth';
+import type { SlotProvider } from './model-slots.js';
 export declare function normalizeSlotProvider(value: unknown): SlotProvider | undefined;
 export declare function parseStringField(value: unknown): string;
-export {};

package/dist/agent/subagent/continuation-guards.d.ts

@@ -0,0 +1,28 @@
+import type { ChainRecord, WorkspaceCheckpoint } from './continuation-registry.js';
+export interface ContinuationOverrides {
+    agent_type?: string;
+    model?: string;
+    cwd?: string;
+    readRoots?: string[];
+    writeRoots?: string[];
+    isolation?: 'worktree';
+    host?: string;
+}
+export declare function checkContinuationOverrides(chain: ChainRecord, call: ContinuationOverrides): string | undefined;
+export type GitOutcome = {
+    ok: true;
+    stdout: string;
+} | {
+    ok: false;
+    timedOut: boolean;
+};
+export type CheckpointGitExec = (cwd: string, args: string[]) => Promise<GitOutcome>;
+export declare const CHECKPOINT_GIT_GLOBAL_ARGS: readonly string[];
+export declare const CHECKPOINT_GIT_TIMEOUT_MS = 10000;
+export declare const CHECKPOINT_GIT_KILL_GRACE_MS = 1000;
+export declare const CHECKPOINT_CAPTURE_DEADLINE_MS = 25000;
+export declare function captureCheckpointWithin(cwd: string, capture?: (cwd: string) => Promise<WorkspaceCheckpoint>, ms?: number): Promise<WorkspaceCheckpoint>;
+export declare function captureWorkspaceCheckpoint(cwd: string, exec?: CheckpointGitExec): Promise<WorkspaceCheckpoint>;
+export declare const CHECKPOINT_UNAVAILABLE_REASON = "workspace checkpoint unavailable (git status failed or timed out), so drift cannot be ruled out; retry the continuation";
+export declare const PRIOR_CHECKPOINT_UNAVAILABLE_REASON: string;
+export declare function checkWorkspaceDrift(chain: ChainRecord, recapture?: (cwd: string) => Promise<WorkspaceCheckpoint>): Promise<string | undefined>;

package/dist/agent/subagent/continuation-registry.d.ts

@@ -0,0 +1,85 @@
+export interface WorkspaceCheckpoint {
+    cwd: string;
+    git: boolean;
+    branch?: string;
+    head?: string;
+    dirtyFingerprint?: string;
+    unavailable?: true;
+}
+export interface ChainDispatchInputs {
+    agent_type?: string;
+    model?: string;
+    cwd?: string;
+    readRoots?: string[];
+    writeRoots?: string[];
+    isolation?: 'worktree';
+    writeCapable: boolean;
+}
+export interface ContinuationLimits {
+    maxRounds: number;
+    maxContinuations: number;
+}
+export interface ChainRecord {
+    chainId: string;
+    owner: string;
+    rootSessionId: string | undefined;
+    latestChildId: string | undefined;
+    inputs: ChainDispatchInputs;
+    roundsCharged: number;
+    continuations: number;
+    limits: ContinuationLimits;
+    inFlight: boolean;
+    initialUncharged: boolean;
+    checkpoint: WorkspaceCheckpoint | undefined;
+    lastEndReason: string | undefined;
+    settling: Promise<void> | undefined;
+    admitting: boolean;
+}
+export type AdmissionResult = {
+    ok: true;
+    chain: ChainRecord;
+    allowance: number;
+    index: number;
+    rollback: () => void;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface TerminalUpdate {
+    childId: string;
+    journalUsable: boolean;
+    roundsUsed: number;
+    checkpoint: WorkspaceCheckpoint | undefined;
+    endReason: string;
+}
+export declare const CONTINUATION_DEFAULTS: ContinuationLimits;
+export declare function resolveContinuationLimits(): ContinuationLimits;
+export declare const MAX_CHAINS = 256;
+export declare class ContinuationRegistry {
+    private readonly limits;
+    private readonly maxChains;
+    private readonly chains;
+    readonly rootActor: string;
+    constructor(limits?: ContinuationLimits, maxChains?: number);
+    get size(): number;
+    private evictForInsert;
+    createChain(args: {
+        owner: string;
+        rootSessionId: string | undefined;
+        inputs: ChainDispatchInputs;
+        roundCap: number;
+    }): ChainRecord;
+    get(chainId: string): ChainRecord | undefined;
+    admitContinuation(chainId: string, caller: string, requested: number | undefined, defaultAllowance: number, reserved?: boolean): AdmissionResult;
+    reserveAdmission(chainId: string): {
+        ok: true;
+        release: () => void;
+    } | {
+        ok: false;
+        reason: string;
+    };
+    chargeInitialRounds(chainId: string, roundsUsed: number): void;
+    setSettling(chainId: string, settling: Promise<void>): void;
+    recordTerminal(chainId: string, update: TerminalUpdate): void;
+}
+export declare function formatContinuationLine(chain: ChainRecord): string;

package/dist/agent/subagent/fork-lifecycle.d.ts

@@ -10,6 +10,11 @@ export interface EmitForkStartedArgs {
     promptHead: string | undefined;
     effectiveAgentType: string | undefined;
     effectiveResolvedAgentType: string | undefined;
+    continuation?: {
+        chainId: string;
+        continuationOf: string;
+        continuationIndex: number;
+    } | undefined;
 }
 export declare function emitForkStarted(args: EmitForkStartedArgs): string;
 export interface AppendForkTelemetryArgs {

package/dist/agent/subagent/fork-resolution.d.ts

@@ -1,6 +1,6 @@
 import type { HookRegistry } from '../hooks.js';
 import type { TraceSink } from '../trace/index.js';
-import type { AgentModelInput } from '../types.js';
+import type { AgentConfig, AgentModelInput } from '../types.js';
 import type { ForkSubagentOptions } from './fork-types.js';
 export interface ResolveForkInputsArgs {
     options: ForkSubagentOptions;
@@ -19,3 +19,4 @@ export interface ForkResolved {
     effectiveTimeoutMs: number;
 }
 export declare function resolveForkInputs(args: ResolveForkInputsArgs): ForkResolved;
+export declare function applyContinuationSeed(config: AgentConfig, options: Pick<ForkSubagentOptions, 'continuation'>): AgentConfig;

package/dist/agent/subagent/fork-types.d.ts

@@ -7,7 +7,7 @@ import type { SubagentProgressSink, OutputEvent } from '../types/session-types.j
 import type { TraceSink } from '../trace/index.js';
 import type { Surface } from '../awareness/types.js';
 import type { PhaseRole } from '../tools/nesting.js';
-import type { MessageJournal } from '../journal/index.js';
+import type { MessageJournal, JournalMessage } from '../journal/index.js';
 export interface ForkParent {
     sessionId?: string;
     id?: string;
@@ -27,6 +27,12 @@ export interface ForkSubagentOptions<T = unknown> {
     parentId?: string;
     promptHead?: string;
     denyElicitations?: boolean;
+    continuation?: {
+        messages: JournalMessage[];
+        chainId: string;
+        continuationOf: string;
+        continuationIndex: number;
+    };
     progressEvents?: boolean;
     phaseRole?: PhaseRole;
     nestedAgentAllowlist?: readonly string[];

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

@@ -56,6 +56,7 @@ export declare class SubagentHandleImpl<T> implements SubagentHandle<T> {
     _parentId: string | undefined;
     _currentTrace: SubagentTrace;
     _lastStreamedContent: string;
+    _runtimeRoundsUsed: number;
     _pauseCeiling: PauseAwareCeiling | undefined;
     _lastStopReason: string | undefined;
     _billingContext: RunBillingContext;

package/dist/agent/subagent/handle.streaming.d.ts

@@ -10,3 +10,4 @@ export declare function runInBackground<T>(handle: SubagentHandleImpl<T>, prompt
 export declare function dispatchStopAndRelease<T>(handle: SubagentHandleImpl<T>, reportedStatus: SubagentStatus, options?: {
     deferInjectContextToCaller?: boolean;
 }): Promise<void>;
+export declare function countRuntimeRounds<T>(handle: Pick<SubagentHandleImpl<T>, '_runtimeRoundsUsed'>, event: OutputEvent, last: number): number;

package/dist/agent/subagent/identity-preamble.d.ts

@@ -1,9 +1,11 @@
 import type { AgentConfig } from '../types/config-types.js';
+export declare const WORKTREE_STASH_RULE: string;
 export interface SubagentIdentityFacts {
     isNonInteractive: boolean | undefined;
     depth: number | undefined;
     maxDepth: number | undefined;
     nestedAgentAllowlist?: readonly string[];
+    cwd?: string;
 }
 export declare function renderSubagentIdentityPreamble(facts: SubagentIdentityFacts): string;
 export declare function injectSubagentIdentityPreamble(config: AgentConfig, nestedAgentAllowlist?: readonly string[]): AgentConfig;

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

@@ -49,6 +49,14 @@ export interface SubagentResult<T = unknown> extends Partial<CappedHandoff> {
     trace?: SubagentTrace;
     signal?: Signal;
     stopReason?: string;
+    continuation?: {
+        chainId: string;
+        roundsCharged: number;
+        maxRounds: number;
+        continuations: number;
+        maxContinuations: number;
+        continuable: boolean;
+    };
     setupNotice?: string;
 }
 export declare function buildResultFromMessage<T>(id: string, status: SubagentStatus, message: Message, outputSchema: ZodType<T> | undefined, trace?: SubagentTrace, stopReason?: string): SubagentResult<T>;

package/dist/agent/tools/handlers/lsp-shared.d.ts

@@ -7,3 +7,4 @@ export declare function parseMessages(buf: Buffer): {
 };
 export declare function languageIdForExt(ext: string): string | undefined;
 export declare function getTimeoutMs(): number;
+export declare function getSymbolsTimeoutMs(): number;

package/dist/agent/tools/handlers/lsp-symbols.d.ts

@@ -9,12 +9,14 @@ export interface LspSymbolResult {
     error?: string;
 }
 export type SymbolSubcommand = 'definition' | 'references';
+export declare const DEFAULT_LSP_CMD: readonly string[];
+export declare function parseLocation(raw: unknown): LspLocation | null;
 export declare function isLspSymbolsEnabled(): boolean;
-export declare function queryLspSymbol(filePath: string, subcommand: SymbolSubcommand, line: number, col: number, rootDir?: string, serverCmd?: readonly string[]): Promise<LspSymbolResult>;
+export declare function queryLspSymbol(filePath: string, subcommand: SymbolSubcommand, line: number, col: number, rootDir?: string, serverCmd?: readonly string[], signal?: AbortSignal): Promise<LspSymbolResult>;
 export declare function formatSymbolResult(filePath: string, subcommand: SymbolSubcommand, line: number, col: number, result: LspSymbolResult): string;
 export declare function handleCodeSymbols(input: {
     file_path: string;
     subcommand: SymbolSubcommand;
     line: number;
     col: number;
-}, context?: ToolHandlerContext, cwd?: string, serverCmd?: readonly string[]): Promise<string>;
+}, context?: ToolHandlerContext, cwd?: string, serverCmd?: readonly string[], signal?: AbortSignal): Promise<string>;

package/dist/agent/tools/schemas.order.d.ts

@@ -1,3 +1,3 @@
 import type { AnthropicToolDef } from './types.js';
-export declare const INVARIANT_CORE_COUNT = 26;
+export declare const INVARIANT_CORE_COUNT = 23;
 export declare function sortMcpSchemas(schemas: AnthropicToolDef[]): AnthropicToolDef[];

package/dist/agent/tools/subagent/child-config.d.ts

@@ -42,6 +42,7 @@ export interface BuildChildConfigArgs {
     onSubagentSucceeded?: import('../../subagent/fork-types.js').SubagentManagerOptions['onSubagentSucceeded'];
     workspaceStore?: import('../../workspace/index.js').WorkspaceStore;
     delegationBudget?: import('../../tools/delegation-budget.js').DelegationBudget;
+    continuationRegistry?: import('../../subagent/continuation-registry.js').ContinuationRegistry;
     hookRegistry?: import('../../hooks.js').HookRegistry;
     parentRootSessionId?: string;
     parentBillingStreams?: Set<Promise<void>>;

package/dist/agent/tools/subagent/continuation-dispatch.d.ts

@@ -0,0 +1,88 @@
+import type { ToolResult } from '../types.js';
+import { type AgentInput } from './input-parse.js';
+import { type ChainRecord, type ContinuationRegistry, type WorkspaceCheckpoint } from '../../subagent/continuation-registry.js';
+import type { ContinuationPlan } from './continuation-run.js';
+import type { TraceSink } from '../../trace/writer.js';
+export interface ContinuationResultFields {
+    continuation?: {
+        chainId: string;
+        roundsCharged: number;
+        maxRounds: number;
+        continuations: number;
+        maxContinuations: number;
+        continuable: boolean;
+    };
+}
+export declare function parseDispatchInput(input: unknown): {
+    parsed: AgentInput;
+} | {
+    error: ToolResult;
+};
+export interface ActorCtx {
+    depth: number;
+    continuationRegistry?: ContinuationRegistry;
+    parentSession: {
+        sessionId?: string | undefined;
+    };
+}
+export declare function actorIdentity(ctx: ActorCtx): string | undefined;
+export interface MintChainArgs {
+    registry: ContinuationRegistry | undefined;
+    owner: string | undefined;
+    rootSessionId: string | undefined;
+    parsed: AgentInput;
+    model: string | undefined;
+    cwd: string | undefined;
+    writeCapable: boolean;
+    roundCap: number | undefined;
+}
+export declare function mintDispatchChain(args: MintChainArgs): ChainRecord | undefined;
+export interface ChainTerminalArgs {
+    registry: ContinuationRegistry | undefined;
+    chain: ChainRecord | undefined;
+    childId: string;
+    cwd: string | undefined;
+    roundsUsed: number | undefined;
+    journalUsable: boolean;
+    endReason: string;
+    capture?: (cwd: string) => Promise<WorkspaceCheckpoint>;
+    traceWriter?: TraceSink | undefined;
+}
+export declare function recordChainTerminal(args: ChainTerminalArgs): Promise<WorkspaceCheckpoint | undefined>;
+export declare function markChainPromoted(handle: object): void;
+export declare function annotateChainResult<R extends ToolResult>(result: R, chain: ChainRecord | undefined, always?: boolean, handle?: object): R & ContinuationResultFields;
+export declare function endReasonOf(result: ToolResult): string;
+type ChainHandle = {
+    readonly id: string;
+    runToResult(prompt: never, ...rest: never[]): Promise<import('../../subagent/result.js').SubagentResult>;
+    runInBackground(prompt: never, onResult?: (r: import('../../subagent/result.js').SubagentResult) => void, ...rest: never[]): unknown;
+};
+export declare function instrumentHandleForChain(handle: ChainHandle, terminal: Omit<ChainTerminalArgs, 'childId' | 'roundsUsed' | 'endReason' | 'journalUsable'> & {
+    journalUsable: () => boolean;
+    flushJournal?: () => Promise<void>;
+    rollbackIfNotStarted?: () => void;
+    alwaysLine?: boolean;
+}): void;
+export type SettleDegradedReason = 'flush_timeout' | 'checkpoint_unavailable' | 'error';
+export declare const JOURNAL_FLUSH_TIMEOUT_MS = 5000;
+export declare function wireDispatchChain(args: {
+    ctx: ActorCtx & {
+        parentRootSessionId?: string;
+        traceWriter?: TraceSink | undefined;
+    };
+    parsed: AgentInput;
+    handle: ChainHandle & {
+        session?: {
+            messageJournal?: unknown;
+        };
+    };
+    childConfig: {
+        model?: string;
+        cwd?: string;
+        maxToolUseIterations?: number;
+    };
+    currentCwd: string | undefined;
+    writeCapable: boolean;
+    plan?: ContinuationPlan | undefined;
+}): ChainRecord | undefined;
+export {};

package/dist/agent/tools/subagent/continuation-run.d.ts

@@ -0,0 +1,33 @@
+import type { ToolCall, ToolResult } from '../types.js';
+import type { AgentInput } from './input-parse.js';
+import type { ForkSubagentOptions } from '../../subagent/fork-types.js';
+import type { ChainRecord, ContinuationRegistry, WorkspaceCheckpoint } from '../../subagent/continuation-registry.js';
+export interface ContinuationPlan {
+    chain: ChainRecord;
+    allowance: number;
+    rollback: () => void;
+    wired: boolean;
+    fork: NonNullable<ForkSubagentOptions['continuation']>;
+}
+interface AdmitCtx {
+    depth: number;
+    continuationRegistry?: ContinuationRegistry;
+    parentSession: {
+        sessionId?: string | undefined;
+    };
+    parentRootSessionId?: string;
+    recaptureCheckpoint?: (cwd: string) => Promise<WorkspaceCheckpoint>;
+}
+export declare function refuseContinuation(reason: string): {
+    error: ToolResult;
+};
+export declare function continuationNote(chain: ChainRecord, index: number, allowance: number): string;
+export declare const SETTLING_WAIT_MS = 15000;
+export declare function admitContinuationCall(parsed: AgentInput, ctx: AdmitCtx): Promise<{
+    plan: ContinuationPlan;
+    input: Record<string, unknown>;
+} | {
+    error: ToolResult;
+}>;
+export declare function runContinuation(call: ToolCall, parsed: AgentInput, ctx: AdmitCtx, dispatch: (call: ToolCall, plan: ContinuationPlan) => Promise<ToolResult>): Promise<ToolResult>;
+export {};

package/dist/agent/tools/subagent/foreground-promotion.d.ts

@@ -48,5 +48,6 @@ export interface RunForegroundArgs {
     promotionTookBudget?: {
         value: boolean;
     };
+    onPromoted?: () => void;
 }
 export declare function runForegroundWithPromotion(args: RunForegroundArgs): Promise<ToolResult>;

package/dist/agent/tools/subagent/input-parse.d.ts

@@ -16,5 +16,6 @@ export interface AgentInput {
     isolation?: 'worktree';
     progress_events?: boolean;
     host?: string;
+    continuation_chain_id?: string;
 }
 export declare function parseAgentInput(input: unknown): AgentInput;

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

@@ -36,6 +36,7 @@ export interface SubagentExecutorContext {
     traceWriter?: TraceSink;
     workspaceStore?: import('../../workspace/index.js').WorkspaceStore;
     delegationBudget?: DelegationBudget;
+    continuationRegistry?: import('../../subagent/continuation-registry.js').ContinuationRegistry;
     hookRegistry?: HookRegistry;
     allowedTools?: string[];
     readOnlyBash?: boolean;

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

@@ -16,6 +16,7 @@ export declare class SubagentExecutor implements SubagentControl {
     setCwd(cwd: string): void;
     setTraceWriter(writer: TraceSink | undefined): void;
     describeAgentTool(): AnthropicToolDef;
+    describeAgentTypeListing(): string;
     private readonly promotionTriggers;
     private readonly activeForegroundHandles;
     private readonly waveTracker;

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

@@ -4,6 +4,7 @@ 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';
+import { type ContinuationPlan } from './subagent/continuation-run.js';
 export interface ExecuteOnceArgs {
     ctx: SubagentExecutorContext;
     currentCwd: string | undefined;
@@ -19,4 +20,4 @@ export interface ExecuteOnceArgs {
     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>;
+export declare function executeOnce(call: ToolCall, args: ExecuteOnceArgs, probe?: StreamCutProbe, retryCancelGeneration?: number, plan?: ContinuationPlan): Promise<ToolResult>;

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

@@ -0,0 +1,8 @@
+import type { RegisteredAgent } from '../agents/index.js';
+import type { ToolResult } from './types.js';
+import type { SubagentExecutorContext } from './subagent-executor/types.js';
+export declare function resolveNamedAgent(ctx: Pick<SubagentExecutorContext, 'agentRegistry'>, agentType: string | undefined): {
+    namedAgent: RegisteredAgent | undefined;
+} | {
+    error: ToolResult;
+};

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

@@ -64,6 +64,7 @@ export interface ForkAndCheckCancelArgs {
     updateCurrentWaveUnit: (callId: string, status: 'running' | 'done' | 'failed', error?: string, cwd?: string) => void;
     callId: string;
     modelFallback?: ForkSubagentOptions['modelFallback'];
+    continuation?: ForkSubagentOptions['continuation'];
 }
 export type ForkResult = {
     handle: Awaited<ReturnType<SubagentManager['forkSubagent']>>;

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

@@ -2,6 +2,9 @@ import type { AgentInput } from './subagent/input-parse.js';
 import type { ToolResult } from './types.js';
 import { readUnlockPassword } from '../../remote/keychain-unlock.js';
 import { defaultSshRunner } from '../../remote/ssh-runner.js';
+import { type RemoteRunOutcome } from '../../remote/remote-run.js';
+import type { RemoteHost } from '../../remote/hosts.js';
+export declare function formatRemoteOutcome(outcome: RemoteRunOutcome, host: RemoteHost, runId: string, sessionId: string): ToolResult;
 export interface RemoteAgentDispatchDeps {
     runner?: typeof defaultSshRunner;
     loadHostsFn?: () => Promise<Record<string, import('../../remote/hosts.js').RemoteHost>>;

package/dist/agent/trace/events.d.ts

@@ -435,6 +435,9 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         agentType: z.ZodOptional<z.ZodString>;
         resolvedAgentType: z.ZodOptional<z.ZodString>;
         maxToolUseIterations: z.ZodOptional<z.ZodNumber>;
+        chainId: z.ZodOptional<z.ZodString>;
+        continuationOf: z.ZodOptional<z.ZodString>;
+        continuationIndex: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         provider: z.ZodOptional<z.ZodString>;
         tokens: z.ZodOptional<z.ZodObject<{
@@ -752,6 +755,8 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             hook_block_repeat_tripped: "hook_block_repeat_tripped";
             billing_settled: "billing_settled";
             subagent_model_fallback: "subagent_model_fallback";
+            round_cap_notice_dropped: "round_cap_notice_dropped";
+            continuation_settle_degraded: "continuation_settle_degraded";
         }>;
         durationMs: z.ZodOptional<z.ZodNumber>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
@@ -890,6 +895,9 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         agentType: z.ZodOptional<z.ZodString>;
         resolvedAgentType: z.ZodOptional<z.ZodString>;
         maxToolUseIterations: z.ZodOptional<z.ZodNumber>;
+        chainId: z.ZodOptional<z.ZodString>;
+        continuationOf: z.ZodOptional<z.ZodString>;
+        continuationIndex: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         provider: z.ZodOptional<z.ZodString>;
         tokens: z.ZodOptional<z.ZodObject<{
@@ -1231,6 +1239,8 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             hook_block_repeat_tripped: "hook_block_repeat_tripped";
             billing_settled: "billing_settled";
             subagent_model_fallback: "subagent_model_fallback";
+            round_cap_notice_dropped: "round_cap_notice_dropped";
+            continuation_settle_degraded: "continuation_settle_degraded";
         }>;
         durationMs: z.ZodOptional<z.ZodNumber>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;

package/dist/agent/trace/events.session-phase.d.ts

@@ -51,6 +51,8 @@ export declare const SessionPhaseNameSchema: z.ZodEnum<{
     hook_block_repeat_tripped: "hook_block_repeat_tripped";
     billing_settled: "billing_settled";
     subagent_model_fallback: "subagent_model_fallback";
+    round_cap_notice_dropped: "round_cap_notice_dropped";
+    continuation_settle_degraded: "continuation_settle_degraded";
 }>;
 export declare const SessionPhasePayloadSchema: z.ZodObject<{
     phase: z.ZodEnum<{
@@ -105,6 +107,8 @@ export declare const SessionPhasePayloadSchema: z.ZodObject<{
         hook_block_repeat_tripped: "hook_block_repeat_tripped";
         billing_settled: "billing_settled";
         subagent_model_fallback: "subagent_model_fallback";
+        round_cap_notice_dropped: "round_cap_notice_dropped";
+        continuation_settle_degraded: "continuation_settle_degraded";
     }>;
     durationMs: z.ZodOptional<z.ZodNumber>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;

package/dist/agent/trace/events.subagent-lifecycle.d.ts

@@ -24,6 +24,9 @@ export declare const SubagentStartedPayloadSchema: z.ZodObject<{
     agentType: z.ZodOptional<z.ZodString>;
     resolvedAgentType: z.ZodOptional<z.ZodString>;
     maxToolUseIterations: z.ZodOptional<z.ZodNumber>;
+    chainId: z.ZodOptional<z.ZodString>;
+    continuationOf: z.ZodOptional<z.ZodString>;
+    continuationIndex: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const SubagentSucceededPayloadSchema: z.ZodObject<{
     provider: z.ZodOptional<z.ZodString>;
@@ -96,6 +99,9 @@ export declare const SubagentLifecyclePayloadSchema: z.ZodDiscriminatedUnion<[z.
     agentType: z.ZodOptional<z.ZodString>;
     resolvedAgentType: z.ZodOptional<z.ZodString>;
     maxToolUseIterations: z.ZodOptional<z.ZodNumber>;
+    chainId: z.ZodOptional<z.ZodString>;
+    continuationOf: z.ZodOptional<z.ZodString>;
+    continuationIndex: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     provider: z.ZodOptional<z.ZodString>;
     tokens: z.ZodOptional<z.ZodObject<{

package/dist/agent/trace/types.d.ts

@@ -60,6 +60,9 @@ export interface SubagentStartedPayload {
     agentType?: string;
     resolvedAgentType?: string;
     maxToolUseIterations?: number;
+    chainId?: string;
+    continuationOf?: string;
+    continuationIndex?: number;
 }
 export interface SubagentSucceededPayload extends SubagentBillingFields {
     incomplete?: true;