@staff0rd/assist 0.955.2 → 0.956.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.955.2",
+  version: "0.956.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -605,16 +605,87 @@ function mergeRawConfigs(globalRaw, projectRaw) {
   return merged;
 }
 
+// src/shared/readRepoConfigCache.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
+
+// src/shared/loadJson.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  renameSync,
+  rmSync as rmSync2,
+  writeFileSync
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+function getStoreDir() {
+  return process.env.ASSIST_STORE_DIR || join5(homedir3(), ".assist");
+}
+function getStorePath(filename) {
+  return join5(getStoreDir(), filename);
+}
+function loadJson(filename) {
+  const path108 = getStorePath(filename);
+  if (existsSync3(path108)) {
+    try {
+      return JSON.parse(readFileSync3(path108, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function saveJson(filename, data) {
+  const dir = getStoreDir();
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const path108 = getStorePath(filename);
+  const tmp = `${path108}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(data, null, 2));
+    renameSync(tmp, path108);
+  } catch (error) {
+    rmSync2(tmp, { force: true });
+    throw error;
+  }
+}
+
+// src/shared/readRepoConfigCache.ts
+function repoConfigCachePath() {
+  return join6(getStoreDir(), "repo-config-cache.json");
+}
+function readConfigCacheFile() {
+  const path108 = repoConfigCachePath();
+  if (!existsSync4(path108)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync4(path108, "utf8"));
+    return parsed ?? {};
+  } catch {
+    return {};
+  }
+}
+function readRepoConfigCache() {
+  return readConfigCacheFile().repos ?? {};
+}
+
+// src/shared/readUserConfigCache.ts
+function readUserConfigCache() {
+  return readConfigCacheFile().user ?? {};
+}
+
 // src/shared/resolveRepoLayer.ts
 import chalk2 from "chalk";
 
 // src/shared/findRepoRoot.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import path from "path";
 function findRepoRoot(dir) {
   let current = dir;
   while (current !== path.dirname(current)) {
-    if (existsSync3(path.join(current, ".git"))) {
+    if (existsSync5(path.join(current, ".git"))) {
       return current;
     }
     current = path.dirname(current);
@@ -703,69 +774,6 @@ function getCachedOrigin(cwd) {
   return origin;
 }
 
-// src/shared/readRepoConfigCache.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
-
-// src/shared/loadJson.ts
-import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync3,
-  renameSync,
-  rmSync as rmSync2,
-  writeFileSync
-} from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
-function getStoreDir() {
-  return process.env.ASSIST_STORE_DIR || join5(homedir3(), ".assist");
-}
-function getStorePath(filename) {
-  return join5(getStoreDir(), filename);
-}
-function loadJson(filename) {
-  const path108 = getStorePath(filename);
-  if (existsSync4(path108)) {
-    try {
-      return JSON.parse(readFileSync3(path108, "utf8"));
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-function saveJson(filename, data) {
-  const dir = getStoreDir();
-  if (!existsSync4(dir)) {
-    mkdirSync2(dir, { recursive: true });
-  }
-  const path108 = getStorePath(filename);
-  const tmp = `${path108}.${process.pid}.tmp`;
-  try {
-    writeFileSync(tmp, JSON.stringify(data, null, 2));
-    renameSync(tmp, path108);
-  } catch (error) {
-    rmSync2(tmp, { force: true });
-    throw error;
-  }
-}
-
-// src/shared/readRepoConfigCache.ts
-function repoConfigCachePath() {
-  return join6(getStoreDir(), "repo-config-cache.json");
-}
-function readRepoConfigCache() {
-  const path108 = repoConfigCachePath();
-  if (!existsSync5(path108)) return {};
-  try {
-    const parsed = JSON.parse(readFileSync4(path108, "utf8"));
-    return parsed?.repos ?? {};
-  } catch {
-    return {};
-  }
-}
-
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
@@ -1444,7 +1452,7 @@ function loadConfigFrom(cwd, globalConfigPath = getGlobalConfigPath()) {
   const globalRaw = loadRawYaml(globalConfigPath);
   const projectRaw = loadRawYaml(projectConfigPathFrom(cwd));
   const globalWithRepo = mergeRawConfigs(
-    globalRaw,
+    mergeRawConfigs(readUserConfigCache(), globalRaw),
     resolveRepoLayer(globalRaw, cwd).override
   );
   const merged = stripLegacyConfigKeys(
@@ -1995,7 +2003,7 @@ function expandTilde(value) {
 import { asc, eq } from "drizzle-orm";
 
 // src/shared/db/schema.ts
-import { integer as integer13, pgTable as pgTable15, text as text15 } from "drizzle-orm/pg-core";
+import { integer as integer13, pgTable as pgTable16, text as text15 } from "drizzle-orm/pg-core";
 
 // src/shared/db/backups.ts
 import { bigint, integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
@@ -2251,12 +2259,20 @@ var usagePeaks = pgTable14(
   (t) => [primaryKey10({ columns: [t.window, t.resetsAt, t.segment] })]
 );
 
+// src/shared/db/userConfig.ts
+import { jsonb as jsonb2, pgTable as pgTable15, smallint, timestamp as timestamp7 } from "drizzle-orm/pg-core";
+var userConfig = pgTable15("user_config", {
+  id: smallint().primaryKey().default(1),
+  config: jsonb2().$type().notNull(),
+  updatedAt: timestamp7("updated_at", { withTimezone: true }).notNull().defaultNow()
+});
+
 // src/shared/db/schema.ts
-var metadata = pgTable15("metadata", {
+var metadata = pgTable16("metadata", {
   key: text15().primaryKey(),
   value: text15().notNull()
 });
-var feeds = pgTable15("feeds", {
+var feeds = pgTable16("feeds", {
   id: integer13().generatedByDefaultAsIdentity().primaryKey(),
   url: text15().notNull().unique()
 });
@@ -2276,7 +2292,8 @@ var schema = {
   phaseCycleContext,
   phaseSessions,
   repoConfigs,
-  inboxMessages
+  inboxMessages,
+  userConfig
 };
 
 // src/shared/db/planPhaseCounts.ts
@@ -3366,6 +3383,20 @@ var migration0009InboxMessages = {
   sql: sql12
 };
 
+// src/shared/db/migrations/migration0010UserConfig.ts
+var sql13 = `
+	CREATE TABLE IF NOT EXISTS user_config (
+		id SMALLINT PRIMARY KEY DEFAULT 1 CHECK (id = 1),
+		config JSONB NOT NULL,
+		updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+	);
+`;
+var migration0010UserConfig = {
+  id: 10,
+  name: "user-config",
+  sql: sql13
+};
+
 // src/shared/db/migrations.ts
 var migrations = [
   migration0001Baseline,
@@ -3376,7 +3407,8 @@ var migrations = [
   migration0006BackfillPhaseSessions,
   migration0007GithubIssue,
   migration0008RepoConfigs,
-  migration0009InboxMessages
+  migration0009InboxMessages,
+  migration0010UserConfig
 ];
 var latestMigrationId = migrations.reduce(
   (max, m) => Math.max(max, m.id),
@@ -3459,8 +3491,8 @@ async function assertMigrationsInSync(exec3) {
 // src/shared/db/migrations/MigrationExecutor.ts
 function pgExecutor(queryable) {
   return {
-    exec: (sql29) => queryable.query(sql29),
-    query: async (sql29, params) => (await queryable.query(sql29, params)).rows
+    exec: (sql30) => queryable.query(sql30),
+    query: async (sql30, params) => (await queryable.query(sql30, params)).rows
   };
 }
 
@@ -3614,13 +3646,13 @@ async function loadItem(orm, id) {
 }
 
 // src/commands/backlog/saveAllItems.ts
-import { eq as eq8, sql as sql13 } from "drizzle-orm";
+import { eq as eq8, sql as sql14 } from "drizzle-orm";
 
 // src/commands/backlog/deleteItemRelations.ts
 import { eq as eq7 } from "drizzle-orm";
 
 // src/commands/backlog/searchItemIds.ts
-import { and as and3, asc as asc5, eq as eq9, ilike, or, sql as sql14 } from "drizzle-orm";
+import { and as and3, asc as asc5, eq as eq9, ilike, or, sql as sql15 } from "drizzle-orm";
 async function searchItemIds(orm, query, origin) {
   const pattern2 = `%${query}%`;
   const numberPattern = `%${query.replace(/^#/, "")}%`;
@@ -3634,7 +3666,7 @@ async function searchItemIds(orm, query, origin) {
         ilike(items.jiraKey, pattern2),
         ilike(comments.text, pattern2),
         ilike(planPhases.name, pattern2),
-        ilike(sql14`${items.id}::text`, numberPattern)
+        ilike(sql15`${items.id}::text`, numberPattern)
       )
     )
   ).orderBy(asc5(items.id));
@@ -4052,7 +4084,7 @@ import * as fs4 from "fs";
 function extractSessionMeta(lines2) {
   let sessionId = "";
   let cwd = "";
-  let timestamp7 = "";
+  let timestamp8 = "";
   let name = "";
   let commandName = "";
   let commandArgs = "";
@@ -4060,14 +4092,14 @@ function extractSessionMeta(lines2) {
     const entry = safeParse(line);
     if (!entry) continue;
     sessionId ||= strField(entry, "sessionId");
-    timestamp7 ||= strField(entry, "timestamp");
+    timestamp8 ||= strField(entry, "timestamp");
     cwd ||= strField(entry, "cwd");
     if (entry.type === "user" && !entry.isMeta) {
       ({ name, commandName, commandArgs } = parseFirstUserEntry(entry));
       break;
     }
   }
-  return { sessionId, cwd, timestamp: timestamp7, name, commandName, commandArgs };
+  return { sessionId, cwd, timestamp: timestamp8, name, commandName, commandArgs };
 }
 function parseFirstUserEntry(entry) {
   const raw = messageText(entry);
@@ -4120,13 +4152,13 @@ async function parseSessionFile(filePath, origin = "wsl") {
     handle = await fs4.promises.open(filePath, "r");
     const meta = extractSessionMeta(await readHeadLines(handle));
     if (!meta.sessionId) return null;
-    const timestamp7 = meta.timestamp || (await fs4.promises.stat(filePath)).mtime.toISOString();
+    const timestamp8 = meta.timestamp || (await fs4.promises.stat(filePath)).mtime.toISOString();
     return {
       sessionId: meta.sessionId,
       name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
       project: deriveProject(meta.cwd, filePath, origin),
       cwd: meta.cwd,
-      timestamp: timestamp7,
+      timestamp: timestamp8,
       origin,
       ...deriveHistoryFields(meta.commandName, meta.commandArgs, meta.name)
     };
@@ -5917,6 +5949,7 @@ function readRawConfigLayers(cwd, globalConfigPath = getGlobalConfigPath()) {
   return {
     project: loadRawYaml(projectConfigPathFrom(cwd)),
     global,
+    user: readUserConfigCache(),
     repoOverride: repo.override,
     ...repo.key === void 0 ? {} : { repoKey: repo.key },
     ...repo.source === void 0 ? {} : { repoSource: repo.source }
@@ -6022,7 +6055,8 @@ function getNestedValue(obj, path108) {
 var LAYERS = [
   ["project", "project"],
   ["repo", "repoOverride"],
-  ["global", "global"]
+  ["global", "global"],
+  ["user", "user"]
 ];
 function configEntryLayers(key, layers, node) {
   const entryLayers = {};
@@ -6831,6 +6865,7 @@ function resolveConfigSources(key, layers) {
   if (getNestedValue(layers.repoOverride, key) !== void 0)
     sources.push("repo");
   if (getNestedValue(layers.global, key) !== void 0) sources.push("global");
+  if (getNestedValue(layers.user, key) !== void 0) sources.push("user");
   return sources;
 }
 
@@ -7533,11 +7568,11 @@ async function deleteItemComment(res, itemId2, commentId) {
 }
 
 // src/commands/backlog/appendComment.ts
-import { sql as sql15 } from "drizzle-orm";
+import { sql as sql16 } from "drizzle-orm";
 async function appendComment(orm, itemId2, text18, opts = {}) {
   await orm.insert(comments).values({
     itemId: itemId2,
-    idx: sql15`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId2})`,
+    idx: sql16`(SELECT COALESCE(MAX(${comments.idx}) + 1, 0) FROM ${comments} WHERE ${comments.itemId} = ${itemId2})`,
     text: text18,
     phase: opts.phase ?? null,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8030,11 +8065,11 @@ async function historySearch(req, res) {
 }
 
 // src/shared/db/listInboxMessages.ts
-import { desc as desc2, isNull as isNull2, sql as sql16 } from "drizzle-orm";
+import { desc as desc2, isNull as isNull2, sql as sql17 } from "drizzle-orm";
 function listInboxMessages(orm) {
   return orm.select().from(inboxMessages).where(isNull2(inboxMessages.dismissedAt)).orderBy(
     desc2(
-      sql16`coalesce(${inboxMessages.receivedAt}, ${inboxMessages.flaggedAt})`
+      sql17`coalesce(${inboxMessages.receivedAt}, ${inboxMessages.flaggedAt})`
     )
   );
 }
@@ -9180,12 +9215,12 @@ async function countUsagePeaks(db, window) {
 import { and as and7, desc as desc3, eq as eq18, getTableColumns } from "drizzle-orm";
 
 // src/shared/db/avgContextPerCycle.ts
-import { count as count2, sql as sql17 } from "drizzle-orm";
+import { count as count2, sql as sql18 } from "drizzle-orm";
 function avgContextPerCycle(db) {
   return db.select({
     window: phaseCycleContext.window,
     resetsAt: phaseCycleContext.resetsAt,
-    avgContextPct: sql17`cast(avg(${phaseCycleContext.peakContextPct}) as double precision)`.as(
+    avgContextPct: sql18`cast(avg(${phaseCycleContext.peakContextPct}) as double precision)`.as(
       "avg_context_pct"
     ),
     phaseCount: count2().as("phase_count")
@@ -9274,9 +9309,9 @@ function listUsageHistory(req, res) {
 }
 
 // src/shared/db/countItemUsageByOrigin.ts
-import { asc as asc8, desc as desc4, eq as eq19, sql as sql18 } from "drizzle-orm";
+import { asc as asc8, desc as desc4, eq as eq19, sql as sql19 } from "drizzle-orm";
 async function countItemUsageByOrigin(db) {
-  const count10 = sql18`count(distinct ${phaseUsage.itemId})::int`;
+  const count10 = sql19`count(distinct ${phaseUsage.itemId})::int`;
   const rows = await db.select({ origin: items.origin, count: count10 }).from(items).innerJoin(phaseUsage, eq19(phaseUsage.itemId, items.id)).groupBy(items.origin).orderBy(desc4(count10), asc8(items.origin));
   return rows.map((row3) => ({ origin: row3.origin, count: Number(row3.count) }));
 }
@@ -9318,22 +9353,22 @@ function parseItemUsageSort(field, direction) {
 }
 
 // src/shared/db/itemUsageStats.ts
-import { eq as eq21, sql as sql19 } from "drizzle-orm";
+import { eq as eq21, sql as sql20 } from "drizzle-orm";
 function median(value) {
-  return sql19`coalesce(percentile_cont(0.5) within group (order by (${value})::double precision), 0)`;
+  return sql20`coalesce(percentile_cont(0.5) within group (order by (${value})::double precision), 0)`;
 }
 async function itemUsageStats(db, options2) {
   const totals = phaseUsageTotals(db);
   const planned = planPhaseCounts(db);
   const [row3] = await db.select({
-    itemCount: sql19`count(*)::int`,
-    doneCount: sql19`count(*) filter (where ${items.status} = 'done')::int`,
-    repoCount: sql19`count(distinct ${items.origin})::int`,
+    itemCount: sql20`count(*)::int`,
+    doneCount: sql20`count(*) filter (where ${items.status} = 'done')::int`,
+    repoCount: sql20`count(distinct ${items.origin})::int`,
     medianPhases: median(
-      sql19`coalesce(${planned.count}, ${totals.recordedPhases})`
+      sql20`coalesce(${planned.count}, ${totals.recordedPhases})`
     ),
     medianActiveMs: median(totals.activeMs),
-    medianTokens: median(sql19`${totals.tokensUp} + ${totals.tokensDown}`)
+    medianTokens: median(sql20`${totals.tokensUp} + ${totals.tokensDown}`)
   }).from(items).innerJoin(totals, eq21(totals.itemId, items.id)).leftJoin(planned, eq21(planned.itemId, items.id)).where(itemUsageWhere(options2));
   return {
     itemCount: Number(row3?.itemCount ?? 0),
@@ -9349,27 +9384,27 @@ async function itemUsageStats(db, options2) {
 import { eq as eq22 } from "drizzle-orm";
 
 // src/shared/db/itemUsageOrderBy.ts
-import { desc as desc5, sql as sql20 } from "drizzle-orm";
+import { desc as desc5, sql as sql21 } from "drizzle-orm";
 function itemUsageOrderBy(joins, sort = defaultItemUsageSort) {
   const { totals, planned, lastPhase } = joins;
   const sortable = {
-    phases: sql20`coalesce(${planned.count}, ${totals.recordedPhases})`,
-    active: sql20`${totals.activeMs}`,
-    tokens: sql20`${totals.tokensUp} + ${totals.tokensDown}`,
-    peakContext: sql20`${totals.peakContextPct}`,
-    lastPhase: sql20`${lastPhase.at}`
+    phases: sql21`coalesce(${planned.count}, ${totals.recordedPhases})`,
+    active: sql21`${totals.activeMs}`,
+    tokens: sql21`${totals.tokensUp} + ${totals.tokensDown}`,
+    peakContext: sql21`${totals.peakContextPct}`,
+    lastPhase: sql21`${lastPhase.at}`
   };
-  const order = sort.direction === "asc" ? sql20`asc` : sql20`desc`;
-  return [sql20`${sortable[sort.field]} ${order} nulls last`, desc5(items.id)];
+  const order = sort.direction === "asc" ? sql21`asc` : sql21`desc`;
+  return [sql21`${sortable[sort.field]} ${order} nulls last`, desc5(items.id)];
 }
 
 // src/shared/db/lastPhaseActivity.ts
-import { sql as sql21 } from "drizzle-orm";
+import { sql as sql22 } from "drizzle-orm";
 function lastPhaseActivity(db) {
   return db.select({
     itemId: phaseSessions.itemId,
-    at: sql21`max(${phaseSessions.createdAt})`.as("last_phase_at"),
-    atIso: sql21`to_char(max(${phaseSessions.createdAt}) at time zone 'utc', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`.as(
+    at: sql22`max(${phaseSessions.createdAt})`.as("last_phase_at"),
+    atIso: sql22`to_char(max(${phaseSessions.createdAt}) at time zone 'utc', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`.as(
       "last_phase_at_iso"
     )
   }).from(phaseSessions).groupBy(phaseSessions.itemId).as("last_phase_activity");
@@ -11206,15 +11241,22 @@ async function saveRepoConfig(orm, repoKey, config) {
   });
 }
 
+// src/shared/db/readUserConfig.ts
+async function readUserConfig(orm) {
+  const [row3] = await orm.select().from(userConfig);
+  return row3?.config ?? {};
+}
+
 // src/shared/writeRepoConfigCache.ts
 import { mkdirSync as mkdirSync6, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname12 } from "path";
-function writeRepoConfigCache(repos2) {
+function writeRepoConfigCache(repos2, user = {}) {
   const path108 = repoConfigCachePath();
   mkdirSync6(dirname12(path108), { recursive: true });
   const cache7 = {
     refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    repos: repos2
+    repos: repos2,
+    user
   };
   const tmp = `${path108}.${process.pid}.tmp`;
   writeFileSync5(tmp, JSON.stringify(cache7, null, 2));
@@ -11223,8 +11265,9 @@ function writeRepoConfigCache(repos2) {
 
 // src/shared/refreshRepoConfigCache.ts
 async function refreshRepoConfigCache(orm) {
-  const repos2 = await listRepoConfigs(orm ?? await getDb());
-  writeRepoConfigCache(repos2);
+  const db = orm ?? await getDb();
+  const repos2 = await listRepoConfigs(db);
+  writeRepoConfigCache(repos2, await readUserConfig(db));
   return Object.keys(repos2).length;
 }
 
@@ -11247,12 +11290,66 @@ async function applySharedRepoConfigSet(key, coerced, repoName, cwd = process.cw
   return { ok: true, target: "repo", label };
 }
 
+// src/shared/db/updateUserConfig.ts
+import { eq as eq24 } from "drizzle-orm";
+async function updateUserConfig(orm, update3) {
+  return orm.transaction(async (tx) => {
+    const [row3] = await tx.select().from(userConfig).where(eq24(userConfig.id, 1)).for("update");
+    const outcome = update3(row3?.config ?? {});
+    if (!outcome.ok) return outcome;
+    if (Object.keys(outcome.config).length === 0) {
+      await tx.delete(userConfig).where(eq24(userConfig.id, 1));
+      return outcome;
+    }
+    await tx.insert(userConfig).values({ id: 1, config: outcome.config }).onConflictDoUpdate({
+      target: userConfig.id,
+      set: { config: outcome.config, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    return outcome;
+  });
+}
+
+// src/commands/config/userDbKeyError.ts
+var DB_EXCLUDED_ROOTS = ["repos", "database"];
+function isNodeOnlyKey(key) {
+  const root2 = key.split(".")[0];
+  return isGlobalOnlyConfigKey(key) || DB_EXCLUDED_ROOTS.includes(root2);
+}
+function userDbKeyError(key, verb) {
+  if (!isNodeOnlyKey(key)) return void 0;
+  return {
+    ok: false,
+    errors: [
+      `"${key}" can't be stored in user (db); it stays in user (node). ${verb} it in ~/.assist.yml with -g`
+    ]
+  };
+}
+
+// src/commands/config/applyUserConfigSet.ts
+async function applyUserConfigSet(key, coerced) {
+  const nodeOnly = userDbKeyError(key, "Set");
+  if (nodeOnly) return nodeOnly;
+  const orm = await getDb();
+  const outcome = await updateUserConfig(orm, (current) => {
+    const config = setNestedValue(current, key, coerced);
+    const validation = validateConfig(config, key);
+    return validation.ok ? { ok: true, config, result: void 0 } : validation;
+  });
+  if (!outcome.ok) return outcome;
+  await refreshRepoConfigCache(orm);
+  return { ok: true, target: "user" };
+}
+
 // src/commands/sessions/web/applyScopedConfigSet.ts
 async function applyScopedConfigSet(key, value, cwd, scope, globalConfigPath) {
   if (scope === "repo") {
     const result2 = await applySharedRepoConfigSet(key, value, void 0, cwd);
     return result2.ok ? { ok: true, payload: { target: result2.target, repoKey: result2.label } } : result2;
   }
+  if (scope === "user") {
+    const result2 = await applyUserConfigSet(key, value);
+    return result2.ok ? { ok: true, payload: { target: result2.target } } : result2;
+  }
   const result = applyConfigSet(
     key,
     value,
@@ -11265,7 +11362,7 @@ async function applyScopedConfigSet(key, value, cwd, scope, globalConfigPath) {
 
 // src/commands/config/ConfigWriteScope.ts
 function isConfigWriteScope(value) {
-  return value === "project" || value === "global" || value === "repo";
+  return value === "project" || value === "global" || value === "repo" || value === "user";
 }
 
 // src/commands/sessions/web/parseConfigWriteRequest.ts
@@ -11452,6 +11549,22 @@ async function applySharedRepoConfigUnset(key, repoName, cwd = process.cwd()) {
   return { ok: true, target: "repo", label, removed: unset.removed };
 }
 
+// src/commands/config/applyUserConfigUnset.ts
+async function applyUserConfigUnset(key) {
+  const nodeOnly = userDbKeyError(key, "Unset");
+  if (nodeOnly) return nodeOnly;
+  const orm = await getDb();
+  const outcome = await updateUserConfig(orm, (current) => {
+    const { config, removed } = unsetNestedValue(current, key);
+    if (!removed) return { ok: true, config: current, result: false };
+    const validation = validateConfig(config, key);
+    return validation.ok ? { ok: true, config, result: true } : validation;
+  });
+  if (!outcome.ok) return outcome;
+  if (outcome.result) await refreshRepoConfigCache(orm);
+  return { ok: true, target: "user", removed: outcome.result };
+}
+
 // src/commands/sessions/web/applyScopedConfigUnset.ts
 async function applyScopedConfigUnset(key, cwd, scope, globalConfigPath) {
   if (scope === "repo") {
@@ -11465,6 +11578,13 @@ async function applyScopedConfigUnset(key, cwd, scope, globalConfigPath) {
       }
     } : result2;
   }
+  if (scope === "user") {
+    const result2 = await applyUserConfigUnset(key);
+    return result2.ok ? {
+      ok: true,
+      payload: { target: result2.target, removed: result2.removed }
+    } : result2;
+  }
   const result = applyConfigUnset(
     key,
     scope === "global",
@@ -14963,8 +15083,8 @@ async function buildDump(tables, copyOut) {
 // src/commands/backlog/dump/copyTableOut.ts
 import { to as copyTo } from "pg-copy-streams";
 async function copyTableOut(client, table) {
-  const sql29 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
-  const stream = client.query(copyTo(sql29));
+  const sql30 = `COPY ${table.name} (${table.columns.join(", ")}) TO STDOUT`;
+  const stream = client.query(copyTo(sql30));
   const chunks = [];
   for await (const chunk of stream) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -15076,8 +15196,8 @@ async function backup({ out }) {
   const dir = expandTilde(out ?? loadConfig().backup.dir);
   await mkdir3(dir, { recursive: true });
   const start2 = Date.now();
-  const timestamp7 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const filePath = resolve15(join42(dir, `backup-${timestamp7}.dump`));
+  const timestamp8 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filePath = resolve15(join42(dir, `backup-${timestamp8}.dump`));
   await exportBacklog(filePath);
   const { size } = await stat4(filePath);
   const durationMs = Date.now() - start2;
@@ -15428,11 +15548,11 @@ function registerActivityCommands(cmd) {
 
 // src/commands/backlog/associateGithub.ts
 import chalk43 from "chalk";
-import { eq as eq25 } from "drizzle-orm";
+import { eq as eq26 } from "drizzle-orm";
 
 // src/commands/backlog/beginAssociation.ts
 import chalk42 from "chalk";
-import { eq as eq24 } from "drizzle-orm";
+import { eq as eq25 } from "drizzle-orm";
 async function beginAssociation(id, options2, clearPatch, label) {
   const found = await findOneItem(id);
   if (!found) {
@@ -15442,7 +15562,7 @@ async function beginAssociation(id, options2, clearPatch, label) {
   const { orm } = found;
   const itemId2 = found.item.id;
   if (options2.clear) {
-    await orm.update(items).set(clearPatch).where(eq24(items.id, itemId2));
+    await orm.update(items).set(clearPatch).where(eq25(items.id, itemId2));
     console.log(
       chalk42.green(
         `Cleared ${label} association on item ${formatItemId(itemId2)}.`
@@ -15510,7 +15630,7 @@ async function associateGithub(id, issue, options2) {
     return;
   }
   const title = fetchGithubIssueTitle(normalized);
-  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq25(items.id, itemId2));
+  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq26(items.id, itemId2));
   console.log(
     chalk43.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     title ? chalk43.dim(`(${title})`) : ""
@@ -15524,7 +15644,7 @@ function registerAssociateGithubCommand(cmd) {
 
 // src/commands/backlog/associateJira.ts
 import chalk45 from "chalk";
-import { eq as eq26 } from "drizzle-orm";
+import { eq as eq27 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync17 } from "child_process";
@@ -15589,7 +15709,7 @@ async function associateJira(id, key, options2) {
   const parsed = fetchIssue(normalized, "summary");
   const fields = parsed?.fields;
   const summary = fields?.summary;
-  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq26(items.id, itemId2));
+  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq27(items.id, itemId2));
   console.log(
     chalk45.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     summary ? chalk45.dim(`(${summary})`) : ""
@@ -15871,8 +15991,8 @@ async function confirmReplace(client, tables, incoming, fromStdin) {
 import { finished } from "stream/promises";
 import { from as copyFrom } from "pg-copy-streams";
 async function copyTableIn(client, table, data) {
-  const sql29 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
-  const stream = client.query(copyFrom(sql29));
+  const sql30 = `COPY ${table.name} (${table.columns.join(", ")}) FROM STDIN`;
+  const stream = client.query(copyFrom(sql30));
   stream.end(data);
   await finished(stream);
 }
@@ -15974,15 +16094,15 @@ function isClaudeCode() {
 }
 
 // src/commands/backlog/insertPhaseAt.ts
-import { eq as eq28 } from "drizzle-orm";
+import { eq as eq29 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and9, desc as desc6, eq as eq27, gte } from "drizzle-orm";
+import { and as and9, desc as desc6, eq as eq28, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId2, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and9(eq27(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc6(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and9(eq28(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc6(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and9(eq27(planTasks.itemId, itemId2), eq27(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and9(eq27(planPhases.itemId, itemId2), eq27(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and9(eq28(planTasks.itemId, itemId2), eq28(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and9(eq28(planPhases.itemId, itemId2), eq28(planPhases.idx, p.idx)));
   }
 }
 
@@ -15995,7 +16115,7 @@ async function insertPhaseAt(orm, itemId2, phaseIdx, name, tasks, manualChecks,
       await tx.insert(planTasks).values(tasks.map((task, i) => ({ itemId: itemId2, phaseIdx, idx: i, task })));
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
-      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq28(items.id, itemId2));
+      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq29(items.id, itemId2));
     }
   });
 }
@@ -16152,9 +16272,9 @@ import chalk56 from "chalk";
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk55 from "chalk";
-import { count as count3, eq as eq29 } from "drizzle-orm";
+import { count as count3, eq as eq30 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId2, position) {
-  const [row3] = await orm.select({ cnt: count3() }).from(planPhases).where(eq29(planPhases.itemId, itemId2));
+  const [row3] = await orm.select({ cnt: count3() }).from(planPhases).where(eq30(planPhases.itemId, itemId2));
   const phaseCount = row3?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -16574,9 +16694,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq30 } from "drizzle-orm";
+import { eq as eq31 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq30(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq31(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId: itemId2, targetId } of rows) {
     const bucket = graph.get(itemId2);
@@ -16643,7 +16763,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk64 from "chalk";
-import { and as and10, eq as eq31 } from "drizzle-orm";
+import { and as and10, eq as eq32 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = parseItemId(fromId);
   const toNum = parseItemId(toId);
@@ -16667,7 +16787,7 @@ async function unlink(fromId, toId) {
     );
     return;
   }
-  await orm.delete(links).where(and10(eq31(links.itemId, fromNum), eq31(links.targetId, toNum)));
+  await orm.delete(links).where(and10(eq32(links.itemId, fromNum), eq32(links.targetId, toNum)));
   console.log(
     chalk64.green(
       `Removed link from ${formatItemId(fromNum)} to ${formatItemId(toNum)}.`
@@ -16687,7 +16807,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/moveRepo.ts
 import chalk66 from "chalk";
-import { eq as eq33 } from "drizzle-orm";
+import { eq as eq34 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk65 from "chalk";
@@ -16702,9 +16822,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count4, eq as eq32 } from "drizzle-orm";
+import { count as count4, eq as eq33 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq32(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count4() }).from(items).where(eq33(items.origin, origin));
   return cnt;
 }
 
@@ -16747,7 +16867,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk66.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq33(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq34(items.origin, oldOrigin));
   console.log(
     chalk66.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -16911,9 +17031,9 @@ function processStartedAt(pid) {
 
 // src/commands/backlog/isStaleLock.ts
 var clockSlackMs = 5e3;
-function isStaleLock(pid, timestamp7) {
-  if (typeof timestamp7 !== "string") return false;
-  const lockedAt = Date.parse(timestamp7);
+function isStaleLock(pid, timestamp8) {
+  if (typeof timestamp8 !== "string") return false;
+  const lockedAt = Date.parse(timestamp8);
   if (Number.isNaN(lockedAt)) return false;
   if (lockedAt < bootedAt() - clockSlackMs) return true;
   const startedAt = processStartedAt(pid);
@@ -17219,12 +17339,12 @@ function message(error) {
 import chalk70 from "chalk";
 
 // src/shared/db/findPhaseBySessionId.ts
-import { and as and11, eq as eq34 } from "drizzle-orm";
+import { and as and11, eq as eq35 } from "drizzle-orm";
 async function findPhaseBySessionId(db, itemId2, claudeSessionId) {
   const rows = await db.select({ phaseIdx: phaseUsage.phaseIdx }).from(phaseUsage).where(
     and11(
-      eq34(phaseUsage.itemId, itemId2),
-      eq34(phaseUsage.claudeSessionId, claudeSessionId)
+      eq35(phaseUsage.itemId, itemId2),
+      eq35(phaseUsage.claudeSessionId, claudeSessionId)
     )
   ).limit(1);
   return rows[0]?.phaseIdx;
@@ -17834,7 +17954,7 @@ import { randomUUID as randomUUID6 } from "crypto";
 import os4 from "os";
 
 // src/shared/db/recordPhaseSession.ts
-import { sql as sql22 } from "drizzle-orm";
+import { sql as sql23 } from "drizzle-orm";
 async function recordPhaseSession(db, itemId2, phaseIdx, claudeSessionId, hostname2, osUser) {
   await db.insert(phaseSessions).values({ itemId: itemId2, phaseIdx, claudeSessionId, hostname: hostname2, osUser }).onConflictDoUpdate({
     target: [
@@ -17843,7 +17963,7 @@ async function recordPhaseSession(db, itemId2, phaseIdx, claudeSessionId, hostna
       phaseSessions.claudeSessionId
     ],
     set: { hostname: hostname2, osUser },
-    setWhere: sql22`${phaseSessions.hostname} = 'unknown'`
+    setWhere: sql23`${phaseSessions.hostname} = 'unknown'`
   });
 }
 
@@ -18704,10 +18824,10 @@ async function start(id) {
 
 // src/commands/backlog/stop.ts
 import chalk93 from "chalk";
-import { and as and12, eq as eq35 } from "drizzle-orm";
+import { and as and12, eq as eq36 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and12(eq35(items.status, "in-progress"), eq35(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and12(eq36(items.status, "in-progress"), eq36(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk93.yellow("No in-progress items to stop."));
     return;
@@ -18765,20 +18885,20 @@ function registerStatusCommands(cmd) {
 
 // src/commands/backlog/movePhase.ts
 import chalk96 from "chalk";
-import { count as count6, eq as eq38 } from "drizzle-orm";
+import { count as count6, eq as eq39 } from "drizzle-orm";
 
 // src/commands/backlog/reorderPhaseRows.ts
-import { and as and14, asc as asc10, eq as eq37 } from "drizzle-orm";
+import { and as and14, asc as asc10, eq as eq38 } from "drizzle-orm";
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and13, asc as asc9, count as count5, eq as eq36 } from "drizzle-orm";
+import { and as and13, asc as asc9, count as count5, eq as eq37 } from "drizzle-orm";
 async function reindexPhases(db, itemId2) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq36(planPhases.itemId, itemId2)).orderBy(asc9(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq37(planPhases.itemId, itemId2)).orderBy(asc9(planPhases.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
-    await db.update(planTasks).set({ phaseIdx: i }).where(and13(eq36(planTasks.itemId, itemId2), eq36(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and13(eq36(planPhases.itemId, itemId2), eq36(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and13(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and13(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -18786,24 +18906,24 @@ async function adjustCurrentPhase(db, item, removedIdx) {
   if (currentPhase === void 0) return;
   const currentIdx = currentPhase - 1;
   if (removedIdx < currentIdx) {
-    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq36(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq37(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row3] = await db.select({ cnt: count5() }).from(planPhases).where(eq36(planPhases.itemId, item.id));
+  const [row3] = await db.select({ cnt: count5() }).from(planPhases).where(eq37(planPhases.itemId, item.id));
   const cnt = row3?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq36(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq37(items.id, item.id));
 }
 
 // src/commands/backlog/reorderPhaseRows.ts
 async function reorderPhaseRows(orm, itemId2, fromIdx, toIdx) {
   await orm.transaction(async (tx) => {
-    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and14(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, fromIdx)));
-    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and14(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, fromIdx))).orderBy(asc10(planTasks.idx));
+    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and14(eq38(planPhases.itemId, itemId2), eq38(planPhases.idx, fromIdx)));
+    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and14(eq38(planTasks.itemId, itemId2), eq38(planTasks.phaseIdx, fromIdx))).orderBy(asc10(planTasks.idx));
     await tx.delete(planTasks).where(
-      and14(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, fromIdx))
+      and14(eq38(planTasks.itemId, itemId2), eq38(planTasks.phaseIdx, fromIdx))
     );
-    await tx.delete(planPhases).where(and14(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, fromIdx)));
+    await tx.delete(planPhases).where(and14(eq38(planPhases.itemId, itemId2), eq38(planPhases.idx, fromIdx)));
     await reindexPhases(tx, itemId2);
     await shiftPhasesUp(tx, itemId2, toIdx);
     await tx.insert(planPhases).values({
@@ -18844,7 +18964,7 @@ async function movePhase(id, from, to) {
   if (!found) return;
   const { orm, item } = found;
   const itemId2 = item.id;
-  const [row3] = await orm.select({ cnt: count6() }).from(planPhases).where(eq38(planPhases.itemId, itemId2));
+  const [row3] = await orm.select({ cnt: count6() }).from(planPhases).where(eq39(planPhases.itemId, itemId2));
   const phaseCount = row3?.cnt ?? 0;
   const fromIdx = toIndex2(from, phaseCount);
   if (fromIdx === void 0) return;
@@ -18860,22 +18980,22 @@ async function movePhase(id, from, to) {
 import chalk98 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and15, eq as eq39 } from "drizzle-orm";
+import { and as and15, eq as eq40 } from "drizzle-orm";
 async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
   await orm.transaction(async (tx) => {
     if (fields.name) {
       await tx.update(planPhases).set({ name: fields.name }).where(
-        and15(eq39(planPhases.itemId, itemId2), eq39(planPhases.idx, phaseIdx))
+        and15(eq40(planPhases.itemId, itemId2), eq40(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and15(eq39(planPhases.itemId, itemId2), eq39(planPhases.idx, phaseIdx))
+        and15(eq40(planPhases.itemId, itemId2), eq40(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and15(eq39(planTasks.itemId, itemId2), eq39(planTasks.phaseIdx, phaseIdx))
+        and15(eq40(planTasks.itemId, itemId2), eq40(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -18893,14 +19013,14 @@ async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
 
 // src/commands/backlog/findPhase.ts
 import chalk97 from "chalk";
-import { and as and16, count as count7, eq as eq40 } from "drizzle-orm";
+import { and as and16, count as count7, eq as eq41 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const found = await findOneItem(id);
   if (!found) return void 0;
   const { orm, item } = found;
   const itemId2 = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row3] = await orm.select({ cnt: count7() }).from(planPhases).where(and16(eq40(planPhases.itemId, itemId2), eq40(planPhases.idx, phaseIdx)));
+  const [row3] = await orm.select({ cnt: count7() }).from(planPhases).where(and16(eq41(planPhases.itemId, itemId2), eq41(planPhases.idx, phaseIdx)));
   if (!row3 || row3.cnt === 0) {
     console.log(
       chalk97.red(
@@ -19073,16 +19193,16 @@ function registerUpdatePhaseCommand(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk99 from "chalk";
-import { and as and17, eq as eq41 } from "drizzle-orm";
+import { and as and17, eq as eq42 } from "drizzle-orm";
 async function removePhase(id, phase) {
   const found = await findPhase(id, phase);
   if (!found) return;
   const { item, orm, itemId: itemId2, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and17(eq41(planTasks.itemId, itemId2), eq41(planTasks.phaseIdx, phaseIdx))
+      and17(eq42(planTasks.itemId, itemId2), eq42(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and17(eq41(planPhases.itemId, itemId2), eq41(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and17(eq42(planPhases.itemId, itemId2), eq42(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId2);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -19095,7 +19215,7 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/update.ts
 import chalk103 from "chalk";
-import { eq as eq42 } from "drizzle-orm";
+import { eq as eq43 } from "drizzle-orm";
 
 // src/commands/backlog/update/buildUpdateValues.ts
 import chalk100 from "chalk";
@@ -19206,7 +19326,7 @@ async function update(id, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId2 = found.item.id;
-  await orm.update(items).set(built.set).where(eq42(items.id, itemId2));
+  await orm.update(items).set(built.set).where(eq43(items.id, itemId2));
   console.log(
     chalk103.green(`Updated ${built.fields} on item ${formatItemId(itemId2)}.`)
   );
@@ -19252,7 +19372,7 @@ function readPlanUpdate(source) {
 }
 
 // src/commands/backlog/updatePlan/replacePlan.ts
-import { eq as eq43 } from "drizzle-orm";
+import { eq as eq44 } from "drizzle-orm";
 
 // src/commands/backlog/updatePlan/clampCurrentPhase.ts
 function clampCurrentPhase(currentPhase, phaseCount) {
@@ -19263,8 +19383,8 @@ function clampCurrentPhase(currentPhase, phaseCount) {
 // src/commands/backlog/updatePlan/replacePlan.ts
 async function replacePlan(orm, itemId2, phases, currentPhase) {
   await orm.transaction(async (tx) => {
-    await tx.delete(planTasks).where(eq43(planTasks.itemId, itemId2));
-    await tx.delete(planPhases).where(eq43(planPhases.itemId, itemId2));
+    await tx.delete(planTasks).where(eq44(planTasks.itemId, itemId2));
+    await tx.delete(planPhases).where(eq44(planPhases.itemId, itemId2));
     if (phases.length > 0) {
       await tx.insert(planPhases).values(
         phases.map((phase, idx) => ({
@@ -19282,7 +19402,7 @@ async function replacePlan(orm, itemId2, phases, currentPhase) {
     if (currentPhase === void 0) return;
     const clamped = clampCurrentPhase(currentPhase, phases.length);
     if (clamped === currentPhase) return;
-    await tx.update(items).set({ currentPhase: clamped }).where(eq43(items.id, itemId2));
+    await tx.update(items).set({ currentPhase: clamped }).where(eq44(items.id, itemId2));
   });
 }
 
@@ -23018,8 +23138,8 @@ async function setDbBackedConfigKey(key, value, useRepo) {
 
 // src/commands/config/setFileConfigKey.ts
 import chalk134 from "chalk";
-async function setFileConfigKey({ key, useRepo, repoName, global }, coerced) {
-  const target = useRepo ? `repo: ${await applyRepoOrExit(key, coerced, repoName)}` : applyOrExit(key, coerced, global);
+async function setFileConfigKey({ key, useRepo, repoName, global, user }, coerced) {
+  const target = useRepo ? `repo: ${await applyRepoOrExit(key, coerced, repoName)}` : user ? await applyUserOrExit(key, coerced) : applyOrExit(key, coerced, global);
   const shown = JSON.stringify(maskConfigKeySecrets(key, coerced));
   console.log(chalk134.green(`Set ${key} = ${shown} (${target})`));
 }
@@ -23028,20 +23148,30 @@ function applyOrExit(key, coerced, global) {
   if (!result.ok) exitWithConfigErrors(result.errors);
   return result.target;
 }
+async function applyUserOrExit(key, coerced) {
+  const result = await applyUserConfigSet(key, coerced);
+  if (!result.ok) exitWithConfigErrors(result.errors);
+  return "user (db)";
+}
 async function applyRepoOrExit(key, coerced, repoName) {
   const result = await applySharedRepoConfigSet(key, coerced, repoName);
   if (!result.ok) exitWithConfigErrors(result.errors);
   return result.label;
 }
 
+// src/commands/config/scopeOptionsError.ts
+function scopeOptionsError(options2, repoAction) {
+  if (options2.user && (options2.global || options2.repo !== void 0))
+    return "--user writes user (db); drop -g and --repo";
+  if (options2.repo !== void 0 && !options2.global)
+    return `--repo ${repoAction} the global config; add -g (e.g. -g --repo)`;
+  return void 0;
+}
+
 // src/commands/config/configSet.ts
 async function configSet(key, value, options2 = {}) {
-  if (options2.repo !== void 0 && !options2.global) {
-    console.error(
-      chalk135.red("--repo writes to the global config; add -g (e.g. -g --repo)")
-    );
-    process.exit(1);
-  }
+  const scopeError = scopeOptionsError(options2, "writes to");
+  if (scopeError) exitWithConfigErrors([scopeError]);
   const resolved = resolveRepoTarget(key, value, options2.repo);
   if (resolved.value === void 0) {
     console.error(chalk135.red(`Missing required argument for '${resolved.key}'`));
@@ -23052,7 +23182,11 @@ async function configSet(key, value, options2 = {}) {
   if (isDbBackedConfigKey(resolved.key))
     return setDbBackedConfigKey(resolved.key, coercion.value, resolved.useRepo);
   await setFileConfigKey(
-    { ...resolved, global: options2.global ?? false },
+    {
+      ...resolved,
+      global: options2.global ?? false,
+      user: options2.user ?? false
+    },
     coercion.value
   );
 }
@@ -23086,9 +23220,10 @@ async function unsetFileConfigKey({
   key,
   useRepo,
   repoName,
-  global
+  global,
+  user
 }) {
-  const result = useRepo ? await applySharedRepoConfigUnset(key, repoName) : applyConfigUnset(key, global);
+  const result = useRepo ? await applySharedRepoConfigUnset(key, repoName) : user ? await applyUserConfigUnset(key) : applyConfigUnset(key, global);
   if (!result.ok) exitWithConfigErrors(result.errors);
   if (!result.removed) {
     console.log(chalk137.yellow(`${key} is not set in ${whereLabel(result)}`));
@@ -23097,22 +23232,20 @@ async function unsetFileConfigKey({
   console.log(chalk137.green(`Unset ${key} (${targetLabel(result)})`));
 }
 function whereLabel(result) {
-  return result.target === "repo" ? `repos.${result.label}` : `the ${result.target} config`;
+  if (result.target === "repo") return `repos.${result.label}`;
+  if (result.target === "user") return "user (db)";
+  return `the ${result.target} config`;
 }
 function targetLabel(result) {
-  return result.target === "repo" ? `repo: ${result.label}` : result.target;
+  if (result.target === "repo") return `repo: ${result.label}`;
+  if (result.target === "user") return "user (db)";
+  return result.target;
 }
 
 // src/commands/config/configUnset.ts
 async function configUnset(key, options2 = {}) {
-  if (options2.repo !== void 0 && !options2.global) {
-    console.error(
-      chalk138.red(
-        "--repo removes from the global config; add -g (e.g. -g --repo)"
-      )
-    );
-    process.exit(1);
-  }
+  const scopeError = scopeOptionsError(options2, "removes from");
+  if (scopeError) exitWithConfigErrors([scopeError]);
   const resolved = resolveRepoUnsetTarget(key, options2.repo);
   if (resolved.key === void 0) {
     console.error(chalk138.red("Missing required argument 'key'"));
@@ -23125,25 +23258,34 @@ async function configUnset(key, options2 = {}) {
     key: resolved.key,
     useRepo: resolved.useRepo,
     repoName: resolved.repoName,
-    global: options2.global ?? false
+    global: options2.global ?? false,
+    user: options2.user ?? false
   });
 }
 
-// src/commands/registerConfig.ts
-function registerConfig(program) {
-  const configCommand = configHelp(
-    program.command("config").description("View and modify assist.yml configuration"),
-    configConfigHelp,
-    "Run 'assist config keys [filter]' to list every config key with its default,\nwhat it does, and the command that sets it."
-  );
+// src/commands/config/registerConfigWrites.ts
+function registerConfigWrites(configCommand) {
   configCommand.command("set <key> [value]").description("Set a config value (e.g. commit.push true)").option("-g, --global", "Write to global ~/.assist.yml").option(
     "-r, --repo [name]",
     "Requires -g: write a repo's override to the shared db, seen by every node (defaults to the current repo)"
+  ).option(
+    "-u, --user",
+    "Write to user (db): the shared db, applied to every repo on every node"
   ).action((key, value, options2) => configSet(key, value, options2));
   configCommand.command("unset [key]").description("Remove a config value (e.g. commit.push)").option("-g, --global", "Remove from global ~/.assist.yml").option(
     "-r, --repo [name]",
     "Requires -g: remove the key from a repo's shared db override (defaults to the current repo)"
-  ).action((key, options2) => configUnset(key, options2));
+  ).option("-u, --user", "Remove from user (db) in the shared db").action((key, options2) => configUnset(key, options2));
+}
+
+// src/commands/registerConfig.ts
+function registerConfig(program) {
+  const configCommand = configHelp(
+    program.command("config").description("View and modify assist.yml configuration"),
+    configConfigHelp,
+    "Run 'assist config keys [filter]' to list every config key with its default,\nwhat it does, and the command that sets it."
+  );
+  registerConfigWrites(configCommand);
   configCommand.command("import-repos").description(
     "Move this machine's ~/.assist.yml repos: overrides into the shared db, showing a per-key diff and asking first"
   ).action(configImportRepos);
@@ -23246,8 +23388,8 @@ import { homedir as homedir21 } from "os";
 import { join as join54 } from "path";
 function snapshotPath(tabUrl, now) {
   const host = new URL(tabUrl).host.replace(/[^\w.-]/g, "-");
-  const timestamp7 = now.toISOString().replace(/[:.]/g, "-");
-  return join54(homedir21(), ".assist", "browser", `${host}-${timestamp7}.html`);
+  const timestamp8 = now.toISOString().replace(/[:.]/g, "-");
+  return join54(homedir21(), ".assist", "browser", `${host}-${timestamp8}.html`);
 }
 
 // src/commands/browser/browserSnapshot.ts
@@ -27746,10 +27888,10 @@ async function list3() {
 import chalk173 from "chalk";
 
 // src/shared/db/readInboxLastScan.ts
-import { eq as eq44 } from "drizzle-orm";
+import { eq as eq45 } from "drizzle-orm";
 var INBOX_LAST_SCAN_KEY = "inbox.lastScanAt";
 async function readInboxLastScan(orm) {
-  const [row3] = await orm.select().from(metadata).where(eq44(metadata.key, INBOX_LAST_SCAN_KEY));
+  const [row3] = await orm.select().from(metadata).where(eq45(metadata.key, INBOX_LAST_SCAN_KEY));
   return row3 ? new Date(row3.value) : void 0;
 }
 
@@ -30486,9 +30628,9 @@ async function list4() {
 import chalk189 from "chalk";
 
 // src/commands/backlog/removeFeed.ts
-import { eq as eq45 } from "drizzle-orm";
+import { eq as eq46 } from "drizzle-orm";
 async function removeFeed(db, url) {
-  const deleted = await db.delete(feeds).where(eq45(feeds.url, url)).returning({ id: feeds.id });
+  const deleted = await db.delete(feeds).where(eq46(feeds.url, url)).returning({ id: feeds.id });
   return deleted.length > 0;
 }
 
@@ -32601,8 +32743,8 @@ function bucketPr(pr) {
 }
 
 // src/commands/prs/status/describeAge.ts
-function describeAge(timestamp7, now = Date.now()) {
-  const parsed = new Date(timestamp7).getTime();
+function describeAge(timestamp8, now = Date.now()) {
+  const parsed = new Date(timestamp8).getTime();
   if (Number.isNaN(parsed)) return { hours: null, label: "unknown" };
   const hours = Math.max(0, Math.floor((now - parsed) / 36e5));
   if (hours < 1) return { hours, label: "<1h" };
@@ -34173,8 +34315,8 @@ function buildOutputPath(outputDir, processName) {
   if (!existsSync65(outputDir)) {
     mkdirSync24(outputDir, { recursive: true });
   }
-  const timestamp7 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve24(outputDir, `${processName}-${timestamp7}.png`);
+  const timestamp8 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return resolve24(outputDir, `${processName}-${timestamp8}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
   const scriptPath = join83(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
@@ -41132,8 +41274,8 @@ function filterToSql(filter) {
 // src/commands/seq/fetchSeqData.ts
 function buildDataParams(filter, count10, from, to) {
   const sqlFilter = filterToSql(filter);
-  const sql29 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count10}`;
-  const params = new URLSearchParams({ q: sql29 });
+  const sql30 = `select @Timestamp, @Level, @Exception, @Message from stream where ${sqlFilter} order by @Timestamp desc limit ${count10}`;
+  const params = new URLSearchParams({ q: sql30 });
   if (from) params.set("rangeStartUtc", from);
   if (to) params.set("rangeEndUtc", to);
   return params;
@@ -41647,26 +41789,26 @@ import chalk259 from "chalk";
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
   const raw = loadGlobalConfigRaw();
-  const sql29 = raw.sql;
-  return sql29?.connections ?? [];
+  const sql30 = raw.sql;
+  return sql30?.connections ?? [];
 }
 function saveConnections3(connections) {
   const raw = loadGlobalConfigRaw();
-  const sql29 = raw.sql ?? {};
-  sql29.connections = connections;
-  raw.sql = sql29;
+  const sql30 = raw.sql ?? {};
+  sql30.connections = connections;
+  raw.sql = sql30;
   saveGlobalConfig(raw);
 }
 function getDefaultConnection2() {
   const raw = loadGlobalConfigRaw();
-  const sql29 = raw.sql;
-  return sql29?.defaultConnection;
+  const sql30 = raw.sql;
+  return sql30?.defaultConnection;
 }
 function setDefaultConnection2(name) {
   const raw = loadGlobalConfigRaw();
-  const sql29 = raw.sql ?? {};
-  sql29.defaultConnection = name;
-  raw.sql = sql29;
+  const sql30 = raw.sql ?? {};
+  sql30.defaultConnection = name;
+  raw.sql = sql30;
   saveGlobalConfig(raw);
 }
 
@@ -41737,9 +41879,9 @@ function resolveConnection3(name) {
 }
 
 // src/commands/sql/sqlConnect.ts
-import sql23 from "mssql";
+import sql24 from "mssql";
 async function sqlConnect(conn) {
-  return await sql23.connect({
+  return await sql24.connect({
     server: conn.server,
     port: conn.port,
     user: conn.user,
@@ -41802,11 +41944,11 @@ var MUTATION_PATTERN = new RegExp(
   `\\b(${MUTATION_KEYWORDS.join("|")})\\b`,
   "i"
 );
-function stripComments(sql29) {
-  return sql29.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+function stripComments(sql30) {
+  return sql30.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
 }
-function isMutation(sql29) {
-  const stripped = stripComments(sql29);
+function isMutation(sql30) {
+  const stripped = stripComments(sql30);
   if (MUTATION_PATTERN.test(stripped)) return true;
   return /\bSELECT\b[\s\S]+\bINTO\s+\w/i.test(stripped);
 }
@@ -44830,12 +44972,12 @@ function parseEnvPairs(pairs) {
   if (pairs.length === 0) return void 0;
   const env = {};
   for (const pair of pairs) {
-    const eq48 = pair.indexOf("=");
-    if (eq48 <= 0) {
+    const eq49 = pair.indexOf("=");
+    if (eq49 <= 0) {
       console.error(`--env must be KEY=VALUE, got "${pair}"`);
       process.exit(1);
     }
-    env[pair.slice(0, eq48)] = pair.slice(eq48 + 1);
+    env[pair.slice(0, eq49)] = pair.slice(eq49 + 1);
   }
   return env;
 }
@@ -44848,11 +44990,11 @@ function fail9(spec) {
   process.exit(1);
 }
 function parseParamSpec(spec) {
-  const eq48 = spec.indexOf("=");
-  const name = eq48 === -1 ? spec : spec.slice(0, eq48);
-  if (eq48 !== -1) {
-    if (eq48 === 0 || name.endsWith("!")) fail9(spec);
-    return { name, default: spec.slice(eq48 + 1) };
+  const eq49 = spec.indexOf("=");
+  const name = eq49 === -1 ? spec : spec.slice(0, eq49);
+  if (eq49 !== -1) {
+    if (eq49 === 0 || name.endsWith("!")) fail9(spec);
+    return { name, default: spec.slice(eq49 + 1) };
   }
   if (name.endsWith("!")) {
     if (name.length === 1) fail9(spec);
@@ -45362,6 +45504,9 @@ function createAutoExit(exit, graceMs = DEFAULT_GRACE_MS) {
 
 // src/commands/sessions/daemon/pollRepoConfigCache.ts
 var POLL_MS = 6e4;
+function cacheSnapshot() {
+  return JSON.stringify([readRepoConfigCache(), readUserConfigCache()]);
+}
 function pollRepoConfigCache(intervalMs = POLL_MS) {
   let inFlight2 = false;
   let failing = false;
@@ -45369,11 +45514,11 @@ function pollRepoConfigCache(intervalMs = POLL_MS) {
     if (inFlight2) return;
     inFlight2 = true;
     try {
-      const before = JSON.stringify(readRepoConfigCache());
+      const before = cacheSnapshot();
       const count10 = await refreshRepoConfigCache();
       if (failing) daemonLog("repo config cache poll recovered");
       failing = false;
-      if (JSON.stringify(readRepoConfigCache()) !== before)
+      if (cacheSnapshot() !== before)
         daemonLog(`repo config cache updated (${count10} repos)`);
     } catch (error) {
       if (!failing)
@@ -47509,13 +47654,13 @@ function drainSessions(sessions, notify2) {
 }
 
 // src/shared/db/recordPhaseActiveMs.ts
-import { sql as sql24 } from "drizzle-orm";
+import { sql as sql25 } from "drizzle-orm";
 async function recordPhaseActiveMs(db, itemId2, phaseIdx, activeMs) {
   if (activeMs <= 0) return;
   await db.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, activeMs }).onConflictDoUpdate({
     target: [phaseUsage.itemId, phaseUsage.phaseIdx],
     set: {
-      activeMs: sql24`${phaseUsage.activeMs} + excluded.active_ms`
+      activeMs: sql25`${phaseUsage.activeMs} + excluded.active_ms`
     }
   });
 }
@@ -48116,10 +48261,10 @@ function applyReviewPause(session, activity2) {
 }
 
 // src/shared/db/getPhaseActiveMs.ts
-import { and as and18, eq as eq46 } from "drizzle-orm";
+import { and as and18, eq as eq47 } from "drizzle-orm";
 async function getPhaseActiveMs(db, itemId2, phaseIdx) {
   const [row3] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
-    and18(eq46(phaseUsage.itemId, itemId2), eq46(phaseUsage.phaseIdx, phaseIdx))
+    and18(eq47(phaseUsage.itemId, itemId2), eq47(phaseUsage.phaseIdx, phaseIdx))
   );
   return row3?.activeMs ?? 0;
 }
@@ -48904,7 +49049,7 @@ async function readTranscriptUsage(transcriptPath2) {
 }
 
 // src/shared/db/recordPhaseCycleContext.ts
-import { sql as sql25 } from "drizzle-orm";
+import { sql as sql26 } from "drizzle-orm";
 async function recordPhaseCycleContext(db, itemId2, phaseIdx, window, resetsAt, pct) {
   if (pct <= 0) return;
   await db.insert(phaseCycleContext).values({ itemId: itemId2, phaseIdx, window, resetsAt, peakContextPct: pct }).onConflictDoUpdate({
@@ -48915,24 +49060,24 @@ async function recordPhaseCycleContext(db, itemId2, phaseIdx, window, resetsAt,
       phaseCycleContext.resetsAt
     ],
     set: {
-      peakContextPct: sql25`GREATEST(${phaseCycleContext.peakContextPct}, ${pct})`
+      peakContextPct: sql26`GREATEST(${phaseCycleContext.peakContextPct}, ${pct})`
     }
   });
 }
 
 // src/shared/db/recordPhasePeakContext.ts
-import { sql as sql26 } from "drizzle-orm";
+import { sql as sql27 } from "drizzle-orm";
 async function recordPhasePeakContext(db, itemId2, phaseIdx, pct) {
   await db.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, peakContextPct: pct }).onConflictDoUpdate({
     target: [phaseUsage.itemId, phaseUsage.phaseIdx],
     set: {
-      peakContextPct: sql26`GREATEST(${phaseUsage.peakContextPct}, ${pct})`
+      peakContextPct: sql27`GREATEST(${phaseUsage.peakContextPct}, ${pct})`
     }
   });
 }
 
 // src/shared/db/recordPhaseTranscriptUsage.ts
-import { sql as sql27 } from "drizzle-orm";
+import { sql as sql28 } from "drizzle-orm";
 async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
   const byId = /* @__PURE__ */ new Map();
   for (const r of responses) byId.set(r.messageId, r);
@@ -48952,8 +49097,8 @@ async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
     await tx.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, tokensUp, tokensDown }).onConflictDoUpdate({
       target: [phaseUsage.itemId, phaseUsage.phaseIdx],
       set: {
-        tokensUp: sql27`${phaseUsage.tokensUp} + ${tokensUp}`,
-        tokensDown: sql27`${phaseUsage.tokensDown} + ${tokensDown}`
+        tokensUp: sql28`${phaseUsage.tokensUp} + ${tokensUp}`,
+        tokensDown: sql28`${phaseUsage.tokensDown} + ${tokensDown}`
       }
     });
     return { tokensUp, tokensDown };
@@ -48961,17 +49106,17 @@ async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
 }
 
 // src/shared/db/recordWindowTokens.ts
-import { and as and19, eq as eq47, sql as sql28 } from "drizzle-orm";
+import { and as and19, eq as eq48, sql as sql29 } from "drizzle-orm";
 async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
   if (tokensUp <= 0 && tokensDown <= 0) return;
   await db.update(usagePeaks).set({
-    tokensUp: sql28`${usagePeaks.tokensUp} + ${tokensUp}`,
-    tokensDown: sql28`${usagePeaks.tokensDown} + ${tokensDown}`
+    tokensUp: sql29`${usagePeaks.tokensUp} + ${tokensUp}`,
+    tokensDown: sql29`${usagePeaks.tokensDown} + ${tokensDown}`
   }).where(
     and19(
-      eq47(usagePeaks.window, window),
-      eq47(usagePeaks.resetsAt, resetsAt),
-      eq47(usagePeaks.segment, 0)
+      eq48(usagePeaks.window, window),
+      eq48(usagePeaks.resetsAt, resetsAt),
+      eq48(usagePeaks.segment, 0)
     )
   );
 }