tau-all-agent 0.3.1 → 0.4.1

package/README.md

@@ -6,6 +6,8 @@ Tau turns Pi's minimal core into an opinionated, polished agent setup with the f
 
 ## Install
 
+Requires Pi 1.3.0 or newer.
+
 ```bash
 pi install npm:tau-all-agent
 ```

package/extensions/branch-term/index.ts

@@ -1,7 +1,12 @@
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { SessionManager, highlightCode, type SessionHeader } from "@earendil-works/pi-coding-agent";
+import {
+  copyToClipboard,
+  SessionManager,
+  highlightCode,
+  type SessionHeader,
+} from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
 
 const TERMINAL_FLAG = "branch-term";
@@ -113,50 +118,22 @@ function shellQuote(value: string): string {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 
-function runClipboardCommand(command: string, args: string[], text: string): boolean {
-  try {
-    const result = spawnSync(command, args, {
-      input: text,
-      stdio: ["pipe", "ignore", "ignore"],
-      timeout: 3000,
-    });
-    return result.status === 0;
-  } catch {
-    return false;
-  }
-}
-
-function copyToClipboard(text: string): boolean {
-  if (process.platform === "darwin") {
-    return runClipboardCommand("pbcopy", [], text);
-  }
-
-  if (process.platform === "win32") {
-    return runClipboardCommand("clip", [], text);
-  }
-
-  if (process.platform === "linux") {
-    return (
-      runClipboardCommand("wl-copy", [], text) ||
-      runClipboardCommand("xclip", ["-selection", "clipboard"], text) ||
-      runClipboardCommand("xsel", ["--clipboard", "--input"], text)
-    );
-  }
-
-  return false;
-}
-
 function formatCommandMessageIntro(intro: string, copiedToClipboard: boolean): string {
   return `${intro}${copiedToClipboard ? " (copied to clipboard)" : ""}:`;
 }
 
-function showCommandMessage(
+async function showCommandMessage(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
   intro: string,
   command: string,
-): void {
-  const copiedToClipboard = copyToClipboard(command);
+): Promise<void> {
+  const copiedToClipboard =
+    ctx.mode === "tui" &&
+    (await copyToClipboard(command).then(
+      () => true,
+      () => false,
+    ));
   if (ctx.mode === "print") {
     console.log(formatCommandMessageIntro(intro, copiedToClipboard));
     console.log(command);
@@ -310,7 +287,7 @@ export default function (pi: ExtensionAPI) {
 
       const terminalFlag = getStringFlag(pi, TERMINAL_FLAG);
       if (terminalFlag) {
-        launchTerminal(terminalFlag, forkFile, resumeCommand, ctx);
+        await launchTerminal(terminalFlag, forkFile, resumeCommand, ctx);
         return;
       }
 
@@ -339,7 +316,9 @@ export default function (pi: ExtensionAPI) {
           } else {
             console.error(`tmux failed: ${details}`);
           }
-          showCommandMessage(pi, ctx, MANUAL_RESUME_INTRO, resumeCommand);
+          await joinRecoveryReport(() =>
+            showCommandMessage(pi, ctx, MANUAL_RESUME_INTRO, resumeCommand),
+          );
           return;
         }
 
@@ -347,28 +326,31 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      showCommandMessage(pi, ctx, MANUAL_RESUME_INTRO, resumeCommand);
+      await joinRecoveryReport(() =>
+        showCommandMessage(pi, ctx, MANUAL_RESUME_INTRO, resumeCommand),
+      );
     },
   });
 
-  function launchTerminal(
+  async function launchTerminal(
     template: string,
     forkFile: string,
     resumeCommand: string,
     ctx: ExtensionCommandContext,
   ) {
-    const reportFailure = (message: string) => {
-      try {
-        if (ctx.hasUI) ctx.ui.notify(`Terminal command failed: ${message}`, "error");
-        else console.error(`Terminal command failed: ${message}`);
-        showCommandMessage(pi, ctx, MANUAL_RESUME_INTRO, resumeCommand);
-      } catch (error) {
-        console.error(
-          `Could not show terminal recovery instructions: ${error instanceof Error ? error.message : String(error)}`,
-        );
-        console.error(`${MANUAL_RESUME_INTRO}:\n${resumeCommand}`);
-      }
-    };
+    const reportFailure = (message: string) =>
+      joinRecoveryReport(async () => {
+        try {
+          if (ctx.hasUI) ctx.ui.notify(`Terminal command failed: ${message}`, "error");
+          else console.error(`Terminal command failed: ${message}`);
+          await showCommandMessage(pi, ctx, MANUAL_RESUME_INTRO, resumeCommand);
+        } catch (error) {
+          console.error(
+            `Could not show terminal recovery instructions: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          console.error(`${MANUAL_RESUME_INTRO}:\n${resumeCommand}`);
+        }
+      });
     try {
       const child = spawn("bash", ["-c", renderTerminalCommand(template)], {
         cwd: ctx.cwd,
@@ -388,11 +370,15 @@ export default function (pi: ExtensionAPI) {
       };
       const onError = (error: Error) => {
         stopObserving();
-        reportFailure(error.message);
+        void reportFailure(error.message).catch(console.error);
       };
       const onClose = (code: number | null, signal: NodeJS.Signals | null) => {
         stopObserving();
-        if (code !== 0) reportFailure(signal ? `terminated by ${signal}` : `exit code ${code}`);
+        if (code !== 0) {
+          void reportFailure(signal ? `terminated by ${signal}` : `exit code ${code}`).catch(
+            console.error,
+          );
+        }
       };
       // A detached, user-owned launcher may still emit an error after Pi stops observing it.
       child.on("error", ignoreDetachedLauncherError);
@@ -401,12 +387,18 @@ export default function (pi: ExtensionAPI) {
       launchObservers.add(stopObserving);
       child.unref();
     } catch (error) {
-      reportFailure(error instanceof Error ? error.message : String(error));
+      await reportFailure(error instanceof Error ? error.message : String(error));
       return;
     }
     if (ctx.hasUI) ctx.ui.notify("Terminal launch requested", "info");
   }
 
+  function joinRecoveryReport(publish: () => Promise<void>): Promise<void> {
+    const report = publish();
+    const unsubscribe = pi.on("session_shutdown", () => report);
+    return report.finally(unsubscribe);
+  }
+
   function releaseLaunchObservers() {
     for (const stopObserving of launchObservers) stopObserving();
   }

package/extensions/loop.ts

@@ -205,6 +205,7 @@ export default function loopExtension(pi: ExtensionAPI): void {
   let loopGeneration = 0;
   let lastAssistantStopReason: string | undefined;
   let pendingLoopPrompt: ReturnType<typeof setImmediate> | undefined;
+  let pendingLoopDispatch: Promise<void> | undefined;
   let pendingSummary: { controller: AbortController; done: Promise<void> } | undefined;
 
   function persistState(state: LoopStateData): void {
@@ -272,9 +273,13 @@ export default function loopExtension(pi: ExtensionAPI): void {
     });
   }
 
-  function triggerLoopPrompt(ctx: ExtensionContext): void {
+  async function triggerLoopPrompt(ctx: ExtensionContext): Promise<void> {
     const prompt = loopState.prompt;
     if (!loopState.active || !loopState.mode || !prompt) return;
+    if (!pi.getActiveTools().includes("signal_loop_success")) {
+      if (await setLoopState({ active: false }, ctx)) notifyMissingSuccessTool(ctx);
+      return;
+    }
     if (ctx.hasPendingMessages()) return;
 
     const loopCount = (loopState.loopCount ?? 0) + 1;
@@ -295,13 +300,28 @@ export default function loopExtension(pi: ExtensionAPI): void {
     );
   }
 
+  function notifyMissingSuccessTool(ctx: ExtensionContext): void {
+    const message =
+      "Loop requires the active signal_loop_success tool. Enable it before starting /loop.";
+    if (ctx.hasUI) ctx.ui.notify(message, "warning");
+    else console.error(message);
+  }
+
   function scheduleLoopPrompt(ctx: ExtensionContext): void {
-    if (pendingLoopPrompt) return;
+    if (pendingLoopPrompt || pendingLoopDispatch) return;
 
     pendingLoopPrompt = setImmediate(() => {
       pendingLoopPrompt = undefined;
       if (!loopState.active || !ctx.isIdle()) return;
-      triggerLoopPrompt(ctx);
+      const done = triggerLoopPrompt(ctx)
+        .catch((error: unknown) => {
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(`Loop dispatch failed: ${message}`);
+        })
+        .finally(() => {
+          if (pendingLoopDispatch === done) pendingLoopDispatch = undefined;
+        });
+      pendingLoopDispatch = done;
     });
     pendingLoopPrompt.unref?.();
   }
@@ -439,12 +459,18 @@ export default function loopExtension(pi: ExtensionAPI): void {
         }
       }
 
+      if (!pi.getActiveTools().includes("signal_loop_success")) {
+        notifyMissingSuccessTool(ctx);
+        return;
+      }
+
       const summarizedState: LoopStateData = { ...nextState, summary: undefined, loopCount: 0 };
       if (!(await setLoopState(summarizedState, ctx))) return;
+      const generation = loopGeneration;
       ctx.ui.notify("Loop active", "info");
-      triggerLoopPrompt(ctx);
+      await triggerLoopPrompt(ctx);
 
-      startSummary(ctx);
+      if (generation === loopGeneration) startSummary(ctx);
     },
   });
 
@@ -512,7 +538,7 @@ export default function loopExtension(pi: ExtensionAPI): void {
     cancelScheduledLoopPrompt();
     const generation = ++loopGeneration;
     lastAssistantStopReason = undefined;
-    const cancelled = cancelSummary();
+    const cancelled = Promise.all([cancelSummary(), pendingLoopDispatch]);
     try {
       loopState = loadState(ctx);
       updateStatus(ctx, loopState);
@@ -529,6 +555,6 @@ export default function loopExtension(pi: ExtensionAPI): void {
   pi.on("session_shutdown", async () => {
     loopGeneration += 1;
     cancelScheduledLoopPrompt();
-    await cancelSummary();
+    await Promise.all([cancelSummary(), pendingLoopDispatch]);
   });
 }

package/extensions/review/README.md

@@ -0,0 +1,24 @@
+# Review
+
+`/review` runs multi-focus code reviews. `/fix` applies findings or starts a fresh review. `/triage` classifies GitHub PR feedback. See `/review help` for modes and options.
+
+## Defaults
+
+Create `review.json` in your Pi agent directory (normally `~/.pi/agent`, or `PI_CODING_AGENT_DIR`):
+
+```json
+{
+  "models": [
+    "openai-codex/gpt-6.1-sol:high",
+    "anthropic/claude-sonnet-5.5:medium",
+    "openrouter/moonshotai/kimi-k3:high"
+  ],
+  "focuses": ["general", "security", "testing"]
+}
+```
+
+- Both fields are optional: current model and all six focuses are the defaults. Model entries accept `:thinking` suffixes. `focuses`, when present, must be nonempty.
+- `models=...` and `focuses=...` override independently. Use `focuses=all` to override a saved subset. Every model runs every selected focus; per-model focus selection is not supported.
+- Commands and config also accept `model` and `focus` as aliases. Config values remain arrays; do not specify both names for one setting.
+- Defaults are agent-global and reread on each command, without `/reload`. Invalid configuration stops the command. Explicitly supplying both models and focuses bypasses the file.
+- Fresh `/fix` reviews use these defaults. Bare `/fix` still reuses the last report, and `/fix loop` keeps its initial defaults. Fix execution, deduplication, and `/triage` are unchanged.

package/extensions/review/config.ts

@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+import { parseReviewFocuses } from "./focus.js";
+import type { ParsedRequest } from "./schema.js";
+
+type ReviewDefaults = Pick<ParsedRequest, "models" | "focuses">;
+
+export function loadReviewDefaults(): ReviewDefaults {
+  const configPath = path.join(getAgentDir(), "review.json");
+  try {
+    let value: unknown = {};
+    try {
+      value = JSON.parse(readFileSync(configPath, "utf8"));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+    return parseReviewDefaults(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid review config at ${configPath}: ${message}`);
+  }
+}
+
+function parseReviewDefaults(value: unknown): ReviewDefaults {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Expected an object with optional models and focuses arrays");
+  const config = value as Record<string, unknown>;
+  for (const key of Object.keys(config)) {
+    if (!["models", "model", "focuses", "focus"].includes(key))
+      throw new Error(`Unknown field ${JSON.stringify(key)}`);
+  }
+  const models = parseStringList(readAliasedField(config, "models", "model"), "models");
+  const rawFocuses = readAliasedField(config, "focuses", "focus");
+  const focuses = parseStringList(rawFocuses, "focuses");
+  if (rawFocuses !== undefined && focuses.length === 0)
+    throw new Error("focuses must contain at least one focus name; omit it to use all focuses");
+  return { models, focuses: parseReviewFocuses(focuses) };
+}
+
+function readAliasedField(
+  config: Record<string, unknown>,
+  field: "models" | "focuses",
+  alias: "model" | "focus",
+): unknown {
+  if (Object.hasOwn(config, field) && Object.hasOwn(config, alias))
+    throw new Error(`Use either ${JSON.stringify(field)} or ${JSON.stringify(alias)}, not both`);
+  return Object.hasOwn(config, field) ? config[field] : config[alias];
+}
+
+function parseStringList(value: unknown, field: "models" | "focuses"): string[] {
+  if (value === undefined) return [];
+  const item = field === "models" ? "model pattern" : "focus name";
+  if (!Array.isArray(value)) throw new Error(`${field} must be an array of ${item}s`);
+
+  const entries = value.map((entry: unknown, index: number) => {
+    if (typeof entry !== "string" || !entry.trim())
+      throw new Error(`${field}[${index}] must be a nonblank ${item}`);
+    if (entry.includes(","))
+      throw new Error(`${field}[${index}] must contain one ${item}, not a comma-separated list`);
+    return entry.trim();
+  });
+  return [...new Set(entries)];
+}

package/extensions/review/focus.ts

@@ -0,0 +1,48 @@
+import { REVIEW_FOCUS_NAMES, type ReviewFocus } from "./schema.js";
+
+const REVIEW_FOCUS_ALL_VALUE = "all";
+const VALID_REVIEW_FOCUS_VALUES = [REVIEW_FOCUS_ALL_VALUE, ...REVIEW_FOCUS_NAMES].join(", ");
+
+export function parseReviewFocuses(rawFocuses: string[]): ReviewFocus[] {
+  if (rawFocuses.length === 0) return [...REVIEW_FOCUS_NAMES];
+
+  const selected: ReviewFocus[] = [];
+  const seen = new Set<ReviewFocus>();
+  let includeAll = false;
+
+  for (const rawFocus of rawFocuses) {
+    if (!rawFocus) {
+      throw new Error(
+        `focuses= requires at least one value. Valid values: ${VALID_REVIEW_FOCUS_VALUES}.`,
+      );
+    }
+
+    for (const part of rawFocus.split(",")) {
+      const focus = part.trim().toLowerCase();
+      if (!focus) {
+        throw new Error(
+          `focuses= contains an empty focus name. Valid values: ${VALID_REVIEW_FOCUS_VALUES}.`,
+        );
+      }
+      if (focus === REVIEW_FOCUS_ALL_VALUE) {
+        includeAll = true;
+        continue;
+      }
+      if (!isReviewFocus(focus)) {
+        throw new Error(
+          `Invalid focus "${part.trim()}". Valid values: ${VALID_REVIEW_FOCUS_VALUES}.`,
+        );
+      }
+      if (!seen.has(focus)) {
+        selected.push(focus);
+        seen.add(focus);
+      }
+    }
+  }
+
+  return includeAll ? [...REVIEW_FOCUS_NAMES] : selected;
+}
+
+export function isReviewFocus(value: string): value is ReviewFocus {
+  return (REVIEW_FOCUS_NAMES as readonly string[]).includes(value);
+}

package/extensions/review/request.ts

@@ -1,5 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
+import { loadReviewDefaults } from "./config.js";
+import { isReviewFocus, parseReviewFocuses } from "./focus.js";
 import {
   REVIEW_FOCUS_NAMES,
   type ReviewFocus,
@@ -22,13 +24,11 @@ const REVIEW_MODE_HINTS = [
   "custom",
 ] as const;
 
-const REVIEW_FOCUS_ALL_VALUE = "all";
 const REVIEW_FOCUS_OPTION_HINTS = [
-  "focus=testing",
-  `focus=${REVIEW_FOCUS_NAMES.join(",")}`,
-  "focus=all",
+  "focuses=testing",
+  `focuses=${REVIEW_FOCUS_NAMES.join(",")}`,
+  "focuses=all",
 ] as const;
-const VALID_REVIEW_FOCUS_VALUES = [REVIEW_FOCUS_ALL_VALUE, ...REVIEW_FOCUS_NAMES] as const;
 
 function isHelpRequest(args: string | undefined): boolean {
   const tokens = tokenizeArgs(args?.trim() ?? "");
@@ -73,11 +73,11 @@ export function showReviewHelp(pi: ExtensionAPI) {
     details: { kind: "help" satisfies ReviewMessageKind },
     content: `## /review help
 
-Run findings-only code review across up to 6 parallel focuses (general, security, reuse, quality, testing, efficiency). Defaults to all focuses.
+Run findings-only code review across up to 6 parallel focuses (general, security, reuse, quality, testing, efficiency). Defaults to all focuses unless configured.
 
 ### Syntax
-- \`/review [mode] [models=<a,b>] [focus=<focuses>] [context=<text>]\`
-- \`/fix [loop] [mode] [models=<a,b>] [focus=<focuses>] [context=<text>]\`
+- \`/review [mode] [models=<a,b>] [focuses=<a,b>] [context=<text>]\`
+- \`/fix [loop] [mode] [models=<a,b>] [focuses=<a,b>] [context=<text>]\`
 - \`/triage <number|url>\`
 
 ### Modes
@@ -90,29 +90,44 @@ Run findings-only code review across up to 6 parallel focuses (general, security
 - \`custom "<instructions>"\`: custom scoped review instructions.
 
 ### Options
-- \`models=<a,b>\`: run requested review focuses for each listed model.
-- \`focus=<focuses>\`: comma-separated focuses to run: \`general\`, \`security\`, \`reuse\`, \`quality\`, \`testing\`, \`efficiency\`. Use \`focus=all\` for all focuses.
+- \`models=<a,b>\`: run requested review focuses for each listed model, overriding saved defaults. Each model accepts an optional \`:thinking\` suffix.
+- \`focuses=<a,b>\`: comma-separated focuses to run: \`general\`, \`security\`, \`reuse\`, \`quality\`, \`testing\`, \`efficiency\`. Use \`focuses=all\` for all focuses.
 - \`context=<text>\`: add extra guidance.
   - For \`/review\`, guides every requested review focus.
   - For \`/fix\`, guides the fix pass; if \`/fix\` must run a fresh review, it guides review too.
   - For spaces, quote the value, e.g. \`context="security and backpressure"\`.
 
+### Review defaults
+Create \`review.json\` in your Pi agent directory (normally \`~/.pi/agent\`):
+\`\`\`json
+{
+  "models": ["openai-codex/gpt-6.1-sol:high", "anthropic/claude-sonnet-5.5:medium"],
+  "focuses": ["general", "security", "testing"]
+}
+\`\`\`
+- \`models=...\` and \`focuses=...\` independently replace their configured lists. Use \`focuses=all\` to override a saved subset.
+- \`model\` and \`focus\` are aliases for \`models\` and \`focuses\` in both commands and configuration. Config values remain arrays; do not specify both names for one setting.
+- Omitted settings default to the current model and all focuses. \`models: []\` also uses the current model; \`focuses\` must be nonempty when present.
+- Defaults are read on each command, including fresh reviews started by \`/fix\`. A fix loop keeps the defaults it started with.
+- Invalid configuration stops the command. Supplying both models and focuses explicitly bypasses the file.
+- Every selected model runs every selected focus.
+
 ### Examples
 - \`/review\`
 - \`/review help\`
 - \`/review branch main\`
 - \`/review pr 123 models=sonnet,gpt-5\`
-- \`/review folder src/features/foo focus=testing\`
-- \`/review uncommitted focus=testing,quality\`
+- \`/review folder src/features/foo focuses=testing\`
+- \`/review uncommitted focuses=testing,quality\`
 - \`/review uncommitted context="security and error handling"\`
 - \`/triage 123\`
 - \`/triage https://github.com/owner/repo/pull/123\`
 - \`/fix\`
 - \`/fix help\`
 - \`/fix context="do not test mocks"\`
-- \`/fix folder src/features/foo focus=testing context="testing-only cleanup"\`
+- \`/fix folder src/features/foo focuses=testing context="testing-only cleanup"\`
 - \`/fix branch main models=sonnet\`
-- \`/fix loop focus=testing\`
+- \`/fix loop focuses=testing\`
 - \`/fix loop models=sonnet,gpt-5\`
 
 ### /fix behavior
@@ -151,59 +166,6 @@ function parseKeyValueOption(
   return value;
 }
 
-function isReviewFocus(value: string): value is ReviewFocus {
-  return (REVIEW_FOCUS_NAMES as readonly string[]).includes(value);
-}
-
-function formatValidReviewFocusValues(): string {
-  return VALID_REVIEW_FOCUS_VALUES.join(", ");
-}
-
-function parseFocusList(rawFocuses: string[]): { focuses: ReviewFocus[]; explicit: boolean } {
-  if (rawFocuses.length === 0) {
-    return { focuses: [...REVIEW_FOCUS_NAMES], explicit: false };
-  }
-
-  const selected: ReviewFocus[] = [];
-  const seen = new Set<ReviewFocus>();
-  let includeAll = false;
-
-  for (const rawFocus of rawFocuses) {
-    if (!rawFocus) {
-      throw new Error(
-        `focus= requires at least one value. Valid values: ${formatValidReviewFocusValues()}.`,
-      );
-    }
-
-    for (const part of rawFocus.split(",")) {
-      const focus = part.trim().toLowerCase();
-      if (!focus) {
-        throw new Error(
-          `focus= contains an empty focus name. Valid values: ${formatValidReviewFocusValues()}.`,
-        );
-      }
-      if (focus === REVIEW_FOCUS_ALL_VALUE) {
-        includeAll = true;
-        continue;
-      }
-      if (!isReviewFocus(focus)) {
-        throw new Error(
-          `Invalid focus "${part.trim()}". Valid values: ${formatValidReviewFocusValues()}.`,
-        );
-      }
-      if (!seen.has(focus)) {
-        selected.push(focus);
-        seen.add(focus);
-      }
-    }
-  }
-
-  return {
-    focuses: includeAll ? [...REVIEW_FOCUS_NAMES] : selected,
-    explicit: true,
-  };
-}
-
 export function parseRequestArgs(args: string | undefined): ParsedRequest {
   const raw = args?.trim() ?? "";
   if (!raw) {
@@ -213,6 +175,7 @@ export function parseRequestArgs(args: string | undefined): ParsedRequest {
       models: [],
       focuses: [...REVIEW_FOCUS_NAMES],
       targetExplicit: false,
+      modelsExplicit: false,
       focusExplicit: false,
     };
   }
@@ -234,7 +197,7 @@ export function parseRequestArgs(args: string | undefined): ParsedRequest {
       continue;
     }
 
-    const focusValue = parseKeyValueOption(token, "focus") ?? parseKeyValueOption(token, "focuses");
+    const focusValue = parseKeyValueOption(token, "focuses") ?? parseKeyValueOption(token, "focus");
     if (focusValue !== undefined) {
       rawFocuses.push(focusValue);
       continue;
@@ -250,7 +213,8 @@ export function parseRequestArgs(args: string | undefined): ParsedRequest {
   }
 
   const models = Array.from(new Set(rawModels));
-  const { focuses, explicit: focusExplicit } = parseFocusList(rawFocuses);
+  const focuses = parseReviewFocuses(rawFocuses);
+  const focusExplicit = rawFocuses.length > 0;
   const additionalContextJoined = rawContext
     .map((c) => c.trim())
     .filter(Boolean)
@@ -281,6 +245,7 @@ export function parseRequestArgs(args: string | undefined): ParsedRequest {
     models,
     focuses,
     targetExplicit,
+    modelsExplicit: models.length > 0,
     focusExplicit,
     additionalContext,
   });
@@ -295,7 +260,7 @@ export function parseRequestArgs(args: string | undefined): ParsedRequest {
   if (mode === "auto" || mode === "uncommitted") {
     if (rest.length > 0)
       throw new Error(
-        `${mode} mode does not accept positional args. Use models=..., focus=..., and/or context=...`,
+        `${mode} mode does not accept positional args. Use models=..., focuses=..., and/or context=...`,
       );
     return withMeta({ type: mode }, true);
   }
@@ -312,7 +277,7 @@ export function parseRequestArgs(args: string | undefined): ParsedRequest {
       const valueLabel =
         mode === "branch" ? "branch name" : mode === "commit" ? "SHA" : "reference";
       throw new Error(
-        `${mode} mode accepts one ${valueLabel}. Use models=..., focus=..., and/or context=... for options.`,
+        `${mode} mode accepts one ${valueLabel}. Use models=..., focuses=..., and/or context=... for options.`,
       );
     }
 
@@ -434,7 +399,7 @@ function buildContextlessStoredRequestSignature(signature: string): string | nul
 }
 
 function isOpenEndedFixRequest(request: ParsedRequest): boolean {
-  return !request.targetExplicit && request.models.length === 0 && !request.focusExplicit;
+  return !request.targetExplicit && !request.modelsExplicit && !request.focusExplicit;
 }
 
 export function reviewMatchesFixRequest(
@@ -466,7 +431,13 @@ export function parseCommandRequest(args: string | undefined): ParseResult<Parse
   }
 
   try {
-    return { ok: true, value: parseRequestArgs(args) };
+    const request = parseRequestArgs(args);
+    if (!request.modelsExplicit || !request.focusExplicit) {
+      const defaults = loadReviewDefaults();
+      if (!request.modelsExplicit) request.models = defaults.models;
+      if (!request.focusExplicit) request.focuses = defaults.focuses;
+    }
+    return { ok: true, value: request };
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : String(error) };
   }

package/extensions/review/runner.ts

@@ -104,7 +104,11 @@ function extractSubmitToolPayloadFromEvent(event: unknown, submitTool: string):
   if (!record || record.type !== "message_end") return null;
 
   const message = asRecord(record.message);
-  return message?.role === "toolResult" && message.toolName === submitTool ? message.details : null;
+  return message?.role === "toolResult" &&
+    message.toolName === submitTool &&
+    message.isError === false
+    ? message.details
+    : null;
 }
 
 export function parseJsonFromText(raw: string): unknown {

package/extensions/review/schema.ts

@@ -43,6 +43,7 @@ export type ParsedRequest = {
   models: string[];
   focuses: ReviewFocus[];
   targetExplicit: boolean;
+  modelsExplicit: boolean;
   focusExplicit: boolean;
   additionalContext?: string;
 };