agent-afk 5.108.0 → 5.108.2

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

@@ -42,6 +42,15 @@ The only shell permitted is **read-only inspection**: `git diff` / `git show` /
 
 Never fabricate intent. When none is available the value is the literal `(none supplied)`; agents disclose its absence rather than guess.
 
+**Pre-fetch file contents at reviewed ref (inline).** After capturing `reviewed_ref` and the diff, and before dispatching any Wave 1 agent, the orchestrator (which has Bash) pre-reads every changed file at the reviewed ref and bundles the results for injection into sub-agent prompts. This is required because Wave 1 and Wave 1.5 agents are `research-agent` instances with no shell — they cannot run `git show` themselves.
+
+1. Extract the list of changed files from the diff: `git diff --name-only <base>..<reviewed-ref>` (or parse `--- a/<file>` / `+++ b/<file>` headers from a patch-file diff).
+2. For each file, run `git show <reviewed-ref>:<file>` and capture the full output. If the command fails (file does not exist at that ref — e.g. the file was added and the ref predates it, or the ref is `unknown` for a patch-file input), skip that file and note it as `unavailable at ref`.
+3. Bundle as a **`prefetched-files`** block: `[{ file, content, status: "ok"|"unavailable" }]`.
+4. Include this block verbatim in every Wave 1 and Wave 1.5 agent prompt alongside the diff. Agents verify `file-state` citations against the injected content — they do **not** call `read_file` for ref-anchored verification (the working tree may be on a different branch).
+
+When `reviewed_ref` is `unknown` (patch-file input), skip pre-fetch entirely and note `prefetched-files: none — patch-file input`. Agents fall back to `diff-context` citations only and tag any `file-state` citation `[UNVERIFIED: no live ref]`.
+
 **Triage (inline).** From the resolved diff extract: change type (hotfix | feature | refactor | dep-bump | new-service), files changed, total lines changed, summary. Classify regime: `light` if ≤300 lines or change type is hotfix/dep-bump; `full` otherwise.
 
 **Concurrency floor — declared, conditional, and enforced.** *Through synthesis*, a full-regime review peaks at **2 concurrent sub-agent sessions** (Wave 1's two dimension agents) and dispatches **3 in total** (Wave 1 ×2, then Wave 2 ×1, sequential). Wave 1.5 runs inline in the orchestrator and dispatches nothing. **No wave nests a child**: the sub-agents are shell-less by design, and nothing in this skill requires them to run a command, so none of them needs to nest a `git-investigator` to comply. If you add a requirement here that needs a shell, you have silently doubled this floor — put that requirement in Wave 1.5 instead.
@@ -54,10 +63,10 @@ Never fabricate intent. When none is available the value is the literal `(none s
 
 Each agent receives: full diff + file tree + triage header + **reviewed ref (SHA)** + the **stated intent** (what the change is meant to accomplish, or `(none supplied)`), the severity rubric, **the `blocking` default table plus its overrides and assignment-order invariant**, and the finding schema. The blocking rules are not optional context: the finding schema mandates a `blocking` value per finding, so an agent that receives the schema without the table is being told to emit a field whose assignment rules it was never given.
 
-**Citation requirement (enforced per agent).** Wave 1 agents cite from the diff and from file reads available in their own session. They do **not** run git and do **not** re-read at the reviewed ref — that verification is centralized in Wave 1.5 below, which re-reads every `blocking`/`critical`/`high` citation **and every `file-state` citation at any severity** at the ref, then drops the fabricated ones. Each agent must:
+**Citation requirement (enforced per agent).** Wave 1 agents cite from the diff and from the **`prefetched-files` block injected by the orchestrator**. They do **not** call `read_file` for ref-anchored verification (the working tree may be on a different branch) and do **not** run git. Centralized verification runs in Wave 1.5, which checks every `blocking`/`critical`/`high` citation **and every `file-state` citation at any severity** against the same pre-fetched content, then drops fabricated ones. Each agent must:
 1. State the reviewed ref it was given in each finding: `ref: <sha>`.
-2. Classify every citation as `diff-context` (line visible in the diff hunk) or `file-state` (line in the post-merge file, not visible in the hunk). Tag every `file-state` citation `[UNVERIFIED: not re-read]` so Wave 1.5 knows to check it — a Wave 1 `Read` observes the **working tree**, which equals the reviewed ref only when that ref is the checked-out HEAD, so for a PR, branch, or commit target that is not checked out locally the tag is load-bearing, not decorative.
-3. Never paraphrase or reconstruct a line from memory. If the line is not visible in the diff, cite it as `file-state` and let Wave 1.5 resolve it — do not invent the content.
+2. Classify every citation as `diff-context` (line visible in the diff hunk) or `file-state` (line in the post-merge file, not visible in the hunk). For `file-state` citations, look up the line in the injected `prefetched-files` content. If the file's status is `unavailable` in the bundle, tag the citation `[UNVERIFIED: file unavailable at ref]` so Wave 1.5 knows it could not be pre-fetched.
+3. Never paraphrase or reconstruct a line from memory. If the line is not visible in the diff and not present in the pre-fetched content, cite it as `file-state [UNVERIFIED: file unavailable at ref]` — do not invent the content.
 
 **Invariant — why Wave 1 does not run git.** `research-agent` has no shell (`tools: Read, Grep, Glob, WebFetch, WebSearch, Agent(git-investigator)` — no `Bash`, and that single `Agent(...)` entry is the nesting path this rule closes), so a mandatory `git show` forces it to dispatch a nested `git-investigator` purely to run one command. That doubles the concurrent session count of *every* Wave 1 agent, and is the structural cause of the rate-limit cascade in #726. Ref-anchored verification is therefore performed once, centrally, by a shell-capable actor — never N times by shell-less ones. Do not reintroduce a per-agent re-read here.
 
@@ -85,7 +94,7 @@ This is the agent's first-line self-check; **Wave 1.5 Check B** independently re
 
 **Wave 1.5 — Citation + absence-claim verification (INLINE — run by the orchestrator, dispatches nothing).** Run after Wave 1 returns, before Wave 2 synthesis. The orchestrator already holds exactly the read-only shell this verification needs (`git show` / `git diff` / `gh pr diff` / `grep` / `rg` — see the shell grant above), so running it inline costs **zero** additional sessions and zero nesting. A shell-less sub-agent here would have to nest a `git-investigator` to run the very commands the orchestrator can already run. Two independent checks:
 
-**Check A — Citation verification.** Extracts (a) every `file:line` citation from any `blocking`, `critical`, or `high` finding, **and (b) every citation tagged `file-state` at any severity** — `medium`, `low`, and `nit` included — across all Wave 1 results. Both sets are checked, because Wave 1 never re-reads at the ref: an unverified `file-state` citation in a `low` finding is exactly as fabricable as one in a `high` finding, and quoting a line absent from the reviewed change is a defect at every tier. For each citation, runs `git show <reviewed-ref>:<file>` (or equivalent) and checks whether the quoted evidence snippet actually appears at that line in the reviewed ref — not in main, not in diff context alone. Classifies each citation as:
+**Check A — Citation verification.** Extracts (a) every `file:line` citation from any `blocking`, `critical`, or `high` finding, **and (b) every citation tagged `file-state` at any severity** — `medium`, `low`, and `nit` included — across all Wave 1 results. Both sets are checked, because Wave 1 never re-reads at the ref independently: an unverified `file-state` citation in a `low` finding is exactly as fabricable as one in a `high` finding, and quoting a line absent from the reviewed change is a defect at every tier. For each citation, looks up the file in the **`prefetched-files` block** (already captured by the orchestrator before Wave 1 ran) and checks whether the quoted evidence snippet actually appears at that line — not in main, not in diff context alone. If the file's status is `unavailable` in the bundle, falls back to `git show <reviewed-ref>:<file>` (the orchestrator has shell). Classifies each citation as:
 - `verified` — content matches what is actually at that line on the reviewed ref.
 - `diff-only` — line appears in the diff hunk but no longer exists at the reviewed ref HEAD (e.g., deleted block). Finding must be downgraded: the issue may already be resolved.
 - `fabricated` — line does not exist at the reviewed ref and was not in the diff hunk; the evidence snippet is unverifiable. Finding is **dropped** from the report.

package/dist/cli/commands/interactive/surface-setup.history-tracking.d.ts

@@ -0,0 +1,5 @@
+import type { InputSurface } from '../../input/input-surface.js';
+export interface HistorySubmissionTracker {
+    getLastSubmitted: () => string | undefined;
+}
+export declare function installHistorySubmissionTracker(surface: InputSurface): HistorySubmissionTracker;

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

@@ -0,0 +1,25 @@
+import type { InputSurface } from '../../input/input-surface.js';
+import type { SuggestContext, SuggestEngine } from '../../input/suggest.js';
+import type { HistorySubmissionTracker } from './surface-setup.history-tracking.js';
+export interface SuggestCtxStats {
+    model: string | undefined;
+    cwd?: string | undefined;
+    turns: readonly {
+        user: string;
+        assistant: string;
+    }[];
+}
+export declare function buildSuggestConfig(opts: {
+    enabled: boolean;
+    engine: SuggestEngine;
+    surface: InputSurface;
+    stats: SuggestCtxStats;
+    apiKey: string | undefined;
+    baseUrl: string | undefined;
+    historyTracker: HistorySubmissionTracker;
+}): {
+    suggest: {
+        engine: SuggestEngine;
+        getContext: () => SuggestContext;
+    };
+} | Record<string, never>;

package/dist/cli/input/slash-match.d.ts

@@ -0,0 +1,13 @@
+export declare const MAX_SLASH_MATCHES = 20;
+export interface CommandEntry {
+    name: string;
+    summary?: string;
+    hint?: string;
+}
+export interface SlashCandidate {
+    value: string;
+    summary?: string;
+    hint?: string;
+}
+export declare function isSubsequence(needle: string, haystack: string): boolean;
+export declare function matchSlashCandidates(universe: readonly CommandEntry[], query: string, recentHistory?: readonly string[]): SlashCandidate[];

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

@@ -2,6 +2,7 @@ import type { CompleteRequest, SuggestContext } from './suggest-types.js';
 export declare function buildPromptSuggestionSystem(): string;
 export declare function buildPromptSuggestionUser(ctx: SuggestContext): string;
 export declare function hasSuggestionGrounding(ctx: SuggestContext): boolean;
+export declare function isEchoOfLastInput(suggestion: string, ctx: SuggestContext): boolean;
 export declare function isValidPromptSuggestion(reply: string): boolean;
 export declare function normalizePromptSuggestion(raw: string): string | null;
 export type PromptCompleteRequest = CompleteRequest;

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

@@ -8,6 +8,7 @@ export interface SuggestContext {
     getHistory(): string[];
     getDropdownTopCandidate(buffer: string): string | null;
     getTranscriptTail(): string;
+    lastSubmitted?: string;
     getRecentCommands(): string[];
     llmEnabled(): boolean;
     promptSuggestEnabled?(): boolean;

package/dist/cli/input/trigger.d.ts

@@ -1,6 +1,8 @@
+import { type CommandEntry } from './slash-match.js';
 import type { Candidate, Trigger } from './types.js';
 export declare function detectTrigger(buffer: string, cursorCol: number): Trigger | null;
 export declare function filterSlashCandidates(query: string, recentHistory?: readonly string[]): Candidate[];
+export declare function buildSlashUniverse(): CommandEntry[];
 export interface FileDirent {
     name: string;
     isDirectory(): boolean;

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

@@ -7,6 +7,7 @@ export interface IHistoryRing {
     resetRecall(): void;
     readonly inRecall: boolean;
     getEntries?(): readonly string[];
+    push?(text: string): void;
 }
 export type Trigger = {
     kind: 'slash';