agent-afk 5.290.4 → 5.291.0

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

@@ -1,3 +1,4 @@
+import type { CompactUsageEntry } from '../usage/usage-formatter.js';
 export type Surface = 'cli' | 'repl' | 'daemon' | 'telegram' | 'subagent' | 'web' | 'unknown';
 export type PhaseRole = 'read-only' | 'read-write';
 export type SubagentStatusLiteValue = 'idle' | 'running' | 'succeeded' | 'failed' | 'cancelled';
@@ -50,11 +51,13 @@ export interface RuntimeWorkspace {
     dirtyCount: number | null;
     remoteUrl: string | null;
 }
+export type RuntimeUsageEntry = CompactUsageEntry;
 export interface RuntimeSnapshot {
     self: RuntimeSelf;
     tools: RuntimeTools;
     subagents: RuntimeSubagents;
     workspace: RuntimeWorkspace;
+    usage?: RuntimeUsageEntry[];
 }
 export type RuntimeView = 'self' | 'tools' | 'subagents' | 'workspace' | 'all';
 export interface RuntimeStateSource {
@@ -62,4 +65,5 @@ export interface RuntimeStateSource {
     getTools(): RuntimeTools;
     getSubagents(): RuntimeSubagents;
     getWorkspace(): RuntimeWorkspace;
+    getUsage(): RuntimeUsageEntry[];
 }

package/dist/agent/daemon/budget-gate.d.ts

@@ -0,0 +1,31 @@
+import type { FetchSubscriptionUsageOptions, UsageResult } from '../subscription-usage.js';
+import { type BindingWindow } from '../usage/usage-budget.js';
+export interface BudgetGatePass {
+    readonly skip: false;
+}
+export interface BudgetGateSkip {
+    readonly skip: true;
+    readonly provider: string;
+    readonly binding: BindingWindow;
+}
+export type BudgetGateResult = BudgetGatePass | BudgetGateSkip;
+export interface UsageTarget {
+    readonly provider: string;
+    readonly account: string;
+}
+export interface BudgetGateOptions {
+    readonly skipPct?: number;
+    readonly target?: UsageTarget | null;
+    readonly fetchUsage?: (opts?: FetchSubscriptionUsageOptions) => Promise<UsageResult>;
+    readonly fetchCodex?: () => Promise<UsageResult>;
+    readonly now?: number;
+}
+export declare function resolveDaemonUsageTarget(model: string | undefined, apiKey?: string, chatgptSignedIn?: () => boolean): UsageTarget | null;
+export declare function evaluateBudgetGate(options?: BudgetGateOptions): Promise<BudgetGateResult>;
+export declare function describeBudgetSkip(skip: BudgetGateSkip, now?: number): string;
+export declare function formatBudgetSkipMessage(skip: BudgetGateSkip, taskId: string, now?: number): string;
+export declare class BudgetAlertLatch {
+    private alerted;
+    shouldAlert(skip: BudgetGateSkip): boolean;
+    clear(): void;
+}

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

@@ -1,5 +1,5 @@
 export declare const DEFAULT_SESSIONSTART_COOLDOWN_MS: number;
-export type SessionStartSkipReason = 'cooldown' | 'overlap';
+export type SessionStartSkipReason = 'cooldown' | 'overlap' | 'budget-over';
 export interface GateDecision {
     fire: boolean;
     skipReason?: SessionStartSkipReason;

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

@@ -22,6 +22,7 @@ export interface SchedulerOptions {
     bot?: Telegraf;
     primaryChatId?: number;
     primaryThreadId?: number;
+    budgetGate?: () => Promise<import('./budget-gate.js').BudgetGateResult>;
 }
 export type TelemetryTrigger = 'cron' | 'sessionstart' | 'pull';
 export type TelemetryStatus = 'success' | 'error' | 'skipped';
@@ -54,6 +55,7 @@ export declare class CronScheduler {
     private isDequeuing;
     private readonly queueDir;
     private readonly inFlightTaskIds;
+    private readonly budgetAlerts;
     constructor(options?: SchedulerOptions);
     register(task: ScheduledTask): void;
     unregister(taskId: string): void;

package/dist/agent/daemon/scheduler.overlap-guard.d.ts

@@ -1,5 +1,7 @@
 import type { ScheduledTask } from './triggers.js';
 import type { GateDecision } from './gates.js';
 import type { TelemetryRecord, TelemetryTrigger } from './scheduler.js';
+import { type BudgetGateSkip } from './budget-gate.js';
 export declare function makeOverlapSkipRecord(task: ScheduledTask, trigger: TelemetryTrigger, nowMs: number): TelemetryRecord;
+export declare function makeBudgetSkipRecord(task: ScheduledTask, trigger: TelemetryTrigger, nowMs: number, skip: BudgetGateSkip): TelemetryRecord;
 export declare function makeSessionStartSkipRecord(task: ScheduledTask, decision: GateDecision, nowMs: number): TelemetryRecord;

package/dist/agent/daemon/tool-health-task.d.ts

@@ -0,0 +1,17 @@
+import type { TelemetryRecord, TelemetryTrigger } from './scheduler.js';
+export declare const TOOL_HEALTH_LOOKBACK_MS: number;
+export declare const TOOL_HEALTH_MIN_SESSIONS = 2;
+export declare const TOOL_HEALTH_COOLDOWN_MS: number;
+export declare const TOOL_HEALTH_MAX_FILES = 200;
+export interface ToolHealthTaskOptions {
+    now: () => number;
+    telemetryPath: () => string;
+    writeTelemetry: (record: TelemetryRecord) => void;
+    lookbackMs?: number;
+    alertStatePath?: string;
+}
+export declare function runBuiltinToolHealthTask(task: {
+    taskId: string;
+    command: string;
+    cronExpression?: string;
+}, trigger: TelemetryTrigger, options: ToolHealthTaskOptions): Promise<TelemetryRecord>;

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

@@ -1,6 +1,6 @@
 export type TriggerMode = 'cron' | 'sessionstart' | 'both' | 'pull';
 export type TaskExecutor = 'agent' | 'shell' | 'builtin';
-export declare const KNOWN_BUILTINS: readonly ["worktree-prune"];
+export declare const KNOWN_BUILTINS: readonly ["worktree-prune", "tool-health"];
 export type BuiltinTaskName = (typeof KNOWN_BUILTINS)[number];
 export interface ScheduledTask {
     taskId: string;

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

@@ -34,6 +34,14 @@ export declare const StoredSessionInputSchema: z.ZodObject<{
     model: z.ZodString;
     startedAt: z.ZodNumber;
     savedAt: z.ZodNumber;
+    endedAt: z.ZodOptional<z.ZodNumber>;
+    exitReason: z.ZodOptional<z.ZodEnum<{
+        sigint: "sigint";
+        sigterm: "sigterm";
+        sighup: "sighup";
+        "exit-command": "exit-command";
+        eof: "eof";
+    }>>;
     totalTurns: z.ZodNumber;
     totalCostUsd: z.ZodOptional<z.ZodNumber>;
     totalTokens: z.ZodOptional<z.ZodNumber>;
@@ -106,7 +114,7 @@ export declare const YieldTrackingSchema: z.ZodObject<{
     is_scheduled_session: z.ZodBoolean;
     produced_pr: z.ZodNullable<z.ZodBoolean>;
     pr_merged: z.ZodNullable<z.ZodBoolean>;
-    pr_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pr_url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export type YieldTracking = z.infer<typeof YieldTrackingSchema>;
 export declare const SubagentToolSummarySchema: z.ZodObject<{
@@ -197,7 +205,7 @@ export declare const SessionFacetSchema: z.ZodObject<{
         is_scheduled_session: z.ZodBoolean;
         produced_pr: z.ZodNullable<z.ZodBoolean>;
         pr_merged: z.ZodNullable<z.ZodBoolean>;
-        pr_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pr_url: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     decisions: z.ZodArray<z.ZodString>;
     evidence_pointers: z.ZodArray<z.ZodString>;

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

@@ -27,8 +27,8 @@ export declare const VerifiedOutcomeSchema: z.ZodObject<{
     session_id: z.ZodString;
     label: z.ZodEnum<{
         failed: "failed";
-        succeeded: "succeeded";
         unknown: "unknown";
+        succeeded: "succeeded";
         blocked: "blocked";
         interrupted: "interrupted";
     }>;

package/dist/agent/peer/admission-queue.d.ts

@@ -0,0 +1,39 @@
+export type AdmissionEntry = {
+    readonly kind: 'human';
+    readonly seq: number;
+    readonly text: string;
+    readonly bytes: number;
+} | {
+    readonly kind: 'peer';
+    readonly seq: number;
+    readonly text: string;
+    readonly bytes: number;
+    readonly senderId: string;
+};
+export interface AdmissionSnapshot {
+    readonly entries: readonly AdmissionEntry[];
+    readonly cutoff: number;
+}
+export interface AdmissionQueueOptions {
+    maxCount?: number;
+    maxBytes?: number;
+    maxPerSender?: number;
+}
+export declare class AdmissionQueue {
+    private readonly entries;
+    private readonly maxCount;
+    private readonly maxBytes;
+    private readonly maxPerSender;
+    private totalBytes;
+    private seq;
+    constructor(opts?: AdmissionQueueOptions);
+    get size(): number;
+    get pending(): boolean;
+    get full(): boolean;
+    submitHuman(text: string): boolean;
+    submitPeer(senderId: string, text: string): boolean;
+    snapshot(): AdmissionSnapshot;
+    drain(snap: AdmissionSnapshot): string;
+    clear(): void;
+    private canAdmit;
+}

package/dist/agent/peer/inbox-store.d.ts

@@ -6,6 +6,7 @@ export interface SendResult {
     reason?: PeerRefusal;
     detail?: string;
 }
+export declare function envelopeFilename(env: Pick<PeerEnvelope, 'ts' | 'messageId'>): string;
 export declare function writeEnvelope(env: PeerEnvelope): Promise<void>;
 export declare function listPending(sessionId: string): Promise<string[]>;
 export declare function claimPending(sessionId: string, file: string): Promise<PeerEnvelope | null>;
@@ -19,6 +20,7 @@ export declare function listHeld(sessionId: string): Promise<Array<{
 export declare function releaseHeld(sessionId: string, file: string): Promise<boolean>;
 export declare function dropHeld(sessionId: string, file: string): Promise<boolean>;
 export declare function countPending(sessionId: string): Promise<number>;
+export declare function reclaimDelivered(sessionId: string, file: string): Promise<boolean>;
 export declare function findDeliveredEnvelope(sessionId: string, messageId: string): Promise<PeerEnvelope | null>;
 export declare function sweepPeerInboxes(opts: {
     liveSessionIds: ReadonlySet<string>;

package/dist/agent/provider.d.ts

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

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

@@ -3,6 +3,7 @@ import type { AuthMode } from './types.js';
 export declare const EXTENDED_CACHE_TTL_BETA = "extended-cache-ttl-2025-04-11";
 export declare const OAUTH_BETA_HEADER = "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,extended-cache-ttl-2025-04-11";
 export declare const EFFORT_BETA_HEADER = "effort-2025-11-24";
+export declare const THINKING_BINDING_CONTROLS_BETA_HEADER = "thinking-binding-controls-2026-08-01";
 export declare const CLI_USER_AGENT = "claude-cli/2.1.280 (external, cli)";
 export declare const BILLING_HEADER_TEXT = "x-anthropic-billing-header: cc_version=2.1.280; cc_entrypoint=cli; cch=00000;";
 export declare function detectAuthMode(token: string): AuthMode;
@@ -15,5 +16,5 @@ export declare function buildClientOptions(token: string, mode: AuthMode, baseUr
     fetch?: typeof fetch;
     maxRetries: 0;
 };
-export declare function buildRequestHeaders(mode: AuthMode, sessionId: string, requestId: string, withEffort?: boolean, extendedCacheTtl?: boolean, withFast?: boolean): Record<string, string>;
+export declare function buildRequestHeaders(mode: AuthMode, sessionId: string, requestId: string, withEffort?: boolean, extendedCacheTtl?: boolean, withFast?: boolean, withThinkingBindingControls?: boolean): Record<string, string>;
 export declare function buildSystemPrefix(mode: AuthMode): ContentBlockParam[] | null;

package/dist/agent/providers/anthropic-direct/beta-headers.d.ts

@@ -4,7 +4,9 @@ export interface BetaHeaderOptions {
     effort?: boolean;
     extendedCacheTtl?: boolean;
     fast?: boolean;
+    thinkingBindingControls?: boolean;
     effortEntry: string;
     extendedCacheEntry: string;
+    thinkingBindingControlsEntry?: string;
 }
 export declare function composeBetaHeader(options: BetaHeaderOptions): string | undefined;

package/dist/agent/providers/anthropic-direct/input-transformations.d.ts

@@ -0,0 +1,3 @@
+export declare const KNOWN_DROP_REASONS: Set<string>;
+export declare function warnOnDroppedThinkingBlocks(transformations: unknown, source: 'message_start' | 'message_delta'): void;
+export declare function _resetWarnCountForTest(): void;

package/dist/agent/providers/anthropic-direct/loop/round-request.d.ts

@@ -37,5 +37,5 @@ export interface OpenRoundContext {
     ttfbTimeoutMs: number;
     stallTimeoutMs: number;
 }
-export declare function buildRoundParams(input: Pick<RunTurnInput, 'model' | 'maxTokens' | 'messages' | 'system' | 'tools' | 'thinking' | 'effort' | 'temperature' | 'fastMode'>): AnthropicMessagesCreateParams;
+export declare function buildRoundParams(input: Pick<RunTurnInput, 'model' | 'maxTokens' | 'messages' | 'system' | 'tools' | 'thinking' | 'effort' | 'temperature' | 'thinkingBlockBinding' | 'fastMode'>): AnthropicMessagesCreateParams;
 export declare function openRound({ input, turn, retry, ttfbTimeoutMs, stallTimeoutMs, }: OpenRoundContext): AsyncGenerator<ProviderEvent, OpenRoundResult, void>;

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

@@ -18,6 +18,7 @@ export interface TurnRequestInput {
     thinking?: RunTurnInput['thinking'];
     effort?: RunTurnInput['effort'];
     temperature?: number;
+    thinkingBlockBinding?: RunTurnInput['thinkingBlockBinding'];
     maxToolUseIterations?: number;
     softDeadlineMs?: number;
     traceWriter?: RunTurnInput['traceWriter'];

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

@@ -23,7 +23,9 @@ export interface AnthropicDirectQueryOptions {
     systemPrefix: ContentBlockParam[] | null;
     tokenRefresher?: () => Promise<Anthropic | null>;
     thinking?: import('@anthropic-ai/sdk/resources').ThinkingConfigParam;
+    rawThinkingConfig?: import('../../types/sdk-types.js').ThinkingConfig;
     effort?: import('../../types/sdk-types.js').EffortLevel;
+    rawEffort?: import('../../types/sdk-types.js').EffortLevel;
     temperature?: number;
     baseUrl?: string;
     maxToolUseIterations?: number;

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

@@ -9,7 +9,10 @@ export declare class AnthropicDirectQuery implements ProviderQuery {
     private readonly tools;
     private readonly systemPrefix;
     private readonly thinking?;
+    private readonly rawThinkingConfig?;
     private readonly effort?;
+    private readonly rawEffort?;
+    private readonly launchModel;
     private readonly temperature?;
     private readonly baseUrl?;
     private readonly maxToolUseIterations?;

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

@@ -16,6 +16,7 @@ export interface TurnDriverContext {
     readonly thinking: import('@anthropic-ai/sdk/resources').ThinkingConfigParam | undefined;
     readonly effort: import('../../types/sdk-types.js').EffortLevel | undefined;
     readonly temperature: number | undefined;
+    readonly thinkingBlockBinding: import('./types.js').RunTurnInput['thinkingBlockBinding'] | undefined;
     readonly baseUrl: string | undefined;
     readonly maxToolUseIterations: number | undefined;
     readonly softDeadlineMs: number | undefined;

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

@@ -17,6 +17,9 @@ export interface RunTurnInput {
     thinking?: ThinkingConfigParam;
     effort?: import('../../types/sdk-types.js').EffortLevel;
     temperature?: number;
+    thinkingBlockBinding?: {
+        prefix_mismatch_behavior: 'drop_block';
+    };
     fastMode?: boolean;
     baseUrl?: string;
     traceWriter?: import('../../trace/index.js').TraceSink;
@@ -51,7 +54,11 @@ export interface AnthropicMessagesCreateParams {
     messages: MessageParam[];
     system?: ContentBlockParam[] | string;
     tools?: WireToolDef[];
-    thinking?: ThinkingConfigParam;
+    thinking?: ThinkingConfigParam & {
+        block_binding?: {
+            prefix_mismatch_behavior: 'drop_block';
+        };
+    };
     output_config?: {
         effort?: import('../../types/sdk-types.js').EffortLevel;
     };

package/dist/agent/providers/anthropic-direct/resolve-params.d.ts

@@ -1,8 +1,11 @@
 import type { ContentBlockParam, MessageParam, ThinkingConfigParam } from '@anthropic-ai/sdk/resources';
 import type { AgentConfig, ResumeHistoryTurn } from '../../types/config-types.js';
 import type { EffortLevel, ThinkingConfig } from '../../types/sdk-types.js';
+export declare const isFable51: (model: string) => boolean;
 export { resolveAutoCompactThreshold } from '../shared/auto-compact.js';
-export declare function resolveAnthropicTemperature(temperature: number | undefined): number | undefined;
+export declare function _resetWarnedTemperatureClampsForTest(): void;
+export declare function isNonDefaultSamplingForbiddenModel(model: string | undefined): boolean;
+export declare function resolveAnthropicTemperature(temperature: number | undefined, model?: string): number | undefined;
 export declare function resolveMaxTokens(config: AgentConfig, model: string): number;
 export declare function filterContentBlocks(raw: unknown[] | undefined): ContentBlockParam[];
 export declare function hasValidToolUsePairing(assistantBlocks: ContentBlockParam[], nextUserBlocks: ContentBlockParam[] | undefined): boolean;

package/dist/agent/providers/openai-compatible/complete-wire.d.ts

@@ -0,0 +1,11 @@
+import OpenAI from 'openai';
+import { type OpenAIOneShotInput } from './oneshot.js';
+export type { OpenAIOneShotInput } from './oneshot.js';
+export interface CompleteWireClientOptions {
+    apiKey: string;
+    baseURL?: string;
+    defaultHeaders?: Record<string, string>;
+    maxRetries: number;
+}
+export type CompleteWireClientFactory = (opts: CompleteWireClientOptions) => OpenAI;
+export declare function completeWithWire(input: OpenAIOneShotInput, clientFactory?: CompleteWireClientFactory): Promise<string>;

package/dist/agent/providers/openai-compatible/oneshot.d.ts

@@ -7,6 +7,7 @@ export type OneShotOpenAIClientFactory = (opts: {
     apiKey: string;
     baseURL?: string;
     defaultHeaders?: Record<string, string>;
+    maxRetries: number;
 }) => OpenAI;
 export declare function __setOpenAIOneShotClientFactory(factory: OneShotOpenAIClientFactory | null): void;
 export interface OpenAIOneShotInput {

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

@@ -8,3 +8,4 @@ export type OpenAIClientFactory = (opts: {
 export declare function __setOpenAIClientFactory(factory: OpenAIClientFactory | null): void;
 export declare function resolveClientFactory(): OpenAIClientFactory;
 export declare function buildOpenAIAdmissionFetch(baseURL: string | undefined): typeof fetch | undefined;
+export declare function ledgerAccountForBaseUrl(baseURL: string | undefined): string;

package/dist/agent/providers/openai-compatible/query/overload-pause-tier.d.ts

@@ -3,6 +3,7 @@ import type { TraceSink } from '../../../trace/index.js';
 import type { IterationResult } from './stream-drive.js';
 export declare const OPENAI_COMPAT_OVERLOAD_EXHAUSTED_NOTICE: string;
 export declare function isOverloadErrorEvent(event: ProviderEvent): boolean;
+export declare function overloadTrigger(event: ProviderEvent): 'status' | 'body';
 export interface OverloadPauseTierContext {
     surface: string | undefined;
     traceWriter: TraceSink | undefined;

package/dist/agent/providers/router/provider-router.d.ts

@@ -27,6 +27,7 @@ export declare class ProviderRouter implements ProviderQuery {
     private pendingUserText;
     private pendingAssistantText;
     private lastSessionId;
+    private _beforeNextRound;
     constructor(args: ProviderRouterArgs, deps: ProviderRouterDeps);
     private resolveInner;
     private buildInner;
@@ -36,6 +37,7 @@ export declare class ProviderRouter implements ProviderQuery {
     [Symbol.asyncIterator](): AsyncGenerator<ProviderEvent, void, unknown>;
     private driveUntilInit;
     interrupt(reason?: import('../../abort-reason.js').ProviderAbortReason): Promise<void>;
+    setBeforeNextRound(cb: (() => string | undefined) | undefined): void;
     setModel(model?: string): Promise<void>;
     setPermissionMode(mode: string): Promise<void>;
     setCwd(cwd: string): void;

package/dist/agent/providers/router/provider-router.switch.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderUserTurn } from '../../provider.js';
+export declare function stringifyUserContent(content: ProviderUserTurn['content']): string;
+export declare function buildSwitchNotice(previousModel: string, currentModel: string, previousFamily: string | undefined, currentFamily: string): string;
+export declare function prependNotice(content: ProviderUserTurn['content'], notice: string): ProviderUserTurn['content'];

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

@@ -1,4 +1,5 @@
 import type { ProviderCompactResult } from '../../provider.js';
+import { type RetryInfo } from './transient-retry.js';
 export declare const COMPACT_SYSTEM_PROMPT: string;
 export declare const COMPACT_SUMMARY_HEADER = "[Compacted summary of earlier conversation]";
 export declare const COMPACT_ACK_TEXT = "Acknowledged. Continuing from the summary above.";
@@ -70,5 +71,8 @@ export interface CompactionCoreDeps<M> {
     abortInFlight?(): void;
     timeoutMs?: number;
     onSuccess?(info: CompactionSuccess<M>): void;
+    onRetry?(info: RetryInfo): void;
+    retrySleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    signal?: AbortSignal;
 }
 export declare function runCompactionCore<M>(deps: CompactionCoreDeps<M>): Promise<ProviderCompactResult>;

package/dist/agent/providers/shared/rate-limit-bucket.d.ts

@@ -1,3 +1,4 @@
+export declare const PEER_SYNC_INTERVAL_MS = 1000;
 export interface RateLimitSnapshot {
     requestsRemaining?: number;
     requestsLimit?: number;
@@ -8,8 +9,20 @@ export interface RateLimitSnapshot {
     outputTokensRemaining?: number;
     outputTokensResetAt?: number;
 }
+export interface PeerRateLimitObservation {
+    requestsRemaining?: number;
+    requestsLimit?: number;
+    requestsResetAt?: number;
+    tokensRemaining?: number;
+    tokensLimit?: number;
+    tokensResetAt?: number;
+    frozenUntil?: number;
+    observedAt: number;
+}
+export type PeerRateLimitReader = () => PeerRateLimitObservation | undefined;
 export declare function estimateInputTokens(body: unknown): number;
 export declare class RateLimitBucket {
+    private readonly peerReader?;
     private requestsRemaining;
     private requestsResetAt;
     private requestsLimit;
@@ -18,10 +31,15 @@ export declare class RateLimitBucket {
     private inputTokensLimit;
     private outputTokensRemainingVal;
     private frozenUntil;
+    private lastObservedAt;
+    private peerSyncedAt;
+    constructor(peerReader?: PeerRateLimitReader | undefined);
     resetForTests(): void;
     get outputTokensRemaining(): number;
     update(snap: RateLimitSnapshot): void;
     freeze(retryAfterMs: number): void;
+    adoptPeer(peer: PeerRateLimitObservation, now?: number): void;
+    private syncPeer;
     private maybeResetWindows;
     acquirePermit(estimatedInputTokens: number, signal?: AbortSignal): Promise<void>;
 }

package/dist/agent/providers/shared/rate-limit-bucket.registry.d.ts

@@ -0,0 +1,3 @@
+import { RateLimitBucket } from './rate-limit-bucket.js';
+export declare function getRateLimitBucket(provider: string, account: string): RateLimitBucket;
+export declare function resetRateLimitBucketsForTests(): void;

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

@@ -0,0 +1,18 @@
+export declare const DEFAULT_TRANSIENT_MAX_RETRIES = 2;
+export interface RetryInfo {
+    attempt: number;
+    delayMs: number;
+    error: unknown;
+    status?: number;
+    code?: string;
+}
+export interface TransientRetryOpts {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    retryAfterCeilingMs?: number;
+    shouldStop?: () => boolean;
+    signal?: AbortSignal;
+    onRetry?: (info: RetryInfo) => void;
+    sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+}
+export declare function withTransientRetry<T>(attempt: () => Promise<T>, opts?: TransientRetryOpts): Promise<T>;

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

@@ -0,0 +1,3 @@
+import type { TraceSink } from '../../trace/index.js';
+import type { RetryInfo } from './transient-retry.js';
+export declare function traceTransientRetry(traceWriter: TraceSink | undefined, source: string, maxRetries: number): (info: RetryInfo) => void;

package/dist/agent/session/model-slots.d.ts

@@ -15,6 +15,7 @@ export declare const CLAUDE_SONNET_ID = "claude-sonnet-4-6";
 export declare const CLAUDE_OPUS_ID = "claude-opus-5-5";
 export declare const CLAUDE_OPUS_55_ID = "claude-opus-5-5";
 export declare const CLAUDE_FABLE_5_ID = "claude-fable-5";
+export declare const CLAUDE_FABLE_5_1_ID = "claude-fable-5-1";
 export declare const GROK_FLAGSHIP_ID = "grok-4.6";
 export declare const DEFAULT_SLOT_BINDINGS: ModelSlots;
 export declare const AUTO_SENTINEL = "auto";

package/dist/agent/state/state-store.d.ts

@@ -28,6 +28,7 @@ export declare class StateStore {
     get(namespace: string, key: string): QueryRow | null;
     put(namespace: string, key: string, value: unknown, opts?: PutOpts, producer?: string): PutResult;
     cas(namespace: string, key: string, expectedVersion: number, value: unknown, opts?: PutOpts, producer?: string): CasResult;
+    insertIfAbsent(namespace: string, key: string, value: unknown, opts?: PutOpts): PutResult;
     del(namespace: string, key: string): DelResult;
     query(namespace: string, opts?: {
         key_prefix?: string;

package/dist/agent/subagent/usage-limit-park-policy.d.ts

@@ -0,0 +1,3 @@
+import type { Surface } from '../awareness/types.js';
+export declare function isSubagentAutoResumeEnvEnabled(): boolean;
+export declare function resolveChildAutoResume(explicitCallerValue: boolean | undefined, childSurface: Surface | undefined): boolean;

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

@@ -2,6 +2,8 @@ import type { RepeatFailureGuard } from './repeat-failure-guard.js';
 import type { ToolCall, ToolResult } from '../providers/anthropic-direct/types.js';
 import type { SubagentExecutor } from './subagent-executor.js';
 import type { Batch } from './dispatch-batching.js';
+import type { TraceSink } from '../trace/index.js';
+import type { ToolHealthMonitor } from './tool-health-monitor.js';
 export interface IndexedCall {
     call: ToolCall;
     originalIndex: number;
@@ -14,6 +16,8 @@ export interface BatchExecDeps {
     sessionId: string | undefined;
     maxConcurrentSafeCalls: number;
     onActivity?: (activeIds: readonly string[]) => void;
+    toolHealthMonitor: ToolHealthMonitor;
+    traceWriter: TraceSink | undefined;
 }
 export declare function reconcileOutcomes(settled: PromiseSettledResult<{
     result: ToolResult;

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

@@ -75,6 +75,7 @@ export declare class SessionToolDispatcher implements ToolDispatcher {
     private readonly bashOutputTailReporter;
     private readonly gateState;
     private readonly repeatFailureGuard;
+    private readonly toolHealthMonitor;
     private readonly grantManager;
     constructor(opts: SessionToolDispatcherOptions);
     private get handlerContext();

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

@@ -5,6 +5,7 @@ import type { ToolActivityReporter } from '../providers/shared/tool-activity.js'
 import type { RepeatFailureGuard } from './repeat-failure-guard.js';
 import type { SubagentExecutor } from './subagent-executor.js';
 import type { ConcurrencyClassifier } from './types.js';
+import type { ToolHealthMonitor } from './tool-health-monitor.js';
 export interface ExecuteBatchDeps {
     execute: (call: ToolCall) => Promise<ToolResult>;
     classifier: ConcurrencyClassifier;
@@ -18,5 +19,6 @@ export interface ExecuteBatchDeps {
     maxConcurrentSafeCalls: number;
     gateDeps: () => PreDispatchGateDeps;
     traceWriter: TraceSink | undefined;
+    toolHealthMonitor: ToolHealthMonitor;
 }
 export declare function executeBatchImpl(calls: ToolCall[], deps: ExecuteBatchDeps, onActivity?: ToolActivityReporter): Promise<ToolResult[]>;

package/dist/agent/tools/handlers/worktree-managed.d.ts

@@ -6,6 +6,7 @@ export interface RepoContext {
 }
 export declare function resolveRepoContext(execFile: ExecFileFn, cwd: string): Promise<RepoContext>;
 export declare function sanitizeSlug(name: string): string;
+export declare function detectRemoteDefaultRef(execFile: ExecFileFn, repoRoot: string): Promise<string | undefined>;
 export declare function resolveAnchorBaseRef(execFile: ExecFileFn, anchor: string): Promise<string>;
 export interface CreateManagedWorktreeArgs {
     execFile: ExecFileFn;

package/dist/agent/tools/tool-health-monitor.d.ts

@@ -0,0 +1,26 @@
+import type { ToolCall, ToolResult } from '../providers/anthropic-direct/types.js';
+import type { TraceSink } from '../trace/index.js';
+export declare const HEALTH_WINDOW_SIZE = 10;
+export declare const HEALTH_MIN_SAMPLE = 8;
+export declare const HEALTH_ERROR_RATE_THRESHOLD = 0.9;
+export declare const HEALTH_DOMINANT_ERROR_THRESHOLD = 0.8;
+export interface HealthVerdict {
+    readonly degraded: false;
+}
+export interface DegradedHealthVerdict {
+    readonly degraded: true;
+    readonly tool: string;
+    readonly errorHead: string;
+    readonly errorCount: number;
+    readonly callCount: number;
+    readonly notice: string;
+    readonly emitTrace: boolean;
+}
+export type HealthVerdictResult = HealthVerdict | DegradedHealthVerdict;
+export declare class ToolHealthMonitor {
+    private readonly windows;
+    observe(call: ToolCall, result: ToolResult): HealthVerdictResult;
+    windowSizeFor(toolName: string): number;
+}
+export declare function emitToolDegraded(traceWriter: TraceSink | undefined, verdict: DegradedHealthVerdict): void;
+export declare function applyToolHealth(monitor: ToolHealthMonitor, traceWriter: TraceSink | undefined, call: ToolCall, result: ToolResult): ToolResult;

package/dist/agent/tools/usage-notice.d.ts

@@ -0,0 +1,8 @@
+import type { TraceSink } from '../trace/index.js';
+import type { UsageRecord } from '../usage/usage-record.js';
+import { type UsageEvaluation } from '../usage/usage-budget.js';
+export declare function buildUsageNotice(ev: UsageEvaluation, now?: number): string | undefined;
+export declare function evaluateDispatchUsage(provider: string, traceWriter: TraceSink | undefined, readRecord?: () => UsageRecord | undefined): Promise<string | undefined>;
+export declare function evaluateDispatchUsageForModel(model: unknown, traceWriter: TraceSink | undefined): Promise<string | undefined>;
+export declare function prependUsageNotice(notice: string | undefined, content: string): string;
+export declare function prependUsageNotice(notice: string | undefined, content: unknown): unknown;