agent-afk 5.307.13 → 5.308.0

package/README.md

@@ -22,7 +22,7 @@ Open source. Runs locally. Works with any model provider, including local models
 ## Quick Start
 
 ```bash
-npm install -g agent-afk    # Node 22.22.2+, 24.15+, or 26+
+npm install -g agent-afk    # Node 22.22.2–22.x, 24.15–24.x, or 26+ (23.x and 25.x excluded)
 afk login                   # authenticate (auto-detects Claude Code / Codex creds)
 afk doctor                  # verify everything works
 afk chat "hello"             # first real conversation

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

@@ -1,5 +1,5 @@
 export type { Surface, PhaseRole, SubagentStatusLite, SubagentStatusLiteValue, BgJobLite, BgJobStatus, McpServerSummary, McpFailedServer, RuntimeSelf, RuntimeTools, RuntimeSubagents, RuntimeWorkspace, RuntimeSnapshot, RuntimeView, RuntimeStateSource, } from './types.js';
-export { buildRuntimeSnapshot, parseView, formatEnvironmentFragment, formatEnvironmentDateLine, } from './runtime-snapshot.js';
+export { buildRuntimeSnapshot, parseView, formatEnvironmentFragment, formatEnvironmentDateLine, formatClock, snapshotClock, } 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';

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

@@ -1,5 +1,9 @@
 import type { RuntimeStateSource, RuntimeSnapshot, RuntimeView, RuntimeWorkspace } from './types.js';
 export declare function buildRuntimeSnapshot(source: RuntimeStateSource, view?: RuntimeView): Partial<RuntimeSnapshot>;
+export declare function snapshotClock(epochMs: number): {
+    iso: string;
+    local: string;
+};
 export declare function parseView(raw: unknown): RuntimeView;
 export declare function formatEnvironmentFragment(args: {
     cwd: string;
@@ -12,3 +16,4 @@ export declare function formatEnvironmentFragment(args: {
     timeZone?: string;
 }): string;
 export declare function formatEnvironmentDateLine(now: Date, timeZone?: string): string;
+export declare function formatClock(epochMs: number, timeZone?: string): string;

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

@@ -59,6 +59,10 @@ export interface RuntimeSnapshot {
     subagents: RuntimeSubagents;
     workspace: RuntimeWorkspace;
     usage?: RuntimeUsageEntry[];
+    clock?: {
+        iso: string;
+        local: string;
+    };
     subagentOutcomeSummary?: SubagentOutcomeSummaryEntry[];
 }
 export type { SubagentOutcomeSummaryEntry } from '../../insights/aggregators/subagent-outcomes.js';

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

@@ -10,6 +10,8 @@ export interface ScheduledTaskConfig {
     enabled: boolean;
     notifyOn?: 'failure' | 'always' | 'never';
     notifyChat?: number | string;
+    maxAttempts?: number;
+    retryDelayMs?: number;
     createdAt: string;
     updatedAt: string;
 }

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

@@ -26,6 +26,7 @@ export interface SchedulerOptions {
     primaryChatId?: number;
     primaryThreadId?: number;
     budgetGate?: () => Promise<import('./budget-gate.js').BudgetGateResult>;
+    retrySleep?: (ms: number, signal: AbortSignal) => Promise<void>;
 }
 export type TelemetryTrigger = 'cron' | 'sessionstart' | 'pull';
 type TelemetryStatus = 'success' | 'error' | 'skipped';
@@ -42,6 +43,7 @@ export interface TelemetryRecord {
     skipReason?: SessionStartSkipReason;
     name?: string;
     doneUnverified?: boolean;
+    attempts?: number;
 }
 export interface TaskCompletionDetails {
     responseText?: string;
@@ -61,6 +63,7 @@ export declare class CronScheduler {
     private readonly budgetAlerts;
     private readonly overlapAlerts;
     private readonly telemetryAlerts;
+    private shutdownController;
     constructor(options?: SchedulerOptions);
     register(task: ScheduledTask): void;
     unregister(taskId: string): void;

package/dist/agent/daemon/scheduler.execute-agent-task.d.ts

@@ -37,6 +37,9 @@ export interface AgentTaskContext {
         dispose: () => void;
     }>;
     writeTelemetry: (record: TelemetryRecord, task: ScheduledTask, details?: TaskCompletionDetails) => void;
+    shutdownSignal?: AbortSignal;
+    isCancelled?: () => boolean;
+    retrySleep?: (ms: number, signal: AbortSignal) => Promise<void>;
 }
 export declare function executeAgentTask(ctx: AgentTaskContext, task: ScheduledTask, trigger: TelemetryTrigger): Promise<TelemetryRecord>;
 export {};

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

@@ -0,0 +1,41 @@
+export declare const TASK_MAX_ATTEMPTS_LIMIT = 5;
+export declare const TASK_RETRY_DELAY_MIN_MS = 1000;
+export declare const TASK_RETRY_DELAY_MAX_MS: number;
+export declare const DEFAULT_TASK_RETRY_DELAY_MS: number;
+export interface TaskRetryFields {
+    maxAttempts?: number;
+    retryDelayMs?: number;
+}
+export type ParseTaskRetryResult = {
+    ok: true;
+    value: TaskRetryFields;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseTaskRetryFields(obj: Record<string, unknown>): ParseTaskRetryResult;
+export interface ResolvedTaskRetry {
+    maxAttempts: number;
+    retryDelayMs: number;
+}
+export declare function resolveTaskRetryPolicy(task: TaskRetryFields): ResolvedTaskRetry;
+export interface TaskRetryRunOptions extends ResolvedTaskRetry {
+    signal: AbortSignal;
+    isCancelled?: () => boolean;
+    sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    onRetry?: (info: {
+        attempt: number;
+        error: unknown;
+        delayMs: number;
+    }) => void;
+}
+export type TaskRetryOutcome<T> = {
+    ok: true;
+    value: T;
+    attempts: number;
+} | {
+    ok: false;
+    error: unknown;
+    attempts: number;
+};
+export declare function runWithTaskRetry<T>(attempt: (attemptNumber: number) => Promise<T>, opts: TaskRetryRunOptions): Promise<TaskRetryOutcome<T>>;

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

@@ -10,5 +10,7 @@ export interface ScheduledTask {
     notifyOn?: 'failure' | 'always' | 'never';
     notifyChat?: number | string;
     cwd?: string;
+    maxAttempts?: number;
+    retryDelayMs?: number;
 }
 export declare function validateScheduledTask(task: ScheduledTask): void;

package/dist/agent/plugins/tool-injector.d.ts

@@ -3,6 +3,8 @@ export interface PluginSkillMetadata {
     description?: string;
     argumentHint?: string;
     whenToUse?: string;
+    flags?: string[];
+    category?: string;
     origin?: 'command';
     allowedTools?: string[];
     context?: string;

package/dist/agent/provider.d.ts

@@ -197,6 +197,8 @@ export interface ProviderCommandInfo {
     description?: string;
     argumentHint?: string;
     whenToUse?: string;
+    flags?: readonly string[];
+    category?: string;
     source?: 'builtin' | 'user' | 'project' | 'plugin' | 'imported' | 'command';
 }
 export interface ProviderModelInfo {

package/dist/agent/providers/anthropic-direct/cache-policy.d.ts

@@ -19,14 +19,13 @@ export interface CacheableToolLike {
     cache_control?: {
         type: string;
     } | null;
-    [k: string]: unknown;
 }
-export declare function clampBreakpoints(params: {
+export declare function clampBreakpoints<T extends CacheableToolLike>(params: {
     system?: readonly ContentBlockParam[];
-    tools?: readonly CacheableToolLike[];
+    tools?: readonly T[];
     messages: readonly MessageParam[];
 }): {
     system?: readonly ContentBlockParam[];
-    tools?: readonly CacheableToolLike[];
+    tools?: readonly T[];
     messages: readonly MessageParam[];
 };

package/dist/agent/providers/anthropic-direct/loop/tool-results.d.ts

@@ -1,4 +1,4 @@
 import type { ProviderEvent } from '../../../provider.js';
 import type { RunTurnInput, ToolCall, ToolResult } from '../types.js';
 export type ToolResultsOutcome = 'committed' | 'denial-tripped';
-export declare function emitAndCommitToolResults(calls: ToolCall[], results: ToolResult[], startTimes: Map<string, number>, input: RunTurnInput): AsyncGenerator<ProviderEvent, ToolResultsOutcome, void>;
+export declare function emitAndCommitToolResults(calls: ToolCall[], results: ToolResult[], startTimes: Map<string, number>, input: RunTurnInput, vitalsNote?: string): AsyncGenerator<ProviderEvent, ToolResultsOutcome, void>;

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

@@ -0,0 +1,6 @@
+import type { RunTurnInput } from '../types.js';
+import type { RetryTierContext } from './retry-context.js';
+type RefreshResult = Awaited<ReturnType<RetryTierContext['forceClientRefresh']>>;
+export declare function adoptFreshClient(ctx: Pick<RetryTierContext, 'forceClientRefresh' | 'getClient' | 'rotateHeaders'>, runInput: RunTurnInput): Promise<RefreshResult>;
+export declare function liveAccountId(ctx: Pick<RetryTierContext, 'getClientToken'>): string;
+export {};

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

@@ -9,6 +9,7 @@ export interface RetryTierContext {
     readonly autoResumeOnUsageLimit: boolean;
     readonly tokenRefresher: (() => Promise<Anthropic | null>) | undefined;
     getClient(): Anthropic;
+    getClientToken(): string | undefined;
     rotateHeaders(runInput: Pick<RunTurnInput, 'effort' | 'fastMode'>): Record<string, string>;
     forceClientRefresh(): Promise<{
         accountId: string;

package/dist/agent/providers/anthropic-direct/query/usage-limit-catch-up.d.ts

@@ -0,0 +1,3 @@
+import type { RunTurnInput } from '../types.js';
+import type { RetryTierContext } from './retry-context.js';
+export declare function catchUpStaleCredential(ctx: RetryTierContext, runInput: RunTurnInput): Promise<boolean>;

package/dist/agent/providers/anthropic-direct/query/usage-limit-pause.d.ts

@@ -1,5 +1,6 @@
 import type { ProviderEvent } from '../../../provider.js';
 import type { RunTurnInput } from '../types.js';
-import type { RetryTierContext, TierGenerator } from './retry-context.js';
+import type { RetryTierContext, TierGenerator, UsageLimitWaitResult } from './retry-context.js';
+export declare function joinUsageLimitWait(shared: Promise<UsageLimitWaitResult>, signal: AbortSignal): Promise<UsageLimitWaitResult>;
 export declare function usageLimitNoTimestampPause(ctx: RetryTierContext, runInput: RunTurnInput, isClosed: () => boolean, next: TierGenerator, pendingErrorEvent: ProviderEvent): AsyncGenerator<ProviderEvent, void, void>;
 export declare function usageLimitResetPause(ctx: RetryTierContext, runInput: RunTurnInput, isClosed: () => boolean, next: TierGenerator, pendingErrorEvent: ProviderEvent, resetsAt: Date): AsyncGenerator<ProviderEvent, void, void>;

package/dist/agent/providers/openai-compatible/query/dispatch-append.d.ts

@@ -13,5 +13,6 @@ export interface DispatchAndAppendInput {
     priorTurns: OpenAIMessage[];
     sessionId: string;
     subagentId?: string | undefined;
+    vitalsNote?: string | undefined;
 }
-export declare function dispatchAndAppendToolCalls({ state, signal, vision, toolDispatcher, traceWriter, priorTurns, sessionId, subagentId, }: DispatchAndAppendInput): AsyncGenerator<ProviderEvent, ToolResult | undefined>;
+export declare function dispatchAndAppendToolCalls({ state, signal, vision, toolDispatcher, traceWriter, priorTurns, sessionId, subagentId, vitalsNote, }: DispatchAndAppendInput): AsyncGenerator<ProviderEvent, ToolResult | undefined>;

package/dist/agent/providers/shared/transient-retry.d.ts

@@ -16,4 +16,5 @@ export interface TransientRetryOpts {
     onExhausted?: (info: RetryInfo) => void;
     sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
 }
+export declare function isTransientError(err: unknown): boolean;
 export declare function withTransientRetry<T>(attempt: () => Promise<T>, opts?: TransientRetryOpts): Promise<T>;

package/dist/agent/providers/shared/vitals.d.ts

@@ -0,0 +1,24 @@
+import type { UsageRecord } from '../../usage/usage-record.js';
+export declare const VITALS_PREFIX = "[vitals]";
+export declare const CONTEXT_SHOW_PCT = 50;
+export declare const USAGE_SHOW_PCT = 80;
+export declare const HIGH_PCT = 90;
+export declare const USAGE_CACHE_TTL_MS = 60000;
+export interface VitalsInput {
+    readonly turnStartedAt: number;
+    readonly softDeadlineMs?: number | undefined;
+    readonly contextTokens?: number | undefined;
+    readonly model?: string | undefined;
+    readonly subagentId?: string | undefined;
+    readonly claudeUsage?: boolean | undefined;
+}
+export interface VitalsDeps {
+    readonly now?: () => number;
+    readonly timeZone?: string;
+    readonly readClaudeUsage?: () => UsageRecord | undefined;
+    readonly contextLimit?: (model: string) => number;
+}
+export declare function vitalsEnabled(): boolean;
+export declare function buildVitalsNote(input: VitalsInput, deps?: VitalsDeps): string | undefined;
+export declare function resetVitalsUsageCacheForTests(): void;
+export declare function formatDuration(ms: number, seconds?: boolean): string;

package/dist/agent/tools/skill-bridge.d.ts

@@ -7,6 +7,8 @@ export interface SkillManifestEntry {
     source: 'builtin' | 'user' | 'project' | 'plugin' | 'imported' | 'command';
     argumentHint?: string;
     whenToUse?: string;
+    flags?: readonly string[];
+    category?: string;
     disableModelInvocation?: boolean;
 }
 export declare function buildSkillManifest(pluginConfigs?: SdkPluginConfig[], opts?: BuildSkillManifestOptions): string;

package/dist/cli/slash/_lib/flag-harvest.d.ts

@@ -1,9 +1 @@
-export declare function normalizeFlag(flag: string): string;
-export declare function extractFlagsFromBody(body: string): string[];
-export interface ParsedSkillMd {
-    frontmatter: Record<string, string> | null;
-    frontmatterFlags: string[] | null;
-    body: string;
-}
-export declare function parseSkillMd(content: string): ParsedSkillMd;
-export declare function harvestFlagsFromSkillMd(content: string): string[];
+export { normalizeFlag, extractFlagsFromBody, parseFlagsField, resolveSkillFlags, parseSkillMd, harvestFlagsFromSkillMd, type ParsedSkillMd, } from '../../../utils/skill-md.js';

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

@@ -5,6 +5,7 @@ export interface DiscoveredSkill {
     argumentHint?: string;
     source?: SkillManifestEntry['source'];
     category?: string;
+    flags?: readonly string[];
     whenToUse?: string;
 }
 export interface PluginCollision {