@staff0rd/assist 0.208.0 → 0.209.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.208.0",
+  version: "0.209.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -96,7 +96,7 @@ var package_default = {
 };
 
 // src/commands/backlog/next.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import enquirer2 from "enquirer";
 
 // src/shared/exitOnCancel.ts
@@ -112,13 +112,276 @@ async function exitOnCancel(promise) {
 }
 
 // src/commands/backlog/acquireLock.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6 } from "path";
 
 // src/commands/backlog/shared.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+import chalk2 from "chalk";
+
+// src/shared/loadConfig.ts
+import { existsSync as existsSync2, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
 import chalk from "chalk";
+import { stringify as stringifyYaml } from "yaml";
+
+// src/shared/loadRawYaml.ts
+import { existsSync, readFileSync } from "fs";
+import { parse as parseYaml } from "yaml";
+function loadRawYaml(path53) {
+  if (!existsSync(path53)) return {};
+  try {
+    const content = readFileSync(path53, "utf-8");
+    return parseYaml(content) || {};
+  } catch {
+    return {};
+  }
+}
+
+// src/shared/mergeDenyRules.ts
+function mergeDenyRules(globalDeny, projectDeny) {
+  if (!globalDeny && !projectDeny) return void 0;
+  if (!globalDeny) return projectDeny;
+  if (!projectDeny) return globalDeny;
+  const projectPatterns = new Set(projectDeny.map((r) => r.pattern));
+  const globalOnly = globalDeny.filter((r) => !projectPatterns.has(r.pattern));
+  return [...globalOnly, ...projectDeny];
+}
+function mergeRawConfigs(globalRaw, projectRaw) {
+  const deny = mergeDenyRules(
+    globalRaw.deny,
+    projectRaw.deny
+  );
+  const merged = { ...globalRaw, ...projectRaw };
+  if (deny !== void 0) {
+    merged.deny = deny;
+  }
+  return merged;
+}
+
+// src/shared/types.ts
+import { z as z2 } from "zod";
+
+// src/shared/runConfigSchema.ts
+import { z } from "zod";
+var runParamSchema = z.strictObject({
+  name: z.string(),
+  required: z.boolean().optional(),
+  default: z.string().optional(),
+  description: z.string().optional()
+});
+var runConfigSchema = z.strictObject({
+  name: z.string(),
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  params: z.array(runParamSchema).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  filter: z.string().optional(),
+  pre: z.array(z.string()).optional(),
+  cwd: z.string().optional()
+});
+var runLinkSchema = z.strictObject({
+  link: z.string(),
+  prefix: z.string()
+});
+
+// src/shared/types.ts
+var transcriptConfigSchema = z2.strictObject({
+  vttDir: z2.string(),
+  transcriptsDir: z2.string(),
+  summaryDir: z2.string()
+});
+var DEFAULT_WAKE_WORDS = ["computer"];
+var DEFAULT_MODELS_DIR = "~/.assist/voice/models";
+var assistConfigSchema = z2.strictObject({
+  commit: z2.strictObject({
+    conventional: z2.boolean().default(false),
+    pull: z2.boolean().default(false),
+    push: z2.boolean().default(false)
+  }).default({ conventional: false, pull: false, push: false }),
+  devlog: z2.strictObject({
+    name: z2.string().optional(),
+    ignore: z2.array(z2.string()).optional(),
+    skip: z2.record(z2.string(), z2.array(z2.string())).optional()
+  }).optional(),
+  notify: z2.strictObject({
+    enabled: z2.boolean().default(true)
+  }).default({ enabled: true }),
+  complexity: z2.strictObject({
+    ignore: z2.array(z2.string()).default(["**/*test.ts*"])
+  }).default({ ignore: ["**/*test.ts*"] }),
+  hardcodedColors: z2.strictObject({
+    ignore: z2.array(z2.string()).default([])
+  }).optional(),
+  restructure: z2.strictObject({
+    ignore: z2.array(z2.string()).default([])
+  }).optional(),
+  jira: z2.strictObject({
+    acField: z2.string().default("customfield_11937")
+  }).optional(),
+  roam: z2.strictObject({
+    clientId: z2.string(),
+    clientSecret: z2.string(),
+    accessToken: z2.string().optional(),
+    refreshToken: z2.string().optional(),
+    tokenExpiresAt: z2.number().optional()
+  }).optional(),
+  run: z2.array(z2.union([runConfigSchema, runLinkSchema])).optional(),
+  transcript: transcriptConfigSchema.optional(),
+  cliReadVerbs: z2.record(z2.string(), z2.array(z2.string())).optional(),
+  news: z2.strictObject({
+    feeds: z2.array(z2.string()).default([])
+  }).default({ feeds: [] }),
+  dotnet: z2.strictObject({
+    inspect: z2.strictObject({
+      suppress: z2.array(z2.string()).default([])
+    }).default({ suppress: [] })
+  }).optional(),
+  ravendb: z2.strictObject({
+    connections: z2.array(
+      z2.strictObject({
+        name: z2.string(),
+        url: z2.string(),
+        database: z2.string(),
+        apiKeyRef: z2.string()
+      })
+    ).default([]),
+    defaultConnection: z2.string().optional()
+  }).optional(),
+  seq: z2.strictObject({
+    connections: z2.array(
+      z2.strictObject({
+        name: z2.string(),
+        url: z2.string(),
+        apiToken: z2.string()
+      })
+    ).default([]),
+    defaultConnection: z2.string().optional()
+  }).optional(),
+  sql: z2.strictObject({
+    connections: z2.array(
+      z2.strictObject({
+        name: z2.string(),
+        server: z2.string(),
+        port: z2.number(),
+        user: z2.string(),
+        password: z2.string(),
+        database: z2.string()
+      })
+    ).default([]),
+    defaultConnection: z2.string().optional()
+  }).optional(),
+  screenshot: z2.strictObject({
+    outputDir: z2.string().default("./screenshots")
+  }).default({ outputDir: "./screenshots" }),
+  backlog: z2.strictObject({
+    autoCommit: z2.boolean().default(false)
+  }).default({ autoCommit: false }),
+  mermaid: z2.strictObject({
+    krokiUrl: z2.string().default("https://kroki.io")
+  }).default({ krokiUrl: "https://kroki.io" }),
+  deny: z2.array(
+    z2.strictObject({
+      pattern: z2.string(),
+      message: z2.string()
+    })
+  ).optional(),
+  sync: z2.strictObject({
+    autoConfirm: z2.boolean().default(false)
+  }).default({ autoConfirm: false }),
+  voice: z2.strictObject({
+    wakeWords: z2.array(z2.string()).default(DEFAULT_WAKE_WORDS),
+    mic: z2.string().optional(),
+    cwd: z2.string().optional(),
+    modelsDir: z2.string().default(DEFAULT_MODELS_DIR),
+    lockDir: z2.string().optional(),
+    submitWindows: z2.array(z2.string()).optional(),
+    models: z2.strictObject({
+      vad: z2.string().optional(),
+      smartTurn: z2.string().optional()
+    }).default({})
+  }).default({
+    wakeWords: DEFAULT_WAKE_WORDS,
+    modelsDir: DEFAULT_MODELS_DIR,
+    models: {}
+  })
+});
+function isRunLink(entry) {
+  return "link" in entry;
+}
+
+// src/shared/loadConfig.ts
+function findConfigUp(startDir) {
+  let current = startDir;
+  while (current !== dirname(current)) {
+    const claudePath = join(current, ".claude", "assist.yml");
+    if (existsSync2(claudePath))
+      return { configPath: claudePath, rootDir: current };
+    const rootPath = join(current, "assist.yml");
+    if (existsSync2(rootPath)) return { configPath: rootPath, rootDir: current };
+    current = dirname(current);
+  }
+  return null;
+}
+function getConfigPath() {
+  const found = findConfigUp(process.cwd());
+  if (found) return found.configPath;
+  return join(process.cwd(), "assist.yml");
+}
+function getGlobalConfigPath() {
+  return join(homedir(), ".assist.yml");
+}
+function getConfigDir() {
+  return dirname(getConfigPath());
+}
+function getProjectRoot() {
+  const found = findConfigUp(process.cwd());
+  return found?.rootDir ?? process.cwd();
+}
+function loadConfig() {
+  const globalRaw = loadRawYaml(getGlobalConfigPath());
+  const projectRaw = loadRawYaml(getConfigPath());
+  const merged = mergeRawConfigs(globalRaw, projectRaw);
+  return assistConfigSchema.parse(merged);
+}
+function loadConfigFrom(startDir) {
+  const found = findConfigUp(startDir);
+  const configPath = found?.configPath ?? join(startDir, "assist.yml");
+  const globalRaw = loadRawYaml(getGlobalConfigPath());
+  const projectRaw = loadRawYaml(configPath);
+  const merged = mergeRawConfigs(globalRaw, projectRaw);
+  return {
+    config: assistConfigSchema.parse(merged),
+    configDir: dirname(configPath)
+  };
+}
+function loadProjectConfig() {
+  return loadRawYaml(getConfigPath());
+}
+function loadGlobalConfigRaw() {
+  return loadRawYaml(getGlobalConfigPath());
+}
+function saveGlobalConfig(config) {
+  writeFileSync(getGlobalConfigPath(), stringifyYaml(config, { lineWidth: 0 }));
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  writeFileSync(configPath, stringifyYaml(config, { lineWidth: 0 }));
+}
+function getTranscriptConfig() {
+  const config = loadConfig();
+  if (!config.transcript) {
+    console.error(
+      chalk.red(
+        "Transcript directories not configured. Run 'assist transcript configure' first."
+      )
+    );
+    process.exit(1);
+  }
+  return config.transcript;
+}
 
 // src/commands/backlog/deleteItemRelations.ts
 function deleteItemRelations(db, itemId) {
@@ -139,8 +402,8 @@ function deleteItem(db, id) {
 }
 
 // src/commands/backlog/exportToJsonl.ts
-import { statSync, writeFileSync } from "fs";
-import { join } from "path";
+import { statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
 
 // src/commands/backlog/loadComments.ts
 function loadComments(db, itemId) {
@@ -210,13 +473,13 @@ function loadAllItems(db) {
 
 // src/commands/backlog/exportToJsonl.ts
 function getJsonlPath(dir) {
-  return join(dir, ".assist", "backlog.jsonl");
+  return join2(dir, ".assist", "backlog.jsonl");
 }
 function exportToJsonl(db, dir) {
   const jsonlPath = getJsonlPath(dir);
   const items = loadAllItems(db);
   const lines = items.map((item) => JSON.stringify(item));
-  writeFileSync(jsonlPath, lines.length > 0 ? `${lines.join("\n")}
+  writeFileSync2(jsonlPath, lines.length > 0 ? `${lines.join("\n")}
 ` : "");
   const mtimeMs = statSync(jsonlPath).mtimeMs;
   db.prepare(
@@ -225,7 +488,7 @@ function exportToJsonl(db, dir) {
 }
 
 // src/commands/backlog/importFromJsonlIfNeeded.ts
-import { readFileSync, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
 
 // src/commands/backlog/insertItemRelations.ts
 function insertComments(db, item) {
@@ -332,43 +595,43 @@ function saveAllItems(db, items) {
 }
 
 // src/commands/backlog/types.ts
-import { z } from "zod";
-var backlogStatusSchema = z.enum(["todo", "in-progress", "done", "wontdo"]);
-var backlogTypeSchema = z.enum(["story", "bug"]);
-var planTaskSchema = z.object({
-  task: z.string()
+import { z as z3 } from "zod";
+var backlogStatusSchema = z3.enum(["todo", "in-progress", "done", "wontdo"]);
+var backlogTypeSchema = z3.enum(["story", "bug"]);
+var planTaskSchema = z3.object({
+  task: z3.string()
 }).strip();
-var planPhaseSchema = z.strictObject({
-  name: z.string(),
-  tasks: z.array(planTaskSchema),
-  manualChecks: z.array(z.string()).optional()
+var planPhaseSchema = z3.strictObject({
+  name: z3.string(),
+  tasks: z3.array(planTaskSchema),
+  manualChecks: z3.array(z3.string()).optional()
 });
-var backlogCommentTypeSchema = z.enum(["comment", "summary"]);
-var backlogCommentSchema = z.strictObject({
-  id: z.number().optional(),
-  text: z.string(),
-  phase: z.number().optional(),
-  timestamp: z.string(),
+var backlogCommentTypeSchema = z3.enum(["comment", "summary"]);
+var backlogCommentSchema = z3.strictObject({
+  id: z3.number().optional(),
+  text: z3.string(),
+  phase: z3.number().optional(),
+  timestamp: z3.string(),
   type: backlogCommentTypeSchema
 });
-var backlogLinkTypeSchema = z.enum(["relates-to", "depends-on"]);
-var backlogLinkSchema = z.strictObject({
+var backlogLinkTypeSchema = z3.enum(["relates-to", "depends-on"]);
+var backlogLinkSchema = z3.strictObject({
   type: backlogLinkTypeSchema,
-  targetId: z.number()
+  targetId: z3.number()
 });
-var backlogItemSchema = z.strictObject({
-  id: z.number(),
+var backlogItemSchema = z3.strictObject({
+  id: z3.number(),
   type: backlogTypeSchema.default("story"),
-  name: z.string(),
-  description: z.string().optional(),
-  acceptanceCriteria: z.array(z.string()),
-  plan: z.array(planPhaseSchema).optional(),
-  currentPhase: z.number().optional(),
+  name: z3.string(),
+  description: z3.string().optional(),
+  acceptanceCriteria: z3.array(z3.string()),
+  plan: z3.array(planPhaseSchema).optional(),
+  currentPhase: z3.number().optional(),
   status: backlogStatusSchema,
-  comments: z.array(backlogCommentSchema).optional(),
-  links: z.array(backlogLinkSchema).optional()
+  comments: z3.array(backlogCommentSchema).optional(),
+  links: z3.array(backlogLinkSchema).optional()
 });
-var backlogFileSchema = z.array(backlogItemSchema);
+var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/importFromJsonlIfNeeded.ts
 function getLastImportMs(db) {
@@ -391,7 +654,7 @@ function importFromJsonlIfNeeded(db, dir) {
   const fileMtimeMs = stat.mtimeMs;
   const lastImportMs = getLastImportMs(db);
   if (fileMtimeMs <= lastImportMs) return;
-  const content = readFileSync(jsonlPath, "utf-8").trim();
+  const content = readFileSync2(jsonlPath, "utf-8").trim();
   if (content.length === 0) {
     setLastImportMs(db, fileMtimeMs);
     return;
@@ -405,14 +668,14 @@ function importFromJsonlIfNeeded(db, dir) {
 }
 
 // src/commands/backlog/migrateYamlIfNeeded.ts
-import { existsSync, readFileSync as readFileSync2, renameSync } from "fs";
-import { parse as parseYaml } from "yaml";
+import { existsSync as existsSync3, readFileSync as readFileSync3, renameSync } from "fs";
+import { parse as parseYaml2 } from "yaml";
 function migrateYamlIfNeeded(db, yamlPath) {
-  if (!existsSync(yamlPath)) return false;
+  if (!existsSync3(yamlPath)) return false;
   const existing = db.prepare("SELECT COUNT(*) as count FROM items").get();
   if (existing.count > 0) return false;
-  const content = readFileSync2(yamlPath, "utf-8");
-  const raw = parseYaml(content) || [];
+  const content = readFileSync3(yamlPath, "utf-8");
+  const raw = parseYaml2(content) || [];
   const items = backlogFileSchema.parse(raw);
   if (items.length > 0) {
     saveAllItems(db, items);
@@ -424,21 +687,21 @@ function migrateYamlIfNeeded(db, yamlPath) {
 
 // src/commands/backlog/openDb.ts
 import { mkdirSync } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import Database from "better-sqlite3";
 
 // src/commands/backlog/ensureGitignore.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
 var gitignoreEntries = [".assist-*", ".assist/*.db*"];
 function ensureGitignore(dir) {
-  const gitignorePath = join2(dir, ".gitignore");
-  const existing = existsSync2(gitignorePath) ? readFileSync3(gitignorePath, "utf-8") : "";
+  const gitignorePath = join3(dir, ".gitignore");
+  const existing = existsSync4(gitignorePath) ? readFileSync4(gitignorePath, "utf-8") : "";
   const lines = existing.split(/\r?\n/);
   const missing = gitignoreEntries.filter((entry) => !lines.includes(entry));
   if (missing.length === 0) return;
   const suffix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-  writeFileSync2(gitignorePath, `${existing}${suffix}${missing.join("\n")}
+  writeFileSync3(gitignorePath, `${existing}${suffix}${missing.join("\n")}
 `);
 }
 
@@ -478,7 +741,7 @@ function migrateToOneBasedPhases(db) {
 // src/commands/backlog/openDb.ts
 var _db;
 function getDbPath(dir) {
-  return join3(dir, ".assist", "backlog.db");
+  return join4(dir, ".assist", "backlog.db");
 }
 function initSchema(db) {
   db.exec(`
@@ -535,7 +798,7 @@ function initSchema(db) {
 function openDb(dir) {
   if (_db) return _db;
   const dbPath = getDbPath(dir);
-  mkdirSync(join3(dir, ".assist"), { recursive: true });
+  mkdirSync(join4(dir, ".assist"), { recursive: true });
   const db = new Database(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
@@ -584,14 +847,14 @@ function setBacklogDir(dir) {
   _backlogDir = dir;
 }
 function getBacklogDir() {
-  return _backlogDir ?? process.cwd();
+  return _backlogDir ?? getProjectRoot();
 }
 function getBacklogPath() {
-  return join4(getBacklogDir(), "assist.backlog.yml");
+  return join5(getBacklogDir(), "assist.backlog.yml");
 }
 function backlogExists() {
   const dir = getBacklogDir();
-  return existsSync3(join4(dir, ".assist", "backlog.db")) || existsSync3(join4(dir, ".assist", "backlog.jsonl")) || existsSync3(join4(dir, "assist.backlog.yml"));
+  return existsSync5(join5(dir, ".assist", "backlog.db")) || existsSync5(join5(dir, ".assist", "backlog.jsonl")) || existsSync5(join5(dir, "assist.backlog.yml"));
 }
 function getDb() {
   const dir = getBacklogDir();
@@ -624,7 +887,7 @@ function loadAndFindItem(id) {
   const items = loadBacklog();
   const item = findItem(items, Number.parseInt(id, 10));
   if (!item) {
-    console.log(chalk.red(`Item #${id} not found.`));
+    console.log(chalk2.red(`Item #${id} not found.`));
     return void 0;
   }
   return { items, item };
@@ -652,14 +915,10 @@ function removeItem(id) {
   exportToJsonl(db, getBacklogDir());
   return result.item.name;
 }
-function getNextId(items) {
-  if (items.length === 0) return 1;
-  return Math.max(...items.map((item) => item.id)) + 1;
-}
 
 // src/commands/backlog/acquireLock.ts
 function getLockPath(itemId) {
-  return join5(getBacklogDir(), `.assist-lock-${itemId}.json`);
+  return join6(getBacklogDir(), `.assist-lock-${itemId}.json`);
 }
 function isProcessAlive(pid) {
   try {
@@ -671,9 +930,9 @@ function isProcessAlive(pid) {
 }
 function isLockedByOther(itemId) {
   const lockPath = getLockPath(itemId);
-  if (!existsSync4(lockPath)) return false;
+  if (!existsSync6(lockPath)) return false;
   try {
-    const lock = JSON.parse(readFileSync4(lockPath, "utf-8"));
+    const lock = JSON.parse(readFileSync5(lockPath, "utf-8"));
     if (lock.pid === process.pid) return false;
     return isProcessAlive(lock.pid);
   } catch {
@@ -681,7 +940,7 @@ function isLockedByOther(itemId) {
   }
 }
 function acquireLock(itemId) {
-  writeFileSync3(
+  writeFileSync4(
     getLockPath(itemId),
     JSON.stringify({ pid: process.pid, timestamp: (/* @__PURE__ */ new Date()).toISOString() })
   );
@@ -695,30 +954,30 @@ function releaseLock(itemId) {
 }
 
 // src/commands/backlog/list/shared.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 function statusIcon(status2) {
   switch (status2) {
     case "todo":
-      return chalk2.dim("[ ]");
+      return chalk3.dim("[ ]");
     case "in-progress":
-      return chalk2.yellow("[~]");
+      return chalk3.yellow("[~]");
     case "done":
-      return chalk2.green("[x]");
+      return chalk3.green("[x]");
     case "wontdo":
-      return chalk2.dim("[-]");
+      return chalk3.dim("[-]");
   }
 }
 function typeLabel(type) {
   switch (type) {
     case "bug":
-      return chalk2.magenta("Bug");
+      return chalk3.magenta("Bug");
     case "story":
-      return chalk2.cyan("Story");
+      return chalk3.cyan("Story");
   }
 }
 function phaseLabel(item) {
   if (!item.plan) return "";
-  return chalk2.dim(` (phase ${item.currentPhase ?? 1}/${item.plan.length})`);
+  return chalk3.dim(` (phase ${item.currentPhase ?? 1}/${item.plan.length})`);
 }
 function isBlocked(item, items) {
   const deps2 = (item.links ?? []).filter((l) => l.type === "depends-on");
@@ -730,15 +989,15 @@ function isBlocked(item, items) {
 function dependencyLabel(item, items) {
   const deps2 = (item.links ?? []).filter((l) => l.type === "depends-on");
   if (deps2.length === 0) return "";
-  if (isBlocked(item, items)) return chalk2.red(" [blocked]");
-  return chalk2.dim(` [${deps2.length} dep${deps2.length > 1 ? "s" : ""}]`);
+  if (isBlocked(item, items)) return chalk3.red(" [blocked]");
+  return chalk3.dim(` [${deps2.length} dep${deps2.length > 1 ? "s" : ""}]`);
 }
 function printVerboseDetails(item) {
   if (item.description) {
-    console.log(`  ${chalk2.dim("Description:")} ${item.description}`);
+    console.log(`  ${chalk3.dim("Description:")} ${item.description}`);
   }
   if (item.acceptanceCriteria.length > 0) {
-    console.log(`  ${chalk2.dim("Acceptance criteria:")}`);
+    console.log(`  ${chalk3.dim("Acceptance criteria:")}`);
     for (const [i, criterion] of item.acceptanceCriteria.entries()) {
       console.log(`    ${i + 1}. ${criterion}`);
     }
@@ -754,17 +1013,17 @@ function findResumable(items) {
 }
 
 // src/commands/backlog/findUnblockedTodos.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 function findUnblockedTodos(items) {
   const todo = items.filter((i) => i.status === "todo");
   if (todo.length === 0) {
-    console.log(chalk3.green("All backlog items complete."));
+    console.log(chalk4.green("All backlog items complete."));
     return void 0;
   }
   const unblocked = todo.filter((i) => !isBlocked(i, items));
   if (unblocked.length === 0) {
     console.log(
-      chalk3.yellow("All remaining todo items are blocked by dependencies.")
+      chalk4.yellow("All remaining todo items are blocked by dependencies.")
     );
     return void 0;
   }
@@ -772,7 +1031,7 @@ function findUnblockedTodos(items) {
 }
 
 // src/commands/backlog/run.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 
 // src/commands/backlog/buildCommentLines.ts
 function buildCommentLines(comments2) {
@@ -891,11 +1150,11 @@ function buildReviewPhase() {
 }
 
 // src/commands/backlog/executePhase.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 
 // src/commands/backlog/resolvePhaseResult.ts
-import { existsSync as existsSync6, unlinkSync as unlinkSync2 } from "fs";
-import chalk4 from "chalk";
+import { existsSync as existsSync8, unlinkSync as unlinkSync2 } from "fs";
+import chalk5 from "chalk";
 
 // src/commands/backlog/handleIncompletePhase.ts
 import enquirer from "enquirer";
@@ -914,28 +1173,28 @@ async function handleIncompletePhase() {
 }
 
 // src/commands/backlog/readSignal.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 
 // src/commands/backlog/writeSignal.ts
-import { writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
 function getSignalPath() {
   const sessionId = process.env.ASSIST_SESSION_ID;
   const filename = sessionId ? `.assist-signal-${sessionId}.json` : ".assist-signal.json";
-  return join6(getBacklogDir(), filename);
+  return join7(getBacklogDir(), filename);
 }
 function writeSignal(event, data) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   const signal = { event, ...sessionId && { sessionId }, ...data };
-  writeFileSync4(getSignalPath(), JSON.stringify(signal));
+  writeFileSync5(getSignalPath(), JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
   const path53 = getSignalPath();
-  if (!existsSync5(path53)) return void 0;
+  if (!existsSync7(path53)) return void 0;
   try {
-    return JSON.parse(readFileSync5(path53, "utf-8"));
+    return JSON.parse(readFileSync6(path53, "utf-8"));
   } catch {
     return void 0;
   }
@@ -944,7 +1203,7 @@ function readSignal() {
 // src/commands/backlog/resolvePhaseResult.ts
 function cleanupSignal() {
   const statusPath = getSignalPath();
-  if (existsSync6(statusPath)) {
+  if (existsSync8(statusPath)) {
     unlinkSync2(statusPath);
   }
 }
@@ -954,7 +1213,7 @@ function isTerminalStatus(itemId) {
   return item?.status === "done" || item?.status === "wontdo";
 }
 async function resolvePhaseResult(phaseIndex, itemId) {
-  if (!existsSync6(getSignalPath())) {
+  if (!existsSync8(getSignalPath())) {
     if (isTerminalStatus(itemId)) return -1;
     const action = await handleIncompletePhase();
     if (action === "abort") return -1;
@@ -965,12 +1224,12 @@ async function resolvePhaseResult(phaseIndex, itemId) {
   if (signal?.event === "rewind") {
     const targetPhase = signal.targetPhase;
     const targetPhaseNumber = targetPhase + 1;
-    console.log(chalk4.yellow(`
+    console.log(chalk5.yellow(`
 Rewinding to phase ${targetPhaseNumber}.`));
     return targetPhase;
   }
   const phaseNumber = phaseIndex + 1;
-  console.log(chalk4.green(`
+  console.log(chalk5.green(`
 Phase ${phaseNumber} completed.`));
   return phaseIndex + 1;
 }
@@ -993,11 +1252,11 @@ function spawnClaude(prompt, options2 = {}) {
 }
 
 // src/commands/backlog/watchForMarker.ts
-import { existsSync as existsSync7, unwatchFile, watchFile } from "fs";
+import { existsSync as existsSync9, unwatchFile, watchFile } from "fs";
 function watchForMarker(child) {
   const statusPath = getSignalPath();
   watchFile(statusPath, { interval: 1e3 }, () => {
-    if (!existsSync7(statusPath)) return;
+    if (!existsSync9(statusPath)) return;
     const signal = readSignal();
     if (signal) {
       unwatchFile(statusPath);
@@ -1014,7 +1273,7 @@ async function executePhase(item, phaseIndex, phases, spawnOptions) {
   const phase = phases[phaseIndex];
   const phaseNumber = phaseIndex + 1;
   console.log(
-    chalk5.bold(
+    chalk6.bold(
       `
 --- Phase ${phaseNumber}/${phases.length}: ${phase.name} ---
 `
@@ -1032,7 +1291,7 @@ async function executePhase(item, phaseIndex, phases, spawnOptions) {
 }
 
 // src/commands/backlog/prepareRun.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/commands/backlog/resolvePlan.ts
 function resolvePlan(item) {
@@ -1055,13 +1314,13 @@ function prepareRun(id) {
   const plan2 = resolvePlan(item);
   const startPhase = (item.currentPhase ?? 1) - 1;
   if (item.status === "done") {
-    console.log(chalk6.green(`Already done: #${id}: ${item.name}`));
+    console.log(chalk7.green(`Already done: #${id}: ${item.name}`));
     return void 0;
   }
   if (startPhase > plan2.length) {
     setStatus(id, "done");
     console.log(
-      chalk6.green(`All phases already complete for #${id}: ${item.name}`)
+      chalk7.green(`All phases already complete for #${id}: ${item.name}`)
     );
     return void 0;
   }
@@ -1086,13 +1345,13 @@ async function run(id, spawnOptions) {
   }
 }
 function logProgress(id, name, startPhase, total) {
-  console.log(chalk7.bold(`Running plan for #${id}: ${name}`));
+  console.log(chalk8.bold(`Running plan for #${id}: ${name}`));
   if (startPhase > 0) {
     const phaseNumber = startPhase + 1;
-    console.log(chalk7.dim(`Resuming from phase ${phaseNumber}/${total}
+    console.log(chalk8.dim(`Resuming from phase ${phaseNumber}/${total}
 `));
   } else {
-    console.log(chalk7.dim(`${total} phase(s)
+    console.log(chalk8.dim(`${total} phase(s)
 `));
   }
 }
@@ -1125,7 +1384,7 @@ async function runReview(item, plan2, spawnOptions) {
 // src/commands/backlog/next.ts
 function toChoice(item, items) {
   const name = `${typeLabel(item.type)} #${item.id}: ${item.name}`;
-  return isBlocked(item, items) ? { name, disabled: chalk8.red("[blocked]") } : { name };
+  return isBlocked(item, items) ? { name, disabled: chalk9.red("[blocked]") } : { name };
 }
 async function selectItem(todo, items) {
   const { selected } = await exitOnCancel(
@@ -1142,7 +1401,7 @@ async function pickItem(items, firstPick = false) {
   const resumable = findResumable(items);
   if (resumable) {
     console.log(
-      chalk8.bold(
+      chalk9.bold(
         `Resuming in-progress item #${resumable.id}: ${resumable.name}`
       )
     );
@@ -1152,7 +1411,7 @@ async function pickItem(items, firstPick = false) {
   if (!unblocked) return void 0;
   if (firstPick && unblocked.length === 1) {
     const item = unblocked[0];
-    console.log(chalk8.bold(`Auto-selecting item #${item.id}: ${item.name}`));
+    console.log(chalk9.bold(`Auto-selecting item #${item.id}: ${item.name}`));
     return String(item.id);
   }
   const todo = items.filter((i) => i.status === "todo");
@@ -1170,7 +1429,7 @@ async function next(options2) {
 }
 
 // src/commands/backlog/phaseDone.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 
 // src/commands/backlog/addComment.ts
 function addComment(item, text, phase) {
@@ -1205,7 +1464,7 @@ function phaseDone(id, phase, summary) {
   });
   const result = loadAndFindItem(id);
   if (result?.item.status === "done") {
-    console.log(chalk9.dim(`Item #${id} already done, skipping phase advance.`));
+    console.log(chalk10.dim(`Item #${id} already done, skipping phase advance.`));
     return;
   }
   if (result) {
@@ -1214,24 +1473,24 @@ function phaseDone(id, phase, summary) {
   }
   setCurrentPhase(id, phaseNumber + 1);
   console.log(
-    chalk9.green(`Phase ${phaseNumber} of item #${id} marked as complete.`)
+    chalk10.green(`Phase ${phaseNumber} of item #${id} marked as complete.`)
   );
 }
 
 // src/commands/backlog/plan.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 function plan(id) {
   const result = loadAndFindItem(id);
   if (!result) return;
   const { item } = result;
   if (!item.plan || item.plan.length === 0) {
-    console.log(chalk10.dim("No plan defined for this item."));
+    console.log(chalk11.dim("No plan defined for this item."));
     return;
   }
-  console.log(chalk10.bold(item.name));
+  console.log(chalk11.bold(item.name));
   console.log();
   for (const [i, phase] of item.plan.entries()) {
-    console.log(`${chalk10.bold(`Phase ${i + 1}:`)} ${phase.name}`);
+    console.log(`${chalk11.bold(`Phase ${i + 1}:`)} ${phase.name}`);
     for (const task of phase.tasks) {
       console.log(`  - ${task.task}`);
     }
@@ -1240,35 +1499,35 @@ function plan(id) {
 }
 
 // src/commands/backlog/show/index.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 
 // src/commands/backlog/formatComment.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 function formatComment(entry) {
-  const id = entry.id !== void 0 ? chalk11.dim(`#${entry.id} `) : "";
-  const tag = entry.type === "summary" ? chalk11.magenta("[summary]") : chalk11.cyan("[comment]");
-  const phase = entry.phase !== void 0 ? chalk11.dim(` (phase ${entry.phase})`) : "";
-  const time = chalk11.dim(entry.timestamp);
+  const id = entry.id !== void 0 ? chalk12.dim(`#${entry.id} `) : "";
+  const tag = entry.type === "summary" ? chalk12.magenta("[summary]") : chalk12.cyan("[comment]");
+  const phase = entry.phase !== void 0 ? chalk12.dim(` (phase ${entry.phase})`) : "";
+  const time = chalk12.dim(entry.timestamp);
   return `${id}${tag}${phase} ${time}
   ${entry.text}`;
 }
 
 // src/commands/backlog/show/printLinks.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 function printLinks(item, items) {
   const links = item.links ?? [];
   if (links.length === 0) return;
-  console.log(chalk12.bold("Links"));
+  console.log(chalk13.bold("Links"));
   for (const link3 of links) {
     const target = items.find((i) => i.id === link3.targetId);
-    const typeLabel2 = link3.type === "depends-on" ? chalk12.red("depends-on") : chalk12.blue("relates-to");
+    const typeLabel2 = link3.type === "depends-on" ? chalk13.red("depends-on") : chalk13.blue("relates-to");
     if (target) {
       console.log(
-        `  ${typeLabel2} #${target.id} ${target.name} ${chalk12.dim(`(${target.status})`)}`
+        `  ${typeLabel2} #${target.id} ${target.name} ${chalk13.dim(`(${target.status})`)}`
       );
     } else {
       console.log(
-        `  ${typeLabel2} #${link3.targetId} ${chalk12.dim("(not found)")}`
+        `  ${typeLabel2} #${link3.targetId} ${chalk13.dim("(not found)")}`
       );
     }
   }
@@ -1276,15 +1535,15 @@ function printLinks(item, items) {
 }
 
 // src/commands/backlog/show/printPhaseTasks.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 function printPhaseTasks(phase) {
   for (const task of phase.tasks) {
     console.log(`      - ${task.task}`);
   }
   if (phase.manualChecks && phase.manualChecks.length > 0) {
-    console.log(`      ${chalk13.dim("Manual checks:")}`);
+    console.log(`      ${chalk14.dim("Manual checks:")}`);
     for (const check2 of phase.manualChecks) {
-      console.log(`        ${chalk13.dim(`- ${check2}`)}`);
+      console.log(`        ${chalk14.dim(`- ${check2}`)}`);
     }
   }
 }
@@ -1292,7 +1551,7 @@ function printPhaseTasks(phase) {
 // src/commands/backlog/show/index.ts
 function printPlan(item) {
   if (!item.plan || item.plan.length === 0) return;
-  console.log(chalk14.bold("Plan"));
+  console.log(chalk15.bold("Plan"));
   for (const [i, phase] of item.plan.entries()) {
     const isCurrent = item.currentPhase === i + 1;
     printPhase(phase, i, isCurrent);
@@ -1301,8 +1560,8 @@ function printPlan(item) {
 }
 function phaseHeader(index, name, isCurrent) {
   const phaseNumber = index + 1;
-  const marker = isCurrent ? chalk14.green("\u25B6 ") : "  ";
-  const label2 = isCurrent ? chalk14.green.bold(`Phase ${phaseNumber}: ${name}`) : `${chalk14.bold(`Phase ${phaseNumber}:`)} ${name}`;
+  const marker = isCurrent ? chalk15.green("\u25B6 ") : "  ";
+  const label2 = isCurrent ? chalk15.green.bold(`Phase ${phaseNumber}: ${name}`) : `${chalk15.bold(`Phase ${phaseNumber}:`)} ${name}`;
   return `${marker}${label2}`;
 }
 function printPhase(phase, index, isCurrent) {
@@ -1310,15 +1569,15 @@ function printPhase(phase, index, isCurrent) {
   printPhaseTasks(phase);
 }
 function printHeader(item) {
-  console.log(chalk14.bold(`#${item.id} ${item.name}`));
+  console.log(chalk15.bold(`#${item.id} ${item.name}`));
   console.log(
-    `${chalk14.dim("Type:")} ${item.type}  ${chalk14.dim("Status:")} ${item.status}`
+    `${chalk15.dim("Type:")} ${item.type}  ${chalk15.dim("Status:")} ${item.status}`
   );
   console.log();
 }
 function printAcceptanceCriteria(criteria) {
   if (criteria.length === 0) return;
-  console.log(chalk14.bold("Acceptance Criteria"));
+  console.log(chalk15.bold("Acceptance Criteria"));
   for (const [i, ac] of criteria.entries()) {
     console.log(`  ${i + 1}. ${ac}`);
   }
@@ -1330,7 +1589,7 @@ function show(id) {
   const { item, items } = result;
   printHeader(item);
   if (item.description) {
-    console.log(chalk14.bold("Description"));
+    console.log(chalk15.bold("Description"));
     console.log(item.description);
     console.log();
   }
@@ -1342,7 +1601,7 @@ function show(id) {
 function printComments(item) {
   const entries = item.comments ?? [];
   if (entries.length === 0) return;
-  console.log(chalk14.bold("Comments"));
+  console.log(chalk15.bold("Comments"));
   for (const entry of entries) {
     console.log(`  ${formatComment(entry)}`);
   }
@@ -1356,7 +1615,7 @@ import { WebSocketServer } from "ws";
 import {
   createServer
 } from "http";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 
 // src/shared/openBrowser.ts
 import { exec } from "child_process";
@@ -1402,27 +1661,27 @@ function startWebServer(label2, port, handler, initialPath) {
     handler(req, res, port);
   });
   server.listen(port, () => {
-    console.log(chalk15.green(`${label2}: ${url}`));
-    console.log(chalk15.dim("Press Ctrl+C to stop"));
+    console.log(chalk16.green(`${label2}: ${url}`));
+    console.log(chalk16.dim("Press Ctrl+C to stop"));
     openBrowser(url);
   });
   return server;
 }
 
 // src/commands/sessions/web/handleRequest.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { createRequire } from "module";
 
 // src/shared/createBundleHandler.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { dirname, join as join7 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname2, join as join8 } from "path";
 import { fileURLToPath } from "url";
 function createBundleHandler(importMetaUrl, bundlePath) {
-  const dir = dirname(fileURLToPath(importMetaUrl));
+  const dir = dirname2(fileURLToPath(importMetaUrl));
   let cache;
   return (_req, res) => {
     if (!cache) {
-      cache = readFileSync6(join7(dir, bundlePath), "utf-8");
+      cache = readFileSync7(join8(dir, bundlePath), "utf-8");
     }
     res.writeHead(200, { "Content-Type": "application/javascript" });
     res.end(cache);
@@ -1507,6 +1766,12 @@ function validateRewind(item, phase) {
   return void 0;
 }
 
+// src/commands/backlog/getNextId.ts
+function getNextId(items) {
+  if (items.length === 0) return 1;
+  return Math.max(...items.map((item) => item.id)) + 1;
+}
+
 // src/commands/backlog/web/shared.ts
 function listItems(req, res) {
   const url = new URL(req.url ?? "/", "http://localhost");
@@ -1626,7 +1891,7 @@ function createCssHandler(packageEntry) {
   return (_req, res) => {
     if (!cache) {
       const resolved = require2.resolve(packageEntry);
-      cache = readFileSync7(resolved, "utf-8");
+      cache = readFileSync8(resolved, "utf-8");
     }
     res.writeHead(200, { "Content-Type": "text/css" });
     res.end(cache);
@@ -1649,264 +1914,6 @@ var handleRequest = createFallbackHandler(
   handleItemRoute
 );
 
-// src/shared/loadConfig.ts
-import { existsSync as existsSync9, writeFileSync as writeFileSync5 } from "fs";
-import { homedir } from "os";
-import { dirname as dirname2, join as join8 } from "path";
-import chalk16 from "chalk";
-import { stringify as stringifyYaml } from "yaml";
-
-// src/shared/loadRawYaml.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { parse as parseYaml2 } from "yaml";
-function loadRawYaml(path53) {
-  if (!existsSync8(path53)) return {};
-  try {
-    const content = readFileSync8(path53, "utf-8");
-    return parseYaml2(content) || {};
-  } catch {
-    return {};
-  }
-}
-
-// src/shared/mergeDenyRules.ts
-function mergeDenyRules(globalDeny, projectDeny) {
-  if (!globalDeny && !projectDeny) return void 0;
-  if (!globalDeny) return projectDeny;
-  if (!projectDeny) return globalDeny;
-  const projectPatterns = new Set(projectDeny.map((r) => r.pattern));
-  const globalOnly = globalDeny.filter((r) => !projectPatterns.has(r.pattern));
-  return [...globalOnly, ...projectDeny];
-}
-function mergeRawConfigs(globalRaw, projectRaw) {
-  const deny = mergeDenyRules(
-    globalRaw.deny,
-    projectRaw.deny
-  );
-  const merged = { ...globalRaw, ...projectRaw };
-  if (deny !== void 0) {
-    merged.deny = deny;
-  }
-  return merged;
-}
-
-// src/shared/types.ts
-import { z as z3 } from "zod";
-
-// src/shared/runConfigSchema.ts
-import { z as z2 } from "zod";
-var runParamSchema = z2.strictObject({
-  name: z2.string(),
-  required: z2.boolean().optional(),
-  default: z2.string().optional(),
-  description: z2.string().optional()
-});
-var runConfigSchema = z2.strictObject({
-  name: z2.string(),
-  command: z2.string(),
-  args: z2.array(z2.string()).optional(),
-  params: z2.array(runParamSchema).optional(),
-  env: z2.record(z2.string(), z2.string()).optional(),
-  filter: z2.string().optional(),
-  pre: z2.array(z2.string()).optional(),
-  cwd: z2.string().optional()
-});
-var runLinkSchema = z2.strictObject({
-  link: z2.string(),
-  prefix: z2.string()
-});
-
-// src/shared/types.ts
-var transcriptConfigSchema = z3.strictObject({
-  vttDir: z3.string(),
-  transcriptsDir: z3.string(),
-  summaryDir: z3.string()
-});
-var DEFAULT_WAKE_WORDS = ["computer"];
-var DEFAULT_MODELS_DIR = "~/.assist/voice/models";
-var assistConfigSchema = z3.strictObject({
-  commit: z3.strictObject({
-    conventional: z3.boolean().default(false),
-    pull: z3.boolean().default(false),
-    push: z3.boolean().default(false)
-  }).default({ conventional: false, pull: false, push: false }),
-  devlog: z3.strictObject({
-    name: z3.string().optional(),
-    ignore: z3.array(z3.string()).optional(),
-    skip: z3.record(z3.string(), z3.array(z3.string())).optional()
-  }).optional(),
-  notify: z3.strictObject({
-    enabled: z3.boolean().default(true)
-  }).default({ enabled: true }),
-  complexity: z3.strictObject({
-    ignore: z3.array(z3.string()).default(["**/*test.ts*"])
-  }).default({ ignore: ["**/*test.ts*"] }),
-  hardcodedColors: z3.strictObject({
-    ignore: z3.array(z3.string()).default([])
-  }).optional(),
-  restructure: z3.strictObject({
-    ignore: z3.array(z3.string()).default([])
-  }).optional(),
-  jira: z3.strictObject({
-    acField: z3.string().default("customfield_11937")
-  }).optional(),
-  roam: z3.strictObject({
-    clientId: z3.string(),
-    clientSecret: z3.string(),
-    accessToken: z3.string().optional(),
-    refreshToken: z3.string().optional(),
-    tokenExpiresAt: z3.number().optional()
-  }).optional(),
-  run: z3.array(z3.union([runConfigSchema, runLinkSchema])).optional(),
-  transcript: transcriptConfigSchema.optional(),
-  cliReadVerbs: z3.record(z3.string(), z3.array(z3.string())).optional(),
-  news: z3.strictObject({
-    feeds: z3.array(z3.string()).default([])
-  }).default({ feeds: [] }),
-  dotnet: z3.strictObject({
-    inspect: z3.strictObject({
-      suppress: z3.array(z3.string()).default([])
-    }).default({ suppress: [] })
-  }).optional(),
-  ravendb: z3.strictObject({
-    connections: z3.array(
-      z3.strictObject({
-        name: z3.string(),
-        url: z3.string(),
-        database: z3.string(),
-        apiKeyRef: z3.string()
-      })
-    ).default([]),
-    defaultConnection: z3.string().optional()
-  }).optional(),
-  seq: z3.strictObject({
-    connections: z3.array(
-      z3.strictObject({
-        name: z3.string(),
-        url: z3.string(),
-        apiToken: z3.string()
-      })
-    ).default([]),
-    defaultConnection: z3.string().optional()
-  }).optional(),
-  sql: z3.strictObject({
-    connections: z3.array(
-      z3.strictObject({
-        name: z3.string(),
-        server: z3.string(),
-        port: z3.number(),
-        user: z3.string(),
-        password: z3.string(),
-        database: z3.string()
-      })
-    ).default([]),
-    defaultConnection: z3.string().optional()
-  }).optional(),
-  screenshot: z3.strictObject({
-    outputDir: z3.string().default("./screenshots")
-  }).default({ outputDir: "./screenshots" }),
-  backlog: z3.strictObject({
-    autoCommit: z3.boolean().default(false)
-  }).default({ autoCommit: false }),
-  mermaid: z3.strictObject({
-    krokiUrl: z3.string().default("https://kroki.io")
-  }).default({ krokiUrl: "https://kroki.io" }),
-  deny: z3.array(
-    z3.strictObject({
-      pattern: z3.string(),
-      message: z3.string()
-    })
-  ).optional(),
-  sync: z3.strictObject({
-    autoConfirm: z3.boolean().default(false)
-  }).default({ autoConfirm: false }),
-  voice: z3.strictObject({
-    wakeWords: z3.array(z3.string()).default(DEFAULT_WAKE_WORDS),
-    mic: z3.string().optional(),
-    cwd: z3.string().optional(),
-    modelsDir: z3.string().default(DEFAULT_MODELS_DIR),
-    lockDir: z3.string().optional(),
-    submitWindows: z3.array(z3.string()).optional(),
-    models: z3.strictObject({
-      vad: z3.string().optional(),
-      smartTurn: z3.string().optional()
-    }).default({})
-  }).default({
-    wakeWords: DEFAULT_WAKE_WORDS,
-    modelsDir: DEFAULT_MODELS_DIR,
-    models: {}
-  })
-});
-function isRunLink(entry) {
-  return "link" in entry;
-}
-
-// src/shared/loadConfig.ts
-function findConfigUp(startDir) {
-  let current = startDir;
-  while (current !== dirname2(current)) {
-    const claudePath = join8(current, ".claude", "assist.yml");
-    if (existsSync9(claudePath)) return claudePath;
-    const rootPath = join8(current, "assist.yml");
-    if (existsSync9(rootPath)) return rootPath;
-    current = dirname2(current);
-  }
-  return null;
-}
-function getConfigPath() {
-  const found = findConfigUp(process.cwd());
-  if (found) return found;
-  return join8(process.cwd(), "assist.yml");
-}
-function getGlobalConfigPath() {
-  return join8(homedir(), ".assist.yml");
-}
-function getConfigDir() {
-  return dirname2(getConfigPath());
-}
-function loadConfig() {
-  const globalRaw = loadRawYaml(getGlobalConfigPath());
-  const projectRaw = loadRawYaml(getConfigPath());
-  const merged = mergeRawConfigs(globalRaw, projectRaw);
-  return assistConfigSchema.parse(merged);
-}
-function loadConfigFrom(startDir) {
-  const found = findConfigUp(startDir);
-  const configPath = found ?? join8(startDir, "assist.yml");
-  const globalRaw = loadRawYaml(getGlobalConfigPath());
-  const projectRaw = loadRawYaml(configPath);
-  const merged = mergeRawConfigs(globalRaw, projectRaw);
-  return {
-    config: assistConfigSchema.parse(merged),
-    configDir: dirname2(configPath)
-  };
-}
-function loadProjectConfig() {
-  return loadRawYaml(getConfigPath());
-}
-function loadGlobalConfigRaw() {
-  return loadRawYaml(getGlobalConfigPath());
-}
-function saveGlobalConfig(config) {
-  writeFileSync5(getGlobalConfigPath(), stringifyYaml(config, { lineWidth: 0 }));
-}
-function saveConfig(config) {
-  const configPath = getConfigPath();
-  writeFileSync5(configPath, stringifyYaml(config, { lineWidth: 0 }));
-}
-function getTranscriptConfig() {
-  const config = loadConfig();
-  if (!config.transcript) {
-    console.error(
-      chalk16.red(
-        "Transcript directories not configured. Run 'assist transcript configure' first."
-      )
-    );
-    process.exit(1);
-  }
-  return config.transcript;
-}
-
 // src/shared/resolveRunConfigs.ts
 import { dirname as dirname3, relative, resolve as resolve3 } from "path";
 
@@ -11901,11 +11908,6 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-async function sqlMutate(_query, _connectionName) {
-  throw new Error("assist sql mutate is not yet implemented");
-}
-
-// src/commands/sql/sqlQuery.ts
 import chalk137 from "chalk";
 
 // src/commands/sql/isMutation.ts
@@ -11936,11 +11938,32 @@ function isMutation(sql2) {
   return /\bSELECT\b[\s\S]+\bINTO\s+\w/i.test(stripped);
 }
 
+// src/commands/sql/sqlMutate.ts
+async function sqlMutate(query, connectionName) {
+  if (!isMutation(query)) {
+    console.error(
+      chalk137.red(
+        "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
+      )
+    );
+    process.exit(1);
+  }
+  const conn = resolveConnection3(connectionName);
+  const pool = await sqlConnect(conn);
+  try {
+    const result = await pool.request().query(query);
+    console.log(chalk137.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+  } finally {
+    await pool.close();
+  }
+}
+
 // src/commands/sql/sqlQuery.ts
+import chalk138 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk137.red(
+      chalk138.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -11955,7 +11978,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk137.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk138.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -12001,7 +12024,9 @@ function registerSql(program2) {
   cmd.command("query <sql> [connection]").description("Execute a read-only SQL query (rejects mutating statements)").action(
     (query, connection) => sqlQuery(query, connection)
   );
-  cmd.command("mutate <sql> [connection]").description("Execute a mutating SQL statement (not yet implemented)").action(
+  cmd.command("mutate <sql> [connection]").description(
+    "Execute a mutating SQL statement (rejects non-mutating statements)"
+  ).action(
     (query, connection) => sqlMutate(query, connection)
   );
   cmd.command("tables [connection]").description("List tables in the connected database").action((connection) => sqlTables(connection));
@@ -12533,14 +12558,14 @@ import {
 import { dirname as dirname22, join as join38 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk138 from "chalk";
+import chalk139 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk138.red(
+      chalk139.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -12549,7 +12574,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk138.red(
+      chalk139.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -12945,7 +12970,7 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk139 from "chalk";
+import chalk140 from "chalk";
 
 // src/lib/openBrowser.ts
 import { execSync as execSync37 } from "child_process";
@@ -13120,13 +13145,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk139.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk140.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk139.white("http://localhost:14523/callback\n"));
-  console.log(chalk139.blue("Opening browser for authorization..."));
-  console.log(chalk139.dim("Waiting for authorization callback..."));
+  console.log(chalk140.white("http://localhost:14523/callback\n"));
+  console.log(chalk140.blue("Opening browser for authorization..."));
+  console.log(chalk140.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk139.dim("Exchanging code for tokens..."));
+  console.log(chalk140.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -13142,7 +13167,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk139.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk140.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -13555,7 +13580,7 @@ import { execSync as execSync39 } from "child_process";
 import { existsSync as existsSync43, mkdirSync as mkdirSync16, unlinkSync as unlinkSync12, writeFileSync as writeFileSync30 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
 import { join as join49, resolve as resolve13 } from "path";
-import chalk140 from "chalk";
+import chalk141 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -13706,20 +13731,20 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve13(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk140.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk141.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk140.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk141.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk140.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk141.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
 
 // src/commands/sessions/summarise/index.ts
 import * as fs27 from "fs";
-import chalk141 from "chalk";
+import chalk142 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs25 from "fs";
@@ -13859,22 +13884,22 @@ ${firstMessage}`);
 async function summarise3(options2) {
   const files = await discoverSessionJsonlPaths();
   if (files.length === 0) {
-    console.log(chalk141.yellow("No sessions found."));
+    console.log(chalk142.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk141.green("All sessions already summarised."));
+    console.log(chalk142.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk141.cyan(
+    chalk142.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed } = processSessions(toProcess);
   console.log(
-    chalk141.green(`Done: ${succeeded} summarised`) + (failed > 0 ? chalk141.yellow(`, ${failed} skipped`) : "")
+    chalk142.green(`Done: ${succeeded} summarised`) + (failed > 0 ? chalk142.yellow(`, ${failed} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -13894,16 +13919,16 @@ function processSessions(files) {
   let failed = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk141.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk142.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk141.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk142.green("\u2713")} ${summary}
 `);
     } else {
       failed++;
-      process.stdout.write(` ${chalk141.yellow("skip")}
+      process.stdout.write(` ${chalk142.yellow("skip")}
 `);
     }
   }
@@ -13918,10 +13943,10 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk143 from "chalk";
+import chalk144 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk142 from "chalk";
+import chalk143 from "chalk";
 var FIVE_HOUR_SECONDS = 5 * 3600;
 var SEVEN_DAY_SECONDS = 7 * 86400;
 function formatTimeLeft(resetsAt) {
@@ -13944,10 +13969,10 @@ function projectUsage(pct, resetsAt, windowSeconds) {
 function colorizeRateLimit(pct, resetsAt, windowSeconds) {
   const label2 = `${Math.round(pct)}%`;
   const projected = projectUsage(pct, resetsAt, windowSeconds);
-  if (projected == null) return chalk142.green(label2);
-  if (projected > 100) return chalk142.red(label2);
-  if (projected > 75) return chalk142.yellow(label2);
-  return chalk142.green(label2);
+  if (projected == null) return chalk143.green(label2);
+  if (projected > 100) return chalk143.red(label2);
+  if (projected > 75) return chalk143.yellow(label2);
+  return chalk143.green(label2);
 }
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel) {
   const timeLabel = resetsAt ? formatTimeLeft(resetsAt) : fallbackLabel;
@@ -13973,14 +13998,14 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk143.level = 3;
+chalk144.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
-  if (pct > 80) return chalk143.red(label2);
-  if (pct > 40) return chalk143.yellow(label2);
+  if (pct > 80) return chalk144.red(label2);
+  if (pct > 40) return chalk144.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -14003,7 +14028,7 @@ import { fileURLToPath as fileURLToPath7 } from "url";
 // src/commands/sync/syncClaudeMd.ts
 import * as fs28 from "fs";
 import * as path49 from "path";
-import chalk144 from "chalk";
+import chalk145 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path49.join(claudeDir, "CLAUDE.md");
   const target = path49.join(targetBase, "CLAUDE.md");
@@ -14012,12 +14037,12 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs28.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk144.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk145.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = options2?.yes || await promptConfirm(
-        chalk144.red("Overwrite existing CLAUDE.md?"),
+        chalk145.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -14033,7 +14058,7 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs29 from "fs";
 import * as path50 from "path";
-import chalk145 from "chalk";
+import chalk146 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path50.join(claudeDir, "settings.json");
   const target = path50.join(targetBase, "settings.json");
@@ -14049,14 +14074,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk145.yellow(
+          chalk146.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk145.red("Overwrite existing settings.json?"),
+          chalk146.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {