agent-afk 5.290.4 → 5.291.0

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

@@ -381,9 +381,12 @@ export declare const PeerMessagePayloadSchema: z.ZodObject<{
     action: z.ZodEnum<{
         delivered: "delivered";
         sent: "sent";
+        claimed: "claimed";
+        injected: "injected";
         held: "held";
         refused: "refused";
         dropped: "dropped";
+        reclaimed: "reclaimed";
     }>;
     messageId: z.ZodOptional<z.ZodString>;
     peer: z.ZodString;
@@ -714,9 +717,12 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         action: z.ZodEnum<{
             delivered: "delivered";
             sent: "sent";
+            claimed: "claimed";
+            injected: "injected";
             held: "held";
             refused: "refused";
             dropped: "dropped";
+            reclaimed: "reclaimed";
         }>;
         messageId: z.ZodOptional<z.ZodString>;
         peer: z.ZodString;
@@ -757,6 +763,8 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             many_image_degraded: "many_image_degraded";
             stream_accepted_after_drop: "stream_accepted_after_drop";
             connection_retry: "connection_retry";
+            usage_notice: "usage_notice";
+            tool_degraded: "tool_degraded";
         }>;
         durationMs: z.ZodOptional<z.ZodNumber>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
@@ -1110,9 +1118,12 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         action: z.ZodEnum<{
             delivered: "delivered";
             sent: "sent";
+            claimed: "claimed";
+            injected: "injected";
             held: "held";
             refused: "refused";
             dropped: "dropped";
+            reclaimed: "reclaimed";
         }>;
         messageId: z.ZodOptional<z.ZodString>;
         peer: z.ZodString;
@@ -1155,6 +1166,8 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             many_image_degraded: "many_image_degraded";
             stream_accepted_after_drop: "stream_accepted_after_drop";
             connection_retry: "connection_retry";
+            usage_notice: "usage_notice";
+            tool_degraded: "tool_degraded";
         }>;
         durationMs: z.ZodOptional<z.ZodNumber>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;

package/dist/agent/trace/events.session-phase.d.ts

@@ -30,6 +30,8 @@ export declare const SessionPhaseNameSchema: z.ZodEnum<{
     many_image_degraded: "many_image_degraded";
     stream_accepted_after_drop: "stream_accepted_after_drop";
     connection_retry: "connection_retry";
+    usage_notice: "usage_notice";
+    tool_degraded: "tool_degraded";
 }>;
 export declare const SessionPhasePayloadSchema: z.ZodObject<{
     phase: z.ZodEnum<{
@@ -63,6 +65,8 @@ export declare const SessionPhasePayloadSchema: z.ZodObject<{
         many_image_degraded: "many_image_degraded";
         stream_accepted_after_drop: "stream_accepted_after_drop";
         connection_retry: "connection_retry";
+        usage_notice: "usage_notice";
+        tool_degraded: "tool_degraded";
     }>;
     durationMs: z.ZodOptional<z.ZodNumber>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;

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

@@ -162,7 +162,7 @@ export interface QueuedUserMessagePayload {
     byteLength: number;
 }
 export interface PeerMessagePayload {
-    action: 'sent' | 'delivered' | 'held' | 'refused' | 'dropped';
+    action: 'sent' | 'claimed' | 'injected' | 'delivered' | 'held' | 'refused' | 'dropped' | 'reclaimed';
     messageId?: string;
     peer: string;
     bytes: number;
@@ -186,18 +186,8 @@ export interface BrowserEventPayload {
     };
     durationMs: number;
 }
-export type SessionPhaseName = 'bootstrap_start' | 'bootstrap_done' | 'session_init_start' | 'session_init_done' | 'mcp_connect_start' | 'mcp_connect_done' | 'mcp_server_start' | 'mcp_server_done' | 'loop_start' | 'loop_end' | 'model_ttfb' | 'interrupt_halt' | 'rate_limit' | 'ttfb_timeout' | 'usage_limit_pause' | 'usage_limit_resume' | 'overload_pause' | 'overload_resume' | 'idle_watchdog_fired' | 'pause_extension_granted' | 'suspected_loop' | 'compaction_disabled' | 'boot_warning' | 'workspace_subscribed' | 'workspace_delivery' | 'gate_shape' | 'session_id_assigned' | 'many_image_degraded' | 'stream_accepted_after_drop' | 'connection_retry';
-export interface SessionPhasePayload {
-    phase: SessionPhaseName;
-    durationMs?: number;
-    metadata?: Record<string, string | number | boolean>;
-    model?: string;
-    resolvedModel?: string;
-    origin?: 'cli' | 'telegram' | 'daemon' | 'web' | 'unknown';
-    actor?: 'main' | 'subagent';
-    sessionId?: string;
-    priorSessionId?: string;
-}
+export type { SessionPhaseName, SessionPhasePayload } from './types.session-phase.js';
+import type { SessionPhasePayload } from './types.session-phase.js';
 export interface SessionSealedPayload {
     status: 'succeeded' | 'failed' | 'cancelled';
     finalCostUsd: number;

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

@@ -0,0 +1,12 @@
+export type SessionPhaseName = 'bootstrap_start' | 'bootstrap_done' | 'session_init_start' | 'session_init_done' | 'mcp_connect_start' | 'mcp_connect_done' | 'mcp_server_start' | 'mcp_server_done' | 'loop_start' | 'loop_end' | 'model_ttfb' | 'interrupt_halt' | 'rate_limit' | 'ttfb_timeout' | 'usage_limit_pause' | 'usage_limit_resume' | 'overload_pause' | 'overload_resume' | 'idle_watchdog_fired' | 'pause_extension_granted' | 'suspected_loop' | 'compaction_disabled' | 'boot_warning' | 'workspace_subscribed' | 'workspace_delivery' | 'gate_shape' | 'session_id_assigned' | 'many_image_degraded' | 'stream_accepted_after_drop' | 'connection_retry' | 'usage_notice' | 'tool_degraded';
+export interface SessionPhasePayload {
+    phase: SessionPhaseName;
+    durationMs?: number;
+    metadata?: Record<string, string | number | boolean>;
+    model?: string;
+    resolvedModel?: string;
+    origin?: 'cli' | 'telegram' | 'daemon' | 'web' | 'unknown';
+    actor?: 'main' | 'subagent';
+    sessionId?: string;
+    priorSessionId?: string;
+}

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

@@ -84,6 +84,7 @@ export type OutputEvent = {
     resetsAt?: Date;
     accountId?: string;
     autoResume?: boolean;
+    waitDeadline?: Date;
 } | {
     type: 'resumed';
     hotSwapped: boolean;

package/dist/agent/usage/codex-usage.d.ts

@@ -0,0 +1,12 @@
+import type { UsageResult } from '../subscription-usage.js';
+import { type OpenAIAuthResolution } from '../providers/openai-compatible/auth.js';
+import { type UsageHttpOptions } from './usage-http.js';
+export declare const CODEX_SUBSCRIPTION: {
+    readonly provider: "codex";
+    readonly account: "chatgpt-subscription";
+};
+export interface FetchCodexUsageOptions extends UsageHttpOptions {
+    readonly auth?: () => Pick<OpenAIAuthResolution, 'apiKey' | 'source' | 'accountId'>;
+}
+export declare function fetchCodexUsage(options?: FetchCodexUsageOptions): Promise<UsageResult>;
+export declare function parseCodexUsagePayload(body: Record<string, unknown>): UsageResult;

package/dist/agent/usage/usage-budget.d.ts

@@ -0,0 +1,24 @@
+import { type UsageRecord, type WindowKey, type WindowsObservation } from './usage-record.js';
+export type UsageLevel = 'ok' | 'warn' | 'over' | 'unknown';
+export interface UsageThresholds {
+    readonly warnPct: number;
+    readonly overPct: number;
+}
+export declare const DEFAULT_USAGE_THRESHOLDS: UsageThresholds;
+export interface BindingWindow {
+    readonly key: WindowKey;
+    readonly label: string;
+    readonly utilization: number;
+    readonly pct: number;
+    readonly resetsAt?: number;
+}
+export interface UsageEvaluation {
+    readonly level: UsageLevel;
+    readonly stale: boolean;
+    readonly binding?: BindingWindow;
+    readonly frozenUntil?: number;
+}
+export declare function levelFor(utilization: number, t?: UsageThresholds): Exclude<UsageLevel, 'unknown'>;
+export declare function bindingWindow(w: WindowsObservation | undefined): BindingWindow | undefined;
+export declare function isStale(observedAt: number, now: number): boolean;
+export declare function evaluateUsage(rec: UsageRecord | undefined, now?: number, thresholds?: UsageThresholds): UsageEvaluation;

package/dist/agent/usage/usage-formatter.d.ts

@@ -0,0 +1,52 @@
+import { type UsageRecord } from './usage-record.js';
+import { type BindingWindow } from './usage-budget.js';
+export interface UsageWindowSummary {
+    readonly utilization: number;
+    readonly utilizationPct: number;
+    readonly resetsAtMs?: number;
+    readonly resetsIn?: string;
+}
+export interface PerMinuteSummary {
+    readonly requestsRemaining?: number;
+    readonly requestsLimit?: number;
+    readonly tokensRemaining?: number;
+    readonly tokensLimit?: number;
+    readonly frozenUntilMs?: number;
+    readonly frozenFor?: string;
+}
+export interface ProviderUsageSummary {
+    readonly provider: string;
+    readonly account: string;
+    readonly status: 'ok' | 'stale' | 'unknown' | 'error';
+    readonly errorDetail?: string;
+    readonly ageMs?: number;
+    readonly perMinute?: PerMinuteSummary;
+    readonly fiveHour?: UsageWindowSummary;
+    readonly sevenDay?: UsageWindowSummary;
+    readonly sevenDaySonnet?: UsageWindowSummary;
+    readonly sevenDayOpus?: UsageWindowSummary;
+}
+export interface UsageSummary {
+    readonly asOfMs: number;
+    readonly providers: readonly ProviderUsageSummary[];
+}
+export interface CompactUsageEntry {
+    provider: string;
+    account: string;
+    status: ProviderUsageSummary['status'];
+    fiveHourPct?: number;
+    sevenDayPct?: number;
+    frozenUntilMs?: number;
+}
+export declare function summarizeUsageRecord(rec: UsageRecord, now?: number): ProviderUsageSummary;
+export declare function unknownProviderSummary(provider: string, account: string): ProviderUsageSummary;
+export declare function errorProviderSummary(provider: string, account: string, detail: string): ProviderUsageSummary;
+export declare function compactUsageEntries(records: readonly UsageRecord[], now?: number): CompactUsageEntry[];
+export declare function describeBindingWindow(provider: string, binding: BindingWindow, now?: number): string;
+export interface UsageRow {
+    readonly label: string;
+    readonly value: string;
+    readonly level?: 'ok' | 'warn' | 'over' | 'info';
+}
+export declare function usageRows(p: ProviderUsageSummary): UsageRow[];
+export declare function formatUsageSummaryText(summary: UsageSummary): string[];

package/dist/agent/usage/usage-http.d.ts

@@ -0,0 +1,11 @@
+import type { UsageUnavailable } from '../subscription-usage.js';
+export declare const DEFAULT_USAGE_TIMEOUT_MS = 10000;
+export interface UsageHttpOptions {
+    readonly fetchImpl?: typeof fetch;
+    readonly timeoutMs?: number;
+}
+export interface UsageJson {
+    readonly kind: 'json';
+    readonly body: Record<string, unknown>;
+}
+export declare function fetchUsageJson(url: string, headers: Record<string, string>, options?: UsageHttpOptions): Promise<UsageJson | UsageUnavailable>;

package/dist/agent/usage/usage-ledger.d.ts

@@ -0,0 +1,13 @@
+import { type PerMinuteObservation, type UsageRecord, type WindowsObservation } from './usage-record.js';
+import type { QuotaSnapshot } from '../quota-cache.js';
+import type { RateLimitSnapshot } from '../providers/shared/rate-limit-bucket.js';
+import type { RateLimitGate } from '../providers/shared/tracing-fetch-utils.js';
+import type { UsageResult } from '../subscription-usage.js';
+export declare function resetUsageLedgerForTests(): void;
+export declare function publishUsage(rec: UsageRecord, now?: number): void;
+export declare function readLedgerRecords(): UsageRecord[];
+export declare function readLedgerRecord(provider: string, account: string): UsageRecord | undefined;
+export declare function windowsFromQuotaSnapshot(s: QuotaSnapshot): WindowsObservation;
+export declare function windowsFromUsageResult(r: UsageResult, now: number): WindowsObservation | undefined;
+export declare function perMinuteFromRateLimit(s: RateLimitSnapshot, now: number): PerMinuteObservation;
+export declare function publishingGate(gate: RateLimitGate, provider: string, account: string): RateLimitGate;

package/dist/agent/usage/usage-record.d.ts

@@ -0,0 +1,37 @@
+export interface PerMinuteObservation {
+    requestsRemaining?: number;
+    requestsLimit?: number;
+    requestsResetAt?: number;
+    tokensRemaining?: number;
+    tokensLimit?: number;
+    tokensResetAt?: number;
+    frozenUntil?: number;
+    observedAt: number;
+}
+export interface WindowObservation {
+    utilization: number;
+    resetsAt?: number;
+}
+export interface WindowsObservation {
+    fiveHour?: WindowObservation;
+    sevenDay?: WindowObservation;
+    sevenDaySonnet?: WindowObservation;
+    sevenDayOpus?: WindowObservation;
+    observedAt: number;
+}
+export declare const WINDOW_KEYS: readonly ["fiveHour", "sevenDay", "sevenDaySonnet", "sevenDayOpus"];
+export type WindowKey = (typeof WINDOW_KEYS)[number];
+export declare const WINDOW_LABELS: Readonly<Record<WindowKey, string>>;
+export declare const USAGE_STALE_AFTER_MS: number;
+export declare function usageKey(provider: string, account: string): string;
+export interface UsageRecord {
+    v: 1;
+    provider: string;
+    account: string;
+    perMinute?: PerMinuteObservation;
+    windows?: WindowsObservation;
+}
+export declare function mergePerMinute(a: PerMinuteObservation | undefined, b: PerMinuteObservation | undefined): PerMinuteObservation | undefined;
+export declare function mergeWindows(a: WindowsObservation | undefined, b: WindowsObservation | undefined): WindowsObservation | undefined;
+export declare function mergeUsageRecords(existing: UsageRecord | undefined, incoming: UsageRecord): UsageRecord;
+export declare function parseUsageRecord(raw: unknown): UsageRecord | undefined;

package/dist/agent/usage/usage-snapshot.d.ts

@@ -0,0 +1,21 @@
+import { type FetchSubscriptionUsageOptions, type UsageResult } from '../subscription-usage.js';
+import { type UsageRecord } from './usage-record.js';
+export declare const ANTHROPIC_OAUTH: {
+    readonly provider: "anthropic";
+    readonly account: "oauth";
+};
+export declare function readUsageRecords(extra?: readonly UsageRecord[]): UsageRecord[];
+export declare function readUsageRecord(provider: string, account: string): UsageRecord | undefined;
+export interface CollectUsageOptions {
+    readonly fetchUsage?: (opts?: FetchSubscriptionUsageOptions) => Promise<UsageResult>;
+    readonly includeClaude?: boolean;
+    readonly includeCodex?: boolean;
+    readonly fetchCodex?: () => Promise<UsageResult>;
+    readonly now?: number;
+}
+export interface CollectedUsage {
+    readonly records: UsageRecord[];
+    readonly anthropic?: UsageResult;
+    readonly codex?: UsageResult;
+}
+export declare function collectUsage(opts?: CollectUsageOptions): Promise<CollectedUsage>;

package/dist/cli/commands/daemon-builtin-tasks.d.ts

@@ -0,0 +1,15 @@
+import type { ScheduledTask } from '../../agent/daemon/triggers.js';
+import type { CliConfig } from '../config/types.js';
+export declare function buildWorktreePruneTask(cron: string): ScheduledTask;
+export declare function buildToolHealthTask(cron: string): ScheduledTask;
+export declare function appendBuiltinTasks(tasks: ScheduledTask[], config: {
+    daemon?: CliConfig['daemon'];
+}, env: {
+    AFK_WORKTREE_PRUNE_DISABLE?: string;
+    AFK_TOOL_HEALTH_DISABLE?: string;
+}): {
+    worktreePruneCron: string;
+    toolHealthCron: string;
+    worktreePruneEnabled: boolean;
+    toolHealthEnabled: boolean;
+};

package/dist/cli/commands/interactive/interactive.cleanup.d.ts

@@ -1,3 +1,4 @@
+import { type StoredSession } from '../../session-store.js';
 import type { InteractiveCtx } from './shared.js';
 import type { TurnState } from './repl-loop.js';
 import type { WorktreeHandle } from './worktree.js';
@@ -5,6 +6,7 @@ export interface SignalHandlerDeps {
     ctx: InteractiveCtx;
     turnState: TurnState;
     pickerAbort: AbortController;
+    exitReasonRef: ExitReasonRef;
 }
 export interface SignalHandlerDisposers {
     removeListeners: () => void;
@@ -15,7 +17,10 @@ export declare function installSignalHandlers(deps: SignalHandlerDeps): {
 };
 export declare function printExitSummary(ctx: InteractiveCtx, worktreeHandle: WorktreeHandle | undefined, saveCurrentSession: () => string | undefined): void;
 export declare function snapshotGitStateForCancelAll(cwd: string): Promise<void>;
-export declare function makeSessionSaver(ctx: InteractiveCtx): {
+export type ExitReasonRef = {
+    current: StoredSession['exitReason'];
+};
+export declare function makeSessionSaver(ctx: InteractiveCtx, exitReasonRef?: ExitReasonRef): {
     saveCurrentSession: () => string | undefined;
     isSaved: () => boolean;
 };

package/dist/cli/commands/interactive/loop-iteration.boundary.d.ts

@@ -0,0 +1,36 @@
+import type { PeerInboxNotifier } from './peer-inbox-notifier.js';
+import { AdmissionQueue } from '../../../agent/peer/admission-queue.js';
+import type { InteractiveCtx } from './shared.js';
+import type { InputSurface } from '../../input/input-surface.js';
+export interface BoundaryCompositor {
+    hasPendingSubmission(): boolean;
+    peekQueuedText(): {
+        text: string;
+        payloads: readonly unknown[];
+    } | undefined;
+    reserveQueued(snapshot: {
+        payloads: readonly unknown[];
+    }): void;
+    releaseQueued(snapshot: {
+        payloads: readonly unknown[];
+    }): void;
+    dropQueued(snapshot: {
+        payloads: readonly unknown[];
+    }): number;
+}
+export interface BoundarySession {
+    setBeforeNextRound?: (cb: (() => string | undefined) | undefined) => void;
+}
+export interface PeerBoundaryOpts {
+    getSession: () => BoundarySession | undefined;
+    getCompositor: () => BoundaryCompositor | null;
+    peerNotifier: PeerInboxNotifier;
+    admissionQueue: AdmissionQueue;
+}
+export declare function installPeerBoundary(opts: PeerBoundaryOpts): () => void;
+export declare function reinstallPeerBoundary(opts: PeerBoundaryOpts, prevDispose: (() => void) | undefined): () => void;
+export declare function drainAdmissionQueueFallback(text: string, q: AdmissionQueue): string;
+export declare function setupPeerBoundary(ctx: InteractiveCtx, surface: InputSurface, peerNotifier: PeerInboxNotifier): {
+    admissionQueue: AdmissionQueue;
+    reinstall: () => void;
+};

package/dist/cli/commands/interactive/peer-inbox-notifier.d.ts

@@ -1,15 +1,20 @@
 import { type PeerInboundMode } from '../../../agent/peer/inbound-mode.js';
+import { type PeerEnvelope } from '../../../agent/peer/envelope.js';
 import type { TraceSink } from '../../../agent/trace/index.js';
 import type { InteractiveCtx } from './shared.js';
 export interface PeerInboxNotifierOpts {
     getSessionId: () => string | undefined;
     writeLine: (text: string) => void;
     mode?: () => PeerInboundMode;
-    traceWriter?: TraceSink;
     getTraceWriter?: () => TraceSink | undefined;
+    traceWriter?: TraceSink;
     now?: () => number;
     pollMs?: number;
 }
+interface BufferedClaim {
+    envelope: PeerEnvelope;
+    sessionId: string;
+}
 export declare class PeerInboxNotifier {
     private readonly opts;
     onInjectable: (() => void) | null;
@@ -17,6 +22,7 @@ export declare class PeerInboxNotifier {
     private wakeBudget;
     private readonly pollMs;
     private readonly getMode;
+    private readonly resolveTraceWriter;
     private scanning;
     private rescan;
     private watchedId;
@@ -29,7 +35,10 @@ export declare class PeerInboxNotifier {
     constructor(opts: PeerInboxNotifierOpts);
     resetForNewSession(): void;
     hasPendingInjections(): boolean;
+    peekEnvelopes(): readonly BufferedClaim[];
+    consumeEnvelopes(count: number): string;
     drainInjections(): string;
+    reclaim(): Promise<number>;
     start(): void;
     dispose(): void;
     forceAccept(messageIds: ReadonlySet<string> | 'all'): Promise<number>;
@@ -47,3 +56,4 @@ export declare class PeerInboxNotifier {
 }
 export declare function createPeerInboxNotifier(opts: PeerInboxNotifierOpts): PeerInboxNotifier;
 export declare function createReplPeerNotifier(ctx: InteractiveCtx): PeerInboxNotifier;
+export {};

package/dist/cli/commands/interactive/shared.d.ts

@@ -77,17 +77,20 @@ export interface InteractiveCtx {
     worktreeDisposition?: import('./worktree-disposition.js').WorktreeDisposition;
     resolveWorktreeDisposition?: (canPrompt: boolean) => Promise<void>;
     getInFlight?: () => boolean;
+    exitReasonRef?: {
+        current: StoredSession['exitReason'];
+    };
     requestResume?: (target: ResolvedResumeTarget) => Promise<ResumeSwapResult>;
     clearVerdictLedger?: () => void;
     clearBgResultBuffer?: () => void;
     resetPeerNotifier?: () => void;
     traceWriter?: TraceSink;
     clearPendingStopInjection?: () => void;
+    reinstallPeerBoundary?: () => void;
     preArmAnchorRow?: number;
     inputSurfaceRef?: {
         current: import('../../input/input-surface.js').InputSurface | null;
     };
-    suggestApiKey?: string;
     suggestBaseUrl?: string;
     suggestGhostConfig?: boolean;
     viewingTaskId?: string;

package/dist/cli/commands/interactive/surface-setup.suggest-config.d.ts

@@ -14,7 +14,6 @@ export declare function buildSuggestConfig(opts: {
     engine: SuggestEngine;
     surface: InputSurface;
     stats: SuggestCtxStats;
-    apiKey: string | undefined;
     baseUrl: string | undefined;
     historyTracker: HistorySubmissionTracker;
 }): {

package/dist/cli/commands/usage.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from 'commander';
+import { type UsageSummary } from '../../agent/usage/usage-formatter.js';
+import { type OpenAIAuthResolution } from '../../agent/providers/openai-compatible/auth.js';
+export interface UsageCredentialProbes {
+    readonly chatgpt: () => Pick<OpenAIAuthResolution, 'source'>;
+    readonly openaiApiKey: () => string | undefined;
+}
+export declare function collectUsageSummary(now?: number, probes?: UsageCredentialProbes): Promise<UsageSummary>;
+export declare function registerUsageCommand(program: Command): void;

package/dist/cli/config/json-tier-parse.daemon.d.ts

@@ -0,0 +1,2 @@
+import type { CliConfig } from './types.js';
+export declare function parseDaemonBlock(raw: unknown): NonNullable<CliConfig['daemon']>;

package/dist/cli/config/types.d.ts

@@ -31,6 +31,10 @@ export interface CliConfig {
             maxAgeDaysDirty: number;
             scope: string;
         };
+        toolHealth?: {
+            enabled: boolean;
+            cron: string;
+        };
         verifyDone?: boolean;
     };
     telegram?: {
@@ -98,6 +102,10 @@ export interface ConfigFileSchema {
             maxAgeDaysDirty?: number;
             scope?: string;
         };
+        toolHealth?: {
+            enabled?: boolean;
+            cron?: string;
+        };
         verifyDone?: boolean;
     };
     telegram?: {

package/dist/cli/constants.d.ts

@@ -1,6 +1,4 @@
 export declare const SPINNER_VERBS: string[];
 export declare const GOBLIN_SPINNER_VERBS: string[];
-export declare const COMPLETION_VERBS: Record<string, string>;
 export declare function pickRandomVerb(): string;
 export declare function pickRandomGoblinVerb(): string;
-export declare function getCompletionVerb(verb: string): string;

package/dist/cli/input/suggest-credential.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderRouteHints } from '../../agent/providers/index.js';
+export interface SuggestCredential {
+    apiKey?: string;
+    forceChatgptOAuth?: boolean;
+}
+export type ResolveCredentialFn = (model: string | undefined, hints: ProviderRouteHints | undefined) => string | undefined;
+export interface SuggestCredentialResolver {
+    resolve(model: string, hints: ProviderRouteHints | undefined): SuggestCredential | undefined;
+}
+export declare function createSuggestCredentialResolver(resolveFn?: ResolveCredentialFn): SuggestCredentialResolver;

package/dist/cli/input/suggest-types.d.ts

@@ -2,7 +2,6 @@ import type { ModelProvider } from '../../agent/provider.js';
 import type { ProviderRouteHints } from '../../agent/providers/index.js';
 export interface SuggestContext {
     model: string;
-    apiKey?: string;
     baseUrl?: string;
     cwd: string;
     getHistory(): string[];
@@ -22,12 +21,14 @@ export interface CompleteRequest {
     maxTokens: number;
     signal: AbortSignal;
     apiKey?: string;
+    forceChatgptOAuth?: boolean;
     baseUrl?: string;
 }
 export type CompleteFn = (req: CompleteRequest) => Promise<string>;
 export interface SuggestEngineOptions {
     completeFn?: CompleteFn;
     resolveProviderFn?: (model: string | undefined, hints: ProviderRouteHints | undefined) => ModelProvider;
+    resolveCredentialFn?: (model: string | undefined, hints: ProviderRouteHints | undefined) => string | undefined;
     debounceMs?: number;
     timeoutMs?: number;
     onError?: (err: unknown) => void;

package/dist/cli/session-store.d.ts

@@ -10,6 +10,8 @@ export interface StoredSession {
     model: AgentModelInput;
     startedAt: number;
     savedAt: number;
+    endedAt?: number;
+    exitReason?: 'sigint' | 'sigterm' | 'sighup' | 'exit-command' | 'eof';
     totalTurns: number;
     totalCostUsd: number;
     unpricedTurns?: number;
@@ -43,7 +45,10 @@ export interface FoundSession {
     id: string;
     data: StoredSession;
 }
-export declare function saveSession(stats: SessionStats, overrideId?: string): string;
+export declare function saveSession(stats: SessionStats, overrideId?: string, opts?: {
+    closeTime?: boolean;
+    exitReason?: StoredSession['exitReason'];
+}): string;
 export declare function forkStoredSession(stats: SessionStats, opts?: {
     newId?: string;
 }): {

package/dist/cli/tool-category.d.ts

@@ -2,6 +2,7 @@ import { type ChalkInstance } from 'chalk';
 import { categorizeTool, dispatchTagForCategory, SUBAGENT_TOOLS, SKILL_TOOLS, DAG_TOOLS, NESTING_TOOLS, type ToolCategory } from '../agent/tool-category.js';
 export { categorizeTool, dispatchTagForCategory, SUBAGENT_TOOLS, SKILL_TOOLS, DAG_TOOLS, NESTING_TOOLS, type ToolCategory, };
 export declare const CATEGORY_HUMAN_VERB: Record<ToolCategory, string>;
+export declare const TOOL_VERB_OVERRIDES: Partial<Record<string, string>>;
 export declare function humanVerbForTool(toolName: string): string;
 export interface CategoryStyle {
     color: ChalkInstance;