@aion0/forge 0.5.25 → 0.5.26

package/.forge/worktrees/pipeline-e7f78b7a/scripts/bench/tasks/01-text-utils/validator.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# Validator for text utility task.
+# Runs in harness_test project root. Exits 0 = pass, non-zero = fail.
+set -e
+
+PROJECT_ROOT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+cd "$PROJECT_ROOT/src" || { echo "FAIL: src/ directory not found"; exit 1; }
+
+# 1. Check files exist
+[ -f utils/text.js ] || { echo "FAIL: utils/text.js missing"; exit 1; }
+[ -f utils/text.test.js ] || { echo "FAIL: utils/text.test.js missing"; exit 1; }
+
+# 2. Check exports
+grep -q "export.*capitalize" utils/text.js || { echo "FAIL: capitalize not exported"; exit 1; }
+grep -q "export.*reverseWords" utils/text.js || { echo "FAIL: reverseWords not exported"; exit 1; }
+
+# 3. Run tests
+node --test utils/text.test.js 2>&1 | tee /tmp/text-test-output.txt
+TEST_EXIT=${PIPESTATUS[0]}
+if [ "$TEST_EXIT" != "0" ]; then
+  echo "FAIL: tests failed (exit=$TEST_EXIT)"
+  exit 1
+fi
+
+# 4. Additional smoke test — behavior verification independent of agent's tests
+node -e "
+import('./utils/text.js').then(m => {
+  const assert = require('node:assert/strict');
+  // capitalize
+  assert.equal(m.capitalize('hello'), 'Hello', 'capitalize basic');
+  assert.equal(m.capitalize('a'), 'A', 'capitalize single char');
+  try { m.capitalize(''); assert.fail('expected throw on empty'); } catch (e) { assert.ok(e instanceof TypeError); }
+  try { m.capitalize(null); assert.fail('expected throw on null'); } catch (e) { assert.ok(e instanceof TypeError); }
+  try { m.capitalize(123); assert.fail('expected throw on number'); } catch (e) { assert.ok(e instanceof TypeError); }
+  // reverseWords
+  assert.equal(m.reverseWords('hello world'), 'world hello');
+  assert.equal(m.reverseWords('  a  b  c  '), 'c b a');
+  assert.equal(m.reverseWords(''), '');
+  assert.equal(m.reverseWords('single'), 'single');
+  try { m.reverseWords(null); assert.fail('expected throw'); } catch (e) { assert.ok(e instanceof TypeError); }
+  console.log('SMOKE_TEST_PASSED');
+}).catch(err => { console.error('SMOKE_TEST_FAILED:', err.message); process.exit(1); });
+" || { echo "FAIL: smoke test failed"; exit 1; }
+
+echo "PASS"
+exit 0

package/.forge/worktrees/pipeline-e7f78b7a/scripts/bench/tasks/02-pagination/setup.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Create a basic user list module without pagination.
+set -e
+PROJECT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+mkdir -p "$PROJECT/src/api"
+
+cat > "$PROJECT/src/api/users.js" <<'EOF'
+const USERS = Array.from({ length: 127 }, (_, i) => ({
+  id: i + 1,
+  name: `User ${i + 1}`,
+  email: `user${i + 1}@example.com`,
+}));
+
+export function listUsers() {
+  return USERS;
+}
+EOF
+
+echo "Setup complete: created src/api/users.js with 127 users and a listUsers() function."

package/.forge/worktrees/pipeline-e7f78b7a/scripts/bench/tasks/02-pagination/task.md

@@ -0,0 +1,48 @@
+# Task: Add Pagination to User List
+
+The file `src/api/users.js` currently has a `listUsers()` function that returns all users. Add pagination support.
+
+## Requirements
+
+Replace `listUsers()` (or add a new function) with a paginated version:
+
+```
+listUsers({ page = 1, pageSize = 20 } = {})
+```
+
+**Return format**:
+```js
+{
+  items: [...],       // users on the current page
+  total: 127,         // total number of users
+  page: 1,            // current page (1-indexed)
+  pageSize: 20,       // page size (after validation)
+  totalPages: 7,      // Math.ceil(total / pageSize)
+  hasNext: true,      // true if more pages exist
+  hasPrev: false      // true if page > 1
+}
+```
+
+## Validation Rules
+
+- `page` must be integer ≥ 1. If invalid (not a number, < 1, NaN, float), throw `RangeError`.
+- `pageSize` must be integer in [1, 100]. If invalid, throw `RangeError`.
+- If `page` exceeds available pages, return empty `items` array but still return correct `total`, `page`, `pageSize`, `totalPages`, `hasNext: false`, `hasPrev: true`.
+
+## Test File
+
+Also create `src/api/users.test.js` using `node:test` and `node:assert/strict` covering:
+- Default params return page 1 with 20 items
+- Page 2 returns items 21-40
+- Last page (page 7) returns items 121-127
+- Page 8 returns empty items but correct metadata
+- Custom pageSize (e.g., 50)
+- Invalid page (0, -1, 'abc', 1.5, NaN) throws RangeError
+- Invalid pageSize (0, 101, 'abc', 1.5) throws RangeError
+
+## Constraints
+
+- Keep ES module syntax
+- No external deps
+- Preserve the existing USERS array
+- Tests must pass via: `cd src && node --test api/users.test.js`

package/.forge/worktrees/pipeline-e7f78b7a/scripts/bench/tasks/02-pagination/validator.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+set -e
+PROJECT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+cd "$PROJECT/src"
+
+[ -f api/users.js ] || { echo "FAIL: api/users.js missing"; exit 1; }
+[ -f api/users.test.js ] || { echo "FAIL: api/users.test.js missing"; exit 1; }
+grep -q "export function listUsers\|export const listUsers\|export { listUsers" api/users.js || { echo "FAIL: listUsers not exported"; exit 1; }
+
+# Run agent's tests
+node --test api/users.test.js 2>&1 | tee /tmp/paginate-test-output.txt
+TEST_EXIT=${PIPESTATUS[0]}
+[ "$TEST_EXIT" = "0" ] || { echo "FAIL: agent tests failed"; exit 1; }
+
+# Independent smoke test
+node -e "
+import('./api/users.js').then(m => {
+  const assert = require('node:assert/strict');
+  // Default: page 1, 20 items
+  let r = m.listUsers();
+  assert.equal(r.items.length, 20, 'default pageSize 20');
+  assert.equal(r.items[0].id, 1);
+  assert.equal(r.total, 127);
+  assert.equal(r.page, 1);
+  assert.equal(r.pageSize, 20);
+  assert.equal(r.totalPages, 7);
+  assert.equal(r.hasNext, true);
+  assert.equal(r.hasPrev, false);
+
+  // Page 2
+  r = m.listUsers({ page: 2 });
+  assert.equal(r.items[0].id, 21);
+  assert.equal(r.items.length, 20);
+  assert.equal(r.hasPrev, true);
+
+  // Last page (127 / 20 = 6.35 → 7 pages; page 7 has 7 items)
+  r = m.listUsers({ page: 7 });
+  assert.equal(r.items.length, 7, 'last page has 7 items');
+  assert.equal(r.items[0].id, 121);
+  assert.equal(r.hasNext, false);
+
+  // Page 8 (beyond) — empty but correct metadata
+  r = m.listUsers({ page: 8 });
+  assert.equal(r.items.length, 0, 'page beyond: empty items');
+  assert.equal(r.total, 127);
+  assert.equal(r.totalPages, 7);
+  assert.equal(r.hasNext, false);
+
+  // Custom pageSize
+  r = m.listUsers({ page: 1, pageSize: 50 });
+  assert.equal(r.items.length, 50);
+  assert.equal(r.totalPages, 3);
+
+  // Invalid page
+  for (const p of [0, -1, 'abc', 1.5, NaN]) {
+    try { m.listUsers({ page: p }); assert.fail('expected RangeError for page=' + p); }
+    catch (e) { assert.ok(e instanceof RangeError, 'page=' + p + ' should throw RangeError, got: ' + e.constructor.name); }
+  }
+  // Invalid pageSize
+  for (const ps of [0, 101, 'abc', 1.5]) {
+    try { m.listUsers({ page: 1, pageSize: ps }); assert.fail('expected RangeError for pageSize=' + ps); }
+    catch (e) { assert.ok(e instanceof RangeError, 'pageSize=' + ps + ' should throw RangeError'); }
+  }
+  console.log('SMOKE_TEST_PASSED');
+}).catch(err => { console.error('SMOKE_TEST_FAILED:', err.message); process.exit(1); });
+" || { echo "FAIL: smoke test failed"; exit 1; }
+
+echo "PASS"
+exit 0

package/.forge/worktrees/pipeline-e7f78b7a/scripts/bench/tasks/03-bug-fix/setup.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# Create a date range calculator with 2 bugs.
+set -e
+PROJECT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+mkdir -p "$PROJECT/src/lib" "$PROJECT/src/lib/__tests__"
+
+cat > "$PROJECT/src/lib/dateRange.js" <<'EOF'
+// Compute the inclusive number of days between two YYYY-MM-DD dates.
+// Returns a positive integer. If end is before start, throws RangeError.
+export function daysBetween(startStr, endStr) {
+  if (typeof startStr !== 'string' || typeof endStr !== 'string') {
+    throw new TypeError('daysBetween expects two YYYY-MM-DD strings');
+  }
+  const start = new Date(startStr);
+  const end = new Date(endStr);
+  if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
+    throw new TypeError('invalid date format');
+  }
+  if (end < start) throw new RangeError('end before start');
+  // BUG: missing +1 to be inclusive of both endpoints
+  return Math.floor((end - start) / (1000 * 60 * 60 * 24));
+}
+
+// Return array of YYYY-MM-DD strings from start to end (inclusive).
+export function dateRange(startStr, endStr) {
+  const days = daysBetween(startStr, endStr);
+  const result = [];
+  const current = new Date(startStr);
+  // BUG: loop condition uses < instead of <=, excluding final day
+  for (let i = 0; i < days; i++) {
+    result.push(current.toISOString().slice(0, 10));
+    current.setDate(current.getDate() + 1);
+  }
+  return result;
+}
+EOF
+
+cat > "$PROJECT/src/lib/__tests__/dateRange.test.js" <<'EOF'
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { daysBetween, dateRange } from '../dateRange.js';
+
+test('daysBetween: same day returns 1', () => {
+  assert.equal(daysBetween('2026-01-01', '2026-01-01'), 1);
+});
+
+test('daysBetween: one day apart returns 2', () => {
+  assert.equal(daysBetween('2026-01-01', '2026-01-02'), 2);
+});
+
+test('daysBetween: one week', () => {
+  assert.equal(daysBetween('2026-01-01', '2026-01-07'), 7);
+});
+
+test('daysBetween: end before start throws RangeError', () => {
+  assert.throws(() => daysBetween('2026-01-05', '2026-01-01'), RangeError);
+});
+
+test('daysBetween: non-string throws TypeError', () => {
+  assert.throws(() => daysBetween(20260101, '2026-01-02'), TypeError);
+});
+
+test('dateRange: single day returns array with one date', () => {
+  assert.deepEqual(dateRange('2026-01-01', '2026-01-01'), ['2026-01-01']);
+});
+
+test('dateRange: three days', () => {
+  assert.deepEqual(
+    dateRange('2026-01-01', '2026-01-03'),
+    ['2026-01-01', '2026-01-02', '2026-01-03']
+  );
+});
+
+test('dateRange: includes both endpoints', () => {
+  const r = dateRange('2026-03-30', '2026-04-02');
+  assert.equal(r.length, 4);
+  assert.equal(r[0], '2026-03-30');
+  assert.equal(r[r.length - 1], '2026-04-02');
+});
+EOF
+
+echo "Setup complete: created src/lib/dateRange.js (with 2 bugs) and tests that currently fail."

package/.forge/worktrees/pipeline-e7f78b7a/scripts/bench/tasks/03-bug-fix/task.md

@@ -0,0 +1,30 @@
+# Task: Fix Bugs in dateRange Module
+
+The file `src/lib/dateRange.js` has 2 bugs. The existing test file `src/lib/__tests__/dateRange.test.js` describes the expected behavior.
+
+## Your job
+
+1. Run the existing tests — several will fail. Identify what's wrong.
+2. Fix both bugs in `src/lib/dateRange.js`.
+3. Do NOT modify the test file. The tests correctly express the expected behavior.
+4. Do NOT change the function signatures or add new functions.
+5. After fixing, all tests must pass.
+
+## Verify
+
+```bash
+cd src && node --test lib/__tests__/dateRange.test.js
+```
+
+All tests should pass.
+
+## Hints
+
+- `daysBetween('2026-01-01', '2026-01-01')` should return `1` (inclusive count)
+- `dateRange('2026-01-01', '2026-01-03')` should return all 3 days including both endpoints
+
+## Constraints
+
+- Minimal diff — fix only what's broken
+- Keep the functions pure
+- No new dependencies

package/.forge/worktrees/pipeline-e7f78b7a/scripts/bench/tasks/03-bug-fix/validator.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -e
+PROJECT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+cd "$PROJECT/src"
+
+[ -f lib/dateRange.js ] || { echo "FAIL: lib/dateRange.js missing (agent deleted it?)"; exit 1; }
+[ -f lib/__tests__/dateRange.test.js ] || { echo "FAIL: test file missing (agent deleted it?)"; exit 1; }
+
+# Run the existing (unmodified) tests
+node --test lib/__tests__/dateRange.test.js 2>&1 | tee /tmp/bugfix-test-output.txt
+TEST_EXIT=${PIPESTATUS[0]}
+[ "$TEST_EXIT" = "0" ] || { echo "FAIL: tests still failing after fix"; exit 1; }
+
+# Extra smoke: verify functions exist and behave
+node -e "
+import('./lib/dateRange.js').then(m => {
+  const assert = require('node:assert/strict');
+  assert.equal(m.daysBetween('2026-01-01', '2026-01-01'), 1);
+  assert.equal(m.daysBetween('2026-01-01', '2026-01-10'), 10);
+  const r = m.dateRange('2026-01-01', '2026-01-05');
+  assert.equal(r.length, 5, 'should include both endpoints');
+  assert.equal(r[0], '2026-01-01');
+  assert.equal(r[4], '2026-01-05');
+  console.log('SMOKE_TEST_PASSED');
+}).catch(err => { console.error('SMOKE_TEST_FAILED:', err.message); process.exit(1); });
+" || { echo "FAIL: smoke test failed"; exit 1; }
+
+echo "PASS"
+exit 0

package/.forge/worktrees/pipeline-e7f78b7a/scripts/verify-usage.ts

@@ -0,0 +1,178 @@
+/**
+ * Verification script — compares direct JSONL scanning with DB scanner results.
+ * Run: npx tsx scripts/verify-usage.ts
+ */
+
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+
+const CLAUDE_DIR = join(homedir(), '.claude', 'projects');
+
+const PRICING: Record<string, { input: number; output: number }> = {
+  'claude-opus-4': { input: 15, output: 75 },
+  'claude-sonnet-4': { input: 3, output: 15 },
+  'claude-haiku-4': { input: 0.80, output: 4 },
+  'default': { input: 3, output: 15 },
+};
+
+function getModelFamily(model: string): string {
+  if (!model) return 'unknown';
+  if (model.includes('opus')) return 'claude-opus-4';
+  if (model.includes('haiku')) return 'claude-haiku-4';
+  if (model.includes('sonnet')) return 'claude-sonnet-4';
+  return 'unknown';
+}
+
+function calcCost(family: string, input: number, output: number, cacheRead: number, cacheCreate: number): number {
+  const p = PRICING[family] || PRICING['default'];
+  return (
+    (input * p.input / 1_000_000) +
+    (output * p.output / 1_000_000) +
+    (cacheRead * p.input * 0.1 / 1_000_000) +
+    (cacheCreate * p.input * 0.25 / 1_000_000)
+  );
+}
+
+interface ProjectStats {
+  input: number; output: number; cost: number; sessions: number; messages: number;
+  cacheRead: number; cacheCreate: number;
+}
+
+interface ModelStats {
+  input: number; output: number; cost: number; messages: number;
+}
+
+interface DayStats {
+  input: number; output: number; cost: number;
+}
+
+const byProject: Record<string, ProjectStats> = {};
+const byModel: Record<string, ModelStats> = {};
+const byDay: Record<string, DayStats> = {};
+let totalInput = 0, totalOutput = 0, totalCost = 0, totalSessions = 0, totalMessages = 0;
+
+console.log('Scanning JSONL files...\n');
+
+const projectDirs = readdirSync(CLAUDE_DIR);
+let fileCount = 0;
+
+for (const projDir of projectDirs) {
+  const projPath = join(CLAUDE_DIR, projDir);
+  try { if (!statSync(projPath).isDirectory()) continue; } catch { continue; }
+
+  const projectName = projDir.replace(/^-/, '/').replace(/-/g, '/').split('/').pop() || projDir;
+  const files = readdirSync(projPath).filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'));
+
+  for (const file of files) {
+    const filePath = join(projPath, file);
+    fileCount++;
+    let sessionInput = 0, sessionOutput = 0, sessionCost = 0, sessionMsgs = 0;
+
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      for (const line of content.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === 'assistant' && obj.message?.usage) {
+            const u = obj.message.usage;
+            const model = obj.message.model || '';
+            const family = getModelFamily(model);
+            const input = u.input_tokens || 0;
+            const output = u.output_tokens || 0;
+            const cacheRead = u.cache_read_input_tokens || 0;
+            const cacheCreate = u.cache_creation_input_tokens || 0;
+            const cost = calcCost(family, input, output, cacheRead, cacheCreate);
+
+            sessionInput += input;
+            sessionOutput += output;
+            sessionCost += cost;
+            sessionMsgs++;
+
+            if (!byModel[family]) byModel[family] = { input: 0, output: 0, cost: 0, messages: 0 };
+            byModel[family].input += input;
+            byModel[family].output += output;
+            byModel[family].cost += cost;
+            byModel[family].messages++;
+
+            const day = (obj.timestamp || '').slice(0, 10) || 'unknown';
+            if (!byDay[day]) byDay[day] = { input: 0, output: 0, cost: 0 };
+            byDay[day].input += input;
+            byDay[day].output += output;
+            byDay[day].cost += cost;
+          }
+        } catch {}
+      }
+    } catch { continue; }
+
+    if (sessionMsgs > 0) {
+      totalSessions++;
+      totalMessages += sessionMsgs;
+      totalInput += sessionInput;
+      totalOutput += sessionOutput;
+      totalCost += sessionCost;
+
+      if (!byProject[projectName]) byProject[projectName] = { input: 0, output: 0, cost: 0, sessions: 0, messages: 0, cacheRead: 0, cacheCreate: 0 };
+      byProject[projectName].input += sessionInput;
+      byProject[projectName].output += sessionOutput;
+      byProject[projectName].cost += sessionCost;
+      byProject[projectName].sessions++;
+      byProject[projectName].messages += sessionMsgs;
+    }
+  }
+}
+
+// Now run the DB scanner and compare
+console.log('Running DB scanner...\n');
+
+// Set up environment for the scanner
+process.env.FORGE_DATA_DIR = process.env.FORGE_DATA_DIR || join(homedir(), '.forge', 'data');
+
+// Dynamic import to use the actual scanner
+const { scanUsage, queryUsage } = await import('../lib/usage-scanner');
+
+const scanResult = scanUsage();
+console.log(`Scan result: ${scanResult.scanned} files scanned, ${scanResult.updated} updated, ${scanResult.errors} errors\n`);
+
+const dbData = queryUsage({});
+
+// Compare
+console.log('=== COMPARISON ===\n');
+
+console.log('TOTAL:');
+console.log(`  Direct:  ${(totalInput/1000).toFixed(0)}K in, ${(totalOutput/1000).toFixed(0)}K out, $${totalCost.toFixed(2)}, ${totalSessions} sessions, ${totalMessages} msgs`);
+console.log(`  DB:      ${(dbData.total.input/1000).toFixed(0)}K in, ${(dbData.total.output/1000).toFixed(0)}K out, $${dbData.total.cost.toFixed(2)}, ${dbData.total.sessions} sessions, ${dbData.total.messages} msgs`);
+
+const costDiff = Math.abs(totalCost - dbData.total.cost);
+const costMatch = costDiff < 0.1;
+console.log(`  Match:   ${costMatch ? '✅' : '❌'} (diff: $${costDiff.toFixed(2)})\n`);
+
+console.log('BY MODEL:');
+for (const [model, d] of Object.entries(byModel).sort((a, b) => b[1].cost - a[1].cost)) {
+  const dbModel = dbData.byModel.find(m => m.model === model);
+  const dbCost = dbModel?.cost || 0;
+  const match = Math.abs(d.cost - dbCost) < 0.1;
+  console.log(`  ${model.padEnd(20)} Direct: $${d.cost.toFixed(2).padStart(8)}  DB: $${dbCost.toFixed(2).padStart(8)}  ${match ? '✅' : '❌'}`);
+}
+
+console.log('\nBY PROJECT (top 10):');
+const sortedProjects = Object.entries(byProject).sort((a, b) => b[1].cost - a[1].cost).slice(0, 10);
+for (const [name, d] of sortedProjects) {
+  const dbProj = dbData.byProject.find(p => p.name === name);
+  const dbCost = dbProj?.cost || 0;
+  const match = Math.abs(d.cost - dbCost) < 0.1;
+  console.log(`  ${name.padEnd(25)} Direct: $${d.cost.toFixed(2).padStart(8)}  DB: $${dbCost.toFixed(2).padStart(8)}  ${match ? '✅' : '❌'}`);
+}
+
+console.log('\nBY DAY (last 7):');
+const sortedDays = Object.entries(byDay).filter(([d]) => d !== 'unknown').sort((a, b) => b[0].localeCompare(a[0])).slice(0, 7);
+for (const [day, d] of sortedDays) {
+  const dbDay = dbData.byDay.find(dd => dd.date === day);
+  const dbCost = dbDay?.cost || 0;
+  const match = Math.abs(d.cost - dbCost) < 0.1;
+  console.log(`  ${day}  Direct: $${d.cost.toFixed(2).padStart(8)}  DB: $${dbCost.toFixed(2).padStart(8)}  ${match ? '✅' : '❌'}`);
+}
+
+console.log(`\nFiles scanned: ${fileCount}`);
+console.log('');

package/.forge/worktrees/pipeline-e7f78b7a/src/config/index.ts

@@ -0,0 +1,129 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import type { AppConfig, ProviderName, SessionTemplate } from '@/src/types';
+import { getConfigDir as _getConfigDir, getDataDir as _getDataDir } from '@/lib/dirs';
+
+const CONFIG_DIR = _getConfigDir();
+const CONFIG_FILE = join(CONFIG_DIR, 'config.yaml');
+const TEMPLATES_DIR = join(CONFIG_DIR, 'templates');
+
+export function getConfigDir(): string {
+  return CONFIG_DIR;
+}
+
+export function getDataDir(): string {
+  return _getDataDir();
+}
+
+export function getDbPath(): string {
+  return join(getDataDir(), 'workflow.db');
+}
+
+export function ensureDirs() {
+  for (const dir of [CONFIG_DIR, getDataDir()]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+export function loadConfig(): AppConfig {
+  ensureDirs();
+
+  if (!existsSync(CONFIG_FILE)) {
+    // Don't auto-create config.yaml — return defaults in memory only
+    return getDefaultConfig();
+  }
+
+  const raw = readFileSync(CONFIG_FILE, 'utf-8');
+  return YAML.parse(raw) as AppConfig;
+}
+
+export function saveConfig(config: AppConfig) {
+  ensureDirs();
+  writeFileSync(CONFIG_FILE, YAML.stringify(config), 'utf-8');
+}
+
+export function loadTemplate(templateId: string): SessionTemplate | null {
+  const filePath = join(TEMPLATES_DIR, `${templateId}.yaml`);
+  if (!existsSync(filePath)) return null;
+  const raw = readFileSync(filePath, 'utf-8');
+  return YAML.parse(raw) as SessionTemplate;
+}
+
+export function loadAllTemplates(): SessionTemplate[] {
+  ensureDirs();
+  const files = readdirSync(TEMPLATES_DIR).filter(f => f.endsWith('.yaml'));
+  return files.map(f => {
+    const raw = readFileSync(join(TEMPLATES_DIR, f), 'utf-8');
+    return YAML.parse(raw) as SessionTemplate;
+  });
+}
+
+export function saveTemplate(template: SessionTemplate) {
+  ensureDirs();
+  const filePath = join(TEMPLATES_DIR, `${template.id}.yaml`);
+  writeFileSync(filePath, YAML.stringify(template), 'utf-8');
+}
+
+function getDefaultConfig(): AppConfig {
+  return {
+    dataDir: getDataDir(),
+    providers: {
+      anthropic: {
+        name: 'anthropic',
+        displayName: 'Claude',
+        defaultModel: 'claude-sonnet-4-6',
+        models: ['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001'],
+        enabled: true,
+      },
+      google: {
+        name: 'google',
+        displayName: 'Gemini',
+        defaultModel: 'gemini-2.0-flash',
+        models: ['gemini-2.5-pro', 'gemini-2.0-flash', 'gemini-2.0-flash-lite'],
+        enabled: true,
+      },
+      openai: {
+        name: 'openai',
+        displayName: 'OpenAI',
+        defaultModel: 'gpt-4o-mini',
+        models: ['gpt-4o', 'gpt-4o-mini', 'o3-mini'],
+        enabled: false,
+      },
+      grok: {
+        name: 'grok',
+        displayName: 'Grok',
+        defaultModel: 'grok-3-mini-fast',
+        models: ['grok-3', 'grok-3-mini-fast'],
+        enabled: false,
+      },
+    },
+    server: {
+      host: '0.0.0.0',
+      port: 8403,
+    },
+  };
+}
+
+export function getProviderApiKey(provider: ProviderName, profileApiKey?: string): string | undefined {
+  // Priority: profile-level key > settings provider key > env var
+  if (profileApiKey) return profileApiKey;
+
+  try {
+    const { loadSettings } = require('@/lib/settings');
+    const settings = loadSettings();
+    if (settings.providers?.[provider]?.apiKey) {
+      return settings.providers[provider].apiKey;
+    }
+  } catch {}
+
+  const envMap: Record<ProviderName, string> = {
+    anthropic: 'ANTHROPIC_API_KEY',
+    google: 'GOOGLE_GENERATIVE_AI_API_KEY',
+    openai: 'OPENAI_API_KEY',
+    grok: 'XAI_API_KEY',
+  };
+  return process.env[envMap[provider]];
+}