agent-afk 5.156.0 → 5.157.1

package/dist/agent/providers/anthropic-direct/query/session-state.d.ts

@@ -20,4 +20,5 @@ export declare function createSessionState(opts: {
     toolDispatcher: ToolDispatcher;
     initialMessages?: MessageParam[];
     autoCompactThreshold?: number;
+    initialUsageInputTokens?: number;
 }): SessionState;

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

@@ -11,6 +11,7 @@ export interface AnthropicDirectQueryOptions {
     toolDispatcher: ToolDispatcher;
     sessionId?: string;
     initialMessages?: MessageParam[];
+    initialUsageInputTokens?: number;
     model: string;
     requestedModel?: string;
     permissionMode?: string;

package/dist/agent/session/wire-executors.d.ts

@@ -27,6 +27,7 @@ export interface WireExecutorsOptions {
     backgroundRegistry?: BackgroundAgentRegistry;
     agentRegistryWarn?: (message: string) => void;
     workspaceStore?: WorkspaceStore;
+    sessionLabel?: string;
 }
 export interface WiredExecutors {
     rootManager: SubagentManager;

package/dist/agent/subagent/completed-cache.d.ts

@@ -0,0 +1,19 @@
+import type { SubagentHandle } from './handle.js';
+import type { SubagentResult } from './result.js';
+export interface CompletedEntry<T = unknown> {
+    readonly handle: SubagentHandle<T>;
+    readonly result: Pick<SubagentResult, 'id' | 'status'>;
+    readonly completedAt: number;
+}
+export declare class CompletedCache {
+    private readonly entries;
+    private readonly capacity;
+    constructor(capacity?: number);
+    add(id: string, handle: SubagentHandle, result: Pick<SubagentResult, 'id' | 'status'>): void;
+    get(id: string): CompletedEntry | undefined;
+    list(): readonly CompletedEntry[];
+    get size(): number;
+    delete(id: string): boolean;
+    clear(): void;
+    private evictIfNeeded;
+}

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

@@ -37,4 +37,5 @@ export interface SubagentManagerOptions {
     surface?: Surface;
     onSubagentSucceeded?: (usage: import('./result.js').SubagentTrace['usage'], costUsd: number | undefined) => void;
     workspaceStore?: WorkspaceStore;
+    sessionLabel?: string;
 }

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

@@ -3,9 +3,11 @@ import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
 import { AbortGraph } from '../abort-graph.js';
 import type { HookRegistry } from '../hooks.js';
 import type { IAgentSession, Message } from '../types.js';
-import type { OutputEvent, SubagentProgressSink } from '../types/session-types.js';
+import type { OutputEvent, SubagentProgressSink, SubagentProgressMeta } from '../types/session-types.js';
 import type { TraceSink } from '../trace/index.js';
+import { PauseAwareCeiling } from './pause-ceiling.js';
 import { type SubagentResult, type SubagentStatus, type SubagentTrace } from './result.js';
+export type { SubagentProgressMeta };
 export interface SubagentHandle<T = unknown> {
     readonly id: string;
     readonly status: SubagentStatus;
@@ -22,35 +24,38 @@ export interface SubagentHandle<T = unknown> {
 export declare class SubagentHandleImpl<T> implements SubagentHandle<T> {
     readonly id: string;
     readonly session: IAgentSession;
-    private readonly controller;
+    readonly _controller: AbortController;
     private readonly abortGraph;
-    private readonly outputSchema;
+    readonly _outputSchema: ZodType<T> | undefined;
     private readonly timeoutMs;
-    private readonly hookRegistry;
-    private readonly onTerminal;
-    private readonly parentInputStreamRef?;
-    private readonly parentAbortSignal?;
-    private readonly agentType?;
-    private readonly traceWriter?;
+    readonly _hookRegistry: HookRegistry | undefined;
+    readonly _onTerminal: () => void;
+    readonly _parentInputStreamRef?: ReturnType<IAgentSession["getInputStreamRef"]> | undefined;
+    readonly _parentAbortSignal?: AbortSignal | undefined;
+    readonly _agentType?: string | undefined;
+    readonly _traceWriter?: TraceSink | undefined;
     private readonly onSubagentSucceeded?;
-    private readonly idleTimeoutMs;
-    private currentStatus;
+    readonly _idleTimeoutMs: number;
+    _currentStatus: SubagentStatus;
     private inFlight;
-    private lastMessage;
-    private lastDurationMs;
+    _lastMessage: string | undefined;
+    _lastDurationMs: number | undefined;
     private latestTerminalStatus;
-    private stopDispatched;
-    private lastStopInjectContext;
-    private readonly progressSink;
-    private parentId;
-    private currentTrace;
-    private lastStreamedContent;
-    private pauseCeiling;
-    private lastStopReason;
-    constructor(id: string, session: IAgentSession, controller: AbortController, abortGraph: AbortGraph, outputSchema: ZodType<T> | undefined, timeoutMs: number, hookRegistry: HookRegistry | undefined, onTerminal: () => void, parentInputStreamRef?: ReturnType<IAgentSession["getInputStreamRef"]> | undefined, parentAbortSignal?: AbortSignal | undefined, agentType?: string | undefined, progressSink?: SubagentProgressSink, parentId?: string, traceWriter?: TraceSink | undefined, onSubagentSucceeded?: ((usage: SubagentTrace["usage"], costUsd: number | undefined) => void) | undefined, idleTimeoutMs?: number);
+    _stopDispatched: boolean;
+    _lastStopInjectContext: string | undefined;
+    readonly _progressSink: SubagentProgressSink | undefined;
+    _parentId: string | undefined;
+    _currentTrace: SubagentTrace;
+    _lastStreamedContent: string;
+    _pauseCeiling: PauseAwareCeiling | undefined;
+    _lastStopReason: string | undefined;
+    _logWriter?: {
+        write(event: OutputEvent): void;
+        close(): Promise<void>;
+    };
+    constructor(id: string, session: IAgentSession, _controller: AbortController, abortGraph: AbortGraph, _outputSchema: ZodType<T> | undefined, timeoutMs: number, _hookRegistry: HookRegistry | undefined, _onTerminal: () => void, _parentInputStreamRef?: ReturnType<IAgentSession["getInputStreamRef"]> | undefined, _parentAbortSignal?: AbortSignal | undefined, _agentType?: string | undefined, progressSink?: SubagentProgressSink, parentId?: string, _traceWriter?: TraceSink | undefined, onSubagentSucceeded?: ((usage: SubagentTrace["usage"], costUsd: number | undefined) => void) | undefined, _idleTimeoutMs?: number);
     get status(): SubagentStatus;
     run(prompt: string | ContentBlockParam[], sinkOverride?: SubagentProgressSink): Promise<Message>;
-    private streamToFinalMessage;
     runToResult(prompt: string | ContentBlockParam[], sinkOverride?: SubagentProgressSink): Promise<SubagentResult<T>>;
     runInBackground(prompt: string, onResult?: (result: SubagentResult<T>) => void, onProgress?: (event: OutputEvent) => void): void;
     cancel(): Promise<void>;
@@ -58,5 +63,4 @@ export declare class SubagentHandleImpl<T> implements SubagentHandle<T> {
         deferInjectContextToCaller?: boolean;
     }): Promise<void>;
     getLastStopInjectContext(): string | undefined;
-    private dispatchStopAndRelease;
 }

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

@@ -0,0 +1,11 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+import type { OutputEvent, SubagentProgressSink } from '../types/session-types.js';
+import type { Message } from '../types.js';
+import { type SubagentResult, type SubagentStatus } from './result.js';
+import type { SubagentHandleImpl } from './handle.js';
+export declare function streamToFinalMessage<T>(handle: SubagentHandleImpl<T>, prompt: string | ContentBlockParam[], sinkOverride?: SubagentProgressSink): Promise<Message>;
+export declare function runToResult<T>(handle: SubagentHandleImpl<T>, prompt: string | ContentBlockParam[], sinkOverride?: SubagentProgressSink): Promise<SubagentResult<T>>;
+export declare function runInBackground<T>(handle: SubagentHandleImpl<T>, prompt: string, onResult?: (result: SubagentResult<T>) => void, onProgress?: (event: OutputEvent) => void): void;
+export declare function dispatchStopAndRelease<T>(handle: SubagentHandleImpl<T>, reportedStatus: SubagentStatus, options?: {
+    deferInjectContextToCaller?: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,24 @@
+import type { OutputEvent } from '../types/session-types.js';
+export declare class SubagentLogWriter {
+    readonly sessionLabel: string;
+    readonly subagentId: string;
+    readonly logPath: string;
+    private stream;
+    private errored;
+    private closed;
+    private streamReady;
+    private pendingLines;
+    private readyPromise;
+    private readyResolve;
+    private bytesWritten;
+    constructor(sessionLabel: string, subagentId: string);
+    static isEnabled(): boolean;
+    write(event: OutputEvent): void;
+    close(): Promise<void>;
+    private openStream;
+    private writeLine;
+}
+export declare class SubagentLogReader {
+    static readEvents(sessionLabel: string, subagentId: string): AsyncGenerator<OutputEvent>;
+    static list(sessionLabel: string): Promise<string[]>;
+}

package/dist/agent/subagent.d.ts

@@ -3,6 +3,7 @@ import type { AbortOrigin, TraceSink } from './trace/index.js';
 import { type ReadScopeInputs } from './subagent-read-scope.js';
 import { type SubagentHandle } from './subagent/handle.js';
 import type { SubagentStatus, SubagentResult, SubagentTrace } from './subagent/result.js';
+import { CompletedCache } from './subagent/completed-cache.js';
 export type { SubagentStatus, SubagentResult, SubagentTrace, SubagentHandle };
 import { DENY_ELICITATION, SUBAGENT_DEFAULT_MAX_TOOL_USE_ITERATIONS, SUBAGENT_DEFAULT_TIMEOUT_MS, SUBAGENT_DEFAULT_IDLE_TIMEOUT_MS, SUBAGENT_BACKGROUND_TIMEOUT_MS, SUBAGENT_DRAIN_TIMEOUT_MS, resolveSubagentTimeoutMs, resolveSubagentIdleTimeoutMs } from './subagent/constants.js';
 import type { ForkParent, ForkSubagentOptions, SubagentManagerOptions } from './subagent/fork-types.js';
@@ -10,6 +11,7 @@ export { DENY_ELICITATION, SUBAGENT_DEFAULT_MAX_TOOL_USE_ITERATIONS, SUBAGENT_DE
 export type { ForkParent, ForkSubagentOptions, SubagentManagerOptions };
 export declare class SubagentManager {
     private readonly active;
+    readonly completed: CompletedCache;
     private readonly parentCanUseTool;
     private readonly hookRegistry;
     private readonly progressSink;
@@ -24,6 +26,7 @@ export declare class SubagentManager {
     private readonly parentSurface;
     private readonly parentAbortSignal;
     private readonly workspaceStore;
+    private readonly sessionLabel;
     private readonly abortGraph;
     private readonly rootId;
     private rootController;

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

@@ -13,6 +13,7 @@ export interface ToolConfig {
 export interface ResumeHistoryTurn {
     user: string;
     assistant: string;
+    inputTokens?: number;
 }
 export interface PlanExitControls {
     setPermissionMode(mode: PermissionMode): Promise<void>;

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

@@ -129,6 +129,7 @@ export interface IAgentSession {
     getQuery(): ProviderQuery;
     getLastResponseMetadata(): ResponseMetadata | null;
     getOutputStream(): AsyncIterable<OutputEvent>;
+    getHistory?(): readonly Message[];
     getInputStreamRef(): Pick<InputStreamRef, 'pushUserMessage' | 'queueFrameworkContext'>;
     supportedCommands(): Promise<SlashCommand[]>;
     supportedModels(): Promise<ModelInfo[]>;

package/dist/cli/output-event-format.d.ts

@@ -0,0 +1,3 @@
+import type { OutputEvent } from '../agent/types/session-types.js';
+export declare function formatOutputEvent(event: OutputEvent): string | null;
+export declare const formatDiskEvent: typeof formatOutputEvent;

package/dist/cli/slash/commands/tasks.d.ts

@@ -0,0 +1,8 @@
+import type { SlashCommand } from '../types.js';
+import type { SubagentManager } from '../../../agent/subagent.js';
+export declare function setTasksRegistry(manager: SubagentManager, sessionLabel: string): void;
+export declare function resetTasksRegistry(): void;
+export declare const tasksCmd: SlashCommand;
+export declare const tasksViewCmd: SlashCommand;
+export declare const tasksCancelCmd: SlashCommand;
+export declare const tasksCommands: readonly SlashCommand[];

package/dist/cli/slash/plugin-skills/flags.d.ts

@@ -1,3 +1,8 @@
+export interface PluginSkillHarvest {
+    flags: Map<string, string[]>;
+    categories: Map<string, string>;
+}
 export declare function harvestPluginSkillFlags(cacheRoot?: string): Map<string, string[]>;
+export declare function harvestPluginSkillMetadata(cacheRoot?: string): PluginSkillHarvest;
 export declare function harvestAllPluginSkillFlags(): Map<string, string[]>;
 export declare function extractHintFromDescription(description: string): string | undefined;

package/dist/cli/slash/plugin-skills/state.d.ts

@@ -4,6 +4,7 @@ export interface DiscoveredSkill {
     description: string;
     argumentHint?: string;
     source?: SkillManifestEntry['source'];
+    category?: string;
 }
 export interface PluginCollision {
     bare: string;

package/dist/cli/slash/plugin-skills.d.ts

@@ -1,4 +1,4 @@
-export { harvestPluginSkillFlags, extractHintFromDescription, } from './plugin-skills/flags.js';
+export { harvestPluginSkillFlags, harvestPluginSkillMetadata, extractHintFromDescription, type PluginSkillHarvest, } from './plugin-skills/flags.js';
 export { initialSkillsCmd } from './plugin-skills/listing.js';
 export { makeForwardHandler, registerPluginSkills, getPluginShadowingNoticeLines, autoRegisterPluginPassthroughs, } from './plugin-skills/dispatch.js';
 export { buildSourceBreakdown, computeSkillDelta, formatSkillDelta, buildPluginRows, reloadPluginsCmd, } from './plugin-skills/reload.js';