agent-afk 5.1.0 → 5.3.0

package/dist/agent/_lib/skill-sink-channel.d.ts

@@ -0,0 +1,3 @@
+import type { SubagentProgressSink } from '../types/session-types.js';
+export declare function runWithSink<T>(sink: SubagentProgressSink, fn: () => Promise<T>): Promise<T>;
+export declare function getCurrentSink(): SubagentProgressSink | undefined;

package/dist/agent/_lib/trusted-skill-events.d.ts

@@ -0,0 +1,7 @@
+import type { TrustedSkillResult } from '../trusted-skill-result.js';
+export declare function onTrustedSkillComplete(fn: (result: TrustedSkillResult) => void): void;
+export declare function offTrustedSkillComplete(fn: (result: TrustedSkillResult) => void): void;
+export declare function onTrustedSkillStart(fn: (skillName: string) => void): void;
+export declare function offTrustedSkillStart(fn: (skillName: string) => void): void;
+export declare function emitTrustedSkillComplete(result: TrustedSkillResult): void;
+export declare function emitTrustedSkillStart(skillName: string): void;

package/dist/agent/_lib/trusted-skill-registry.d.ts

@@ -0,0 +1,3 @@
+export declare function registerTrustedSkillName(name: string): void;
+export declare function isTrustedSkill(name: string): boolean;
+export declare function clearTrustedSkillNamesForTesting(): void;

package/dist/agent/abort-graph.d.ts

@@ -0,0 +1,20 @@
+import type { AbortOrigin, TraceWriter } from './trace/index.js';
+export interface ChildAbortedEvent {
+    parentId: string;
+    childId: string;
+    reason?: unknown;
+}
+export type ChildAbortedListener = (event: ChildAbortedEvent) => void;
+export declare class AbortGraph {
+    private readonly nodes;
+    private readonly traceWriter;
+    constructor(traceWriter?: TraceWriter);
+    register(id: string, controller: AbortController): void;
+    has(id: string): boolean;
+    getController(id: string): AbortController | undefined;
+    childrenOf(id: string): string[];
+    linkChild(parentId: string, childId: string): void;
+    onChildAborted(parentId: string, listener: ChildAbortedListener): () => void;
+    abort(id: string, reason?: unknown, origin?: AbortOrigin): void;
+    dispose(id: string): void;
+}

package/dist/agent/afk-channel.d.ts

@@ -0,0 +1,9 @@
+import type { ElicitationResult } from './types/sdk-types.js';
+export declare function stableStringify(value: unknown): string;
+export declare function ensureSessionKey(sessionId: string): string | null;
+export declare function readSessionKey(sessionId: string): string | null;
+export declare function signElicitationResponse(key: string, sessionId: string, reqId: string, result: ElicitationResult): string;
+export declare function verifyElicitationResponse(key: string, sessionId: string, reqId: string, result: ElicitationResult, sig: string): boolean;
+export declare function signAbortRequest(key: string, sessionId: string, nonce: string): string;
+export declare function verifyAbortRequest(key: string, sessionId: string, nonce: string, sig: string): boolean;
+export declare function freshChannelId(): string;

package/dist/agent/afk-ledger-channel.d.ts

@@ -0,0 +1,23 @@
+import type { ElicitationHandler } from './elicitation-router.js';
+import type { ElicitationRequest } from './types/sdk-types.js';
+export interface AbortWatcherDeps {
+    sessionId: string;
+    key: string | null;
+    onAbort: (reason: string) => void;
+}
+export interface AbortWatcherHandle {
+    stop: () => void;
+}
+export declare function makeAbortWatcher(deps: AbortWatcherDeps): AbortWatcherHandle;
+export interface LedgerChannelDeps {
+    sessionId: string;
+    key: string | null;
+    emitElicitation: (record: {
+        kind: 'elicitation';
+        reqId: string;
+        request: ElicitationRequest;
+    }) => void;
+    fallback: ElicitationHandler;
+    newReqId?: () => string;
+}
+export declare function makeLedgerChannelHandler(deps: LedgerChannelDeps): ElicitationHandler;

package/dist/agent/afk-mode-gate.d.ts

@@ -0,0 +1,14 @@
+import type { HookHandler } from './hooks.js';
+import type { PermissionMode } from './types/sdk-types.js';
+import type { ElicitationRequest, ElicitationResult } from './types/sdk-types.js';
+import type { TraceWriter } from './trace/index.js';
+export interface AfkModeGateOptions {
+    approvalTimeoutMs?: number;
+    promptForApproval?: boolean;
+    route?: (request: ElicitationRequest, options: {
+        signal: AbortSignal;
+        onActive?: () => void;
+    }) => Promise<ElicitationResult>;
+    traceWriter?: TraceWriter;
+}
+export declare function createAfkModeGate(getMode: () => PermissionMode, cwd?: string, getCwd?: () => string | undefined, opts?: AfkModeGateOptions): HookHandler;

package/dist/agent/auth/credential-resolver.d.ts

@@ -0,0 +1,3 @@
+export declare function loadAnthropicCredential(): string | undefined;
+export declare function loadOpenAICredential(): string | undefined;
+export declare function resolveCredentialForModel(model: string | undefined): string | undefined;

package/dist/agent/auth/keychain.d.ts

@@ -0,0 +1,4 @@
+export declare function loadClaudeCodeOauthToken(): string | undefined;
+export declare function refreshClaudeCodeOauthToken(): Promise<string | undefined>;
+export declare function parseAccountIdentifier(token: string): string;
+export declare function writeLinuxCredentials(credPath: string, blob: string): void;

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

@@ -0,0 +1,6 @@
+export type { Surface, PhaseRole, SubagentStatusLite, SubagentStatusLiteValue, BgJobLite, BgJobStatus, McpServerSummary, RuntimeSelf, RuntimeTools, RuntimeSubagents, RuntimeWorkspace, RuntimeSnapshot, RuntimeView, RuntimeStateSource, } from './types.js';
+export { buildRuntimeSnapshot, parseView, formatEnvironmentFragment, } from './runtime-snapshot.js';
+export { buildRuntimeStateSource, type RuntimeSourceDeps, } from './runtime-source.js';
+export { getRuntimeStateTool, AWARENESS_TOOL_NAMES, createGetRuntimeStateHandler, wrapDispatcherWithRuntimeState, } from './tool.js';
+export { gatherWorkspace } from './workspace-source.js';
+export { writePresenceFile, removePresenceFile, removePresenceFileSync, readPresenceFiles, type PresenceFileInfo, type PresenceRecord, } from './presence.js';

package/dist/agent/awareness/presence.d.ts

@@ -0,0 +1,25 @@
+import type { RuntimeWorkspace } from './types.js';
+import type { TraceActor } from '../session/session-identity.js';
+export interface PresenceFileInfo {
+    sessionId: string;
+    surface: string;
+    actor?: TraceActor;
+    cwd: string;
+    startedAt: string;
+    model: {
+        provider: string;
+        name: string;
+    };
+    workspace: RuntimeWorkspace;
+    pid: number;
+    afk?: boolean;
+}
+export interface PresenceRecord extends PresenceFileInfo {
+    path: string;
+}
+export declare function writePresenceFile(info: PresenceFileInfo): Promise<void>;
+export declare function setPresenceAfk(sessionId: string, afk: boolean): Promise<void>;
+export declare function updatePresenceCwd(sessionId: string, cwd: string): Promise<void>;
+export declare function removePresenceFile(sessionId: string): Promise<void>;
+export declare function removePresenceFileSync(sessionId: string): void;
+export declare function readPresenceFiles(): Promise<PresenceRecord[]>;

package/dist/agent/awareness/runtime-snapshot.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeStateSource, RuntimeSnapshot, RuntimeView, RuntimeWorkspace } from './types.js';
+export declare function buildRuntimeSnapshot(source: RuntimeStateSource, view?: RuntimeView): Partial<RuntimeSnapshot>;
+export declare function parseView(raw: unknown): RuntimeView;
+export declare function formatEnvironmentFragment(args: {
+    cwd: string;
+    sessionId?: string | null;
+    surface?: string | null;
+    depth?: number | null;
+    maxDepth?: number | null;
+    workspace?: RuntimeWorkspace | null;
+    now?: Date;
+    timeZone?: string;
+}): string;

package/dist/agent/awareness/runtime-source.d.ts

@@ -0,0 +1,18 @@
+import type { AnthropicToolDef } from '../tools/types.js';
+import type { RuntimeStateSource, RuntimeSubagents, PhaseRole } from './types.js';
+export interface RuntimeSourceDeps {
+    sessionId?: string | undefined;
+    surface: string;
+    cwd: string;
+    modelName: string;
+    providerName: string;
+    permissionMode: string;
+    parentSessionId?: string | undefined;
+    depth?: number | undefined;
+    maxDepth?: number | undefined;
+    phaseRole?: PhaseRole | undefined;
+    getEnabledToolNames: () => string[];
+    getMcpTools: () => readonly AnthropicToolDef[];
+    getSubagents: () => RuntimeSubagents;
+}
+export declare function buildRuntimeStateSource(deps: RuntimeSourceDeps): RuntimeStateSource;

package/dist/agent/awareness/tool.d.ts

@@ -0,0 +1,7 @@
+import type { AnthropicToolDef, ToolHandler } from '../tools/types.js';
+import type { ToolDispatcher } from '../providers/anthropic-direct/tool-dispatcher.js';
+import type { RuntimeStateSource } from './types.js';
+export declare const getRuntimeStateTool: AnthropicToolDef;
+export declare const AWARENESS_TOOL_NAMES: readonly string[];
+export declare function createGetRuntimeStateHandler(source: RuntimeStateSource): ToolHandler;
+export declare function wrapDispatcherWithRuntimeState(inner: ToolDispatcher, source: RuntimeStateSource): ToolDispatcher;

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

@@ -0,0 +1,60 @@
+export type Surface = 'cli' | 'repl' | 'daemon' | 'telegram' | 'subagent' | 'unknown';
+export type PhaseRole = 'read-only' | 'read-write';
+export type SubagentStatusLiteValue = 'idle' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export type BgJobStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+export interface RuntimeSelf {
+    sessionId: string | null;
+    surface: Surface;
+    parentSessionId: string | null;
+    depth: number | null;
+    maxDepth: number | null;
+    phaseRole: PhaseRole | null;
+    cwd: string;
+    model: {
+        provider: string;
+        name: string;
+    };
+    permissionMode: 'elevated' | 'default';
+}
+export interface McpServerSummary {
+    name: string;
+    toolCount: number;
+}
+export interface RuntimeTools {
+    enabled: string[];
+    mcpServers: McpServerSummary[];
+}
+export interface SubagentStatusLite {
+    id: string;
+    status: SubagentStatusLiteValue;
+}
+export interface BgJobLite {
+    jobId: string;
+    status: BgJobStatus;
+    startedAt: string;
+    label: string | null;
+}
+export interface RuntimeSubagents {
+    active: SubagentStatusLite[];
+    backgroundJobs: BgJobLite[];
+}
+export interface RuntimeWorkspace {
+    branch: string | null;
+    headSha: string | null;
+    dirty: boolean | null;
+    dirtyCount: number | null;
+    remoteUrl: string | null;
+}
+export interface RuntimeSnapshot {
+    self: RuntimeSelf;
+    tools: RuntimeTools;
+    subagents: RuntimeSubagents;
+    workspace: RuntimeWorkspace;
+}
+export type RuntimeView = 'self' | 'tools' | 'subagents' | 'workspace' | 'all';
+export interface RuntimeStateSource {
+    getSelf(): RuntimeSelf;
+    getTools(): RuntimeTools;
+    getSubagents(): RuntimeSubagents;
+    getWorkspace(): RuntimeWorkspace;
+}

package/dist/agent/awareness/workspace-source.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeWorkspace } from './types.js';
+export declare function gatherWorkspace(cwd: string): RuntimeWorkspace;

package/dist/agent/background-registry.d.ts

@@ -0,0 +1,57 @@
+import { EventEmitter } from 'node:events';
+import type { SubagentHandle, SubagentResult } from './subagent.js';
+import type { TraceWriter } from './trace/index.js';
+export type BackgroundJobStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+export interface BackgroundJob {
+    readonly jobId: string;
+    readonly subagentId: string;
+    readonly label: string;
+    readonly model: string;
+    readonly startedAt: number;
+    readonly status: BackgroundJobStatus;
+    readonly result?: SubagentResult;
+    readonly endedAt?: number;
+}
+export declare const MAX_TRANSCRIPT_TAIL_BYTES = 4096;
+export interface BackgroundRegistryOptions {
+    traceWriter?: TraceWriter | undefined;
+    maxConcurrentJobs?: number;
+}
+export interface RegisterArgs {
+    handle: SubagentHandle;
+    prompt: string;
+    model: string;
+    parentSessionId?: string | undefined;
+}
+export declare class BackgroundJobCapError extends Error {
+    constructor(running: number, cap: number);
+}
+export interface BackgroundRegistryEvents {
+    started: [job: BackgroundJob];
+    settled: [job: BackgroundJob];
+    joined: [job: BackgroundJob];
+}
+export declare class BackgroundAgentRegistry extends EventEmitter<BackgroundRegistryEvents> {
+    private readonly jobs;
+    private counter;
+    private readonly traceWriter;
+    private readonly maxConcurrentJobs;
+    constructor(options?: BackgroundRegistryOptions);
+    register(args: RegisterArgs): BackgroundJob;
+    adoptRunning(args: RegisterArgs & {
+        runPromise: Promise<SubagentResult>;
+    }): BackgroundJob;
+    private createJobEntry;
+    get(jobId: string): BackgroundJob | undefined;
+    list(): readonly BackgroundJob[];
+    join(jobId: string): Promise<SubagentResult>;
+    cancelJob(jobId: string): Promise<boolean>;
+    cancelAll(): Promise<void>;
+    appendTranscript(jobId: string, chunk: string): void;
+    getTranscript(jobId: string): string | undefined;
+    private nextJobId;
+    private markTerminal;
+    private _sweepOldJobs;
+    private statusFromResult;
+    private snapshot;
+}

package/dist/agent/background-summarizer.d.ts

@@ -0,0 +1,43 @@
+import type { BackgroundAgentRegistry } from './background-registry.js';
+export interface SummaryEntry {
+    text: string;
+    refreshedAt: number;
+    stale: boolean;
+}
+export interface BackgroundSummarizerOptions {
+    registry: BackgroundAgentRegistry;
+    apiKey: string;
+    model?: string;
+    intervalMs?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxCallsPerSession?: number;
+    callLLM?: (prompt: string, signal?: AbortSignal) => Promise<string>;
+    getTranscript?: (jobId: string) => string | undefined;
+}
+export declare function redactSecrets(text: string): string;
+export declare class BackgroundSummarizer {
+    private readonly registry;
+    private readonly apiKey;
+    private readonly model;
+    private readonly intervalMs;
+    private readonly maxInputTokens;
+    private readonly maxOutputTokens;
+    private readonly maxCallsPerSession;
+    private readonly callLLM;
+    private readonly getTranscriptFn;
+    private readonly summaries;
+    private readonly jobIndexMap;
+    private jobIndexCounter;
+    private callsThisSession;
+    private readonly lastRefreshedAt;
+    private abortController;
+    private tickTimer;
+    private readonly tickIntervalMs;
+    constructor(opts: BackgroundSummarizerOptions);
+    start(): void;
+    stop(): void;
+    getSummary(jobId: string): SummaryEntry | undefined;
+    private tick;
+    private refreshJob;
+}

package/dist/agent/bg-job-log.d.ts

@@ -0,0 +1,41 @@
+import type { OutputEvent } from './types/session-types.js';
+export interface BgJobMeta {
+    jobId: string;
+    subagentId: string;
+    label: string;
+    promptHash: string;
+    model: string;
+    startedAt: number;
+    endedAt?: number;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    parentSessionId?: string;
+    schemaVersion: 1;
+}
+export declare class BgJobLogWriter {
+    private readonly jobId;
+    private readonly logPath;
+    private readonly metaPath;
+    private stream;
+    private errored;
+    private closed;
+    private streamReady;
+    private pendingLines;
+    private readyPromise;
+    private readyResolve;
+    private metaWriteQueue;
+    constructor(jobId: string);
+    write(event: OutputEvent): void;
+    private _openStream;
+    private _writeLine;
+    close(): Promise<void>;
+    writeMeta(meta: BgJobMeta): Promise<void>;
+    private _writeMetaInner;
+}
+export declare class BgJobLogReader {
+    static listJobs(): Promise<BgJobMeta[]>;
+    static readMeta(jobId: string): Promise<BgJobMeta | null>;
+    static readEvents(jobId: string): AsyncGenerator<OutputEvent>;
+    static tailEvents(jobId: string, opts?: {
+        fromStart?: boolean;
+    }): AsyncGenerator<OutputEvent>;
+}

package/dist/agent/daemon/gates.d.ts

@@ -0,0 +1,20 @@
+export declare const DEFAULT_SESSIONSTART_COOLDOWN_MS: number;
+export declare function defaultBriefsDir(): string;
+export type SessionStartSkipReason = 'cooldown' | 'briefs_pending';
+export interface GateDecision {
+    fire: boolean;
+    skipReason?: SessionStartSkipReason;
+    lastFiredAtMs?: number;
+    cooldownRemainingMs?: number;
+    pendingBriefCount?: number;
+}
+export interface GateOptions {
+    taskId: string;
+    cooldownMs: number;
+    nowMs: number;
+    telemetryPath: string;
+    briefsDir: string;
+}
+export declare function readLastTickTime(taskId: string, telemetryPath: string): number | null;
+export declare function countPendingBriefs(briefsDir: string): number;
+export declare function evaluateSessionStartGates(options: GateOptions): GateDecision;

package/dist/agent/daemon/http-client.d.ts

@@ -0,0 +1,6 @@
+export interface DaemonSyncResult {
+    synced: boolean;
+    detail: string;
+}
+export declare const SYNC_FAILED_NOTE: string;
+export declare function trySyncToDaemon(method: 'POST' | 'DELETE', path: string, body?: unknown): Promise<DaemonSyncResult>;

package/dist/agent/daemon/idle-detector.d.ts

@@ -0,0 +1,7 @@
+export declare class IdleDetector {
+    private _count;
+    increment(): void;
+    decrement(): void;
+    isIdle(): boolean;
+    count(): number;
+}

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

@@ -0,0 +1,13 @@
+export interface QueuedTask {
+    id: string;
+    command: string;
+    enqueuedAt: string;
+    sequence: number;
+    notifyOn?: 'failure' | 'always' | 'never';
+}
+export interface EnqueueOptions {
+    notifyOn?: 'failure' | 'always' | 'never';
+}
+export declare function enqueue(command: string, opts?: EnqueueOptions, queueDir?: string): QueuedTask;
+export declare function dequeueNext(queueDir?: string): QueuedTask | null;
+export declare function listPending(queueDir?: string): QueuedTask[];

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

@@ -0,0 +1,20 @@
+import type { ScheduledTask } from './triggers.js';
+export interface ScheduledTaskConfig {
+    id: string;
+    name: string;
+    command: string;
+    cron: string;
+    trigger?: 'cron' | 'sessionstart' | 'both';
+    enabled: boolean;
+    notifyOn?: 'failure' | 'always' | 'never';
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function loadSchedules(path?: string): ScheduledTaskConfig[];
+export declare function saveSchedules(configs: ScheduledTaskConfig[], path?: string): void;
+export declare function addSchedule(config: Omit<ScheduledTaskConfig, 'id' | 'createdAt' | 'updatedAt'>, path?: string): ScheduledTaskConfig;
+export declare function removeSchedule(id: string, path?: string): boolean;
+export declare function getSchedule(id: string, path?: string): ScheduledTaskConfig | undefined;
+export declare function slugify(name: string): string;
+export declare function resolveSlugCollision(base: string, existing: string[]): string;
+export declare function toScheduledTask(config: ScheduledTaskConfig): ScheduledTask;

package/dist/agent/daemon/scheduler.d.ts

@@ -0,0 +1,64 @@
+import type { ExecFileFn } from '../worktree-sweep.js';
+import { AgentSession } from '../session/agent-session.js';
+import type { AgentConfig } from '../types.js';
+import { ScheduledTask } from './triggers.js';
+import { type SessionStartSkipReason } from './gates.js';
+export declare function resolveWorktreePruneRoot(execFile: ExecFileFn, cwd: string, override: string | undefined): Promise<string | null>;
+export declare function daemonTraceLabel(taskId: string): string;
+export interface SchedulerOptions {
+    sessionConfig?: Partial<AgentConfig>;
+    telemetryPath?: string;
+    sessionFactory?: (config: AgentConfig) => AgentSession;
+    cooldownMs?: number;
+    briefsDir?: string;
+    now?: () => number;
+    onTaskComplete?: (record: TelemetryRecord, details?: TaskCompletionDetails) => void | Promise<void>;
+    pullPollIntervalMs?: number;
+    queueDir?: string;
+}
+export type TelemetryTrigger = 'cron' | 'sessionstart' | 'pull';
+export type TelemetryStatus = 'success' | 'error' | 'skipped';
+export interface TelemetryRecord {
+    taskId: string;
+    command: string;
+    trigger: TelemetryTrigger;
+    cronExpression?: string;
+    triggeredAt: string;
+    durationMs: number;
+    status: TelemetryStatus;
+    errorMessage?: string;
+    responseExcerpt?: string;
+    skipReason?: SessionStartSkipReason;
+    name?: string;
+}
+export interface TaskCompletionDetails {
+    responseText?: string;
+}
+export declare class CronScheduler {
+    private readonly registry;
+    private readonly options;
+    private readonly defaultCooldownMs;
+    private readonly briefsDir;
+    private readonly now;
+    private readonly idleDetector;
+    private pullPollTimer;
+    private isDequeuing;
+    private readonly queueDir;
+    constructor(options?: SchedulerOptions);
+    register(task: ScheduledTask): void;
+    unregister(taskId: string): void;
+    list(): ScheduledTask[];
+    tick(taskId: string): Promise<TelemetryRecord>;
+    fireOnStart(): Promise<TelemetryRecord[]>;
+    stop(): Promise<void>;
+    startPullLoop(): void;
+    private pullTick;
+    private runOnce;
+    private recordSkip;
+    private runBuiltinWorktreePrune;
+    private spawnSession;
+    private telemetryPath;
+    private ensureTelemetrySink;
+    private writeTelemetry;
+    private fireOnTaskComplete;
+}

package/dist/agent/daemon/triggers.d.ts

@@ -0,0 +1,10 @@
+export type TriggerMode = 'cron' | 'sessionstart' | 'both' | 'pull';
+export interface ScheduledTask {
+    taskId: string;
+    command: string;
+    trigger: TriggerMode;
+    cronExpression?: string;
+    debounceMs?: number;
+    notifyOn?: 'failure' | 'always' | 'never';
+}
+export declare function validateScheduledTask(task: ScheduledTask): void;

package/dist/agent/daemon.d.ts

@@ -0,0 +1,29 @@
+import type { AgentConfig } from './types.js';
+import { CronScheduler, type SchedulerOptions, type TelemetryRecord } from './daemon/scheduler.js';
+import type { ScheduledTask } from './daemon/triggers.js';
+export interface DaemonOptions {
+    port?: number;
+    host?: string;
+    tasks?: ScheduledTask[];
+    sessionConfig?: Partial<AgentConfig>;
+    telemetryPath?: string;
+    sessionFactory?: SchedulerOptions['sessionFactory'];
+    cooldownMs?: number;
+    briefsDir?: string;
+    now?: () => number;
+    onTaskComplete?: SchedulerOptions['onTaskComplete'];
+    pullPollIntervalMs?: number;
+    queueDir?: string;
+    writePortFile?: boolean;
+}
+export interface DaemonHandle {
+    readonly port: number;
+    readonly host: string;
+    readonly scheduler: CronScheduler;
+    registerTask(task: ScheduledTask): void;
+    unregisterTask(taskId: string): void;
+    tickOnce(taskId: string): Promise<TelemetryRecord>;
+    fireOnStart(): Promise<TelemetryRecord[]>;
+    stop(): Promise<void>;
+}
+export declare function startDaemon(options?: DaemonOptions): Promise<DaemonHandle>;

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

@@ -0,0 +1,28 @@
+import type { ZodType } from 'zod';
+import type { AgentModelInput, CanUseTool, IAgentSession } from './types.js';
+import type { SubagentManager } from './subagent.js';
+import { type DAGEdge, type DAGRunResult } from './dag.js';
+export interface SubagentDAGNode {
+    id: string;
+    systemPrompt: string;
+    promptBuilder: (inputs: Record<string, unknown>) => string;
+    model?: AgentModelInput;
+    outputSchema?: ZodType;
+    canUseTool?: CanUseTool;
+    idPrefix?: string;
+    agentType?: string;
+    parentId?: string;
+    cwd?: string;
+    readRoots?: string[];
+    writeRoots?: string[];
+    apiKey?: string;
+}
+export interface SubagentDAGOptions {
+    manager: SubagentManager;
+    parentSession: Pick<IAgentSession, 'sessionId' | 'abortSignal'>;
+    nodes: SubagentDAGNode[];
+    edges: DAGEdge[];
+    failFast?: boolean;
+    nodeTimeoutMs?: number;
+}
+export declare function runSubagentDAG(options: SubagentDAGOptions): Promise<DAGRunResult>;

package/dist/agent/dag.d.ts

@@ -0,0 +1,26 @@
+export interface DAGNode {
+    id: string;
+    run: (inputs: Record<string, unknown>, signal: AbortSignal) => Promise<unknown>;
+}
+export interface DAGEdge {
+    from: string;
+    to: string;
+}
+export interface DAGGraph {
+    nodes: DAGNode[];
+    edges: DAGEdge[];
+}
+export interface DAGRunOptions {
+    failFast?: boolean;
+    nodeTimeoutMs?: number;
+}
+export interface DAGRunResult {
+    outputs: Record<string, unknown>;
+    failed: Array<{
+        id: string;
+        error: Error;
+    }>;
+    skipped: string[];
+}
+export declare function validateDAG(graph: DAGGraph): void;
+export declare function runDAG(graph: DAGGraph, signal: AbortSignal, options?: DAGRunOptions): Promise<DAGRunResult>;

package/dist/agent/default-hook-registry.d.ts

@@ -0,0 +1,25 @@
+import { type HookRegistry } from './hooks.js';
+import { MemoryStore } from './memory/index.js';
+import type { GrantManager } from '../cli/slash/commands/allow-dir.js';
+import type { PermissionMode } from './types/sdk-types.js';
+import type { TraceWriter } from './trace/index.js';
+import type { LoadedHooksConfig } from './hooks/config-loader.js';
+export interface SubagentCompleteInfo {
+    subagentId: string;
+    status: string;
+    durationMs?: number;
+    agentType?: string;
+}
+export interface DefaultHookRegistryResult {
+    registry: HookRegistry;
+    memoryStore: MemoryStore;
+    pathApprovalGrantRef: {
+        current: GrantManager | undefined;
+    };
+}
+export declare function _resetWarningForTests(): void;
+export declare function createDefaultHookRegistry(onSubagentComplete?: (info: SubagentCompleteInfo) => void, surface?: string, memoryStore?: MemoryStore, getPermissionMode?: () => PermissionMode, hookConfig?: LoadedHooksConfig, agentOptions?: {
+    cwd?: string;
+    sessionId?: string;
+    traceWriter?: TraceWriter;
+}, getCwd?: () => string | undefined): DefaultHookRegistryResult;