agent-afk 5.166.0 → 5.167.0

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

@@ -2,6 +2,7 @@ export interface PluginSkillMetadata {
     name?: string;
     description?: string;
     argumentHint?: string;
+    whenToUse?: string;
     origin?: 'command';
     allowedTools?: string[];
     context?: string;

package/dist/agent/routing-directive.d.ts

@@ -1,4 +1,4 @@
-export declare const ROUTING_DIRECTIVE = "[skill-routing: active]\n\nRoute recurring work through registered skills instead of rolling ad-hoc solutions:\n\n- Before non-trivial implementation (multi-file edits, new features, config/build changes \u2014 anything that writes) \u2192 `/ground-state` first. Do NOT substitute inline `git status`/`get_runtime_state` \u2014 the skill triangulates git + infra + prior-session memory in parallel, which the inline checks miss. If `/ground-state` dispatch fails (depth limit, unavailable), fall back to inline checks AND note the coverage gap.\n- Bugs, failing tests, or regressions \u2192 `/diagnose`\n- High-stakes sub-agent output that will drive edits or commits \u2192 `/shadow-verify` before acting\n- Refactor needing parallel waves \u2192 `/parallelize`\n- Parallel or dependent multi-task work \u2192 `compose` tool (DAG of subagent nodes)\n- Greenfield feature where a written spec would genuinely help (novel scope, multi-day work, or external stakeholders involved) \u2192 `/mint`\n\nDo NOT reach for `/mint` for: bug fixes (use `/diagnose`), refactors with known shape, single-feature edits, work already spec'd in chat, or anything where the spec/approve pause would feel like ceremony. Implement directly in those cases.\n\nCommon composed sequences \u2014 reach for these when the task shape matches:\n\n- Bug with failing test and non-trivial fix \u2192 `/diagnose` \u2192 `/shadow-verify` on the proposed fix\n- Refactor needing parallel waves \u2192 plan \u2192 `/parallelize` \u2192 build waves\n- Diagnose + fix in parallel \u2192 `compose` with two independent nodes\n- Research \u2192 implement \u2192 verify pipeline \u2192 `compose` with edges: research\u2192implement\u2192verify\n- Multiple independent investigations \u2192 `compose` with N nodes, no edges\n\nReach for context-isolated investigators when the task is exploratory:\n\n- Map an unfamiliar module before editing \u2192 `/gather` or `/research`\n- Re-derive a load-bearing claim independently \u2192 `/shadow-verify`\n- Audit a diff before merge \u2192 `/review`\n- Generate alternatives before committing to a plan \u2192 `/devils-advocate`\n\nOr dispatch a raw `agent` call when no skill matches but the work is parallelizable, verification-heavy, or would otherwise consume substantial inline context.\n\nSkip orchestration for: single-line edits, trivial Q&A, and direct tool calls the user explicitly requested. The goal is leverage, not ceremony. If a skill would add overhead without adding value, don't invoke it.\n\nDefault to acting autonomously. `ask_question` is a last resort, not a first move \u2014 every question blocks on the operator, who is often away from keyboard.\n\nBefore you ask, you MUST exhaust the tools you have: read the files, check git, search the codebase and docs, inspect runtime state. If any tool can get you the answer, use the tool \u2014 never ask the operator for something you can discover yourself. When a wrong guess would be cheap or reversible, make a reasonable assumption, proceed, and state the assumption instead of asking.\n\n**Answerability \u2014 a question only helps if a human will actually answer it:**\n\n`surface` (from `get_runtime_state`, view `\"self\"`) is a partial signal, not a guarantee:\n- `daemon`, or any session started by a scheduler, cron job, or another agent, has no human watching \u2014 never block on `ask_question` here.\n- `cli` is ambiguous: the interactive REPL and the Telegram bot can reach a human, but one-shot `chat` runs and sub-agent forks report the same `cli` and have no elicitation handler \u2014 there `ask_question` returns `{ action: 'decline' }` instantly.\n- Even when a handler exists, the operator is usually away, so a blocking question can stall until the turn aborts.\n\nSo treat `ask_question` as best-effort: a `decline` or `cancel` result means \"no answer is coming,\" not a failure to abort the task on. When you cannot be sure a human will answer, instead of asking:\n1. **Proceed on a stated assumption** \u2014 pick the most reasonable interpretation, act on it, and record the assumption in your Done/Blocked terminal state for async review.\n2. **Emit a Blocked artifact** \u2014 if no safe assumption exists and proceeding would be irreversible, end the turn with a **Blocked** terminal state naming exactly what the operator must supply before the next run.\n\nReserve `ask_question` for the narrow set of things no tool can resolve: a genuinely ambiguous requirement whose readings lead to materially different work, a decision with significant or irreversible consequences, or context that lives only in the operator's head (a preference, a secret, an external constraint):\n\n- Question types: `text` (open-ended), `confirm` (yes/no), `choice` (single pick from list), `multi_choice` (multi-pick), `number` (numeric with optional bounds). When `allow_custom: true`, the result may include `custom_value` instead of `value` \u2014 check `content.custom_value !== undefined` to detect a free-form answer.\n- Ask one focused question at a time. Do NOT ask multiple questions in a single call, and do NOT stack several ask_question calls across a turn \u2014 fold the genuine unknowns into the single most decision-relevant question.\n- Do NOT use when the user has already provided sufficient context \u2014 infer and proceed instead.\n- The result `action` will be `accept` (answered), `cancel` (user interrupted), `decline` (no handler), or `skip` (optional question skipped).\n- `allow_custom` (choice/multi_choice only): opt-in to a free-form entry affordance. On accept, `content` has `{ value: null, custom_value: \"<text>\" }` rather than `{ value: \"<listed-string>\" }`.\n- After a `cancel` or `decline`, stop and tell the user what information you need \u2014 do not loop and re-ask.";
+export declare const ROUTING_DIRECTIVE = "[skill-routing: active]\n\nRoute recurring work through registered skills instead of rolling ad-hoc solutions:\n\n- Before non-trivial implementation (multi-file edits, new features, config/build changes \u2014 anything that writes) \u2192 `/ground-state` first. Do NOT substitute inline `git status`/`get_runtime_state` \u2014 the skill triangulates git + infra + prior-session memory in parallel, which the inline checks miss. If `/ground-state` dispatch fails (depth limit, unavailable), fall back to inline checks AND note the coverage gap.\n- Bugs, failing tests, or regressions \u2192 `/diagnose`\n- High-stakes sub-agent output that will drive edits or commits \u2192 `/shadow-verify` before acting\n- Refactor needing parallel waves \u2192 `/parallelize`\n- Parallel or dependent multi-task work \u2192 `compose` tool (DAG of subagent nodes)\n- Greenfield feature where a written spec would genuinely help (novel scope, multi-day work, or external stakeholders involved) \u2192 `/mint`\n\nDo NOT reach for `/mint` for: bug fixes (use `/diagnose`), refactors with known shape, single-feature edits, work already spec'd in chat, or anything where the spec/approve pause would feel like ceremony. Implement directly in those cases.\n\nCommon composed sequences \u2014 reach for these when the task shape matches:\n\n- Bug with failing test and non-trivial fix \u2192 `/diagnose` \u2192 `/shadow-verify` on the proposed fix\n- Refactor needing parallel waves \u2192 plan \u2192 `/parallelize` \u2192 build waves\n- Diagnose + fix in parallel \u2192 `compose` with two independent nodes\n- Research \u2192 implement \u2192 verify pipeline \u2192 `compose` with edges: research\u2192implement\u2192verify\n- Multiple independent investigations \u2192 `compose` with N nodes, no edges\n\nReach for context-isolated investigators when the task is exploratory:\n\n- Map an unfamiliar module before editing \u2192 `/gather` or `/research`\n- Re-derive a load-bearing claim independently \u2192 `/shadow-verify`\n- Audit a diff before merge \u2192 `/review`\n- Generate alternatives before committing to a plan \u2192 `/devils-advocate`\n\nOr dispatch a raw `agent` call when no skill matches but the work is parallelizable, verification-heavy, or would otherwise consume substantial inline context.\n\nAfter local work is ready to push and PR \u2192 `/ship`; to fix PR review feedback or red CI \u2192 `/fix-pr`; to clean up complexity or dead code \u2192 `/simplify`; large-scope structural refactors \u2192 `/refactor`.\n\nSkip orchestration for: single-line edits, trivial Q&A, and direct tool calls the user explicitly requested. The goal is leverage, not ceremony. If a skill would add overhead without adding value, don't invoke it.\n\nDefault to acting autonomously. `ask_question` is a last resort, not a first move \u2014 every question blocks on the operator, who is often away from keyboard.\n\nBefore you ask, you MUST exhaust the tools you have: read the files, check git, search the codebase and docs, inspect runtime state. If any tool can get you the answer, use the tool \u2014 never ask the operator for something you can discover yourself. When a wrong guess would be cheap or reversible, make a reasonable assumption, proceed, and state the assumption instead of asking.\n\n**Answerability \u2014 a question only helps if a human will actually answer it:**\n\n`surface` (from `get_runtime_state`, view `\"self\"`) is a partial signal, not a guarantee:\n- `daemon`, or any session started by a scheduler, cron job, or another agent, has no human watching \u2014 never block on `ask_question` here.\n- `cli` is ambiguous: the interactive REPL and the Telegram bot can reach a human, but one-shot `chat` runs and sub-agent forks report the same `cli` and have no elicitation handler \u2014 there `ask_question` returns `{ action: 'decline' }` instantly.\n- Even when a handler exists, the operator is usually away, so a blocking question can stall until the turn aborts.\n\nSo treat `ask_question` as best-effort: a `decline` or `cancel` result means \"no answer is coming,\" not a failure to abort the task on. When you cannot be sure a human will answer, instead of asking:\n1. **Proceed on a stated assumption** \u2014 pick the most reasonable interpretation, act on it, and record the assumption in your Done/Blocked terminal state for async review.\n2. **Emit a Blocked artifact** \u2014 if no safe assumption exists and proceeding would be irreversible, end the turn with a **Blocked** terminal state naming exactly what the operator must supply before the next run.\n\nReserve `ask_question` for the narrow set of things no tool can resolve: a genuinely ambiguous requirement whose readings lead to materially different work, a decision with significant or irreversible consequences, or context that lives only in the operator's head (a preference, a secret, an external constraint):\n\n- Question types: `text` (open-ended), `confirm` (yes/no), `choice` (single pick from list), `multi_choice` (multi-pick), `number` (numeric with optional bounds). When `allow_custom: true`, the result may include `custom_value` instead of `value` \u2014 check `content.custom_value !== undefined` to detect a free-form answer.\n- Ask one focused question at a time. Do NOT ask multiple questions in a single call, and do NOT stack several ask_question calls across a turn \u2014 fold the genuine unknowns into the single most decision-relevant question.\n- Do NOT use when the user has already provided sufficient context \u2014 infer and proceed instead.\n- The result `action` will be `accept` (answered), `cancel` (user interrupted), `decline` (no handler), or `skip` (optional question skipped).\n- `allow_custom` (choice/multi_choice only): opt-in to a free-form entry affordance. On accept, `content` has `{ value: null, custom_value: \"<text>\" }` rather than `{ value: \"<listed-string>\" }`.\n- After a `cancel` or `decline`, stop and tell the user what information you need \u2014 do not loop and re-ask.";
 export declare const END_OF_TURN_DIRECTIVE = "[end-of-turn protocol]\n\nEvery turn must end in one externally identifiable terminal state. AFK users need inspectable artifacts, not ceremony. Write each bullet as a single sentence.\n\n**Done**\n- What was done: <one-sentence summary>\n- Evidence: <durable location \u2014 file path, commit SHA, trace path, test output, or memory key; never transcript-only>\n- What changed: <world-state delta>\n- Deferred: <anything still pending, with why; or \"none\">\n- If files were written or edited but no `git commit` ran, say so explicitly \u2014 name the uncommitted paths and why (e.g. awaiting review); do not imply clean completion while the work sits uncommitted in the worktree.\n\n**Blocked**\n- What blocks: <the blocker>\n- What must change to unblock: <the unblock condition>\n- What has already been done: <progress so far>\n\n**Asking**\n- Question: <one precise question>\n- Assumption it resolves: <what answering clarifies>\n- Once answered: <what you will do>\n\n**Interrupted**\n- What you were doing: <the in-progress task>\n- Where state was saved: <location>\n- What resumption requires: <prerequisites>\n\nNever end a turn mid-loop without one of these. The terminal-state heading must be the last block of the response, with no trailing prose after it.";
 export type PromptSurface = 'repl' | 'telegram' | 'one-shot' | 'subagent';
 export declare function assembleSystemPrompt(base: string | undefined, autoRouting: boolean, surface?: PromptSurface): string | undefined;

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

@@ -59,6 +59,7 @@ export declare class AgentSession implements IAgentSession {
     setModel(model?: AgentModelInput): Promise<void>;
     setPermissionMode(mode: PermissionMode): Promise<void>;
     getPrePlanMode(): PermissionMode | undefined;
+    setPlanExitQueueCheck(fn: () => boolean): void;
     takePendingPlanExitSeed(): Promise<{
         message: string;
         mode: PermissionMode;

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

@@ -465,6 +465,11 @@ export declare const BrowserEventPayloadSchema: z.ZodObject<{
         wait_for: "wait_for";
     }>>;
     toolUseId: z.ZodString;
+    backend: z.ZodOptional<z.ZodEnum<{
+        "agent-browser": "agent-browser";
+        playwright: "playwright";
+    }>>;
+    backendReason: z.ZodOptional<z.ZodString>;
     target: z.ZodOptional<z.ZodObject<{
         kind: z.ZodEnum<{
             semantic: "semantic";
@@ -835,6 +840,11 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             wait_for: "wait_for";
         }>>;
         toolUseId: z.ZodString;
+        backend: z.ZodOptional<z.ZodEnum<{
+            "agent-browser": "agent-browser";
+            playwright: "playwright";
+        }>>;
+        backendReason: z.ZodOptional<z.ZodString>;
         target: z.ZodOptional<z.ZodObject<{
             kind: z.ZodEnum<{
                 semantic: "semantic";
@@ -1195,6 +1205,11 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             wait_for: "wait_for";
         }>>;
         toolUseId: z.ZodString;
+        backend: z.ZodOptional<z.ZodEnum<{
+            "agent-browser": "agent-browser";
+            playwright: "playwright";
+        }>>;
+        backendReason: z.ZodOptional<z.ZodString>;
         target: z.ZodOptional<z.ZodObject<{
             kind: z.ZodEnum<{
                 semantic: "semantic";

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

@@ -161,6 +161,8 @@ export interface BrowserEventPayload {
     tool: BrowserEventTool;
     action?: BrowserActAction;
     toolUseId: string;
+    backend?: 'playwright' | 'agent-browser';
+    backendReason?: string;
     target?: BrowserEventTarget;
     urlBefore: string | null;
     urlAfter: string | null;

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

@@ -19,6 +19,7 @@ export interface PlanExitControls {
     setPermissionMode(mode: PermissionMode): Promise<void>;
     requestImplementSeed(message: string, mode: PermissionMode): void;
     getPrePlanMode(): PermissionMode | undefined;
+    hasPendingUserMessage?: () => boolean;
 }
 export interface AgentConfig {
     model: AgentModelInput;

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

@@ -35,3 +35,4 @@ export declare class WorkspaceStore {
     close(): void;
     private nextSeq;
 }
+export declare function buildFtsQuery(prompt: string): string;

package/dist/browser/agent-browser/actions.d.ts

@@ -0,0 +1,15 @@
+import type { ActOutcome } from '../provider.js';
+import type { ActInput, InteractiveElement, Target } from '../types.js';
+import type { BrowserConfig } from '../types.js';
+import type { AgentBrowserClient, InspectElement } from './client.js';
+export declare function mapElement(el: InspectElement): InteractiveElement;
+export declare function resolveElementId(knownElements: Map<string, InteractiveElement>, target: Target): string | null;
+export declare function executeAction(client: AgentBrowserClient, tabId: string, action: string, elementId: string, value?: string, timeoutMs?: number): Promise<void>;
+export interface SemanticResolveContext {
+    client: AgentBrowserClient;
+    config: BrowserConfig;
+    tabId: string;
+}
+export declare function resolveSemanticAndAct(ctx: SemanticResolveContext, input: ActInput): Promise<{
+    elementId: string;
+} | ActOutcome>;

package/dist/browser/agent-browser/client.d.ts

@@ -0,0 +1,68 @@
+import type { AgentBrowserConnection } from './connection.js';
+export interface AgentBrowserTab {
+    id: string;
+    title: string;
+    url: string;
+    loading: boolean;
+}
+export interface InspectElement {
+    id: string;
+    tag: string;
+    role: string;
+    label: string;
+    kind: string | null;
+    value: string | null;
+    placeholder: string | null;
+    disabled: boolean;
+    checked?: boolean;
+    selected?: boolean;
+    expanded?: boolean;
+    bbox: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    selector?: string;
+}
+export interface ReadResult {
+    content: string;
+    url: string;
+    title: string;
+    wordCount: number;
+}
+export declare class AgentBrowserClient {
+    private readonly baseUrl;
+    private readonly token;
+    constructor(connection: AgentBrowserConnection);
+    private call;
+    listTabs(): Promise<AgentBrowserTab[]>;
+    openTab(url: string): Promise<{
+        tabId: string;
+    }>;
+    closeTab(tabId: string): Promise<void>;
+    read(tabId: string, opts?: {
+        mode?: string;
+        query?: string;
+        budget?: number;
+    }): Promise<ReadResult>;
+    inspect(tabId: string, opts?: {
+        mode?: string;
+        query?: string;
+        limit?: number;
+    }): Promise<{
+        elements: InspectElement[];
+    }>;
+    click(tabId: string, elementId: string): Promise<void>;
+    fill(tabId: string, elementId: string, value: string): Promise<void>;
+    press(tabId: string, key: string, elementId?: string): Promise<void>;
+    select(tabId: string, elementId: string, value: string): Promise<void>;
+    waitFor(tabId: string, condition: string, opts?: {
+        value?: string;
+        timeout?: number;
+    }): Promise<void>;
+    evalScript(tabId: string, script: string): Promise<unknown>;
+    screenshot(tabId: string): Promise<{
+        data: string;
+    }>;
+}

package/dist/browser/agent-browser/connection.d.ts

@@ -0,0 +1,15 @@
+export interface AgentBrowserConnection {
+    url: string;
+    token: string;
+    pid: number;
+    version: string;
+}
+export declare function readConnectionFile(path?: string): AgentBrowserConnection | null;
+export declare function isPidAlive(pid: number): boolean;
+export declare function probeHealth(baseUrl: string, token: string, timeoutMs?: number): Promise<boolean>;
+export interface AvailabilityResult {
+    available: boolean;
+    connection: AgentBrowserConnection | null;
+    reason: string | null;
+}
+export declare function checkAvailability(connectionPath?: string): Promise<AvailabilityResult>;

package/dist/browser/agent-browser/index.d.ts

@@ -0,0 +1,30 @@
+import type { BrowserProvider, OpenOutcome, ActOutcome } from '../provider.js';
+import type { ActInput, BrowserConfig, BrowserObservation, BrowserProviderState, CloseInput, ExtractInput, ExtractResult, InteractiveElement, ObserveInput, OpenInput, RenderInput, RenderResult, ScreenshotInput, ScreenshotResult } from '../types.js';
+import { AgentBrowserClient } from './client.js';
+import type { AgentBrowserConnection } from './connection.js';
+export interface SessionState {
+    tabId: string;
+    observationCounter: number;
+    knownElements: Map<string, InteractiveElement>;
+    lastAction: string | null;
+    lastActionAt: string | null;
+    currentUrl: string | null;
+    currentTitle: string | null;
+}
+export declare class AgentBrowserProvider implements BrowserProvider {
+    readonly name = "agent-browser";
+    private readonly config;
+    readonly client: AgentBrowserClient;
+    private readonly sessions;
+    constructor(config: BrowserConfig, connection: AgentBrowserConnection);
+    open(input: OpenInput): Promise<OpenOutcome>;
+    observe(input: ObserveInput): Promise<BrowserObservation>;
+    act(input: ActInput): Promise<ActOutcome>;
+    render(_input: RenderInput): Promise<RenderResult>;
+    screenshot(input: ScreenshotInput): Promise<ScreenshotResult>;
+    extract(_input: ExtractInput): Promise<ExtractResult>;
+    close(input: CloseInput): Promise<void>;
+    describe(sessionId: string): BrowserProviderState | null;
+    shutdown(): Promise<void>;
+    private buildObservation;
+}

package/dist/browser/registry.d.ts

@@ -1,7 +1,9 @@
 import type { BrowserProvider } from './provider.js';
 import type { LoadBrowserConfigOptions } from './config.js';
+import { type RoutingDecision } from './routing.js';
 export declare function getBrowserProvider(opts?: LoadBrowserConfigOptions): Promise<BrowserProvider>;
 export declare function closeBrowserProvider(): Promise<void>;
 export declare function browserProviderActive(): boolean;
 export declare function peekBrowserProvider(): BrowserProvider | null;
+export declare function getLastRoutingDecision(): RoutingDecision | null;
 export declare function __resetBrowserRegistryForTests(): void;

package/dist/browser/routing.d.ts

@@ -0,0 +1,14 @@
+import type { BrowserConfig } from './types.js';
+import { type AvailabilityResult } from './agent-browser/connection.js';
+export type RoutingBackend = 'playwright' | 'agent-browser';
+export interface RoutingDecision {
+    backend: RoutingBackend;
+    reason: string;
+    probeMs: number;
+    availability: AvailabilityResult | null;
+}
+export interface RoutingContext {
+    config: BrowserConfig;
+    surface?: string;
+}
+export declare function selectBackend(ctx: RoutingContext): Promise<RoutingDecision>;

package/dist/browser/types.d.ts

@@ -135,7 +135,7 @@ export interface BrowserConfig {
     allowedDomains: readonly string[];
     blockedDomains: readonly string[];
     domSnapshots: boolean;
-    backend: 'playwright';
+    backend: 'playwright' | 'agent-browser' | 'auto';
     configPath: string | null;
     defaultProfile: string;
 }

package/dist/bundled-plugins/awa-bundled/skills/fix-pr/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: fix-pr
 description: "One-verb pipeline for the operator's highest-frequency manual loop: fetch a PR's unresolved reviewer feedback (inline review comments, review-summary bodies, and issue-level conversation comments) and failing CI checks, fix them in an isolated managed worktree via a budget-bounded subagent, verify with the project's test gates, and push the fix back to the PR branch. Replaces the retyped recipe 'send a subagent in a worktree to fix <PR feedback>, then push.' Use when a PR has review comments or red CI that needs addressing — e.g. 'fix pr 286', 'address the review on #215', 'CI is red on the worktree-sweep PR'. Never force-pushes, never touches main, fails closed on missing gh auth or un-pushable fork PRs."
+when-to-use: "A PR has review feedback or red CI that needs fixing."
 argument-hint: "<PR-number-or-URL> [--repo <path>] [--no-push] [--re-review]"
 surface: "afk"
 failure_modes:

package/dist/bundled-plugins/awa-bundled/skills/refactor/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: refactor
 description: "Orchestrates safe, large-scale structural changes across a codebase — symbol renames, API migrations, pattern standardizations, layer restructurings. Enumerates all affected sites, groups them into dependency layers via the DAG executor, applies changes in parallel per layer with worktree isolation, and verifies behavioral preservation at each layer boundary before proceeding. Exits immediately on first regression, surfacing the exact site, diff, and behavioral delta before any commit."
+when-to-use: "Large-scope structural refactors across multiple files or layers."
 argument-hint: "<refactor goal> [--scope <glob-or-path>]"
 failure_modes:
   - bad decomposition

package/dist/bundled-plugins/awa-bundled/skills/ship/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: ship
 description: "Release pipeline for already-done local work. Dispatches /ground-state pre-flight, runs the project test suite, drafts a commit message, pushes, and opens a PR with a structured verification summary. Use when local changes are ready to hand off to review — e.g. 'ship this', 'push and open a PR', 'release this work'. Add --verify to trigger an adversarial verifier wave on the diff before a human reads the PR."
+when-to-use: "Local changes are ready to push and open a PR."
 context: fork
 ---
 

package/dist/bundled-plugins/awa-bundled/skills/simplify/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: simplify
 description: "Discovers incidental complexity, duplication, and dead code in a codebase and produces a ranked, behavior-preserving reduction plan — optionally applying safe changes. Dispatches four parallel read-only discovery lenses (clone detection, dead code, complexity hotspots, wrong abstraction), synthesizes into a prioritized reduction plan, and gates apply mode behind /refactor and a hard test check."
+when-to-use: "Reduce complexity, find duplicates, or remove dead code."
 argument-hint: "[target] [--apply] [--all]"
 context: load
 ---

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

@@ -78,6 +78,7 @@ export interface InteractiveCtx {
     viewingTaskId?: string;
     hookRegistry?: HookRegistry;
     addPreviewDiffRef?: PreviewDiffRef;
+    hasPendingUserMessage?: () => boolean;
 }
 export interface CompletionWriter {
     fn: (line: string) => void;