agent-afk 5.172.1 → 5.175.0

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

@@ -0,0 +1,8 @@
+import { type QueuedTask } from './queue-store.js';
+import { type TaskRecord } from './task-lifecycle.js';
+export declare function leaseTask(task: QueuedTask, srcPath: string, leaseTtlMs?: number, queueDir?: string): TaskRecord;
+export declare function renewLease(taskId: string, leaseTtlMs?: number, queueDir?: string): void;
+export declare function completeTask(taskId: string, status: 'succeeded' | 'failed', error?: string, queueDir?: string): void;
+export declare function recoverExpiredLeases(queueDir?: string): TaskRecord[];
+export declare function getTaskRecord(taskId: string, queueDir?: string): TaskRecord | null;
+export declare function listActiveTasks(queueDir?: string): TaskRecord[];

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

@@ -1,9 +1,16 @@
+import { recoverExpiredLeases } from './lease-store.js';
+export { recoverExpiredLeases };
 export interface QueuedTask {
     id: string;
     command: string;
     enqueuedAt: string;
     sequence: number;
     notifyOn?: 'failure' | 'always' | 'never';
+    attempts?: number;
+    maxAttempts?: number;
+    backoffStrategy?: 'fixed' | 'exponential';
+    backoffBaseMs?: number;
+    eligibleAfter?: number;
 }
 export interface EnqueueOptions {
     notifyOn?: 'failure' | 'always' | 'never';

package/dist/agent/daemon/task-lifecycle.d.ts

@@ -0,0 +1,23 @@
+export type TaskState = 'queued' | 'leased' | 'running' | 'succeeded' | 'failed' | 'retrying' | 'dead-letter';
+export interface TaskRecord {
+    id: string;
+    command: string;
+    state: TaskState;
+    attempts: number;
+    maxAttempts: number;
+    leaseExpiry?: number;
+    lastError?: string;
+    createdAt: number;
+    updatedAt: number;
+    backoffStrategy?: 'fixed' | 'exponential';
+    backoffBaseMs?: number;
+    meta?: Record<string, unknown>;
+}
+export interface RetryPolicy {
+    maxAttempts: number;
+    backoffStrategy: 'fixed' | 'exponential';
+    backoffBaseMs: number;
+}
+export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+export declare const DEFAULT_LEASE_TTL_MS: number;
+export declare function computeBackoffMs(attempts: number, policy: RetryPolicy): number;

package/dist/agent/dag-checkpoint.d.ts

@@ -0,0 +1,15 @@
+import type { DAGGraph } from './dag.js';
+export interface DAGCheckpoint {
+    dagHash: string;
+    completedNodes: string[];
+    nodeOutputs: Record<string, string>;
+    failedNodes: string[];
+    nodeErrors?: Record<string, string>;
+    skippedNodes: string[];
+    timestamp: number;
+}
+export declare function computeDAGHash(graph: DAGGraph): string;
+export declare function saveCheckpoint(dagId: string, checkpoint: DAGCheckpoint): Promise<void>;
+export declare function loadCheckpoint(dagId: string, expectedHash: string): Promise<DAGCheckpoint | null>;
+export declare function clearCheckpoint(dagId: string): Promise<void>;
+export declare function serializeOutput(value: unknown): string;

package/dist/agent/dag.d.ts

@@ -11,6 +11,7 @@ export interface DAGGraph {
     edges: DAGEdge[];
 }
 export interface DAGRunOptions {
+    dagId?: string;
     failFast?: boolean;
     nodeTimeoutMs?: number;
     maxConcurrency?: number;

package/dist/agent/providers/anthropic-direct/build-dispatcher.d.ts

@@ -11,6 +11,7 @@ import type { AnthropicToolDef, ToolHandler } from '../../tools/types.js';
 import type { CustomToolDef } from '../../tools/custom-tool.js';
 import type { GrantManager } from '../../../cli/slash/commands/allow-dir.js';
 import type { RuntimeStateSource } from '../../awareness/index.js';
+import type { SpawnedPidRegistry } from '../../tools/handlers/pid-registry.js';
 import { SessionToolDispatcher } from '../../tools/dispatcher.js';
 import { type ToolPermissionConfig } from '../../tools/permissions.js';
 export interface BuildDispatcherOptions {
@@ -26,6 +27,7 @@ export interface BuildDispatcherOptions {
     runtimeStateSource?: RuntimeStateSource;
     hookRegistry?: HookRegistry;
     planExitControls?: PlanExitControls;
+    spawnedPidRegistry?: SpawnedPidRegistry;
 }
 export interface BuildDispatcherDeps {
     memoryStore: MemoryStore;

package/dist/agent/providers/anthropic-direct/provider-runtime.d.ts

@@ -29,6 +29,7 @@ export declare class AnthropicDirectProvider implements ModelProvider {
     private _mcpHandlersCache;
     private _presenceSessionId;
     private _mintedSessionId;
+    private readonly _spawnedPidRegistry;
     constructor(opts?: AnthropicDirectProviderOptions);
     private buildDispatcher;
     close(): void;

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

@@ -39,6 +39,7 @@ export declare class OpenAICompatibleProvider implements ModelProvider {
     private _sharedCurrentCwd;
     private _presenceSessionId;
     private _mintedSessionId;
+    private readonly _spawnedPidRegistry;
     constructor(opts?: OpenAICompatibleProviderOptions);
     setEndpointDefaults(defaults: {
         baseURL?: string;

package/dist/agent/tools/dispatcher.d.ts

@@ -7,6 +7,7 @@ import type { SubagentExecutor } from './subagent-executor.js';
 import type { SkillExecutor } from './skill-executor.js';
 import type { ComposeExecutor } from './compose-executor.js';
 import type { ToolHandler, ConcurrencyClassifier } from './types.js';
+import type { SpawnedPidRegistry } from './handlers/pid-registry.js';
 import { type ToolPermissionConfig } from './permissions.js';
 import type { CanUseTool } from '../types/sdk-types.js';
 import { type GrantSnapshot } from './grant-manager.js';
@@ -38,6 +39,7 @@ export interface SessionToolDispatcherOptions {
     traceWriter?: TraceSink;
     readOnlyBash?: boolean;
     maxOutputBytes?: number;
+    spawnedPidRegistry?: SpawnedPidRegistry;
 }
 export declare class SessionToolDispatcher implements ToolDispatcher {
     private readonly handlers;
@@ -62,6 +64,7 @@ export declare class SessionToolDispatcher implements ToolDispatcher {
     private readonly traceWriter;
     private readonly readOnlyBash;
     private readonly maxOutputBytes;
+    private readonly spawnedPidRegistry;
     private repeatBreaker;
     private readonly repeatFailureGuard;
     private denialBreaker;

package/dist/agent/tools/handlers/index.d.ts

@@ -19,5 +19,8 @@ import { browserObserveHandler } from './browser-observe.js';
 import { browserActHandler } from './browser-act.js';
 import { browserScreenshotHandler } from './browser-screenshot.js';
 import { browserCloseHandler } from './browser-close.js';
+import { waitForHandler } from './wait-for.js';
+import { patchApplyHandler } from './patch-apply.js';
+import { testRunHandler } from './test-run.js';
 export declare function createBuiltinHandlers(permissionMode?: string, cwd?: string): Map<string, ToolHandler>;
-export { bashHandler, readFileHandler, extractDocumentHandler, writeFileHandler, editFileHandler, globHandler, grepHandler, listDirectoryHandler, sendTelegramHandler, webScrapeHandler, createScheduleHandler, listSchedulesHandler, getScheduleHistoryHandler, cancelScheduleHandler, terminalFontSizeHandler, createWorktreeHandler, configGetHandler, configSetHandler, askQuestionHandler, browserOpenHandler, browserObserveHandler, browserActHandler, browserScreenshotHandler, browserCloseHandler, };
+export { bashHandler, readFileHandler, extractDocumentHandler, writeFileHandler, editFileHandler, globHandler, grepHandler, listDirectoryHandler, sendTelegramHandler, webScrapeHandler, createScheduleHandler, listSchedulesHandler, getScheduleHistoryHandler, cancelScheduleHandler, terminalFontSizeHandler, createWorktreeHandler, configGetHandler, configSetHandler, askQuestionHandler, waitForHandler, patchApplyHandler, browserOpenHandler, browserObserveHandler, browserActHandler, browserScreenshotHandler, browserCloseHandler, testRunHandler, };

package/dist/agent/tools/handlers/patch-apply-engine.d.ts

@@ -0,0 +1,12 @@
+import type { PatchFileChange, ValidationError } from './patch-validate.js';
+export interface PatchApplyResult {
+    status: 'applied' | 'dry_run' | 'validation_failed' | 'partial_failure';
+    diff: string;
+    files_changed: Array<{
+        path: string;
+        before_hash: string;
+        after_hash: string;
+    }>;
+    errors: ValidationError[];
+}
+export declare function applyPatch(changes: PatchFileChange[], fileContents: Map<string, string | null>, resolveBase: string, dryRun: boolean): Promise<PatchApplyResult>;

package/dist/agent/tools/handlers/patch-apply.d.ts

@@ -0,0 +1,3 @@
+import type { ToolHandler } from '../types.js';
+export declare function createPatchApplyHandler(cwd?: string): ToolHandler;
+export declare const patchApplyHandler: ToolHandler;

package/dist/agent/tools/handlers/patch-validate.d.ts

@@ -0,0 +1,22 @@
+import type { ToolHandlerContext } from '../types.js';
+export interface PatchFileChange {
+    path: string;
+    expected_hash?: string;
+    edits?: Array<{
+        old: string;
+        new: string;
+    }>;
+    content?: string;
+}
+export interface ValidationError {
+    path: string;
+    error: string;
+    detail?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    fileContents: Map<string, string | null>;
+}
+export declare function sha256Hex(content: string): string;
+export declare function validatePatchChanges(changes: PatchFileChange[], resolveBase: string, context?: ToolHandlerContext): Promise<ValidationResult>;

package/dist/agent/tools/handlers/pid-registry.d.ts

@@ -0,0 +1,7 @@
+export declare class SpawnedPidRegistry {
+    private readonly _pids;
+    register(pid: number): void;
+    has(pid: number): boolean;
+    clear(): void;
+    get size(): number;
+}

package/dist/agent/tools/handlers/test-failure-parser.d.ts

@@ -0,0 +1,9 @@
+import type { Runner } from './test-runner-detector.js';
+export interface TestFailure {
+    name: string;
+    file?: string;
+    line?: number;
+    message: string;
+    stack?: string;
+}
+export declare function parseTestFailures(output: string, runner: Runner): TestFailure[];

package/dist/agent/tools/handlers/test-run-discovery.d.ts

@@ -0,0 +1,7 @@
+export type DiscoveredRunner = 'vitest' | 'jest' | 'pytest' | 'mocha' | 'go-test' | 'cargo' | 'rspec' | 'node-generic';
+export interface DiscoveredCommand {
+    runner: DiscoveredRunner;
+    command: string;
+    args: string[];
+}
+export declare function discoverTestCommand(cwd: string): DiscoveredCommand | null;

package/dist/agent/tools/handlers/test-run.d.ts

@@ -0,0 +1,13 @@
+import type { ToolHandler } from '../types.js';
+import { type TestFailure } from './test-failure-parser.js';
+export interface TestRunResult {
+    runner: string;
+    command: string;
+    passed: number;
+    failed: number;
+    skipped?: number;
+    duration_ms: number;
+    failures: TestFailure[];
+    raw_output: string;
+}
+export declare const testRunHandler: ToolHandler;

package/dist/agent/tools/handlers/wait-for-conditions.d.ts

@@ -0,0 +1,33 @@
+import type { SpawnedPidRegistry } from './pid-registry.js';
+export type WaitCondition = UrlCondition | FileCondition | ProcessCondition | CommandCondition;
+export interface UrlCondition {
+    type: 'url';
+    url: string;
+    method?: 'HEAD' | 'GET';
+    expected_status?: number;
+    body_contains?: string;
+}
+export interface FileCondition {
+    type: 'file';
+    path: string;
+    content_contains?: string;
+    workspaceRoot?: string;
+}
+export interface ProcessCondition {
+    type: 'process';
+    pid: number;
+}
+export interface CommandCondition {
+    type: 'command';
+    command: string;
+    cwd?: string;
+}
+export interface WaitResult {
+    met: boolean;
+    detail: string;
+    data?: Record<string, unknown>;
+}
+export declare function evaluateUrl(cond: UrlCondition, signal: AbortSignal): Promise<WaitResult>;
+export declare function evaluateFile(cond: FileCondition, signal?: AbortSignal): Promise<WaitResult>;
+export declare function evaluateProcess(cond: ProcessCondition, registry?: SpawnedPidRegistry): WaitResult;
+export declare function evaluateCommand(cond: CommandCondition): WaitResult;

package/dist/agent/tools/handlers/wait-for-poller.d.ts

@@ -0,0 +1,19 @@
+import type { WaitResult } from './wait-for-conditions.js';
+export declare const DEFAULT_TIMEOUT_MS = 120000;
+export declare const MAX_TIMEOUT_MS = 600000;
+export declare const DEFAULT_POLL_INTERVAL_MS = 5000;
+export declare const MIN_POLL_INTERVAL_MS = 1000;
+export interface PollOptions {
+    timeout_ms: number;
+    poll_interval_ms: number;
+    backoff: 'none' | 'linear' | 'exponential';
+    signal: AbortSignal;
+}
+export interface PollResult {
+    status: 'succeeded' | 'timed_out' | 'cancelled' | 'failed';
+    elapsed_ms: number;
+    attempts: number;
+    result?: WaitResult;
+    error?: string;
+}
+export declare function pollUntil(evaluate: (signal: AbortSignal) => Promise<WaitResult>, options: PollOptions): Promise<PollResult>;

package/dist/agent/tools/handlers/wait-for.d.ts

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

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

@@ -1,4 +1,5 @@
 import type { AnthropicToolDef } from './types.js';
+export { waitForTool } from './schemas.wait-for.js';
 export declare const bashTool: AnthropicToolDef;
 export declare const readFileTool: AnthropicToolDef;
 export declare const extractDocumentTool: AnthropicToolDef;

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

@@ -1 +1,2 @@
 export { cancelBackgroundJobTool } from './schemas.background-cancel.js';
+export { patchApplyTool } from './schemas.patch-apply.js';

package/dist/agent/tools/schemas.patch-apply.d.ts

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

package/dist/agent/tools/schemas.test-run.d.ts

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

package/dist/agent/tools/schemas.wait-for.d.ts

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

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

@@ -4,6 +4,7 @@ export type { AnthropicToolDef } from '../providers/anthropic-direct/types.js';
 export type { ToolDispatcher } from '../providers/anthropic-direct/tool-dispatcher.js';
 import type { ToolResult } from '../providers/shared/tool-result.js';
 import type { TraceSink } from '../trace/index.js';
+import type { SpawnedPidRegistry } from './handlers/pid-registry.js';
 export interface ToolHandlerContext {
     cwd?: string;
     resolveBase?: string;
@@ -14,6 +15,7 @@ export interface ToolHandlerContext {
     traceWriter?: TraceSink;
     toolUseId?: string;
     sessionId?: string;
+    spawnedPidRegistry?: SpawnedPidRegistry;
 }
 export type ToolHandler = (input: unknown, signal: AbortSignal, context?: ToolHandlerContext) => Promise<ToolResult>;
 export type ConcurrencyClassifier = (toolName: string, input?: unknown) => boolean;

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

@@ -25,6 +25,7 @@ export interface ToolCallCompletedPayload {
     batchIndex?: number;
     batchSize?: number;
     subagentId?: string;
+    testResult?: import('../tools/handlers/test-runner-detector.js').TestResult;
 }
 export type ToolCallPayload = ToolCallStartedPayload | ToolCallCompletedPayload;
 export type HookEventName = 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'SessionStart' | 'SessionEnd' | 'SubagentStart' | 'SubagentStop';

package/dist/cli/_lib/stream-renderer-lifecycle.d.ts

@@ -33,6 +33,7 @@ export declare function registerOverlaySlots(overlayComposer: OverlayComposer, c
     getSoftStopping: () => boolean;
     getTtfbStartedAt?: () => number | undefined;
     isTtfbDone?: () => boolean;
+    getTtfbSpinnerFrame?: () => number;
     getActiveSubagents?: () => ReadonlyMap<string, SubagentStatusBarSpec>;
 }): void;
 export declare function formatInterruptAffordance(interrupting: boolean): string;

package/dist/cli/_lib/stream-renderer-ttfb.d.ts

@@ -4,12 +4,11 @@ export interface TtfbTickCtx {
     ttfbStartedAt: number | undefined;
     ttfbDone: boolean;
     lastTtfbAnnotation: string;
+    ttfbSpinnerFrame: number;
     isTTY: boolean;
     disposed: boolean;
     overlayComposer: OverlayComposer | null;
 }
 export declare function checkTtfbAnnotation(ctx: TtfbTickCtx, now: number): boolean;
 export declare function applyFirstContent(isDone: boolean, setDone: () => void, overlayComposer: OverlayComposer | null): boolean;
-export declare function renderTtfbWaitingLine(getTtfbStartedAt: (() => number | undefined) | undefined, isTtfbDone: (() => boolean) | undefined, palette: {
-    dim: (s: string) => string;
-}): string;
+export declare function renderTtfbWaitingProgress(getTtfbStartedAt: (() => number | undefined) | undefined, isTtfbDone: (() => boolean) | undefined, getSpinnerFrame: (() => number) | undefined): string;

package/dist/cli/_lib/stream-renderer.d.ts

@@ -44,6 +44,7 @@ export declare class StreamRenderer {
     private readonly ttfbStartedAt;
     private ttfbDone;
     private lastTtfbAnnotation;
+    private ttfbSpinnerFrame;
     private readonly addPreviewDiffRef;
     readonly sink: (event: OutputEvent, meta?: SubagentProgressMeta) => void;
     constructor(opts: StreamRendererOptions);

package/dist/cli/render/file-op-summary.d.ts

@@ -0,0 +1,8 @@
+export interface FileOpSummarySpec {
+    filesRead?: number;
+    filesWritten?: number;
+    filesEdited?: number;
+    filesDeleted?: number;
+    width?: number;
+}
+export declare function fileOpSummary(spec: FileOpSummarySpec): string;

package/dist/cli/render/index.d.ts

@@ -4,7 +4,6 @@ export * from './help-table.js';
 export * from './usage-limit-box.js';
 export * from './card.js';
 export * from './divider.js';
-export * from './progress-bar.js';
 export * from './box.js';
 export * from './subagent-status-bar.js';
 export * from './stream-progress.js';
@@ -18,3 +17,4 @@ export * from './preview-diff.js';
 export * from './context-bar.js';
 export * from './context-sparkline.js';
 export * from './session-summary.js';
+export * from './file-op-summary.js';

package/dist/cli/render/status-panel.d.ts

@@ -1,4 +1,12 @@
 export type StatusKind = 'ok' | 'warn' | 'error' | 'info';
+export interface HealthCheck {
+    name: string;
+    state: 'pass' | 'warn' | 'fail';
+    detail?: string;
+    fix?: string;
+}
+export declare function healthCheckRows(check: HealthCheck): string[];
+export declare function healthCheckSummary(checks: HealthCheck[]): string;
 export interface StatusRow {
     label: string;
     value: string;