@towles/tool 0.0.61 → 0.0.63

package/src/commands/gh/pr.ts

@@ -11,6 +11,7 @@ import { isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
  * Note: Uses tinyexec which is safe (execFile-based, no shell injection)
  */
 export default class Pr extends BaseCommand {
+  static override aliases = ["pr"];
   static override description = "Create a pull request from the current branch";
 
   static override examples = [

package/src/commands/graph/index.ts

@@ -0,0 +1,169 @@
+import { Flags } from "@oclif/core";
+import { DateTime } from "luxon";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { x } from "tinyexec";
+import { BaseCommand } from "../base.js";
+import {
+  buildAllSessionsTreemap,
+  buildBarChartData,
+  buildSessionTreemap,
+  findRecentSessions,
+  findSessionPath,
+  generateTreemapHtml,
+  openInBrowser,
+  parseJsonl,
+  startServer,
+  waitForShutdown,
+} from "../../lib/graph/index.js";
+
+// Re-export public API for consumers and tests
+export {
+  analyzeSession,
+  buildAllSessionsTreemap,
+  buildBarChartData,
+  buildSessionTreemap,
+  calculateCutoffMs,
+  extractSessionLabel,
+  filterByDays,
+  findRecentSessions,
+  findSessionPath,
+  generateTreemapHtml,
+  parseJsonl,
+} from "../../lib/graph/index.js";
+export type {
+  BarChartData,
+  BarChartDay,
+  ProjectBar,
+  SessionResult,
+  TreemapNode,
+} from "../../lib/graph/index.js";
+
+/**
+ * Generate interactive HTML treemap from session token data
+ */
+export default class Graph extends BaseCommand {
+  static override description = "Generate interactive HTML treemap from session token data";
+
+  static override examples = [
+    {
+      description: "Generate treemap for all recent sessions",
+      command: "<%= config.bin %> <%= command.id %>",
+    },
+    {
+      description: "Generate treemap for a specific session",
+      command: "<%= config.bin %> <%= command.id %> --session abc123",
+    },
+    {
+      description: "Generate and auto-open in browser",
+      command: "<%= config.bin %> <%= command.id %> --open",
+    },
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    session: Flags.string({
+      char: "s",
+      description: "Session ID to analyze (shows all sessions if not provided)",
+    }),
+    open: Flags.boolean({
+      char: "o",
+      description: "Open treemap in browser after generating",
+      default: true,
+      allowNo: true,
+    }),
+    serve: Flags.boolean({
+      description: "Start local HTTP server to serve treemap (default: true)",
+      default: true,
+      allowNo: true,
+    }),
+    port: Flags.integer({
+      char: "p",
+      description: "Port for local server",
+      default: 8765,
+    }),
+    days: Flags.integer({
+      description: "Filter to sessions from last N days (0=no limit)",
+      default: 7,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Graph);
+
+    const projectsDir = path.join(os.homedir(), ".claude", "projects");
+    if (!fs.existsSync(projectsDir)) {
+      this.error("No Claude projects directory found at ~/.claude/projects/");
+    }
+
+    const sessionId = flags.session;
+    let treemapData;
+    let barChartData = { days: [] as any[] };
+
+    if (!sessionId) {
+      // All sessions mode
+      const sessions = findRecentSessions(projectsDir, 500, flags.days);
+      if (sessions.length === 0) {
+        this.error("No sessions found");
+      }
+
+      const daysMsg = flags.days > 0 ? ` (last ${flags.days} days)` : "";
+      this.log(`📊 Generating treemap for ${sessions.length} sessions${daysMsg}...`);
+      treemapData = buildAllSessionsTreemap(sessions);
+      barChartData = buildBarChartData(sessions);
+    } else {
+      // Single session mode
+      const sessionPath = findSessionPath(projectsDir, sessionId);
+      if (!sessionPath) {
+        this.error(`Session ${sessionId} not found`);
+      }
+
+      this.log(`📊 Generating treemap for session ${sessionId}...`);
+      const entries = parseJsonl(sessionPath);
+      treemapData = buildSessionTreemap(sessionId, entries);
+      // Bar chart not meaningful for single session, leave empty
+    }
+
+    // Generate HTML
+    const html = generateTreemapHtml(treemapData, barChartData);
+
+    // Write output file
+    const reportsDir = path.join(os.homedir(), ".claude", "reports");
+    if (!fs.existsSync(reportsDir)) {
+      fs.mkdirSync(reportsDir, { recursive: true });
+    }
+
+    const timestamp = DateTime.now().toFormat("yyyy-MM-dd'T'HH-mmZZZ");
+    const daysLabel = flags.days > 0 ? `${flags.days}d` : "all";
+    const filename = sessionId
+      ? `treemap-${sessionId.slice(0, 8)}-${timestamp}.html`
+      : `treemap-${daysLabel}-${timestamp}.html`;
+    const outputPath = path.join(reportsDir, filename);
+
+    fs.writeFileSync(outputPath, html);
+    this.log(`✓ Saved to ${outputPath}`);
+
+    if (flags.serve) {
+      const { server, port: actualPort } = await startServer(html, filename, flags.port);
+      const url = `http://localhost:${actualPort}/`;
+      if (actualPort !== flags.port) {
+        this.log(`\n⚠️  Port ${flags.port} in use, using ${actualPort}`);
+      }
+      this.log(`🌐 Server running at ${url}`);
+      this.log("   Press Ctrl+C to stop\n");
+
+      if (flags.open) {
+        openInBrowser(url);
+      }
+
+      // Keep server running until Ctrl+C
+      await waitForShutdown(server);
+      this.log("\n👋 Stopping server...");
+    } else if (flags.open) {
+      this.log("\n📈 Opening treemap...");
+      const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
+      await x(openCmd, [outputPath]);
+    }
+  }
+}

package/src/commands/graph.test.ts

@@ -2,7 +2,7 @@
  * Tests for graph command --days filtering and bar chart data
  */
 import { describe, it, expect } from "vitest";
-import { calculateCutoffMs, filterByDays, analyzeSession } from "./graph.js";
+import { analyzeSession, calculateCutoffMs, filterByDays } from "../lib/graph/index.js";
 
 describe("graph --days filtering", () => {
   describe("calculateCutoffMs", () => {

package/src/commands/install.ts

@@ -1,19 +1,13 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { homedir } from "node:os";
 import { Flags } from "@oclif/core";
-import pc from "picocolors";
+import { colors } from "consola/utils";
 import consola from "consola";
 import { BaseCommand } from "./base.js";
-
-const CLAUDE_SETTINGS_PATH = path.join(homedir(), ".claude", "settings.json");
-
-interface ClaudeSettings {
-  cleanupPeriodDays?: number;
-  alwaysThinkingEnabled?: boolean;
-  hooks?: Record<string, unknown[]>;
-  [key: string]: unknown;
-}
+import {
+  CLAUDE_SETTINGS_PATH,
+  loadClaudeSettings,
+  applyRecommendedSettings,
+  saveClaudeSettings,
+} from "../lib/install/claude-settings.js";
 
 /**
  * Install and configure towles-tool with Claude Code
@@ -45,62 +39,48 @@ export default class Install extends BaseCommand {
   async run(): Promise<void> {
     const { flags } = await this.parse(Install);
 
-    this.log(pc.bold("\n🔧 towles-tool install\n"));
+    this.log(colors.bold("\n🔧 towles-tool install\n"));
 
     // Load or create Claude settings
-    let claudeSettings: ClaudeSettings = {};
-    if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
-      try {
-        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
-        claudeSettings = JSON.parse(content);
-        this.log(pc.dim(`Found existing Claude settings at ${CLAUDE_SETTINGS_PATH}`));
-      } catch {
-        this.log(
-          pc.yellow(`Warning: Could not parse ${CLAUDE_SETTINGS_PATH}, will create fresh settings`),
-        );
-      }
+    const existing = loadClaudeSettings(CLAUDE_SETTINGS_PATH);
+    if (Object.keys(existing).length > 0) {
+      this.log(colors.dim(`Found existing Claude settings at ${CLAUDE_SETTINGS_PATH}`));
     } else {
-      this.log(pc.dim(`No Claude settings file found, will create one`));
+      this.log(colors.dim(`No Claude settings file found, will create one`));
     }
 
-    // Configure recommended settings
-    let modified = false;
+    // Apply recommended settings
+    const { settings, changes } = applyRecommendedSettings(existing);
 
-    // Prevent log deletion (set to ~274 years)
-    if (claudeSettings.cleanupPeriodDays !== 99999) {
-      claudeSettings.cleanupPeriodDays = 99999;
-      modified = true;
-      this.log(pc.green("✓ Set cleanupPeriodDays: 99999 (prevent log deletion)"));
-    } else {
-      this.log(pc.dim("✓ cleanupPeriodDays already set to 99999"));
+    for (const change of changes) {
+      this.log(colors.green(`✓ ${change}`));
     }
 
-    // Enable thinking by default
-    if (claudeSettings.alwaysThinkingEnabled !== true) {
-      claudeSettings.alwaysThinkingEnabled = true;
-      modified = true;
-      this.log(pc.green("✓ Set alwaysThinkingEnabled: true"));
-    } else {
-      this.log(pc.dim("✓ alwaysThinkingEnabled already set to true"));
+    // Report already-correct settings
+    if (!changes.some((c) => c.includes("cleanupPeriodDays"))) {
+      this.log(colors.dim("✓ cleanupPeriodDays already set to 99999"));
+    }
+    if (!changes.some((c) => c.includes("alwaysThinkingEnabled"))) {
+      this.log(colors.dim("✓ alwaysThinkingEnabled already set to true"));
     }
 
-    // Save settings if modified
-    if (modified) {
-      this.saveClaudeSettings(claudeSettings);
-      this.log(pc.green(`\n✓ Saved Claude settings to ${CLAUDE_SETTINGS_PATH}`));
+    // Save settings if anything changed
+    if (changes.length > 0) {
+      saveClaudeSettings(CLAUDE_SETTINGS_PATH, settings);
+      this.log(colors.green(`\n✓ Saved Claude settings to ${CLAUDE_SETTINGS_PATH}`));
     }
 
     // Show observability setup if requested
     if (flags.observability) {
-      this.log(pc.bold("\n📊 Observability Setup\n"));
+      this.log(colors.bold("\n📊 Observability Setup\n"));
       this.showOtelInstructions();
     }
 
     // Install Claude plugins
-    this.log(pc.bold("\n📦 Claude Plugins\n"));
+    this.log(colors.bold("\n📦 Claude Plugins\n"));
     await this.ensureClaudePlugins();
 
-    this.log(pc.bold(pc.green("\n✅ Installation complete!\n")));
+    this.log(colors.bold(colors.green("\n✅ Installation complete!\n")));
   }
 
   private async ensureClaudePlugins(): Promise<void> {
@@ -126,7 +106,7 @@ export default class Install extends BaseCommand {
       const plugins: { id: string }[] = JSON.parse(result.stdout);
       installedIds = new Set(plugins.map((p) => p.id));
     } catch {
-      this.log(pc.yellow("⚠ Could not list Claude plugins"));
+      this.log(colors.yellow("⚠ Could not list Claude plugins"));
     }
 
     // Ensure marketplaces are added first
@@ -134,7 +114,7 @@ export default class Install extends BaseCommand {
       if (plugin.marketplaceUrl && !installedIds.has(plugin.id)) {
         try {
           await x("claude", ["plugin", "marketplace", "add", plugin.marketplaceUrl]);
-          this.log(pc.dim(`  Added marketplace: ${plugin.marketplace}`));
+          this.log(colors.dim(`  Added marketplace: ${plugin.marketplace}`));
         } catch {
           // marketplace may already be added
         }
@@ -144,7 +124,7 @@ export default class Install extends BaseCommand {
     // Install missing plugins
     for (const plugin of requiredPlugins) {
       if (installedIds.has(plugin.id)) {
-        this.log(pc.dim(`✓ ${plugin.name} already installed`));
+        this.log(colors.dim(`✓ ${plugin.name} already installed`));
         continue;
       }
 
@@ -156,28 +136,20 @@ export default class Install extends BaseCommand {
       if (answer) {
         const result = await x("claude", ["plugin", "install", plugin.id, "--scope", "user"]);
         if (result.exitCode === 0) {
-          this.log(pc.green(`✓ ${plugin.name} installed`));
+          this.log(colors.green(`✓ ${plugin.name} installed`));
         } else {
           if (result.stdout) this.log(result.stdout);
-          if (result.stderr) this.log(pc.dim(result.stderr));
-          this.log(pc.yellow(`⚠ ${plugin.name} install exited with code ${result.exitCode}`));
+          if (result.stderr) this.log(colors.dim(result.stderr));
+          this.log(colors.yellow(`⚠ ${plugin.name} install exited with code ${result.exitCode}`));
         }
       } else {
-        this.log(pc.dim(`  Skipped ${plugin.name}`));
+        this.log(colors.dim(`  Skipped ${plugin.name}`));
       }
     }
   }
 
-  private saveClaudeSettings(settings: ClaudeSettings): void {
-    const dir = path.dirname(CLAUDE_SETTINGS_PATH);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
-  }
-
   private showOtelInstructions(): void {
-    this.log(pc.cyan("Add these environment variables to your shell profile:\n"));
+    this.log(colors.cyan("Add these environment variables to your shell profile:\n"));
 
     consola.box(`export CLAUDE_CODE_ENABLE_TELEMETRY=1
 export OTEL_METRICS_EXPORTER=otlp
@@ -186,10 +158,10 @@ export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317`);
 
     this.log("");
     this.log(
-      pc.dim("For more info, see: https://github.com/anthropics/claude-code-monitoring-guide"),
+      colors.dim("For more info, see: https://github.com/anthropics/claude-code-monitoring-guide"),
     );
     this.log("");
-    this.log(pc.cyan("Quick cost analysis (no setup required):"));
-    this.log(pc.dim("  npx ccusage@latest --breakdown"));
+    this.log(colors.cyan("Quick cost analysis (no setup required):"));
+    this.log(colors.dim("  npx ccusage@latest --breakdown"));
   }
 }

package/src/commands/journal/daily-notes.ts

@@ -11,7 +11,7 @@ import {
   ensureTemplatesExist,
   generateJournalFileInfoByType,
   openInEditor,
-} from "../../lib/journal/utils.js";
+} from "../../lib/journal/index.js";
 
 /**
  * Create or open daily notes journal file
@@ -32,7 +32,7 @@ export default class DailyNotes extends BaseCommand {
     await this.parse(DailyNotes);
 
     try {
-      const journalSettings = this.settings.settings.journalSettings;
+      const journalSettings = this.userSettings.journalSettings;
       const templateDir = journalSettings.templateDir;
 
       // Ensure templates exist on first run
@@ -58,7 +58,7 @@ export default class DailyNotes extends BaseCommand {
       }
 
       await openInEditor({
-        editor: this.settings.settings.preferredEditor,
+        editor: this.userSettings.preferredEditor,
         filePath: fileInfo.fullPath,
         folderPath: journalSettings.baseFolder,
       });

package/src/commands/journal/meeting.ts

@@ -12,7 +12,7 @@ import {
   ensureTemplatesExist,
   generateJournalFileInfoByType,
   openInEditor,
-} from "../../lib/journal/utils.js";
+} from "../../lib/journal/index.js";
 
 /**
  * Create or open meeting notes file
@@ -43,7 +43,7 @@ export default class Meeting extends BaseCommand {
     const { args } = await this.parse(Meeting);
 
     try {
-      const journalSettings = this.settings.settings.journalSettings;
+      const journalSettings = this.userSettings.journalSettings;
       const templateDir = journalSettings.templateDir;
 
       // Ensure templates exist on first run
@@ -77,7 +77,7 @@ export default class Meeting extends BaseCommand {
       }
 
       await openInEditor({
-        editor: this.settings.settings.preferredEditor,
+        editor: this.userSettings.preferredEditor,
         filePath: fileInfo.fullPath,
         folderPath: journalSettings.baseFolder,
       });

package/src/commands/journal/note.ts

@@ -12,7 +12,7 @@ import {
   ensureTemplatesExist,
   generateJournalFileInfoByType,
   openInEditor,
-} from "../../lib/journal/utils.js";
+} from "../../lib/journal/index.js";
 
 /**
  * Create or open general-purpose note file
@@ -43,7 +43,7 @@ export default class Note extends BaseCommand {
     const { args } = await this.parse(Note);
 
     try {
-      const journalSettings = this.settings.settings.journalSettings;
+      const journalSettings = this.userSettings.journalSettings;
       const templateDir = journalSettings.templateDir;
 
       // Ensure templates exist on first run
@@ -77,7 +77,7 @@ export default class Note extends BaseCommand {
       }
 
       await openInEditor({
-        editor: this.settings.settings.preferredEditor,
+        editor: this.userSettings.preferredEditor,
         filePath: fileInfo.fullPath,
         folderPath: journalSettings.baseFolder,
       });

package/src/lib/auto-claude/claude-cli.ts

@@ -0,0 +1,183 @@
+import { createInterface } from "node:readline";
+
+import consola from "consola";
+import pc from "picocolors";
+
+import { getConfig } from "./config.js";
+import { sleep } from "./shell.js";
+import { spawnClaude } from "./spawn-claude.js";
+
+// ── Claude CLI ──
+
+export interface ClaudeResult {
+  result: string;
+  is_error: boolean;
+  total_cost_usd: number;
+  num_turns: number;
+}
+
+const PROCESS_RETRIES = 3;
+const PROCESS_RETRY_DELAY_MS = 5_000;
+
+export async function runClaude(opts: {
+  promptFile: string;
+  maxTurns?: number;
+}): Promise<ClaudeResult> {
+  const cfg = getConfig();
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--include-partial-messages",
+    "--dangerously-skip-permissions",
+    "--model",
+    cfg.model,
+    ...(opts.maxTurns ? ["--max-turns", String(opts.maxTurns)] : []),
+    `@${opts.promptFile}`,
+  ];
+
+  consola.info(
+    `${pc.dim("▶")} Calling Claude${opts.maxTurns ? ` (max ${opts.maxTurns} turns)` : ""}…`,
+  );
+
+  let lastError: Error | undefined;
+  for (let attempt = 1; attempt <= PROCESS_RETRIES; attempt++) {
+    try {
+      const result = await runClaudeStreaming(args);
+      consola.success(`Done — ${result.num_turns} turns, $${result.total_cost_usd.toFixed(4)}`);
+      if (result.result) {
+        consola.log(result.result);
+      }
+      return result;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < PROCESS_RETRIES) {
+        consola.warn(
+          `Claude process failed (attempt ${attempt}/${PROCESS_RETRIES}), retrying in ${PROCESS_RETRY_DELAY_MS / 1000}s…`,
+        );
+        await sleep(PROCESS_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw lastError ?? new Error("runClaude failed after all retries");
+}
+
+function runClaudeStreaming(args: string[]): Promise<ClaudeResult> {
+  return new Promise((resolve, reject) => {
+    const proc = spawnClaude(args);
+    let capturedResult: ClaudeResult | null = null;
+    let turnCount = 0;
+
+    if (!proc.stdout) {
+      reject(new Error("Claude process has no stdout"));
+      return;
+    }
+
+    const rl = createInterface({ input: proc.stdout });
+
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      try {
+        const event = JSON.parse(line) as Record<string, unknown>;
+        handleStreamEvent(event, (turns) => {
+          turnCount = turns;
+        });
+
+        if ("result" in event && "is_error" in event && "num_turns" in event) {
+          capturedResult = {
+            result: String(event.result ?? ""),
+            is_error: Boolean(event.is_error),
+            total_cost_usd: Number(event.total_cost_usd ?? 0),
+            num_turns: Number(event.num_turns),
+          };
+        }
+      } catch {
+        // Skip non-JSON lines
+      }
+    });
+
+    proc.on("error", (err) => {
+      rl.close();
+      reject(err);
+    });
+
+    proc.on("close", (code) => {
+      rl.close();
+      if (capturedResult) {
+        resolve(capturedResult);
+      } else if (code !== 0) {
+        reject(new Error(`Claude process exited with code ${code}`));
+      } else {
+        resolve({ result: "", is_error: false, total_cost_usd: 0, num_turns: turnCount });
+      }
+    });
+  });
+}
+
+function truncate(s: string, max: number): string {
+  return s.length > max ? s.slice(0, max) + "\u2026" : s;
+}
+
+function toolDetail(block: Record<string, unknown>): string {
+  const input =
+    typeof block.input === "object" && block.input !== null
+      ? (block.input as Record<string, unknown>)
+      : null;
+  if (!input) return "";
+
+  const filePath = input.file_path ?? input.path;
+  if (typeof filePath === "string") {
+    let detail = pc.dim(` ${filePath}`);
+    // Show edit context for Edit tool
+    if (typeof input.old_string === "string" && typeof input.new_string === "string") {
+      const old = truncate(input.old_string.split("\n")[0].trim(), 40);
+      const replacement = truncate(input.new_string.split("\n")[0].trim(), 40);
+      detail += pc.dim(` "${old}" → "${replacement}"`);
+    }
+    return detail;
+  }
+  if (typeof input.pattern === "string") return pc.dim(` ${input.pattern}`);
+  if (typeof input.command === "string") {
+    return pc.dim(` ${truncate(input.command, 60)}`);
+  }
+  // TodoWrite/TaskCreate — show subject
+  if (typeof input.subject === "string") return pc.dim(` ${truncate(input.subject, 60)}`);
+  return "";
+}
+
+function logToolUse(block: Record<string, unknown>): void {
+  const name = block.name;
+  if (typeof name === "string") {
+    consola.info(`  ${pc.dim("\u21B3")} ${name}${toolDetail(block)}`);
+  }
+}
+
+function handleStreamEvent(event: Record<string, unknown>, onTurn: (count: number) => void): void {
+  // Only handle stream_event — assistant turn events duplicate the same tools
+  if (event.type === "stream_event" && typeof event.event === "object" && event.event !== null) {
+    const inner = event.event as Record<string, unknown>;
+
+    if (
+      inner.type === "content_block_start" &&
+      typeof inner.content_block === "object" &&
+      inner.content_block !== null
+    ) {
+      const block = inner.content_block as Record<string, unknown>;
+      if (block.type === "tool_use") {
+        logToolUse(block);
+      } else if (block.type === "thinking") {
+        const thinkingText =
+          typeof block.thinking === "string" && block.thinking.length > 0
+            ? pc.dim(` ${truncate(block.thinking.split("\n")[0].trim(), 60)}`)
+            : "";
+        consola.info(`  ${pc.dim("\u21B3")} ${pc.italic("thinking")}${thinkingText}`);
+      }
+    }
+  }
+
+  // Turn count tracking
+  if (typeof event.num_turns === "number" && !("result" in event)) {
+    onTurn(event.num_turns as number);
+  }
+}

package/src/lib/auto-claude/config.test.ts

@@ -12,11 +12,9 @@ describe("AutoClaudeConfigSchema", () => {
     expect(cfg.remote).toBe("origin");
     expect(cfg.maxImplementIterations).toBe(5);
     expect(cfg.maxTurns).toBeUndefined();
+    expect(cfg.model).toBe("opus");
+    expect(cfg.maxReviewRetries).toBe(2);
     expect(cfg.loopIntervalMinutes).toBe(30);
-    expect(cfg.loopRetryEnabled).toBe(false);
-    expect(cfg.maxRetries).toBe(5);
-    expect(cfg.retryDelayMs).toBe(30_000);
-    expect(cfg.maxRetryDelayMs).toBe(300_000);
   });
 
   it("should allow overriding defaults", () => {
@@ -24,14 +22,14 @@ describe("AutoClaudeConfigSchema", () => {
       repo: "owner/repo",
       triggerLabel: "bot",
       maxImplementIterations: 10,
-      maxRetries: 3,
-      loopRetryEnabled: true,
+      model: "sonnet",
+      maxReviewRetries: 5,
     });
 
     expect(cfg.triggerLabel).toBe("bot");
     expect(cfg.maxImplementIterations).toBe(10);
-    expect(cfg.maxRetries).toBe(3);
-    expect(cfg.loopRetryEnabled).toBe(true);
+    expect(cfg.model).toBe("sonnet");
+    expect(cfg.maxReviewRetries).toBe(5);
   });
 
   it("should require repo field", () => {