agent-afk 5.312.9 → 5.313.1

package/dist/agent/memory/memory-evidence.d.ts

@@ -1,9 +1,13 @@
 import type { FactCategory, FactVerification } from './types.js';
 export declare const CODEBASE_FACT_CATEGORIES: ReadonlySet<FactCategory>;
 export declare const UNVERIFIED_TAG = "[unverified]";
+export declare const AUTO_REFLECTED_TAG = "[auto-reflected]";
+export declare const AUTO_REFLECTED_CATEGORIES: ReadonlySet<FactCategory>;
 export declare function isCodebaseFactCategory(category: FactCategory): boolean;
 export declare function evidenceGateEnabled(): boolean;
 export declare function requiresEvidence(category: FactCategory): boolean;
 export declare function normalizeEvidence(evidence: string | null | undefined): string | null;
 export declare function verificationStatus(category: FactCategory, evidence: string | null | undefined): FactVerification;
 export declare function applyUnverifiedTag(content: string, status: FactVerification): string;
+export declare function isAutoReflectedCategory(category: FactCategory): boolean;
+export declare function applyAutoReflectedTag(content: string, category: FactCategory): string;

package/dist/agent/providers/anthropic-direct/loop/stream-consumer.d.ts

@@ -1,5 +1,5 @@
 import type { ProviderEvent } from '../../../provider.js';
-import type { RunTurnInput } from '../types.js';
+import type { RunTurnInput, TurnResult } from '../types.js';
 import type { FirstByteTimeoutHandle } from '../../shared/first-byte-timeout.js';
 import { type StreamStallHandle } from '../../shared/stream-stall-timeout.js';
 import type { RoundRetryBudget } from './retry-budget.js';
@@ -15,4 +15,28 @@ export interface StreamConsumerContext {
     stallTimeoutMs: number;
     requestStartedAt: number;
 }
+export interface StreamRoundState {
+    turnResult: TurnResult | null;
+    translatorErrored: boolean;
+    retryTtfb: boolean;
+    retryOverload: boolean;
+    retryStreamIncomplete: boolean;
+    overloadExhausted: boolean;
+    ttfbEmitted: boolean;
+}
+export declare function handleFirstByteIfNeeded(state: StreamRoundState, input: RunTurnInput, ttfb: FirstByteTimeoutHandle, requestStartedAt: number): void;
+export declare function handleInBandError(state: StreamRoundState, errorEvent: Extract<ProviderEvent, {
+    type: 'error';
+}>, input: RunTurnInput, ttfb: FirstByteTimeoutHandle, stall: StreamStallHandle, stallTimeoutMs: number, retry: RoundRetryBudget): {
+    action: 'break';
+} | {
+    action: 'yield-and-break';
+    yieldEvent: ProviderEvent;
+};
+export declare function handleCatchError(state: StreamRoundState, err: unknown, input: RunTurnInput, turn: TurnAccumulator, ttfb: FirstByteTimeoutHandle, stall: StreamStallHandle, stallTimeoutMs: number, retry: RoundRetryBudget): {
+    done: true;
+    yieldEvent?: ProviderEvent;
+} | {
+    done: false;
+};
 export declare function consumeRoundStream({ events, input, turn, retry, ttfb, stall, stallTimeoutMs, requestStartedAt, }: StreamConsumerContext): AsyncGenerator<ProviderEvent, RoundOutcome, void>;

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

@@ -0,0 +1,9 @@
+import { SubagentManager } from '../subagent.js';
+import type { ComposeExecutorContext } from './compose-executor.context.js';
+export interface CreateComposeManagerArgs {
+    ctx: ComposeExecutorContext;
+    signal: AbortSignal;
+    currentCwd: string | undefined;
+    nodeReadRoots: string[] | undefined;
+}
+export declare function createComposeManager(args: CreateComposeManagerArgs): SubagentManager;

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

@@ -0,0 +1,25 @@
+import type { SubagentDAGNode } from '../dag-subagent.js';
+import type { ComposeNodeInput } from './compose-input-parse.js';
+import { type ResolvedComposeAgent } from './compose-agent-resolve.js';
+import type { ComposeExecutorContext } from './compose-executor.context.js';
+export type ComposeNodeBuildResult = SubagentDAGNode | {
+    attachmentError: true;
+    nodeId: string;
+    error: Error;
+};
+export interface BuildComposeDagNodeArgs {
+    node: ComposeNodeInput;
+    index: number;
+    resolvedAgent: ResolvedComposeAgent;
+    totalNodes: number;
+    composeToolUseId: string;
+    ctx: ComposeExecutorContext;
+    currentCwd: string | undefined;
+    nodeReadRoots: string[] | undefined;
+    maxToolRoundsPerNode: number | undefined;
+    depth: number;
+    maxDepth: number;
+}
+export declare function buildComposeUpstreamPrompt(prompt: string, inputs: Record<string, unknown>): string;
+export declare function resolveComposeNodeApiKey(nodeModel: string, ctx: Pick<ComposeExecutorContext, 'resolveApiKeyForModel' | 'apiKey'>): string | undefined;
+export declare function buildComposeDagNode(args: BuildComposeDagNodeArgs): Promise<ComposeNodeBuildResult>;

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

@@ -0,0 +1,40 @@
+import { type ComposeInput } from './compose-input-parse.js';
+import { deriveOrigin, actorFromDepth } from '../session/session-identity.js';
+import { runSubagentDAG, type SubagentDAGNode } from '../dag-subagent.js';
+import type { SubagentManager } from '../subagent.js';
+import type { ToolCall, ToolResult } from './types.js';
+import type { ComposeExecutorContext } from './compose-executor.context.js';
+export type ComposeRoutingIdentity = {
+    origin: ReturnType<typeof deriveOrigin>;
+    actor: ReturnType<typeof actorFromDepth>;
+} | Record<string, never>;
+export interface ComposePreflightOk {
+    ok: true;
+    parsed: ComposeInput;
+    parseWarnings: string[];
+    identity: ComposeRoutingIdentity;
+    depth: number;
+    maxDepth: number;
+    maxToolRoundsPerNode: number | undefined;
+}
+export declare function preflightComposeCall(call: ToolCall, ctx: ComposeExecutorContext): ComposePreflightOk | {
+    ok: false;
+    result: ToolResult;
+};
+export interface StartComposeDagArgs {
+    manager: SubagentManager;
+    ctx: ComposeExecutorContext;
+    parsed: ComposeInput;
+    dagNodes: SubagentDAGNode[];
+    dagEdges: Array<{
+        from: string;
+        to: string;
+    }>;
+    currentCwd: string | undefined;
+}
+export declare function startComposeDag(args: StartComposeDagArgs): ReturnType<typeof runSubagentDAG>;
+export declare function recordComposeCompleted(identity: ComposeRoutingIdentity, parentSessionId: ComposeExecutorContext['parentSession']['sessionId'], parsed: ComposeInput, result: {
+    outputs: Record<string, unknown>;
+    failed: unknown[];
+    skipped: unknown[];
+}, startedAt: number): void;

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

@@ -0,0 +1,19 @@
+import { formatDAGResult } from './compose-executor.format.js';
+import { prependUsageNotice } from './usage-notice.js';
+type ComposeRunResult = Parameters<typeof formatDAGResult>[0];
+export declare function updateComposeWaveUnits(composeWaveId: string | undefined, result: ComposeRunResult): void;
+export interface BuildComposeResultContentArgs {
+    result: ComposeRunResult;
+    spillSessionId: string;
+    callId: string;
+    parseWarnings: string[];
+    usageNotice: Parameters<typeof prependUsageNotice>[0];
+}
+export declare function buildComposeResultContent(args: BuildComposeResultContentArgs): string;
+export declare function filterComposeEdges<E extends {
+    from: string;
+    to: string;
+}>(edges: E[] | undefined, attachmentErrors: Array<{
+    id: string;
+}>): E[];
+export {};

package/dist/agent/tools/handlers/_output-cap.d.ts

@@ -5,4 +5,5 @@ export declare function capForModel(text: string): {
     content: string;
     truncated: boolean;
 };
-export declare const HARD_CAP_KILL_NOTE = "\n[output truncated \u2014 command exceeded the 8000000-byte output cap and was terminated]";
+export declare function isOutputCapKill(content: string): boolean;
+export declare const HARD_CAP_KILL_NOTE: string;

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

@@ -0,0 +1,22 @@
+import type { RunForegroundArgs, PromotedSubagentInfo } from './foreground-promotion.js';
+import type { ToolResult } from '../types.js';
+import type { QueuedNoteClaim } from './queued-note.js';
+import { type BackgroundDelivery } from './background-delivery.js';
+import { type teardownIsolatedWorktree } from '../handlers/worktree-managed.js';
+type RunPromise = ReturnType<RunForegroundArgs['handle']['runToResult']>;
+export declare function foregroundPromotionPayload(job: {
+    jobId: string;
+    subagentId: string;
+    label: string;
+}, delivery: BackgroundDelivery | undefined): Record<string, unknown>;
+export declare function reportPreservedForegroundWorktree(worktreePath: string, outcome: Awaited<ReturnType<typeof teardownIsolatedWorktree>>): void;
+export declare function prepareForegroundRun(args: RunForegroundArgs): {
+    abortListener: () => void;
+    startedAt: number;
+    promotionSignal: Promise<QueuedNoteClaim | undefined>;
+    resolveJob: (info: PromotedSubagentInfo | null) => void;
+};
+export declare function emitForegroundRejection(args: Pick<RunForegroundArgs, 'identity' | 'handle' | 'idPrefix' | 'parentSessionId' | 'depth'>, err: unknown, startedAt: number): void;
+export declare function foregroundCompletionResult(args: Pick<RunForegroundArgs, 'handle' | 'identity' | 'parentSessionId' | 'depth' | 'model' | 'parentModel' | 'idPrefix'>, result: Awaited<RunPromise>, startedAt: number): ToolResult;
+export declare function adoptForegroundRun(args: Pick<RunForegroundArgs, 'handle' | 'backgroundPrompt' | 'model' | 'parentSessionId' | 'budgetRelease'>, registry: NonNullable<RunForegroundArgs['registry']>, runPromise: RunPromise, isoTd: RunForegroundArgs['isolationTeardown']): import("../../background-registry.types.js").BackgroundJob;
+export {};

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

@@ -1,6 +1,6 @@
 import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
 import type { BackgroundAgentRegistry } from '../../background-registry.js';
-import { type BackgroundDelivery } from './background-delivery.js';
+import type { BackgroundDelivery } from './background-delivery.js';
 import type { SubagentManager } from '../../subagent.js';
 import type { TraceOrigin, TraceActor } from '../../session/session-identity.js';
 import type { TraceSink } from '../../trace/index.js';

package/dist/agent/types/message-types.d.ts

@@ -56,6 +56,7 @@ export interface ToolResultChunk {
     incompleteReason?: string;
     partialNodeCount?: number;
     truncated?: boolean;
+    outputCapKilled?: boolean;
     persistedPath?: string;
     capturePath?: string;
     tailPreview?: string[];

package/dist/cli/terminal-compositor.input-dispatch.enter.submit.d.ts

@@ -0,0 +1,3 @@
+import type { KeyDispatchHost } from './terminal-compositor.input-dispatch.js';
+export declare function handleEnterIdleSubmit(self: KeyDispatchHost): true;
+export declare function handleEnterStreamingQueue(self: KeyDispatchHost): true;