agent-afk 5.83.8 → 5.84.0

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

@@ -47,6 +47,7 @@ export declare class AnthropicDirectProvider implements ModelProvider {
     private readonly subagentExecutor;
     private readonly composeExecutor;
     private readonly surface;
+    private readonly declaredSurface;
     private readonly readOnlyMemory;
     private readonly readOnlyBash;
     private readonly mcpManager;

package/dist/agent/providers/anthropic-direct/overload-pause.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderEvent } from '../../provider.js';
+export declare const OVERLOAD_EXHAUSTED = "overload_exhausted";
+export declare const OVERLOAD_EXHAUSTED_NOTICE: string;
+export declare const OVERLOAD_PAUSE_CEILING_MS: number;
+export declare const OVERLOAD_PAUSE_MAX_MS: number;
+export declare const OVERLOAD_PROBE_MIN_MS: number;
+export declare const OVERLOAD_PROBE_MAX_MS: number;
+export declare function jitterBackoff(baseMs: number, random?: () => number): number;
+export declare function nextProbeDelayMs(random?: () => number): number;
+export declare function classifyOverloadExhaustion(event: ProviderEvent): boolean;
+export declare function resolveOverloadPauseCeilingMs(surface: string | undefined): number;

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

@@ -11,6 +11,7 @@ export interface RetryLayerOptions {
     baseUrl?: string;
     tokenRefresher?: () => Promise<Anthropic | null>;
     autoResumeOnUsageLimit: boolean;
+    surface?: string;
 }
 export declare class RetryLayer {
     private _client;
@@ -19,6 +20,7 @@ export declare class RetryLayer {
     private readonly baseUrl?;
     private readonly tokenRefresher?;
     private readonly autoResumeOnUsageLimit;
+    private readonly surface?;
     private refreshPromise;
     private usageLimitWaitPromise;
     constructor(opts: RetryLayerOptions);
@@ -30,6 +32,7 @@ export declare class RetryLayer {
         swapped: boolean;
     } | null>;
     turnWithRetries(runInput: RunTurnInput, isClosed: () => boolean): AsyncGenerator<ProviderEvent, void, void>;
+    private turnWithOverloadPause;
     private turnWithUsageLimitRetry;
     private turnWithAuthRetry;
     private isRetryableAuth;

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

@@ -26,6 +26,7 @@ export interface AnthropicDirectQueryOptions {
     traceWriter?: import('../../trace/index.js').TraceWriter;
     subagentId?: string;
     autoResumeOnUsageLimit?: boolean;
+    surface?: string;
     cwdDependentsFactory?: (cwd: string) => {
         userSystem: string;
         dispatcher: ToolDispatcher;

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

@@ -492,6 +492,8 @@ export declare const SessionPhaseNameSchema: z.ZodEnum<{
     ttfb_timeout: "ttfb_timeout";
     usage_limit_pause: "usage_limit_pause";
     usage_limit_resume: "usage_limit_resume";
+    overload_pause: "overload_pause";
+    overload_resume: "overload_resume";
     idle_watchdog_fired: "idle_watchdog_fired";
     suspected_loop: "suspected_loop";
     compaction_disabled: "compaction_disabled";
@@ -514,6 +516,8 @@ export declare const SessionPhasePayloadSchema: z.ZodObject<{
         ttfb_timeout: "ttfb_timeout";
         usage_limit_pause: "usage_limit_pause";
         usage_limit_resume: "usage_limit_resume";
+        overload_pause: "overload_pause";
+        overload_resume: "overload_resume";
         idle_watchdog_fired: "idle_watchdog_fired";
         suspected_loop: "suspected_loop";
         compaction_disabled: "compaction_disabled";
@@ -846,6 +850,8 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             ttfb_timeout: "ttfb_timeout";
             usage_limit_pause: "usage_limit_pause";
             usage_limit_resume: "usage_limit_resume";
+            overload_pause: "overload_pause";
+            overload_resume: "overload_resume";
             idle_watchdog_fired: "idle_watchdog_fired";
             suspected_loop: "suspected_loop";
             compaction_disabled: "compaction_disabled";
@@ -1186,6 +1192,8 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             ttfb_timeout: "ttfb_timeout";
             usage_limit_pause: "usage_limit_pause";
             usage_limit_resume: "usage_limit_resume";
+            overload_pause: "overload_pause";
+            overload_resume: "overload_resume";
             idle_watchdog_fired: "idle_watchdog_fired";
             suspected_loop: "suspected_loop";
             compaction_disabled: "compaction_disabled";

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

@@ -205,7 +205,7 @@ 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' | 'idle_watchdog_fired' | 'suspected_loop' | 'compaction_disabled';
+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' | 'suspected_loop' | 'compaction_disabled';
 export interface SessionPhasePayload {
     phase: SessionPhaseName;
     durationMs?: number;

package/dist/bundled-plugins/awa-bundled/skills/intent-lock/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: intent-lock
-description: "Fires before multi-step work when the user's request contains ambiguous referents ('the text', 'her Y'), characterizations of unverified entities ('the meeting is substantive'), or identity assumptions (which contact = the user). Emits a one-sentence interpretation lock for fast async correction; escalates to Asking only when interpretation gates an irreversible action AND multiple plausible reads exist."
+description: "Fires before multi-step work when the user's request contains ambiguous referents ('the text', 'her Y'), characterizations of unverified entities ('the meeting is substantive'), identity assumptions (which contact = the user), code-vs-runtime dual referents, or no task statement at all (a bare path, URL, noun phrase, or pasted trace). Emits a one-sentence interpretation lock for fast async correction; escalates when interpretation gates an irreversible action AND multiple plausible reads exist."
 context: load
 ---
 
@@ -31,12 +31,19 @@ Check for these signal classes before starting any multi-step task:
 - "tool" / "skill" / "plugin" — the project's loadable units OR the agent's available tools
 - "MCP" / "terminal" / "REPL" — primitives the project implements that the agent also has
 
+**No task statement at all** — the request is a bare fragment with no imperative verb, so the referent to resolve is the *goal itself* rather than a noun inside it:
+- A lone path, repo URL, or issue/PR link with no stated ask
+- A bare noun phrase: "the 429s", "usage indicators", "that timeout"
+- A continuation cue whose carried-over goal is not uniquely established: "same as before", "and the 429s?"
+- A pasted error, log line, stack trace, or diff with no question attached
+
 **Skip when:**
 - Referent resolves unambiguously from immediately prior context (file was just read this turn, entity was named and confirmed, prior message established the binding).
 - Request is reversible, exploratory, and any misread is immediately correctable without cost.
 - User has already provided the interpretation explicitly ("I mean X by 'the text'", "agent-afk's memory", "my session", "this codebase's hooks").
 - Single-step clarification would cost more than simply proceeding and correcting.
 - Dual-referent term has no matching symbol in cwd — no parity risk, standard interpretation applies.
+- Fragment's goal is fixed by the immediately prior turn (agent just proposed two options and the user named one) — the task statement carries over intact.
 
 ---
 
@@ -44,7 +51,9 @@ Check for these signal classes before starting any multi-step task:
 
 ### Step 1 — Scan
 
-Before acting, scan the request for signal classes above. List every ambiguous referent, unverified characterization, identity assumption, or code-vs-runtime dual referent found. If zero are found, skip this skill entirely.
+Before acting, scan the request for signal classes above. List every ambiguous referent, unverified characterization, identity assumption, code-vs-runtime dual referent, or missing task statement found. If zero are found, skip this skill entirely.
+
+**When the finding is a missing task statement**, reconstruct the candidate goal from ambient evidence before classifying it — recent commits, branch name, open diff, the named file's contents, the prior turn. Cite the evidence the reconstruction rests on, so a wrong read is visibly wrong rather than silently load-bearing. Resolve this in-context; dispatch one sub-agent with one focused reconstruction question only when in-context reasoning cannot produce a single confident reading, and do not permit a follow-up dispatch. The reconstructed goal is then classified by Step 2 exactly like any other finding.
 
 ### Step 2 — Classify each finding
 
@@ -62,6 +71,8 @@ For each finding, determine:
 | Multiple plausible reads, reversible action | **Lock** — emit most-likely read with explicit note, proceed |
 | Multiple plausible reads, irreversible action | **Asking** — stop, ask one question |
 
+Use **Asking** only when the current surface can receive an answer. On a daemon, scheduled, one-shot, or other non-interactive surface, multiple plausible reads that gate an irreversible action require **Blocked** — take no action and record the exact question whose answer would unblock it.
+
 **Multiple plausible reads** means two or more interpretations that would produce materially different outcomes. "the text" pointing to one of two equally recent documents = multiple. "the text" when only one document was discussed this session = single.
 
 ### Step 4 — Emit the lock
@@ -72,6 +83,10 @@ For each finding, determine:
 
 One sentence. No preamble. Append to the start of the work output, not as a standalone turn. The user can correct asynchronously; work continues.
 
+**Lock format (reconstructed goal):**
+
+> Reading [fragment] as: [reconstructed task statement] (from [evidence]). Proceeding on that basis — correct me if wrong.
+
 **If multiple locks needed:** stack them, one per line, before the work output.
 
 **Asking format (irreversible + multiple reads only):**
@@ -88,13 +103,17 @@ One question. State what it unlocks. Do not proceed until answered.
 
 **ground-state** fires before implementation to survey repo state. Intent-lock fires before *any* multi-step work on requests with ambiguous inputs — including non-implementation work like drafting, research, or messaging. They can both fire on the same request (ground-state runs after intent-lock resolves).
 
+In agent-afk, the `ask_question` hook enforces the reachability rule; where that hook is absent, apply the rule inline. Never emit an unreachable question: on a non-interactive surface, proceed only on a safe assumption or end Blocked without acting when the next action is irreversible. **trajectory-check** is a user-scope skill that may not exist in this installation — reference it only if present, and never block on it. When a session-end goal-vs-execution check is wanted, invoke it with the locked statement from Step 4 as its canonical-goal input, not the original fragment. Do not reimplement that check here.
+
 **premise-gate** checks named-entity and status-claim pairs during research and analysis. Intent-lock fires *before* work begins on the request itself. They address the same underlying hazard at different points in the pipeline: intent-lock at request intake, premise-gate during execution.
 
 ---
 
 ## Exit criteria
 
-- Every ambiguous referent, unverified characterization, identity assumption, and code-vs-runtime dual referent is either locked (one-sentence interpretation emitted) or escalated to Asking.
+- Every ambiguous referent, unverified characterization, identity assumption, code-vs-runtime dual referent, and missing task statement is either locked (one-sentence interpretation emitted), escalated to Asking, or ended Blocked on a non-interactive surface.
+- A reconstructed goal is never acted on silently — the lock names both the reading and the evidence it rests on.
 - No multi-step work begins on a request whose interpretation gates an irreversible action when multiple plausible reads exist.
+- On a non-interactive surface, an unresolved interpretation that gates an irreversible action ends Blocked with no action and the exact unblock question recorded.
 - Lock statements are visible in the turn output before the work they govern.
 - Asking state contains exactly one question and states what it unlocks.

package/dist/cli/commands/interactive/turn-text-seam.d.ts

@@ -0,0 +1 @@
+export declare function joinAtRoundSeam(accumulated: string, next: string): string;