agent-afk 5.177.2 → 5.181.1

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

@@ -0,0 +1,27 @@
+export type HandoffRequestType = 'ask_question' | 'mcp' | 'path_approval';
+export interface HandoffRoute {
+    chatId: number;
+    threadId?: number;
+}
+export interface UpdateHandoffResult {
+    won: boolean;
+}
+export interface HandoffRecord {
+    taskId: string;
+    sessionId: string;
+    question: Record<string, unknown>;
+    requestType: HandoffRequestType;
+    route?: HandoffRoute;
+    elicitId?: string;
+    createdAt: string;
+    status: 'pending' | 'answered' | 'expired' | 'cancelled';
+    answer?: unknown;
+    answeredAt?: string;
+    answerSource?: string;
+    originalCommand: string;
+}
+export declare function writeHandoff(record: HandoffRecord, handoffsDir?: string): Promise<void>;
+export declare function readHandoff(taskId: string, handoffsDir?: string): Promise<HandoffRecord | null>;
+export declare function deleteHandoff(taskId: string, handoffsDir?: string): Promise<void>;
+export declare function listPendingHandoffs(handoffsDir?: string): Promise<HandoffRecord[]>;
+export declare function updateHandoffAnswer(taskId: string, answer: unknown, source: string, handoffsDir?: string): Promise<UpdateHandoffResult>;

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

@@ -1,4 +1,4 @@
-export type TaskState = 'queued' | 'leased' | 'running' | 'succeeded' | 'failed' | 'retrying' | 'dead-letter';
+export type TaskState = 'queued' | 'leased' | 'running' | 'waiting_human_input' | 'succeeded' | 'failed' | 'retrying' | 'dead-letter';
 export interface TaskRecord {
     id: string;
     command: string;

package/dist/agent/effect-ledger/classifier.d.ts

@@ -0,0 +1,5 @@
+export interface Classification {
+    isExternal: boolean;
+    operationType: string;
+}
+export declare function classifyToolCall(toolName: string, input: unknown): Classification;

package/dist/agent/effect-ledger/hook.d.ts

@@ -0,0 +1,4 @@
+import { EffectStore } from './store.js';
+import type { HookHandler } from '../hooks.js';
+export declare function createEffectLedgerPostHook(store?: EffectStore): HookHandler;
+export declare function createEffectLedgerPreHook(pendingIds: Map<string, string>, store?: EffectStore): HookHandler;

package/dist/agent/effect-ledger/idempotency.d.ts

@@ -0,0 +1 @@
+export declare function computeIdempotencyKey(operationType: string, args: unknown): string;

package/dist/agent/effect-ledger/index.d.ts

@@ -0,0 +1,6 @@
+export { EffectStore } from './store.js';
+export { classifyToolCall } from './classifier.js';
+export { computeIdempotencyKey } from './idempotency.js';
+export { createEffectLedgerPostHook, createEffectLedgerPreHook } from './hook.js';
+export type { EffectRecord, EffectStatus, EffectQuery, PendingEffectInput, ExecuteEffectInput, } from './types.js';
+export type { Classification } from './classifier.js';

package/dist/agent/effect-ledger/store.d.ts

@@ -0,0 +1,13 @@
+import type { EffectRecord, EffectQuery, PendingEffectInput, ExecuteEffectInput } from './types.js';
+export declare class EffectStore {
+    private readonly path;
+    private cachedRecords;
+    constructor(path?: string);
+    private readCached;
+    private invalidateCache;
+    writePending(input: PendingEffectInput): EffectRecord;
+    updateStatus(input: ExecuteEffectInput): Promise<EffectRecord>;
+    findByIdempotencyKey(key: string, sessionId?: string): Promise<EffectRecord | null>;
+    query(filters?: EffectQuery): Promise<EffectRecord[]>;
+    all(): Promise<EffectRecord[]>;
+}

package/dist/agent/effect-ledger/types.d.ts

@@ -0,0 +1,32 @@
+export type EffectStatus = 'pending' | 'executed' | 'confirmed' | 'failed' | 'ambiguous';
+export interface EffectRecord {
+    v: 1;
+    id: string;
+    idempotencyKey: string;
+    operationType: string;
+    args: unknown;
+    status: EffectStatus;
+    sessionId?: string;
+    taskId?: string;
+    timestamp: number;
+    result?: unknown;
+    reconciledAt?: number;
+}
+export interface EffectQuery {
+    sessionId?: string;
+    operationType?: string;
+    status?: EffectStatus;
+    idempotencyKey?: string;
+}
+export interface PendingEffectInput {
+    idempotencyKey: string;
+    operationType: string;
+    args: unknown;
+    sessionId?: string;
+    taskId?: string;
+}
+export interface ExecuteEffectInput {
+    id: string;
+    status: Exclude<EffectStatus, 'pending'>;
+    result?: unknown;
+}

package/dist/agent/facets/schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const FACET_VERSION = 2;
+export declare const FACET_VERSION = 3;
 export declare const ToolEventInputSchema: z.ZodObject<{
     toolName: z.ZodString;
     toolUseId: z.ZodOptional<z.ZodString>;
@@ -79,10 +79,10 @@ export declare const WorldChangesSchema: z.ZodObject<{
     mutated: z.ZodBoolean;
 }, z.core.$strip>;
 export declare const TokenBreakdownSchema: z.ZodObject<{
-    input: z.ZodNumber;
-    output: z.ZodNumber;
-    cache_read: z.ZodNumber;
-    cache_creation: z.ZodNumber;
+    input: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodNumber>;
+    cache_read: z.ZodOptional<z.ZodNumber>;
+    cache_creation: z.ZodOptional<z.ZodNumber>;
     cost_usd: z.ZodNumber;
 }, z.core.$strip>;
 export type TokenBreakdown = z.infer<typeof TokenBreakdownSchema>;
@@ -142,10 +142,10 @@ export declare const SessionFacetSchema: z.ZodObject<{
         mutated: z.ZodBoolean;
     }, z.core.$strip>;
     token_breakdown: z.ZodOptional<z.ZodObject<{
-        input: z.ZodNumber;
-        output: z.ZodNumber;
-        cache_read: z.ZodNumber;
-        cache_creation: z.ZodNumber;
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cache_read: z.ZodOptional<z.ZodNumber>;
+        cache_creation: z.ZodOptional<z.ZodNumber>;
         cost_usd: z.ZodNumber;
     }, z.core.$strip>>;
     decisions: z.ZodArray<z.ZodString>;

package/dist/agent/hooks.d.ts

@@ -54,6 +54,7 @@ export interface PostToolUseContext {
     toolName: string;
     input?: unknown;
     output?: unknown;
+    isError?: boolean;
     grantManager?: GrantManager;
     incomplete?: boolean;
     incompleteReason?: string;

package/dist/agent/mcp/client.d.ts

@@ -1,7 +1,8 @@
-import { type Tool as McpTool } from '@modelcontextprotocol/sdk/types.js';
+import { type CallToolResult, type Tool as McpTool } from '@modelcontextprotocol/sdk/types.js';
 import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
 import type { ToolResult } from '../tools/types.js';
 import type { McpServerConfig } from './types.js';
+import type { McpServerLayer } from './env-containment.js';
 export interface McpClientConnectResult {
     tools: McpTool[];
     serverInfo: {
@@ -12,12 +13,14 @@ export interface McpClientConnectResult {
 export declare class McpClient {
     private readonly serverName;
     private readonly config;
+    private readonly layer;
+    private readonly trustedAllowSecretEnv;
     private client;
     private connected;
     private pendingAuthTransport;
     onTransportError?: (err: Error) => void;
     onToolListChanged?: () => void;
-    constructor(serverName: string, config: McpServerConfig);
+    constructor(serverName: string, config: McpServerConfig, layer?: McpServerLayer, trustedAllowSecretEnv?: readonly string[]);
     connect(): Promise<McpClientConnectResult>;
     listTools(): Promise<McpTool[]>;
     refreshTools(): Promise<McpTool[]>;
@@ -25,4 +28,6 @@ export declare class McpClient {
     finishAuth(authorizationCode: string): Promise<void>;
     disconnect(): Promise<void>;
 }
+declare function normalizeCallToolResult(result: CallToolResult): ToolResult;
 export { UnauthorizedError };
+export { normalizeCallToolResult };

package/dist/agent/mcp/config-loader.d.ts

@@ -1,4 +1,5 @@
 import type { McpServerConfig } from './types.js';
+import type { McpServerLayer } from './env-containment.js';
 export interface McpConfigFile {
     mcpServers?: Record<string, McpServerConfig>;
 }
@@ -6,6 +7,8 @@ export interface LoadedMcpConfig {
     mcpServers: Record<string, McpServerConfig>;
     sources: string[];
     warnings: string[];
+    serverLayers: Record<string, McpServerLayer>;
+    userAllowSecretEnv: Record<string, string[]>;
 }
 export declare function getMcpConfigPath(): string;
 export declare function getProjectMcpConfigPath(cwd?: string): string | null;

package/dist/agent/mcp/env-containment.d.ts

@@ -0,0 +1,9 @@
+export type McpServerLayer = 'project' | 'user-global' | 'plugin' | 'cli';
+export declare function isSecretPattern(varName: string): boolean;
+export declare function isDangerousInherited(varName: string): boolean;
+export interface SecretCheckResult {
+    allowed: boolean;
+    warning?: string;
+}
+export declare function checkSecretExpansion(varName: string, layer: McpServerLayer, serverName: string, allowSecretEnv?: readonly string[]): SecretCheckResult;
+export declare function scrubDangerousEnv(base: Record<string, string>): string[];

package/dist/agent/mcp/env.d.ts

@@ -1,6 +1,20 @@
+import { type McpServerLayer } from './env-containment.js';
 export interface EnvExpansionResult<T> {
     value: T;
     missing: string[];
+    blocked: string[];
 }
-export declare function expandEnvString(input: string, source?: NodeJS.ProcessEnv): EnvExpansionResult<string>;
-export declare function expandEnvRecord(input: Record<string, string> | undefined, source?: NodeJS.ProcessEnv): EnvExpansionResult<Record<string, string>>;
+export declare function expandEnvString(input: string, source?: NodeJS.ProcessEnv): Omit<EnvExpansionResult<string>, 'blocked'>;
+export declare function expandEnvRecord(input: Record<string, string> | undefined, source?: NodeJS.ProcessEnv): Omit<EnvExpansionResult<Record<string, string>>, 'blocked'>;
+export interface EnvExpansionContext {
+    layer: McpServerLayer;
+    serverName: string;
+    allowSecretEnv?: readonly string[];
+}
+export declare function expandEnvStringForLayer(input: string, ctx: EnvExpansionContext, source?: NodeJS.ProcessEnv, warn?: (msg: string) => void): EnvExpansionResult<string>;
+export declare function expandEnvRecordForLayer(input: Record<string, string> | undefined, ctx: EnvExpansionContext, source?: NodeJS.ProcessEnv, warn?: (msg: string) => void): EnvExpansionResult<Record<string, string>>;
+export declare function expandHeadersForLayer(headers: Record<string, string> | undefined, ctx: EnvExpansionContext, source?: NodeJS.ProcessEnv, warn?: (msg: string) => void): {
+    headers: Record<string, string>;
+    missing: string[];
+    blocked: string[];
+};

package/dist/agent/mcp/manager.d.ts

@@ -1,9 +1,12 @@
 import type { AnthropicToolDef, ToolHandler } from '../tools/types.js';
 import type { McpClientState, McpServerConfig } from './types.js';
 import type { TraceSink } from '../trace/index.js';
+import type { McpServerLayer } from './env-containment.js';
 export interface McpManagerInitOptions {
     warnings?: string[];
     traceWriter?: TraceSink;
+    serverLayers?: Record<string, McpServerLayer>;
+    userAllowSecretEnv?: Record<string, string[]>;
 }
 export declare class McpManager {
     private readonly records;

package/dist/agent/mcp/transport.d.ts

@@ -1,6 +1,7 @@
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
 import type { McpServerConfig } from './types.js';
+import { type McpServerLayer } from './env-containment.js';
 export declare function expandHeaders(headers: Record<string, string> | undefined, source?: NodeJS.ProcessEnv): {
     headers: Record<string, string>;
     missing: string[];
@@ -9,4 +10,4 @@ export interface CreateTransportResult {
     transport: Transport;
     isSSE: boolean;
 }
-export declare function createTransport(serverName: string, config: McpServerConfig, oauthProvider?: OAuthClientProvider): CreateTransportResult;
+export declare function createTransport(serverName: string, config: McpServerConfig, oauthProvider?: OAuthClientProvider, layer?: McpServerLayer, trustedAllowSecretEnv?: readonly string[]): CreateTransportResult;

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

@@ -10,6 +10,7 @@ export interface McpServerConfig {
     disabled?: boolean;
     alwaysLoad?: boolean;
     timeout?: number;
+    allowSecretEnv?: string[];
 }
 export type McpClientStatus = 'connecting' | 'connected' | 'error' | 'disabled' | 'oauth_pending';
 export interface McpClientState {

package/dist/agent/provider.d.ts

@@ -100,6 +100,11 @@ export type ProviderEvent = {
     incomplete?: boolean;
     incompleteReason?: string;
     failureClass?: ToolFailureClass;
+} | {
+    type: 'tool.activity';
+    activeCount: number;
+    activeToolUseIds: string[];
+    sessionId?: string;
 } | {
     type: 'tool.diff';
     toolUseId: string;

package/dist/agent/providers/anthropic-direct/types.d.ts

@@ -46,7 +46,7 @@ export interface AnthropicToolDef {
 }
 export interface ToolDispatcherLike {
     execute(call: ToolCall): Promise<ToolResult>;
-    executeBatch?(calls: ToolCall[]): Promise<ToolResult[]>;
+    executeBatch?(calls: ToolCall[], onActivity?: (activeIds: readonly string[]) => void): Promise<ToolResult[]>;
     setResolveBase?(cwd: string): void;
     setAllowAll?(allow: boolean): void;
 }

package/dist/agent/providers/shared/event-relay.d.ts

@@ -0,0 +1 @@
+export declare function relayWhilePending<E, R>(start: (emit: (event: E) => void) => Promise<R>): AsyncGenerator<E, R, void>;

package/dist/agent/providers/shared/tool-activity.d.ts

@@ -0,0 +1 @@
+export type ToolActivityReporter = (activeIds: readonly string[]) => void;

package/dist/agent/tools/dispatcher.batch-process.d.ts

@@ -13,6 +13,7 @@ export interface BatchExecDeps {
     subagentExecutor: SubagentExecutor | undefined;
     sessionId: string | undefined;
     maxConcurrentSafeCalls: number;
+    onActivity?: (activeIds: readonly string[]) => void;
 }
 export declare function reconcileOutcomes(settled: PromiseSettledResult<{
     result: ToolResult;

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 { ToolActivityReporter } from '../providers/shared/tool-activity.js';
 import type { SpawnedPidRegistry } from './handlers/pid-registry.js';
 import { type ToolPermissionConfig } from './permissions.js';
 import type { CanUseTool } from '../types/sdk-types.js';
@@ -93,7 +94,7 @@ export declare class SessionToolDispatcher implements ToolDispatcher {
     private runCanUseTool;
     private runPreDispatchGates;
     execute(call: ToolCall): Promise<ToolResult>;
-    executeBatch(calls: ToolCall[]): Promise<ToolResult[]>;
+    executeBatch(calls: ToolCall[], onActivity?: ToolActivityReporter): Promise<ToolResult[]>;
     private executeCore;
     private applyOutputCap;
     private executeCoreInner;

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

@@ -24,5 +24,6 @@ import { waitForHandler } from './wait-for.js';
 import { patchApplyHandler } from './patch-apply.js';
 import { testRunHandler } from './test-run.js';
 import { getFacetHandler } from './get-facet.js';
+import { jsonQueryHandler, createJsonQueryHandler } from './json-query.js';
 export declare function createBuiltinHandlers(permissionMode?: string, cwd?: string): Map<string, ToolHandler>;
-export { bashHandler, readFileHandler, extractDocumentHandler, writeFileHandler, editFileHandler, globHandler, grepHandler, listDirectoryHandler, sendTelegramHandler, webScrapeHandler, webRequestHandler, createScheduleHandler, listSchedulesHandler, getScheduleHistoryHandler, cancelScheduleHandler, terminalFontSizeHandler, createWorktreeHandler, configGetHandler, configSetHandler, askQuestionHandler, waitForHandler, patchApplyHandler, browserOpenHandler, browserObserveHandler, browserActHandler, browserScreenshotHandler, browserCloseHandler, testRunHandler, getFacetHandler, };
+export { bashHandler, readFileHandler, extractDocumentHandler, writeFileHandler, editFileHandler, globHandler, grepHandler, listDirectoryHandler, sendTelegramHandler, webScrapeHandler, webRequestHandler, createScheduleHandler, listSchedulesHandler, getScheduleHistoryHandler, cancelScheduleHandler, terminalFontSizeHandler, createWorktreeHandler, configGetHandler, configSetHandler, askQuestionHandler, waitForHandler, patchApplyHandler, browserOpenHandler, browserObserveHandler, browserActHandler, browserScreenshotHandler, browserCloseHandler, testRunHandler, getFacetHandler, jsonQueryHandler, createJsonQueryHandler, };

package/dist/agent/tools/handlers/json-query.d.ts

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

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

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

package/dist/agent/tools/schemas.json-query.d.ts

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

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

@@ -72,6 +72,10 @@ export type OutputEvent = {
     type: 'notice';
     text: string;
     kind: 'truncation' | 'refusal';
+} | {
+    type: 'tool-activity';
+    activeCount: number;
+    activeToolUseIds: string[];
 } | {
     type: 'paused';
     reason: 'usage-limit';

package/dist/cli/commands/interactive/tool-lane-format.d.ts

@@ -12,4 +12,8 @@ export declare const GROUP_THRESHOLD_LEAF = 3;
 export declare function inProgressVerb(toolName: string): string;
 export declare function formatOutcome(chunk: ToolResultChunk, homeDir?: string, maxPreview?: number, toolName?: string): string;
 export declare function batchBadge(chunk: ToolResultChunk | undefined): string;
+export declare function activeToolBadge(toolUseId: string, activeTools: {
+    activeCount: number;
+    toolUseIds: Set<string>;
+} | null): string;
 export declare function formatToolResultLine(chunk: ToolResultChunk, toolPrefix?: string, homeDir?: string, toolName?: string): string;

package/dist/cli/commands/interactive/tool-lane.d.ts

@@ -9,6 +9,7 @@ export declare class ToolLane {
     private order;
     private agentIdStack;
     private lastElapsedSecond;
+    private activeTools;
     addStart(toolUseId: string, toolName: string, toolInput: string): void;
     addStartWithAgentContext(toolUseId: string, toolName: string, toolInput: string, agentContext: string | undefined, maxWidth?: number): void;
     mergeAgentLabel(parentToolUseId: string, label: string, maxWidth?: number): boolean;
@@ -16,6 +17,7 @@ export declare class ToolLane {
     setAgentResultSummary(toolUseId: string, summary: string): void;
     setThinkingTail(toolUseId: string, tail: string | undefined): void;
     addResult(toolUseId: string, chunk: ToolResultChunk): void;
+    notifyToolActivity(activeCount: number, activeToolUseIds: string[]): void;
     addDiff(toolUseId: string, diff: DiffPayload): void;
     addPreviewDiff(toolUseId: string, diff: DiffPayload): void;
     upsertTextChild(toolUseId: string, agentContext: string, text: string): void;

package/dist/cli/display.d.ts

@@ -5,6 +5,7 @@ export declare function padDisplayRight(text: string, width: number): string;
 export declare function padDisplayLeft(text: string, width: number): string;
 export declare function padDisplay(text: string, width: number, align?: 'left' | 'right' | 'center'): string;
 export declare function truncateDisplayWidth(text: string, maxWidth: number, ellipsis?: string): string;
+export declare function suffixDisplayWidth(text: string, maxWidth: number, ellipsis?: string): string;
 export declare function previousGraphemeIndex(text: string, index: number): number;
 export declare function nextGraphemeIndex(text: string, index: number): number;
 export interface CursorMetrics {

package/dist/cli/terminal-compositor.d.ts

@@ -105,6 +105,7 @@ export declare class TerminalCompositor {
     setInputMode(mode: CompositorInputMode): void;
     getInputMode(): CompositorInputMode;
     arm(): Promise<void>;
+    endTurn(): void;
     disarm(): void;
     setOverlay(text: string): void;
     setSpinner(config: {

package/dist/cli/terminal-compositor.lifecycle.d.ts

@@ -33,10 +33,13 @@ export interface LifecycleHost {
     readonly committedBand: string[];
     readonly committedBandMeta: BandRowMeta[];
     readonly committedBandTopRow: number;
+    readonly committedBandBottomRow: number;
     readonly committedBandPaintedRows: number;
     bandGeometryStale: boolean;
+    clearCommittedBand(): void;
 }
 export declare function suspendInput(self: LifecycleHost): void;
 export declare function resumeInput(self: LifecycleHost): void;
 export declare function arm(self: LifecycleHost & KeyDispatchHost): Promise<void>;
 export declare function disarm(self: LifecycleHost): void;
+export declare function endTurnFlush(self: LifecycleHost): void;