@mndrk/agx 2.4.3 → 2.4.5

package/cloud-runtime/standalone/apps/local/worker/index.js

@@ -762,6 +762,28 @@ var init_boss = __esm({
   }
 });
 
+// apps/local/lib/db/types.ts
+function validateIdentifierPrefix(prefix) {
+  if (prefix === null || prefix === void 0 || prefix === "") return null;
+  if (typeof prefix !== "string") {
+    throw new Error("identifier_prefix must be a string");
+  }
+  const trimmed = prefix.trim().toUpperCase();
+  if (!IDENTIFIER_PREFIX_REGEX.test(trimmed)) {
+    throw new Error(
+      "identifier_prefix must be 2-10 uppercase ASCII letters (e.g. 'TSK', 'AGX')"
+    );
+  }
+  return trimmed;
+}
+var IDENTIFIER_PREFIX_REGEX;
+var init_types = __esm({
+  "apps/local/lib/db/types.ts"() {
+    "use strict";
+    IDENTIFIER_PREFIX_REGEX = /^[A-Z]{2,10}$/;
+  }
+});
+
 // apps/local/lib/auth-mode.ts
 var LOCAL_USER;
 var init_auth_mode = __esm({
@@ -1644,6 +1666,35 @@ var init_workspaces_to_projects_migration = __esm({
   }
 });
 
+// apps/local/lib/migrations/task-identifier-migration.ts
+function runTaskIdentifierMigration(db2) {
+  try {
+    db2.exec("ALTER TABLE projects ADD COLUMN identifier_prefix TEXT");
+  } catch {
+  }
+  try {
+    db2.exec(
+      "ALTER TABLE projects ADD COLUMN next_identifier INTEGER NOT NULL DEFAULT 1"
+    );
+  } catch {
+  }
+  try {
+    db2.exec("ALTER TABLE tasks ADD COLUMN identifier TEXT");
+  } catch {
+  }
+  try {
+    db2.exec(
+      "CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_identifier ON tasks (project_id, identifier) WHERE identifier IS NOT NULL"
+    );
+  } catch {
+  }
+}
+var init_task_identifier_migration = __esm({
+  "apps/local/lib/migrations/task-identifier-migration.ts"() {
+    "use strict";
+  }
+});
+
 // apps/local/lib/sqlite-query-adapter.ts
 var sqlite_query_adapter_exports = {};
 __export(sqlite_query_adapter_exports, {
@@ -1681,6 +1732,7 @@ ${msgs.join("\n")}`);
   }
   dropLegacyTeamsTables(_db);
   ensureProjectScopedTeamTables(_db);
+  ensureWorkspaceEntriesTable(_db);
   return _db;
 }
 function initSQLiteSchema(db2) {
@@ -1736,6 +1788,30 @@ function ensureProjectScopedTeamTables(db2) {
       END;
   `);
 }
+function ensureWorkspaceEntriesTable(db2) {
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS workspace_entries (
+      id TEXT NOT NULL PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      category TEXT NOT NULL,
+      name TEXT NOT NULL,
+      path TEXT DEFAULT NULL,
+      purpose TEXT,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      UNIQUE(project_id, category, name)
+    );
+    CREATE INDEX IF NOT EXISTS idx_workspace_entries_project_id ON workspace_entries(project_id);
+
+    CREATE TRIGGER IF NOT EXISTS workspace_entries_updated_at
+      AFTER UPDATE ON workspace_entries
+      FOR EACH ROW
+      BEGIN
+        UPDATE workspace_entries SET updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') WHERE rowid = NEW.rowid;
+      END;
+  `);
+}
 function runMigrations(db2) {
   const graphTables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='execution_graphs'").all();
   if (graphTables.length > 0) {
@@ -1744,6 +1820,7 @@ function runMigrations(db2) {
       db2.exec("ALTER TABLE execution_graphs ADD COLUMN schedule JSON");
     }
   }
+  runTaskIdentifierMigration(db2);
   const projectTables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='projects'").all();
   if (projectTables.length > 0) {
     const projectCols = pragmaAll(db2, "table_info(projects)");
@@ -1814,6 +1891,7 @@ function runMigrations(db2) {
     CREATE INDEX IF NOT EXISTS idx_agent_skill_bindings_agent ON agent_skill_bindings (agent_id, created_at);
   `);
   ensureProjectScopedTeamTables(db2);
+  ensureWorkspaceEntriesTable(db2);
   db2.exec(`
     CREATE TABLE IF NOT EXISTS project_agents (
       project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
@@ -2227,6 +2305,7 @@ var init_sqlite_query_adapter = __esm({
     init_participants_store();
     init_startup();
     init_workspaces_to_projects_migration();
+    init_task_identifier_migration();
     ({ DatabaseSync: DatabaseSyncCtor3 } = process.getBuiltinModule("node:sqlite"));
     AGX_DATA_DIR3 = process.env.AGX_DATA_DIR || import_path9.default.join(import_os9.default.homedir(), ".agx");
     SqlExpression = class {
@@ -2633,10 +2712,215 @@ function createAdminDbClient() {
 }
 var init_db_adapter = __esm({
   "apps/local/lib/db-adapter.ts"() {
+    "use strict";
     init_auth_mode();
   }
 });
 
+// apps/local/lib/db/shared.ts
+function isMissingRelationError(error, relation) {
+  if (!error) return false;
+  const message = typeof error.message === "string" ? error.message : "";
+  return error.code === "42P01" || error.code === "PGRST205" || message.includes(`relation "${relation}" does not exist`) || message.includes(`Could not find the table 'agx.${relation}'`) || message.includes(`Could not find the table 'public.${relation}'`);
+}
+function resolveTaskConfig(task, stageConfig, userSettings) {
+  const clean = (v) => {
+    if (typeof v !== "string") return null;
+    const t = v.trim();
+    return t ? t : null;
+  };
+  let cliDefaultProvider = null;
+  try {
+    const fs12 = require("fs");
+    const path15 = require("path");
+    const configPath = path15.join(process.env.HOME || "", ".agx", "config.json");
+    const cliConfig = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
+    cliDefaultProvider = clean(cliConfig?.defaultProvider) || null;
+  } catch {
+  }
+  const globalDefaultProvider = clean(userSettings?.default_provider) || cliDefaultProvider || "claude";
+  const provider = clean(task.provider) || clean(stageConfig?.provider) || globalDefaultProvider;
+  const globalDefaultModel = clean(userSettings?.models?.[provider]) || null;
+  const model = clean(task.model) || clean(stageConfig?.model) || globalDefaultModel || null;
+  const swarm = task.swarm ?? stageConfig?.swarm ?? false;
+  const swarm_models = task.swarm_models?.length ? task.swarm_models : stageConfig?.swarm_models || [];
+  return {
+    provider,
+    model,
+    swarm,
+    swarm_models
+  };
+}
+function slugify2(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "task";
+}
+async function generateUniqueSlug(base, db2) {
+  let slug = slugify2(base);
+  for (let i = 0; i < 5; i++) {
+    const { data, error } = await db2.from("tasks").select("id").eq("slug", slug).limit(1);
+    if (error) throw error;
+    if (!data || data.length === 0) return slug;
+    const suffix = Math.random().toString(36).slice(2, 6);
+    slug = `${slugify2(base)}-${suffix}`.slice(0, 48);
+  }
+  return `${slugify2(base)}-${Date.now().toString(36).slice(-4)}`.slice(0, 48);
+}
+async function generateUniqueProjectSlug(base, userId, db2, excludeProjectId) {
+  let slug = slugify2(base);
+  for (let i = 0; i < 5; i++) {
+    let query = db2.from("projects").select("id").eq("slug", slug).eq("user_id", userId);
+    if (excludeProjectId) {
+      query = query.neq("id", excludeProjectId);
+    }
+    const { data, error } = await query.limit(1);
+    if (error) throw error;
+    if (!data || data.length === 0) return slug;
+    const suffix = Math.random().toString(36).slice(2, 6);
+    slug = `${slugify2(base)}-${suffix}`.slice(0, 48);
+  }
+  return `${slugify2(base)}-${Date.now().toString(36).slice(-4)}`.slice(0, 48);
+}
+function getDbClient(client) {
+  return client ?? createAdminDbClient();
+}
+function parseDependsOnValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      return parsed.map((item) => String(item || "").trim()).filter(Boolean);
+    }
+  } catch {
+  }
+  return trimmed.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function normalizeDependsOnInput(input) {
+  if (!input) return [];
+  let candidates;
+  if (Array.isArray(input)) {
+    candidates = input.map((item) => typeof item === "string" ? item : item === null || item === void 0 ? "" : String(item)).filter(Boolean);
+  } else if (typeof input === "string") {
+    candidates = parseDependsOnValue(input);
+  } else {
+    return [];
+  }
+  return Array.from(new Set(candidates.map((id) => id.trim()).filter(Boolean)));
+}
+function parseFrontmatter(markdown) {
+  const match = markdown.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: markdown };
+  }
+  const frontmatter = {};
+  const lines = match[1].split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      if (key === "depends_on") {
+        frontmatter[key] = parseDependsOnValue(value);
+        continue;
+      }
+      if (value === "true") frontmatter[key] = true;
+      else if (value === "false") frontmatter[key] = false;
+      else if (/^\d+$/.test(value)) frontmatter[key] = parseInt(value, 10);
+      else frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body: match[2] };
+}
+async function ensureNoCircularDependency(taskId, dependsOn, client) {
+  if (!taskId || !dependsOn?.length) return;
+  const db2 = getDbClient(client);
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [...dependsOn];
+  while (stack.length) {
+    const candidate = stack.pop();
+    if (!candidate) continue;
+    if (candidate === taskId) {
+      throw new Error("Circular dependency detected");
+    }
+    if (visited.has(candidate)) continue;
+    visited.add(candidate);
+    const { data, error } = await db2.from("tasks").select("depends_on").eq("id", candidate).maybeSingle();
+    if (error) {
+      if (error.code === "PGRST116" || error.code === "42703") continue;
+      throw error;
+    }
+    if (!data) continue;
+    const childDeps = Array.isArray(data.depends_on) ? data.depends_on : [];
+    for (const next of childDeps) {
+      if (next && !visited.has(next)) {
+        stack.push(next);
+      }
+    }
+  }
+}
+function extractTitle(markdown) {
+  const { body } = parseFrontmatter(markdown);
+  const match = body.match(/^#\s+(.+)$/m);
+  return match ? match[1] : void 0;
+}
+var init_shared = __esm({
+  "apps/local/lib/db/shared.ts"() {
+    "use strict";
+    init_db_adapter();
+  }
+});
+
+// apps/local/lib/db/user-settings.ts
+function normalizeChangedAt(value) {
+  if (typeof value === "string") {
+    const t = Date.parse(value);
+    if (Number.isFinite(t)) return new Date(t).toISOString();
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function getUserSettings(userId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("user_settings").select("*").eq("user_id", userId).maybeSingle();
+  if (error) {
+    if (isMissingRelationError(error, "user_settings")) return null;
+    throw error;
+  }
+  if (!data) return null;
+  return data;
+}
+async function upsertUserSettings(userId, input, options) {
+  const onlyIfNewer = options?.onlyIfNewer !== false;
+  const incomingChangedAt = normalizeChangedAt(input.changed_at);
+  const existing = await getUserSettings(userId);
+  if (onlyIfNewer && existing?.changed_at) {
+    const existingTs = Date.parse(existing.changed_at);
+    const incomingTs = Date.parse(incomingChangedAt);
+    if (Number.isFinite(existingTs) && Number.isFinite(incomingTs) && incomingTs <= existingTs) {
+      return { settings: existing, updated: false };
+    }
+  }
+  const payload = {
+    user_id: userId,
+    default_provider: input.default_provider ?? existing?.default_provider ?? null,
+    models: input.models ?? existing?.models ?? {},
+    provenance: input.provenance,
+    changed_at: incomingChangedAt
+  };
+  const db2 = createAdminDbClient();
+  const { error: upsertError } = await db2.from("user_settings").upsert(payload, { onConflict: "user_id" });
+  if (upsertError) throw upsertError;
+  const after = await getUserSettings(userId);
+  if (!after) throw new Error("Failed to load user_settings after upsert");
+  return { settings: after, updated: true };
+}
+var init_user_settings = __esm({
+  "apps/local/lib/db/user-settings.ts"() {
+    "use strict";
+    init_db_adapter();
+    init_shared();
+  }
+});
+
 // apps/local/lib/dependency-helpers.ts
 function describeDependency(entry) {
   if (entry.title) return entry.title;
@@ -2665,11 +2949,82 @@ function isDependencyBlockedReason(reason) {
 var DEPENDENCY_BLOCKED_REASON_PREFIX, MAX_DISPLAYED_DEPENDENCIES;
 var init_dependency_helpers = __esm({
   "apps/local/lib/dependency-helpers.ts"() {
+    "use strict";
     DEPENDENCY_BLOCKED_REASON_PREFIX = "Waiting on dependencies";
     MAX_DISPLAYED_DEPENDENCIES = 3;
   }
 });
 
+// lib/logger.ts
+function scheduleFlush() {
+  if (flushTimer) return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, FLUSH_INTERVAL_MS);
+}
+function enqueue(entry) {
+  if (!LOG_ENABLED) return;
+  buffer.push(entry);
+  if (buffer.length >= MAX_BUFFER_SIZE) {
+    flush();
+  } else {
+    scheduleFlush();
+  }
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message, stack: error.stack };
+  }
+  return { message: String(error) };
+}
+async function flush() {
+  if (buffer.length === 0) return;
+  const entries = buffer.splice(0);
+  try {
+    await fetch(LOG_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(entries)
+    });
+  } catch {
+  }
+}
+var LOG_ENDPOINT, LOG_ENABLED, buffer, flushTimer, FLUSH_INTERVAL_MS, MAX_BUFFER_SIZE, logger;
+var init_logger = __esm({
+  "lib/logger.ts"() {
+    "use strict";
+    LOG_ENDPOINT = process.env.AGX_LOG_ENDPOINT || "https://www.runagx.com/api/logs/ingest";
+    LOG_ENABLED = process.env.AGX_DISABLE_REMOTE_LOGGING !== "1";
+    buffer = [];
+    flushTimer = null;
+    FLUSH_INTERVAL_MS = 5e3;
+    MAX_BUFFER_SIZE = 50;
+    logger = {
+      error(message, context) {
+        console.error(message, context ?? "");
+        enqueue({ level: "error", message, context });
+      },
+      warn(message, context) {
+        console.warn(message, context ?? "");
+        enqueue({ level: "warn", message, context });
+      },
+      info(message, context) {
+        console.log(message, context ?? "");
+        enqueue({ level: "info", message, context });
+      },
+      formatError
+    };
+  }
+});
+
+// apps/local/lib/logger.ts
+var init_logger2 = __esm({
+  "apps/local/lib/logger.ts"() {
+    init_logger();
+  }
+});
+
 // apps/local/lib/notifications/constants.ts
 var NOTIFICATION_EVENT_OPTIONS, NOTIFICATION_EVENT_VALUES;
 var init_constants = __esm({
@@ -2707,7 +3062,7 @@ var init_constants = __esm({
 });
 
 // apps/local/lib/notifications/index.ts
-function isMissingRelationError(error, relation) {
+function isMissingRelationError2(error, relation) {
   if (!error || typeof error !== "object") return false;
   const code = error.code;
   const message = typeof error.message === "string" ? error.message : "";
@@ -2729,7 +3084,7 @@ function mapWebhookRecord(raw) {
   };
 }
 async function handleRelationError(relation, error) {
-  if (isMissingRelationError(error, relation)) {
+  if (isMissingRelationError2(error, relation)) {
     throw new SchemaNotReadyError(`Missing relation: ${relation}`);
   }
   throw error;
@@ -2753,7 +3108,7 @@ async function notifyTaskEvent(payload) {
       console.debug("[notifications] notification_webhooks schema not ready, skipping");
       return;
     }
-    console.error("[notifications] failed to load webhooks", error);
+    logger.error("[notifications] failed to load webhooks", logger.formatError(error));
     return;
   }
   const targets = endpoints.filter(
@@ -2777,28 +3132,36 @@ async function notifyTaskEvent(payload) {
   };
   await Promise.all(
     targets.map(async (endpoint) => {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), WEBHOOK_DELIVERY_TIMEOUT_MS);
       try {
         const response = await fetch(endpoint.url, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(body)
+          body: JSON.stringify(body),
+          signal: controller.signal
         });
         if (!response.ok) {
-          console.error(
+          logger.error(
             `[notifications] webhook ${endpoint.url} responded with ${response.status}`
           );
         }
       } catch (error) {
-        console.error(`[notifications] failed to send to ${endpoint.url}`, error);
+        logger.error(`[notifications] failed to send to ${endpoint.url}`, logger.formatError(error));
+      } finally {
+        clearTimeout(timeout);
       }
     })
   );
 }
-var SchemaNotReadyError;
+var WEBHOOK_DELIVERY_TIMEOUT_MS, SchemaNotReadyError;
 var init_notifications = __esm({
   "apps/local/lib/notifications/index.ts"() {
+    "use strict";
     init_db_adapter();
+    init_logger2();
     init_constants();
+    WEBHOOK_DELIVERY_TIMEOUT_MS = 1e4;
     SchemaNotReadyError = class extends Error {
     };
   }
@@ -2884,9 +3247,9 @@ var require_mark = __commonJS({
   "node_modules/js-yaml/lib/js-yaml/mark.js"(exports2, module2) {
     "use strict";
     var common = require_common();
-    function Mark(name, buffer, position, line, column) {
+    function Mark(name, buffer2, position, line, column) {
       this.name = name;
-      this.buffer = buffer;
+      this.buffer = buffer2;
       this.position = position;
       this.line = line;
       this.column = column;
@@ -5631,7 +5994,7 @@ var require_js_yaml2 = __commonJS({
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function slugify2(value, fallback = "item") {
+function slugify3(value, fallback = "item") {
   const slug = String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return slug || fallback;
 }
@@ -5901,7 +6264,7 @@ var init_vault_store = __esm({
       }
       nextProjectSlug(base, excludeProjectId) {
         const registry = this.readRegistry();
-        const baseSlug = slugify2(base, "project");
+        const baseSlug = slugify3(base, "project");
         let candidate = baseSlug;
         let index = 1;
         while (registry.projects.some((project) => project.slug === candidate && project.id !== excludeProjectId)) {
@@ -5912,7 +6275,7 @@ var init_vault_store = __esm({
       }
       nextRepoSlug(projectSlug, base, excludeRepoId) {
         const manifest = this.readManifest(projectSlug);
-        const baseSlug = slugify2(base, "repo");
+        const baseSlug = slugify3(base, "repo");
         let candidate = baseSlug;
         let index = 1;
         while (manifest?.repos.some((repo) => repo.slug === candidate && repo.id !== excludeRepoId)) {
@@ -6061,7 +6424,7 @@ ${project.description?.trim() || ""}
         const registry = this.readRegistry();
         const existing = registry.agents.find((agent) => agent.id === agentId);
         if (existing) return existing;
-        const slug = slugify2(name || agentId, "agent");
+        const slug = slugify3(name || agentId, "agent");
         const createdAt = nowIso();
         const entry = {
           id: agentId,
@@ -6355,7 +6718,7 @@ ${project.description?.trim() || ""}
         if (!project) throw new Error("Project not found");
         const timestamp = nowIso();
         const id = (0, import_node_crypto3.randomUUID)();
-        const fileSlug = slugify2(import_node_path.default.basename(file) || id, "skill");
+        const fileSlug = slugify3(import_node_path.default.basename(file) || id, "skill");
         writeMarkdownFile(
           import_node_path.default.join(this.projectSkillsDir(project.slug), `${fileSlug}-${id.slice(0, 8)}.md`),
           {
@@ -6407,7 +6770,7 @@ ${project.description?.trim() || ""}
       setProjectVariable(projectId, key, value) {
         const project = this.findProjectRegistryEntryById(projectId);
         if (!project) throw new Error("Project not found");
-        const existingPath = import_node_path.default.join(this.projectVariablesDir(project.slug), `${slugify2(key, "var")}.md`);
+        const existingPath = import_node_path.default.join(this.projectVariablesDir(project.slug), `${slugify3(key, "var")}.md`);
         const existing = readMarkdownFile(existingPath);
         const timestamp = nowIso();
         writeMarkdownFile(
@@ -6429,7 +6792,7 @@ ${project.description?.trim() || ""}
       deleteProjectVariable(projectId, key) {
         const project = this.findProjectRegistryEntryById(projectId);
         if (!project) return;
-        const filePath = import_node_path.default.join(this.projectVariablesDir(project.slug), `${slugify2(key, "var")}.md`);
+        const filePath = import_node_path.default.join(this.projectVariablesDir(project.slug), `${slugify3(key, "var")}.md`);
         if (import_node_fs.default.existsSync(filePath)) {
           import_node_fs.default.unlinkSync(filePath);
         }
@@ -6750,7 +7113,7 @@ ${project.description?.trim() || ""}
       }
       nextKnowledgeEntryPath(scope, subjectId, title) {
         const id = (0, import_node_crypto3.randomUUID)();
-        const fileName = `${slugify2(title, "entry")}-${id.slice(0, 8)}.md`;
+        const fileName = `${slugify3(title, "entry")}-${id.slice(0, 8)}.md`;
         if (scope === "global") {
           return import_node_path.default.join(this.globalEvidenceDir("global"), fileName);
         }
@@ -6878,7 +7241,7 @@ ${addition}` : addition;
         let evidenceFiles = 0;
         for (const learning of globalLearnings) {
           writeMarkdownFile(
-            import_node_path.default.join(this.globalImportedLearningsDir(), `${slugify2(learning.id, "learning")}.md`),
+            import_node_path.default.join(this.globalImportedLearningsDir(), `${slugify3(learning.id, "learning")}.md`),
             {
               id: learning.id,
               type: "imported-artifact",
@@ -6978,7 +7341,7 @@ ${addition}` : addition;
           const projectLearningRows = learnings.filter((learning) => learning.scope === "project" && learning.scope_id === project.id);
           for (const learning of projectLearningRows) {
             writeMarkdownFile(
-              import_node_path.default.join(this.projectImportedDir(project.slug, "learnings"), `${slugify2(learning.id, "learning")}.md`),
+              import_node_path.default.join(this.projectImportedDir(project.slug, "learnings"), `${slugify3(learning.id, "learning")}.md`),
               {
                 id: learning.id,
                 type: "imported-artifact",
@@ -6995,7 +7358,7 @@ ${addition}` : addition;
           }
           for (const memoryRow of projectMemoryRows.filter((row) => row.project_id === project.id)) {
             writeMarkdownFile(
-              import_node_path.default.join(this.projectImportedDir(project.slug, "project-memory"), `${slugify2(memoryRow.id, "memory")}.md`),
+              import_node_path.default.join(this.projectImportedDir(project.slug, "project-memory"), `${slugify3(memoryRow.id, "memory")}.md`),
               {
                 id: memoryRow.id,
                 type: "imported-artifact",
@@ -7037,7 +7400,7 @@ ${addition}` : addition;
             );
             if (repo.notes?.trim()) {
               writeMarkdownFile(
-                import_node_path.default.join(this.projectImportedDir(project.slug, import_node_path.default.join("repo-knowledge", repo.slug)), `${slugify2(repo.id, "repo-notes")}-project-repos-notes.md`),
+                import_node_path.default.join(this.projectImportedDir(project.slug, import_node_path.default.join("repo-knowledge", repo.slug)), `${slugify3(repo.id, "repo-notes")}-project-repos-notes.md`),
                 {
                   id: `${repo.id}:project_repos.notes`,
                   type: "imported-artifact",
@@ -7054,7 +7417,7 @@ ${addition}` : addition;
             }
             for (const row of repoKnowledgeRows.filter((entry) => entry.repo_id === repo.id)) {
               writeMarkdownFile(
-                import_node_path.default.join(this.projectImportedDir(project.slug, import_node_path.default.join("repo-knowledge", repo.slug)), `${slugify2(row.id, "repo-knowledge")}.md`),
+                import_node_path.default.join(this.projectImportedDir(project.slug, import_node_path.default.join("repo-knowledge", repo.slug)), `${slugify3(row.id, "repo-knowledge")}.md`),
                 {
                   id: row.id,
                   type: "imported-artifact",
@@ -7073,7 +7436,7 @@ ${addition}` : addition;
           }
           for (const skill of projectSkills.filter((entry) => entry.project_id === project.id)) {
             writeMarkdownFile(
-              import_node_path.default.join(this.projectSkillsDir(project.slug), `${slugify2(import_node_path.default.basename(skill.file) || skill.id, "skill")}-${skill.id.slice(0, 8)}.md`),
+              import_node_path.default.join(this.projectSkillsDir(project.slug), `${slugify3(import_node_path.default.basename(skill.file) || skill.id, "skill")}-${skill.id.slice(0, 8)}.md`),
               {
                 id: skill.id,
                 type: "project-skill",
@@ -7090,7 +7453,7 @@ ${addition}` : addition;
           }
           for (const variable of projectVariables.filter((entry) => entry.project_id === project.id)) {
             writeMarkdownFile(
-              import_node_path.default.join(this.projectVariablesDir(project.slug), `${slugify2(variable.key, "var")}.md`),
+              import_node_path.default.join(this.projectVariablesDir(project.slug), `${slugify3(variable.key, "var")}.md`),
               {
                 id: `project-variable:${project.id}:${variable.key}`,
                 type: "project-variable",
@@ -7206,283 +7569,418 @@ ${portableKnowledge.trim()}`);
   }
 });
 
-// apps/local/lib/db.ts
-var db_exports = {};
-__export(db_exports, {
-  DEFAULT_WORKFLOW_ID: () => DEFAULT_WORKFLOW_ID,
-  addLearning: () => addLearning,
-  addProjectAgent: () => addProjectAgent,
-  addProjectMemory: () => addProjectMemory,
-  addProjectSkill: () => addProjectSkill,
-  addProjectThread: () => addProjectThread,
-  addTaskComment: () => addTaskComment,
-  addTaskCostEntry: () => addTaskCostEntry,
-  addTaskLog: () => addTaskLog,
-  addTeamAgent: () => addTeamAgent,
-  appendRunToIndex: () => appendRunToIndex,
-  assignOrphanTasksToProject: () => assignOrphanTasksToProject,
-  buildExecutionProvenance: () => buildExecutionProvenance,
-  createAgent: () => createAgent,
-  createProject: () => createProject,
-  createTask: () => createTask,
-  createTeam: () => createTeam,
-  defaultStagePrompts: () => defaultStagePrompts,
-  deleteAgent: () => deleteAgent,
-  deleteLearning: () => deleteLearning,
-  deleteProject: () => deleteProject,
-  deleteProjectMemory: () => deleteProjectMemory,
-  deleteProjectVariable: () => deleteProjectVariable,
-  deleteStagePrompt: () => deleteStagePrompt,
-  deleteTask: () => deleteTask,
-  deleteTaskComment: () => deleteTaskComment,
-  deleteTeam: () => deleteTeam,
-  ensureNoCircularDependency: () => ensureNoCircularDependency,
-  extractTitle: () => extractTitle,
-  getAgent: () => getAgent,
-  getAgentSkills: () => getAgentSkills,
-  getAgents: () => getAgents,
-  getDefaultWorkflowId: () => getDefaultWorkflowId,
-  getLearnings: () => getLearnings,
-  getNextQueuedTask: () => getNextQueuedTask,
-  getProjectAgents: () => getProjectAgents,
-  getProjectBySlug: () => getProjectBySlug,
-  getProjectForThread: () => getProjectForThread,
-  getProjectMemory: () => getProjectMemory,
-  getProjectRepos: () => getProjectRepos,
-  getProjectSkills: () => getProjectSkills,
-  getProjectThreads: () => getProjectThreads,
-  getProjectVariables: () => getProjectVariables,
-  getProjectWithRepos: () => getProjectWithRepos,
-  getProjects: () => getProjects,
-  getStagePrompt: () => getStagePrompt,
-  getStagePrompts: () => getStagePrompts,
-  getTask: () => getTask,
-  getTaskBySlug: () => getTaskBySlug,
-  getTaskComments: () => getTaskComments,
-  getTaskCostEntries: () => getTaskCostEntries,
-  getTaskCostSummary: () => getTaskCostSummary,
-  getTaskLogs: () => getTaskLogs,
-  getTasks: () => getTasks,
-  getTeam: () => getTeam,
-  getTeamAgents: () => getTeamAgents,
-  getTeams: () => getTeams,
-  getUserSettings: () => getUserSettings,
-  getWorkflow: () => getWorkflow,
-  getWorkflowNodeByName: () => getWorkflowNodeByName,
-  getWorkflowNodes: () => getWorkflowNodes,
-  getWorkflowTransitions: () => getWorkflowTransitions,
-  getWorkflowTransitionsFromNode: () => getWorkflowTransitionsFromNode,
-  getWorkflowWithGraph: () => getWorkflowWithGraph,
-  getWorkflows: () => getWorkflows,
-  parseFrontmatter: () => parseFrontmatter,
-  removeProjectAgent: () => removeProjectAgent,
-  removeProjectSkill: () => removeProjectSkill,
-  removeProjectThread: () => removeProjectThread,
-  removeTeamAgent: () => removeTeamAgent,
-  reorderProjectAgents: () => reorderProjectAgents,
-  resolveMemory: () => resolveMemory,
-  resolveSkills: () => resolveSkills,
-  resolveTaskConfig: () => resolveTaskConfig,
-  resolveVariables: () => resolveVariables,
-  setAgentSkills: () => setAgentSkills,
-  setProjectVariable: () => setProjectVariable,
-  summarizeTaskCosts: () => summarizeTaskCosts,
-  updateAgent: () => updateAgent,
-  updateProject: () => updateProject,
-  updateTask: () => updateTask,
-  updateTeam: () => updateTeam,
-  updateWorkflow: () => updateWorkflow,
-  updateWorkflowNodes: () => updateWorkflowNodes,
-  upsertStagePrompt: () => upsertStagePrompt,
-  upsertUserSettings: () => upsertUserSettings
-});
-function isMissingRelationError2(error, relation) {
-  if (!error) return false;
-  const message = typeof error.message === "string" ? error.message : "";
-  return error.code === "42P01" || error.code === "PGRST205" || message.includes(`relation "${relation}" does not exist`) || message.includes(`Could not find the table 'agx.${relation}'`) || message.includes(`Could not find the table 'public.${relation}'`);
+// apps/local/lib/db/projects.ts
+async function insertProjectRepos(projectId, repos, db2) {
+  if (!repos.length) {
+    return [];
+  }
+  const payload = repos.map((repo) => ({
+    ...repo.id ? { id: repo.id } : {},
+    project_id: projectId,
+    name: repo.name,
+    path: repo.path ?? null,
+    git_url: repo.git_url ?? null,
+    notes: repo.notes ?? null
+  }));
+  const { data, error } = await db2.from("project_repos").insert(payload).select("*");
+  if (error) {
+    if (isMissingRelationError(error, "project_repos")) {
+      return [];
+    }
+    throw error;
+  }
+  return data || [];
 }
-function normalizeChangedAt(value) {
-  if (typeof value === "string") {
-    const t = Date.parse(value);
-    if (Number.isFinite(t)) return new Date(t).toISOString();
+async function getProjects(userId, includeArchived = false) {
+  const db2 = createAdminDbClient();
+  let query = db2.from("projects").select("*, project_repos(*)");
+  if (userId) query = query.eq("user_id", userId);
+  if (!includeArchived) query = query.is("archived_at", null);
+  const { data, error } = await query;
+  if (error) {
+    if (isMissingRelationError(error, "projects")) {
+      return [];
+    }
+    throw error;
   }
-  return (/* @__PURE__ */ new Date()).toISOString();
+  const projects = data || [];
+  return projects.map((project) => ({
+    ...project,
+    repos: project.project_repos ?? []
+  }));
 }
-async function getUserSettings(userId) {
+async function getProjectBySlug(slug, userId) {
   const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("user_settings").select("*").eq("user_id", userId).maybeSingle();
+  let query = db2.from("projects").select("*").eq("slug", slug);
+  if (userId) query = query.eq("user_id", userId);
+  const { data, error } = await query.maybeSingle();
+  if (error) {
+    if (isMissingRelationError(error, "projects")) {
+      return null;
+    }
+    throw error;
+  }
+  return data || null;
+}
+async function getProjectRepos(projectId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("project_repos").select("*").eq("project_id", projectId);
   if (error) {
-    if (isMissingRelationError2(error, "user_settings")) return null;
+    if (isMissingRelationError(error, "project_repos")) {
+      return [];
+    }
     throw error;
   }
-  if (!data) return null;
-  return data;
+  return data || [];
 }
-async function upsertUserSettings(userId, input, options) {
-  const onlyIfNewer = options?.onlyIfNewer !== false;
-  const incomingChangedAt = normalizeChangedAt(input.changed_at);
-  const existing = await getUserSettings(userId);
-  if (onlyIfNewer && existing?.changed_at) {
-    const existingTs = Date.parse(existing.changed_at);
-    const incomingTs = Date.parse(incomingChangedAt);
-    if (Number.isFinite(existingTs) && Number.isFinite(incomingTs) && incomingTs <= existingTs) {
-      return { settings: existing, updated: false };
+async function getProjectWithRepos(projectIdOrSlug, userId) {
+  const db2 = createAdminDbClient();
+  const isUuid = UUID_REGEX.test(projectIdOrSlug);
+  let projectQuery = db2.from("projects").select("*");
+  if (isUuid) {
+    projectQuery = projectQuery.eq("id", projectIdOrSlug);
+  } else {
+    projectQuery = projectQuery.eq("slug", projectIdOrSlug);
+  }
+  if (userId) projectQuery = projectQuery.eq("user_id", userId);
+  const projectResult = await projectQuery.maybeSingle();
+  if (projectResult.error) {
+    if (isMissingRelationError(projectResult.error, "projects")) {
+      return null;
     }
+    throw projectResult.error;
+  }
+  const project = projectResult.data;
+  if (!project) return null;
+  const repos = await getProjectRepos(project.id);
+  return { ...project, repos };
+}
+async function createProject(userId, input, dbClient) {
+  if (!input.name?.trim()) {
+    throw new Error("Project name is required");
   }
+  const db2 = getDbClient(dbClient);
+  const baseSlug = input.name.trim() || "project";
+  const slug = await generateUniqueProjectSlug(baseSlug, userId, db2);
+  const identifierPrefix = validateIdentifierPrefix(input.identifier_prefix);
   const payload = {
     user_id: userId,
-    default_provider: input.default_provider ?? existing?.default_provider ?? null,
-    models: input.models ?? existing?.models ?? {},
-    provenance: input.provenance,
-    changed_at: incomingChangedAt
+    name: input.name.trim(),
+    slug,
+    description: input.description ?? null,
+    workflow_id: input.workflow_id ?? null
   };
+  if (identifierPrefix !== null) {
+    payload.identifier_prefix = identifierPrefix;
+  }
+  let { data: project, error } = await db2.from("projects").insert(payload).select("*").single();
+  if (error && error.code === "42703") {
+    const { identifier_prefix: _ignored, ...fallback } = payload;
+    ({ data: project, error } = await db2.from("projects").insert(fallback).select("*").single());
+  }
+  if (error) throw error;
+  const repos = await insertProjectRepos(project.id, input.repos ?? [], db2);
+  return { ...project, repos };
+}
+async function updateProject(projectIdOrSlug, userId, updates, dbClient) {
+  const db2 = getDbClient(dbClient);
+  const isUuid = UUID_REGEX.test(projectIdOrSlug);
+  let projectId = projectIdOrSlug;
+  if (!isUuid) {
+    const project = await getProjectBySlug(projectIdOrSlug, userId);
+    if (!project) return null;
+    projectId = project.id;
+  }
+  const updatePayload = {};
+  if (typeof updates.name !== "undefined") {
+    const trimmedName = updates.name?.trim();
+    if (!trimmedName) {
+      throw new Error("Project name cannot be empty");
+    }
+    updatePayload.name = trimmedName;
+  }
+  if (typeof updates.slug !== "undefined") {
+    const trimmedSlug = updates.slug?.trim();
+    if (trimmedSlug) {
+      updatePayload.slug = trimmedSlug;
+    }
+  }
+  if (typeof updates.description !== "undefined") updatePayload.description = updates.description;
+  if (typeof updates.metadata !== "undefined") updatePayload.metadata = updates.metadata;
+  if (typeof updates.ci_cd_info !== "undefined") updatePayload.ci_cd_info = updates.ci_cd_info;
+  if (typeof updates.workflow_id !== "undefined") updatePayload.workflow_id = updates.workflow_id;
+  if (typeof updates.identifier_prefix !== "undefined") {
+    updatePayload.identifier_prefix = validateIdentifierPrefix(updates.identifier_prefix);
+  }
+  if (Object.keys(updatePayload).length) {
+    const { error } = await db2.from("projects").update(updatePayload).eq("id", projectId).eq("user_id", userId);
+    if (error) throw error;
+  }
+  if (updates.repos) {
+    const { data: existingRepos, error: existingReposError } = await db2.from("project_repos").select("*").eq("project_id", projectId);
+    if (existingReposError && !isMissingRelationError(existingReposError, "project_repos")) {
+      throw existingReposError;
+    }
+    const existingRepoList = existingRepos || [];
+    const existingRepoIds = new Set(existingRepoList.map((repo) => repo.id));
+    const nextRepoIds = new Set(
+      updates.repos.map((repo) => repo.id).filter((repoId) => Boolean(repoId))
+    );
+    for (const existingRepo of existingRepoList) {
+      if (nextRepoIds.has(existingRepo.id)) continue;
+      const { error: deleteError } = await db2.from("project_repos").delete().eq("id", existingRepo.id).eq("project_id", projectId);
+      if (deleteError && !isMissingRelationError(deleteError, "project_repos")) {
+        throw deleteError;
+      }
+    }
+    for (const repo of updates.repos) {
+      const payload = {
+        name: repo.name,
+        path: repo.path ?? null,
+        git_url: repo.git_url ?? null,
+        notes: repo.notes ?? null,
+        project_id: projectId
+      };
+      if (repo.id && existingRepoIds.has(repo.id)) {
+        const { error: repoUpdateError } = await db2.from("project_repos").update(payload).eq("id", repo.id).eq("project_id", projectId);
+        if (repoUpdateError && !isMissingRelationError(repoUpdateError, "project_repos")) {
+          throw repoUpdateError;
+        }
+        continue;
+      }
+      const { error: repoInsertError } = await db2.from("project_repos").insert({
+        ...repo.id ? { id: repo.id } : {},
+        ...payload
+      });
+      if (repoInsertError && !isMissingRelationError(repoInsertError, "project_repos")) {
+        throw repoInsertError;
+      }
+    }
+  }
+  return getProjectWithRepos(projectId, userId);
+}
+async function deleteProject(projectId, userId, dbClient) {
+  const db2 = getDbClient(dbClient);
+  const { error } = await db2.from("projects").update({ archived_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", projectId).eq("user_id", userId);
+  if (error) throw error;
+}
+async function assignOrphanTasksToProject(projectId, userId, dbClient) {
+  const db2 = getDbClient(dbClient);
+  const project = await getProjectWithRepos(projectId, userId);
+  if (!project) {
+    throw new Error("Project not found");
+  }
+  const { data: tasks, error: tasksError } = await db2.from("tasks").select("id, project").eq("user_id", userId).is("project_id", null);
+  if (tasksError) throw tasksError;
+  const slug = String(project.slug || "").trim().toLowerCase();
+  const orphanTaskIds = (tasks || []).filter((task) => {
+    const projectValue = String(task.project || "").trim().toLowerCase();
+    return !projectValue || projectValue === "none" || projectValue === slug;
+  }).map((task) => task.id);
+  if (!orphanTaskIds.length) {
+    return { updatedCount: 0, taskIds: [] };
+  }
+  const { error: updateError } = await db2.from("tasks").update({
+    project: project.slug,
+    project_id: project.id,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).eq("user_id", userId).is("project_id", null).in("id", orphanTaskIds);
+  if (updateError) throw updateError;
+  return { updatedCount: orphanTaskIds.length, taskIds: orphanTaskIds };
+}
+async function getProjectAgents(projectId) {
   const db2 = createAdminDbClient();
-  const { error: upsertError } = await db2.from("user_settings").upsert(payload, { onConflict: "user_id" });
-  if (upsertError) throw upsertError;
-  const after = await getUserSettings(userId);
-  if (!after) throw new Error("Failed to load user_settings after upsert");
-  return { settings: after, updated: true };
+  const { data, error } = await db2.from("project_agents").select("*").eq("project_id", projectId).order("routing_order", { ascending: true });
+  if (error) {
+    if (isMissingRelationError(error, "project_agents")) return [];
+    throw error;
+  }
+  return data || [];
 }
-function resolveTaskConfig(task, stageConfig, userSettings) {
-  const clean = (v) => {
-    if (typeof v !== "string") return null;
-    const t = v.trim();
-    return t ? t : null;
-  };
-  let cliDefaultProvider = null;
-  try {
-    const fs12 = require("fs");
-    const path15 = require("path");
-    const configPath = path15.join(process.env.HOME || "", ".agx", "config.json");
-    const cliConfig = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
-    cliDefaultProvider = clean(cliConfig?.defaultProvider) || null;
-  } catch {
+async function addProjectAgent(projectId, agentId, routingOrder) {
+  const db2 = createAdminDbClient();
+  if (routingOrder === void 0) {
+    const { data: existing } = await db2.from("project_agents").select("routing_order").eq("project_id", projectId).order("routing_order", { ascending: false }).limit(1);
+    routingOrder = (existing?.[0]?.routing_order ?? -1) + 1;
   }
-  const globalDefaultProvider = clean(userSettings?.default_provider) || cliDefaultProvider || "claude";
-  const provider = clean(task.provider) || clean(stageConfig?.provider) || globalDefaultProvider;
-  const globalDefaultModel = clean(userSettings?.models?.[provider]) || null;
-  const model = clean(task.model) || clean(stageConfig?.model) || globalDefaultModel || null;
-  const swarm = task.swarm ?? stageConfig?.swarm ?? false;
-  const swarm_models = task.swarm_models?.length ? task.swarm_models : stageConfig?.swarm_models || [];
-  return {
-    provider,
-    model,
-    swarm,
-    swarm_models
-  };
+  const { data, error } = await db2.from("project_agents").upsert({ project_id: projectId, agent_id: agentId, routing_order: routingOrder }).select().single();
+  if (error) throw error;
+  return data;
 }
-function slugify3(input) {
-  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "task";
+async function removeProjectAgent(projectId, agentId) {
+  const db2 = createAdminDbClient();
+  const { error } = await db2.from("project_agents").delete().eq("project_id", projectId).eq("agent_id", agentId);
+  if (error) throw error;
 }
-async function generateUniqueSlug(base, db2) {
-  let slug = slugify3(base);
-  for (let i = 0; i < 5; i++) {
-    const { data, error } = await db2.from("tasks").select("id").eq("slug", slug).limit(1);
-    if (error) throw error;
-    if (!data || data.length === 0) return slug;
-    const suffix = Math.random().toString(36).slice(2, 6);
-    slug = `${slugify3(base)}-${suffix}`.slice(0, 48);
+async function reorderProjectAgents(projectId, orderedAgentIds) {
+  const db2 = createAdminDbClient();
+  for (let i = 0; i < orderedAgentIds.length; i++) {
+    await db2.from("project_agents").update({ routing_order: i }).eq("project_id", projectId).eq("agent_id", orderedAgentIds[i]);
   }
-  return `${slugify3(base)}-${Date.now().toString(36).slice(-4)}`.slice(0, 48);
+  return getProjectAgents(projectId);
 }
-async function generateUniqueProjectSlug(base, userId, db2, excludeProjectId) {
-  let slug = slugify3(base);
-  for (let i = 0; i < 5; i++) {
-    let query = db2.from("projects").select("id").eq("slug", slug).eq("user_id", userId);
-    if (excludeProjectId) {
-      query = query.neq("id", excludeProjectId);
-    }
-    const { data, error } = await query.limit(1);
-    if (error) throw error;
-    if (!data || data.length === 0) return slug;
-    const suffix = Math.random().toString(36).slice(2, 6);
-    slug = `${slugify3(base)}-${suffix}`.slice(0, 48);
+async function getProjectSkills(projectId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("project_skills").select("*").eq("project_id", projectId).order("created_at", { ascending: true });
+  if (error) {
+    if (isMissingRelationError(error, "project_skills")) return [];
+    throw error;
   }
-  return `${slugify3(base)}-${Date.now().toString(36).slice(-4)}`.slice(0, 48);
+  return data || [];
 }
-function getDbClient(client) {
-  return client ?? createAdminDbClient();
+async function addProjectSkill(projectId, file, condition) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("project_skills").insert({ project_id: projectId, file, condition: condition ?? null }).select().single();
+  if (error) throw error;
+  return data;
 }
-function parseDependsOnValue(value) {
-  const trimmed = value.trim();
-  if (!trimmed) return [];
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (Array.isArray(parsed)) {
-      return parsed.map((item) => String(item || "").trim()).filter(Boolean);
-    }
-  } catch {
+async function removeProjectSkill(skillId) {
+  const db2 = createAdminDbClient();
+  const { error } = await db2.from("project_skills").delete().eq("id", skillId);
+  if (error) throw error;
+}
+async function getProjectVariables(projectId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("project_variables").select("*").eq("project_id", projectId);
+  if (error) {
+    if (isMissingRelationError(error, "project_variables")) return [];
+    throw error;
   }
-  return trimmed.split(",").map((item) => item.trim()).filter(Boolean);
+  return data || [];
 }
-function normalizeDependsOnInput(input) {
-  if (!input) return [];
-  let candidates;
-  if (Array.isArray(input)) {
-    candidates = input.map((item) => typeof item === "string" ? item : item === null || item === void 0 ? "" : String(item)).filter(Boolean);
-  } else if (typeof input === "string") {
-    candidates = parseDependsOnValue(input);
-  } else {
-    return [];
+async function setProjectVariable(projectId, key, value) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("project_variables").upsert({ project_id: projectId, key, value }, { onConflict: "project_id,key" }).select().single();
+  if (error) throw error;
+  return data;
+}
+async function deleteProjectVariable(projectId, key) {
+  const db2 = createAdminDbClient();
+  const { error } = await db2.from("project_variables").delete().eq("project_id", projectId).eq("key", key);
+  if (error) throw error;
+}
+async function getProjectMemory(projectId, producer) {
+  void producer;
+  return vaultStore.getProjectMemory(projectId);
+}
+async function addProjectMemory(projectId, content, source, producer = "human") {
+  return vaultStore.addProjectMemory(projectId, content, source, producer);
+}
+async function deleteProjectMemory(memoryId) {
+  vaultStore.deleteProjectMemory(memoryId);
+}
+async function getProjectThreads(projectId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("project_threads").select("*").eq("project_id", projectId).order("created_at", { ascending: true });
+  if (error) {
+    if (isMissingRelationError(error, "project_threads")) return [];
+    throw error;
   }
-  return Array.from(new Set(candidates.map((id) => id.trim()).filter(Boolean)));
+  return data || [];
 }
-function parseFrontmatter(markdown) {
-  const match = markdown.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match) {
-    return { frontmatter: {}, body: markdown };
+async function addProjectThread(projectId, threadId) {
+  const db2 = createAdminDbClient();
+  const { error } = await db2.from("project_threads").upsert(
+    { project_id: projectId, thread_id: threadId },
+    { onConflict: "project_id,thread_id", ignoreDuplicates: true }
+  );
+  if (error) throw error;
+  const { data, error: fetchError } = await db2.from("project_threads").select("*").eq("project_id", projectId).eq("thread_id", threadId).single();
+  if (fetchError) throw fetchError;
+  return data;
+}
+async function removeProjectThread(projectId, threadId) {
+  const db2 = createAdminDbClient();
+  const { error } = await db2.from("project_threads").delete().eq("project_id", projectId).eq("thread_id", threadId);
+  if (error) throw error;
+}
+async function getProjectForThread(threadId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("project_threads").select("project_id").eq("thread_id", threadId).maybeSingle();
+  if (error) {
+    if (isMissingRelationError(error, "project_threads")) return null;
+    return null;
   }
-  const frontmatter = {};
-  const lines = match[1].split("\n");
-  for (const line of lines) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex > 0) {
-      const key = line.slice(0, colonIndex).trim();
-      const value = line.slice(colonIndex + 1).trim();
-      if (key === "depends_on") {
-        frontmatter[key] = parseDependsOnValue(value);
-        continue;
-      }
-      if (value === "true") frontmatter[key] = true;
-      else if (value === "false") frontmatter[key] = false;
-      else if (/^\d+$/.test(value)) frontmatter[key] = parseInt(value);
-      else frontmatter[key] = value;
-    }
+  return data?.project_id ?? null;
+}
+async function getProjectWorkspace(projectId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("workspace_entries").select("*").eq("project_id", projectId).order("category", { ascending: true }).order("sort_order", { ascending: true }).order("name", { ascending: true });
+  if (error) {
+    if (isMissingRelationError(error, "workspace_entries")) return {};
+    throw error;
   }
-  return { frontmatter, body: match[2] };
+  const entries = data || [];
+  return entries.reduce((acc, entry) => {
+    if (!acc[entry.category]) acc[entry.category] = [];
+    acc[entry.category].push(entry);
+    return acc;
+  }, {});
 }
-async function ensureNoCircularDependency(taskId, dependsOn, client) {
-  if (!taskId || !dependsOn?.length) return;
-  const db2 = getDbClient(client);
-  const visited = /* @__PURE__ */ new Set();
-  const stack = [...dependsOn];
-  while (stack.length) {
-    const candidate = stack.pop();
-    if (!candidate) continue;
-    if (candidate === taskId) {
-      throw new Error("Circular dependency detected");
-    }
-    if (visited.has(candidate)) continue;
-    visited.add(candidate);
-    const { data, error } = await db2.from("tasks").select("depends_on").eq("id", candidate).maybeSingle();
-    if (error) {
-      if (error.code === "PGRST116" || error.code === "42703") continue;
-      throw error;
-    }
-    if (!data) continue;
-    const childDeps = Array.isArray(data.depends_on) ? data.depends_on : [];
-    for (const next of childDeps) {
-      if (next && !visited.has(next)) {
-        stack.push(next);
-      }
-    }
+async function createWorkspaceEntry(projectId, entry) {
+  const db2 = createAdminDbClient();
+  const id = (0, import_crypto.randomUUID)();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const { data, error } = await db2.from("workspace_entries").insert({
+    id,
+    project_id: projectId,
+    category: entry.category,
+    name: entry.name,
+    path: entry.path || null,
+    purpose: entry.purpose || null,
+    sort_order: 0,
+    created_at: now,
+    updated_at: now
+  }).select().single();
+  if (error) throw error;
+  return data;
+}
+async function updateWorkspaceEntry(projectId, entryId, updates) {
+  const db2 = createAdminDbClient();
+  const payload = {};
+  if (updates.name !== void 0) payload.name = updates.name;
+  if (updates.path !== void 0) payload.path = updates.path;
+  if (updates.purpose !== void 0) payload.purpose = updates.purpose;
+  if (updates.sort_order !== void 0) payload.sort_order = updates.sort_order;
+  const { data, error } = await db2.from("workspace_entries").update(payload).eq("id", entryId).eq("project_id", projectId).select().single();
+  if (error) {
+    if (error.code === "PGRST116") return null;
+    throw error;
   }
+  return data;
 }
-function extractTitle(markdown) {
-  const { body } = parseFrontmatter(markdown);
-  const match = body.match(/^#\s+(.+)$/m);
-  return match ? match[1] : void 0;
+async function deleteWorkspaceEntry(projectId, entryId) {
+  const db2 = createAdminDbClient();
+  const { error } = await db2.from("workspace_entries").delete().eq("id", entryId).eq("project_id", projectId);
+  if (error) throw error;
 }
+async function getWorkspaceMapForContext(projectId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("workspace_entries").select("category, name, path, purpose").eq("project_id", projectId).order("category", { ascending: true }).order("sort_order", { ascending: true }).order("name", { ascending: true });
+  if (error) {
+    if (isMissingRelationError(error, "workspace_entries")) return [];
+    throw error;
+  }
+  return (data || []).map((row) => ({
+    location: `${row.category}/${row.name}`,
+    path: row.path || null,
+    purpose: row.purpose || null
+  }));
+}
+var import_crypto, UUID_REGEX;
+var init_projects = __esm({
+  "apps/local/lib/db/projects.ts"() {
+    "use strict";
+    import_crypto = require("crypto");
+    init_db_adapter();
+    init_vault_store();
+    init_shared();
+    init_types();
+    UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  }
+});
+
+// apps/local/lib/db/tasks.ts
 function normalizeDescriptionBody(markdownBody) {
   return String(markdownBody || "").replace(/^#\s+.+(\r?\n|$)/, "").trim();
 }
@@ -7580,7 +8078,6 @@ async function createTask(content, userId, options) {
     const project = await getProjectWithRepos(projectId);
     if (project?.slug) projectSlug = project.slug;
   }
-  const hadFrontmatter = /^---\n/.test(content);
   const provider = typeof frontmatter.provider === "string" ? frontmatter.provider : null;
   const model = typeof frontmatter.model === "string" ? frontmatter.model : null;
   const engine = typeof frontmatter.engine === "string" ? frontmatter.engine : null;
@@ -7588,8 +8085,21 @@ async function createTask(content, userId, options) {
   const frontmatterDepends = normalizeDependsOnInput(frontmatter.depends_on);
   const optionDepends = normalizeDependsOnInput(options?.dependsOn);
   const dependsOn = optionDepends.length > 0 ? optionDepends : frontmatterDepends;
+  let identifier = null;
+  if (projectId) {
+    try {
+      const { data: projectRow } = await db2.from("projects").select("identifier_prefix, next_identifier").eq("id", projectId).single();
+      if (projectRow && typeof projectRow.identifier_prefix === "string" && projectRow.identifier_prefix) {
+        const n = typeof projectRow.next_identifier === "number" ? projectRow.next_identifier : 1;
+        identifier = `${projectRow.identifier_prefix}-${n}`;
+        await db2.from("projects").update({ next_identifier: n + 1 }).eq("id", projectId);
+      }
+    } catch {
+      identifier = null;
+    }
+  }
   const insertPayload = {
-    id: (0, import_crypto.randomUUID)(),
+    id: (0, import_crypto2.randomUUID)(),
     content,
     description: normalizeDescriptionBody(body),
     title,
@@ -7599,6 +8109,7 @@ async function createTask(content, userId, options) {
     project: projectSlug || null,
     ...projectId !== void 0 ? { project_id: projectId } : {},
     ...workflowId !== void 0 ? { workflow_id: workflowId } : {},
+    ...identifier !== null ? { identifier } : {},
     priority: frontmatter.priority,
     engine,
     provider,
@@ -7608,7 +8119,6 @@ async function createTask(content, userId, options) {
     depends_on: dependsOn.length ? dependsOn : null,
     created_by: createdBy,
     user_id: userId,
-    // Working set fields
     current_plan: options?.currentPlan || null,
     open_blockers: options?.openBlockers || [],
     next_action: options?.nextAction || null,
@@ -7626,6 +8136,7 @@ async function createTask(content, userId, options) {
       next_action,
       version,
       depends_on,
+      identifier: _identifier,
       ...fallbackPayload
     } = insertPayload;
     ({ data, error } = await db2.from("tasks").insert(fallbackPayload).select().single());
@@ -7692,7 +8203,6 @@ async function updateTask(id, content, userId, options) {
     swarm_models: options?.swarmModels ?? void 0,
     ...shouldUpdateDepends ? { depends_on: dependsOnForUpdate.length ? dependsOnForUpdate : null } : {},
     updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    // Working set fields
     current_plan: options?.currentPlan ?? void 0,
     open_blockers: options?.openBlockers ?? void 0,
     next_action: options?.nextAction ?? void 0
@@ -7705,14 +8215,8 @@ async function updateTask(id, content, userId, options) {
   if (shouldUpdateDepends) {
     await ensureNoCircularDependency(id, dependsOnForUpdate, db2);
   }
-  let query = db2.from("tasks").update({
-    ...updatePayload,
-    version: db2.rpc("increment_version")
-    // This will be used in the actual SQL via RPC or raw query if possible
-  }).eq("id", id);
-  if (userId) query = query.eq("user_id", userId);
   if (options?.expectedVersion !== void 0) {
-    query = query.eq("version", options.expectedVersion);
+    void options.expectedVersion;
   }
   let { data, error } = await db2.from("tasks").update({
     ...updatePayload
@@ -7805,213 +8309,20 @@ async function getNextQueuedTask(engine) {
   }
   return data;
 }
-async function getProjects(userId, includeArchived = false) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("projects").select("*, project_repos(*)");
-  if (userId) query = query.eq("user_id", userId);
-  if (!includeArchived) query = query.is("archived_at", null);
-  const { data, error } = await query;
-  if (error) {
-    if (isMissingRelationError2(error, "projects")) {
-      return [];
-    }
-    throw error;
-  }
-  const projects = data || [];
-  return projects.map((project) => ({
-    ...project,
-    repos: project.project_repos ?? []
-  }));
-}
-async function getProjectBySlug(slug, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("projects").select("*").eq("slug", slug);
-  if (userId) query = query.eq("user_id", userId);
-  const { data, error } = await query.maybeSingle();
-  if (error) {
-    if (isMissingRelationError2(error, "projects")) {
-      return null;
-    }
-    throw error;
-  }
-  return data || null;
-}
-async function getProjectRepos(projectId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_repos").select("*").eq("project_id", projectId);
-  if (error) {
-    if (isMissingRelationError2(error, "project_repos")) {
-      return [];
-    }
-    throw error;
-  }
-  return data || [];
-}
-async function getProjectWithRepos(projectIdOrSlug, userId) {
-  const db2 = createAdminDbClient();
-  const isUuid = UUID_REGEX.test(projectIdOrSlug);
-  let projectQuery = db2.from("projects").select("*");
-  if (isUuid) {
-    projectQuery = projectQuery.eq("id", projectIdOrSlug);
-  } else {
-    projectQuery = projectQuery.eq("slug", projectIdOrSlug);
-  }
-  if (userId) projectQuery = projectQuery.eq("user_id", userId);
-  const projectResult = await projectQuery.maybeSingle();
-  if (projectResult.error) {
-    if (isMissingRelationError2(projectResult.error, "projects")) {
-      return null;
-    }
-    throw projectResult.error;
-  }
-  const project = projectResult.data;
-  if (!project) return null;
-  const repos = await getProjectRepos(project.id);
-  return { ...project, repos };
-}
-async function insertProjectRepos(projectId, repos, db2) {
-  if (!repos.length) {
-    return [];
-  }
-  const payload = repos.map((repo) => ({
-    ...repo.id ? { id: repo.id } : {},
-    project_id: projectId,
-    name: repo.name,
-    path: repo.path ?? null,
-    git_url: repo.git_url ?? null,
-    notes: repo.notes ?? null
-  }));
-  const { data, error } = await db2.from("project_repos").insert(payload).select("*");
-  if (error) {
-    if (isMissingRelationError2(error, "project_repos")) {
-      return [];
-    }
-    throw error;
-  }
-  return data || [];
-}
-async function createProject(userId, input, dbClient) {
-  if (!input.name?.trim()) {
-    throw new Error("Project name is required");
-  }
-  const db2 = getDbClient(dbClient);
-  const baseSlug = input.name.trim() || "project";
-  const slug = await generateUniqueProjectSlug(baseSlug, userId, db2);
-  const payload = {
-    user_id: userId,
-    name: input.name.trim(),
-    slug,
-    description: input.description ?? null,
-    workflow_id: input.workflow_id ?? null
-  };
-  const { data: project, error } = await db2.from("projects").insert(payload).select("*").single();
-  if (error) throw error;
-  const repos = await insertProjectRepos(project.id, input.repos ?? [], db2);
-  return { ...project, repos };
-}
-async function updateProject(projectIdOrSlug, userId, updates, dbClient) {
-  const db2 = getDbClient(dbClient);
-  const isUuid = UUID_REGEX.test(projectIdOrSlug);
-  let projectId = projectIdOrSlug;
-  if (!isUuid) {
-    const project = await getProjectBySlug(projectIdOrSlug, userId);
-    if (!project) return null;
-    projectId = project.id;
-  }
-  const updatePayload = {};
-  if (typeof updates.name !== "undefined") {
-    const trimmedName = updates.name?.trim();
-    if (!trimmedName) {
-      throw new Error("Project name cannot be empty");
-    }
-    updatePayload.name = trimmedName;
-  }
-  if (typeof updates.slug !== "undefined") {
-    const trimmedSlug = updates.slug?.trim();
-    if (trimmedSlug) {
-      updatePayload.slug = trimmedSlug;
-    }
-  }
-  if (typeof updates.description !== "undefined") updatePayload.description = updates.description;
-  if (typeof updates.metadata !== "undefined") updatePayload.metadata = updates.metadata;
-  if (typeof updates.ci_cd_info !== "undefined") updatePayload.ci_cd_info = updates.ci_cd_info;
-  if (typeof updates.workflow_id !== "undefined") updatePayload.workflow_id = updates.workflow_id;
-  if (Object.keys(updatePayload).length) {
-    const { error } = await db2.from("projects").update(updatePayload).eq("id", projectId).eq("user_id", userId);
-    if (error) throw error;
-  }
-  if (updates.repos) {
-    const { data: existingRepos, error: existingReposError } = await db2.from("project_repos").select("*").eq("project_id", projectId);
-    if (existingReposError && !isMissingRelationError2(existingReposError, "project_repos")) {
-      throw existingReposError;
-    }
-    const existingRepoList = existingRepos || [];
-    const existingRepoIds = new Set(existingRepoList.map((repo) => repo.id));
-    const nextRepoIds = new Set(
-      updates.repos.map((repo) => repo.id).filter((repoId) => Boolean(repoId))
-    );
-    for (const existingRepo of existingRepoList) {
-      if (nextRepoIds.has(existingRepo.id)) continue;
-      const { error: deleteError } = await db2.from("project_repos").delete().eq("id", existingRepo.id).eq("project_id", projectId);
-      if (deleteError && !isMissingRelationError2(deleteError, "project_repos")) {
-        throw deleteError;
-      }
-    }
-    for (const repo of updates.repos) {
-      const payload = {
-        name: repo.name,
-        path: repo.path ?? null,
-        git_url: repo.git_url ?? null,
-        notes: repo.notes ?? null,
-        project_id: projectId
-      };
-      if (repo.id && existingRepoIds.has(repo.id)) {
-        const { error: repoUpdateError } = await db2.from("project_repos").update(payload).eq("id", repo.id).eq("project_id", projectId);
-        if (repoUpdateError && !isMissingRelationError2(repoUpdateError, "project_repos")) {
-          throw repoUpdateError;
-        }
-        continue;
-      }
-      const { error: repoInsertError } = await db2.from("project_repos").insert({
-        ...repo.id ? { id: repo.id } : {},
-        ...payload
-      });
-      if (repoInsertError && !isMissingRelationError2(repoInsertError, "project_repos")) {
-        throw repoInsertError;
-      }
-    }
-  }
-  return getProjectWithRepos(projectId, userId);
-}
-async function deleteProject(projectId, userId, dbClient) {
-  const db2 = getDbClient(dbClient);
-  const { error } = await db2.from("projects").update({ archived_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", projectId).eq("user_id", userId);
-  if (error) throw error;
-}
-async function assignOrphanTasksToProject(projectId, userId, dbClient) {
-  const db2 = getDbClient(dbClient);
-  const project = await getProjectWithRepos(projectId, userId);
-  if (!project) {
-    throw new Error("Project not found");
-  }
-  const { data: tasks, error: tasksError } = await db2.from("tasks").select("id, project").eq("user_id", userId).is("project_id", null);
-  if (tasksError) throw tasksError;
-  const slug = String(project.slug || "").trim().toLowerCase();
-  const orphanTaskIds = (tasks || []).filter((task) => {
-    const projectValue = String(task.project || "").trim().toLowerCase();
-    return !projectValue || projectValue === "none" || projectValue === slug;
-  }).map((task) => task.id);
-  if (!orphanTaskIds.length) {
-    return { updatedCount: 0, taskIds: [] };
+var import_crypto2;
+var init_tasks = __esm({
+  "apps/local/lib/db/tasks.ts"() {
+    "use strict";
+    import_crypto2 = require("crypto");
+    init_db_adapter();
+    init_dependency_helpers();
+    init_notifications();
+    init_projects();
+    init_shared();
   }
-  const { error: updateError } = await db2.from("tasks").update({
-    project: project.slug,
-    project_id: project.id,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).eq("user_id", userId).is("project_id", null).in("id", orphanTaskIds);
-  if (updateError) throw updateError;
-  return { updatedCount: orphanTaskIds.length, taskIds: orphanTaskIds };
-}
+});
+
+// apps/local/lib/db/workflows.ts
 async function ensureDefaultWorkflowGraphExists(userId) {
   const db2 = createAdminDbClient();
   const ownerId = userId || DEFAULT_SYSTEM_USER_ID;
@@ -8039,9 +8350,7 @@ async function ensureDefaultWorkflowGraphExists(userId) {
       {
         workflow_id: DEFAULT_SDLC_WORKFLOW_ID,
         from_node_id: "00000000-0000-0000-0001-000000000001",
-        // INTAKE
         to_node_id: "00000000-0000-0000-0001-000000000002",
-        // PROGRESS
         condition: "done",
         priority: 0,
         metadata: {}
@@ -8049,9 +8358,7 @@ async function ensureDefaultWorkflowGraphExists(userId) {
       {
         workflow_id: DEFAULT_SDLC_WORKFLOW_ID,
         from_node_id: "00000000-0000-0000-0001-000000000002",
-        // PROGRESS
         to_node_id: "00000000-0000-0000-0001-000000000003",
-        // DONE
         condition: "done",
         priority: 0,
         metadata: {}
@@ -8065,7 +8372,7 @@ async function getWorkflows(userId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("workflows").select("*").or(`user_id.eq.${userId},user_id.eq.00000000-0000-0000-0000-000000000000`).order("created_at", { ascending: false });
   if (error) {
-    if (isMissingRelationError2(error, "workflows")) return [];
+    if (isMissingRelationError(error, "workflows")) return [];
     throw error;
   }
   return data || [];
@@ -8073,17 +8380,17 @@ async function getWorkflows(userId) {
 async function getWorkflow(id, userId) {
   const db2 = createAdminDbClient();
   let query = db2.from("workflows").select("*").eq("id", id);
-  if (userId) {
-  }
+  void userId;
   const { data, error } = await query.maybeSingle();
   if (error) {
-    if (isMissingRelationError2(error, "workflows")) return null;
+    if (isMissingRelationError(error, "workflows")) return null;
     throw error;
   }
   return data;
 }
 async function updateWorkflow(id, userId, updates) {
   const db2 = createAdminDbClient();
+  void userId;
   const payload = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
   if (updates.definition !== void 0) payload.definition = updates.definition;
   if (updates.name !== void 0) payload.name = updates.name;
@@ -8096,7 +8403,7 @@ async function getWorkflowNodes(workflowId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("workflow_nodes").select("*").eq("workflow_id", workflowId).order("position", { ascending: true });
   if (error) {
-    if (isMissingRelationError2(error, "workflow_nodes")) return [];
+    if (isMissingRelationError(error, "workflow_nodes")) return [];
     throw error;
   }
   return data || [];
@@ -8149,7 +8456,7 @@ async function getWorkflowNodeByName(workflowId, name) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("workflow_nodes").select("*").eq("workflow_id", workflowId).eq("name", name).maybeSingle();
   if (error) {
-    if (isMissingRelationError2(error, "workflow_nodes")) return null;
+    if (isMissingRelationError(error, "workflow_nodes")) return null;
     throw error;
   }
   return data;
@@ -8158,7 +8465,7 @@ async function getWorkflowTransitions(workflowId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("workflow_transitions").select("*").eq("workflow_id", workflowId).order("priority", { ascending: true });
   if (error) {
-    if (isMissingRelationError2(error, "workflow_transitions")) return [];
+    if (isMissingRelationError(error, "workflow_transitions")) return [];
     throw error;
   }
   return data || [];
@@ -8167,7 +8474,7 @@ async function getWorkflowTransitionsFromNode(workflowId, fromNodeId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("workflow_transitions").select("*").eq("workflow_id", workflowId).eq("from_node_id", fromNodeId).order("priority", { ascending: true });
   if (error) {
-    if (isMissingRelationError2(error, "workflow_transitions")) return [];
+    if (isMissingRelationError(error, "workflow_transitions")) return [];
     throw error;
   }
   return data || [];
@@ -8184,6 +8491,115 @@ async function getWorkflowWithGraph(id, userId) {
 function getDefaultWorkflowId() {
   return DEFAULT_SDLC_WORKFLOW_ID;
 }
+async function getStagePrompts(userId, workflowId) {
+  const db2 = createAdminDbClient();
+  let query = db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).order("stage", { ascending: true });
+  if (userId) {
+    query = query.or(`user_id.eq.${userId},is_default.eq.true`);
+  } else {
+    query = query.eq("is_default", true);
+  }
+  const { data, error } = await query;
+  if (error) throw error;
+  return data || [];
+}
+async function getStagePrompt(stage, userId, workflowId) {
+  const db2 = createAdminDbClient();
+  if (userId) {
+    const { data: userPrompt } = await db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).eq("stage", stage).eq("user_id", userId).single();
+    if (userPrompt) return userPrompt;
+  }
+  const { data: defaultPrompt } = await db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).eq("stage", stage).eq("is_default", true).single();
+  return defaultPrompt || null;
+}
+async function upsertStagePrompt(stage, prompt, outputs = [], userId, modelConfig, workflowId) {
+  const db2 = createAdminDbClient();
+  const payload = {
+    stage,
+    prompt,
+    outputs,
+    user_id: userId,
+    is_default: !userId,
+    workflow_id: workflowId
+  };
+  if (modelConfig) {
+    if (modelConfig.swarm !== void 0) payload.swarm = modelConfig.swarm;
+    if (modelConfig.provider !== void 0) payload.provider = modelConfig.provider;
+    if (modelConfig.model !== void 0) payload.model = modelConfig.model;
+    if (modelConfig.swarm_models !== void 0) payload.swarm_models = modelConfig.swarm_models;
+  }
+  const { data, error } = await db2.from("stage_prompts").upsert(payload, {
+    onConflict: userId ? "workflow_id,stage,user_id" : "workflow_id,stage,is_default"
+  }).select().single();
+  if (error) throw error;
+  return data;
+}
+async function deleteStagePrompt(id, userId) {
+  const db2 = createAdminDbClient();
+  let query = db2.from("stage_prompts").delete().eq("id", id);
+  if (userId) query = query.eq("user_id", userId);
+  const { error } = await query;
+  if (error) throw error;
+}
+var DEFAULT_SDLC_WORKFLOW_ID, DEFAULT_SYSTEM_USER_ID, DEFAULT_WORKFLOW_NODE_SEED, DEFAULT_WORKFLOW_NODE_SEED_BY_ID, defaultStagePrompts, DEFAULT_WORKFLOW_ID;
+var init_workflows = __esm({
+  "apps/local/lib/db/workflows.ts"() {
+    "use strict";
+    init_db_adapter();
+    init_shared();
+    DEFAULT_SDLC_WORKFLOW_ID = "00000000-0000-0000-0000-000000000001";
+    DEFAULT_SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
+    DEFAULT_WORKFLOW_NODE_SEED = [
+      {
+        id: "00000000-0000-0000-0001-000000000001",
+        name: "INTAKE",
+        label: "Intake",
+        prompt: "New task. Triage, scope, and prepare for work.",
+        position: 0,
+        node_type: "step"
+      },
+      {
+        id: "00000000-0000-0000-0001-000000000002",
+        name: "PROGRESS",
+        label: "Progress",
+        prompt: "Task is actively being worked on.",
+        position: 1,
+        node_type: "step"
+      },
+      {
+        id: "00000000-0000-0000-0001-000000000003",
+        name: "DONE",
+        label: "Done",
+        prompt: "Task completed.",
+        position: 2,
+        node_type: "terminal"
+      }
+    ];
+    DEFAULT_WORKFLOW_NODE_SEED_BY_ID = new Map(
+      DEFAULT_WORKFLOW_NODE_SEED.map((node) => [node.id, node])
+    );
+    defaultStagePrompts = {
+      INTAKE: {
+        prompt: "New task. Triage, scope, and prepare for work.",
+        outputs: [],
+        swarm: false
+      },
+      PROGRESS: {
+        prompt: "Task is actively being worked on.",
+        outputs: [],
+        swarm: false
+      },
+      DONE: {
+        prompt: "Task completed.",
+        outputs: [],
+        swarm: false
+      }
+    };
+    DEFAULT_WORKFLOW_ID = "00000000-0000-0000-0000-000000000001";
+  }
+});
+
+// apps/local/lib/db/task-logs.ts
 async function getTaskLogs(taskId, options = {}) {
   const db2 = createAdminDbClient();
   const limit = Math.max(1, Math.min(2e3, Number(options.limit ?? options.tail ?? 500)));
@@ -8214,6 +8630,14 @@ async function addTaskLog(taskId, content, logType, nodeId) {
   if (error) throw error;
   return data;
 }
+var init_task_logs = __esm({
+  "apps/local/lib/db/task-logs.ts"() {
+    "use strict";
+    init_db_adapter();
+  }
+});
+
+// apps/local/lib/db/task-costs.ts
 function normalizeTokenCount(value) {
   const parsed = Number(value ?? 0);
   if (!Number.isFinite(parsed)) return 0;
@@ -8283,6 +8707,14 @@ async function getTaskCostSummary(taskId) {
   const entries = await getTaskCostEntries(taskId);
   return summarizeTaskCosts(entries);
 }
+var init_task_costs = __esm({
+  "apps/local/lib/db/task-costs.ts"() {
+    "use strict";
+    init_db_adapter();
+  }
+});
+
+// apps/local/lib/db/task-comments.ts
 async function getTaskComments(taskId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("task_comments").select("*").eq("task_id", taskId).is("deleted_at", null).order("created_at", { ascending: true }).order("id", { ascending: true });
@@ -8306,6 +8738,14 @@ async function deleteTaskComment(commentId, userId) {
   const { error } = await db2.from("task_comments").update({ deleted_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", commentId).is("deleted_at", null);
   if (error) throw error;
 }
+var init_task_comments = __esm({
+  "apps/local/lib/db/task-comments.ts"() {
+    "use strict";
+    init_db_adapter();
+  }
+});
+
+// apps/local/lib/db/learnings.ts
 async function getLearnings(scope, scopeId, userId) {
   if (scope !== "task") {
     return vaultStore.getLearnings(scope, scopeId);
@@ -8343,61 +8783,21 @@ async function deleteLearning(id, userId) {
   const { error } = await query;
   if (error) throw error;
 }
-async function getStagePrompts(userId, workflowId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).order("stage", { ascending: true });
-  if (userId) {
-    query = query.or(`user_id.eq.${userId},is_default.eq.true`);
-  } else {
-    query = query.eq("is_default", true);
-  }
-  const { data, error } = await query;
-  if (error) throw error;
-  return data || [];
-}
-async function getStagePrompt(stage, userId, workflowId) {
-  const db2 = createAdminDbClient();
-  if (userId) {
-    const { data: userPrompt } = await db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).eq("stage", stage).eq("user_id", userId).single();
-    if (userPrompt) return userPrompt;
-  }
-  const { data: defaultPrompt } = await db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).eq("stage", stage).eq("is_default", true).single();
-  return defaultPrompt || null;
-}
-async function upsertStagePrompt(stage, prompt, outputs = [], userId, modelConfig, workflowId) {
-  const db2 = createAdminDbClient();
-  const payload = {
-    stage,
-    prompt,
-    outputs,
-    user_id: userId,
-    is_default: !userId,
-    workflow_id: workflowId
-  };
-  if (modelConfig) {
-    if (modelConfig.swarm !== void 0) payload.swarm = modelConfig.swarm;
-    if (modelConfig.provider !== void 0) payload.provider = modelConfig.provider;
-    if (modelConfig.model !== void 0) payload.model = modelConfig.model;
-    if (modelConfig.swarm_models !== void 0) payload.swarm_models = modelConfig.swarm_models;
+var init_learnings = __esm({
+  "apps/local/lib/db/learnings.ts"() {
+    "use strict";
+    init_db_adapter();
+    init_vault_store();
+    init_projects();
   }
-  const { data, error } = await db2.from("stage_prompts").upsert(payload, {
-    onConflict: userId ? "workflow_id,stage,user_id" : "workflow_id,stage,is_default"
-  }).select().single();
-  if (error) throw error;
-  return data;
-}
-async function deleteStagePrompt(id, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("stage_prompts").delete().eq("id", id);
-  if (userId) query = query.eq("user_id", userId);
-  const { error } = await query;
-  if (error) throw error;
-}
+});
+
+// apps/local/lib/db/agents.ts
 async function getAgents(userId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("agents").select("*").eq("user_id", userId).order("created_at", { ascending: false });
   if (error) {
-    if (isMissingRelationError2(error, "agents")) return [];
+    if (isMissingRelationError(error, "agents")) return [];
     throw error;
   }
   return data || [];
@@ -8406,7 +8806,7 @@ async function getAgent(id, userId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("agents").select("*").eq("id", id).eq("user_id", userId).maybeSingle();
   if (error) {
-    if (error.code === "PGRST116" || isMissingRelationError2(error, "agents")) return null;
+    if (error.code === "PGRST116" || isMissingRelationError(error, "agents")) return null;
     throw error;
   }
   return data;
@@ -8415,7 +8815,7 @@ async function getAgentSkills(agentId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("agent_skills").select("*").eq("agent_id", agentId).order("created_at", { ascending: true });
   if (error) {
-    if (isMissingRelationError2(error, "agent_skills")) return [];
+    if (isMissingRelationError(error, "agent_skills")) return [];
     throw error;
   }
   return data || [];
@@ -8436,19 +8836,19 @@ async function setAgentSkills(agentId, skills) {
   for (const skill of existing) {
     if (!normalized.has(skill.file)) {
       const { error } = await db2.from("agent_skills").delete().eq("agent_id", agentId).eq("file", skill.file);
-      if (error && !isMissingRelationError2(error, "agent_skills")) throw error;
+      if (error && !isMissingRelationError(error, "agent_skills")) throw error;
     }
   }
   for (const entry of normalized.values()) {
     const existingSkill = existing.find((skill) => skill.file === entry.file);
     if (!existingSkill) {
       const { error } = await db2.from("agent_skills").insert(entry);
-      if (error && !isMissingRelationError2(error, "agent_skills")) throw error;
+      if (error && !isMissingRelationError(error, "agent_skills")) throw error;
       continue;
     }
     if ((existingSkill.condition ?? null) !== entry.condition) {
       const { error } = await db2.from("agent_skills").update({ condition: entry.condition }).eq("agent_id", agentId).eq("file", entry.file);
-      if (error && !isMissingRelationError2(error, "agent_skills")) throw error;
+      if (error && !isMissingRelationError(error, "agent_skills")) throw error;
     }
   }
   return getAgentSkills(agentId);
@@ -8470,7 +8870,7 @@ async function createAgent(userId, input) {
   if (input.color !== void 0) payload.color = input.color;
   const { data, error } = await db2.from("agents").insert(payload).select().single();
   if (error) {
-    if (isMissingRelationError2(error, "agents")) {
+    if (isMissingRelationError(error, "agents")) {
       throw new Error("Agents table does not exist");
     }
     throw error;
@@ -8494,7 +8894,7 @@ async function updateAgent(id, userId, input) {
   }
   const { data, error } = await db2.from("agents").update(updatePayload).eq("id", id).eq("user_id", userId).select().single();
   if (error) {
-    if (error.code === "PGRST116" || isMissingRelationError2(error, "agents")) return null;
+    if (error.code === "PGRST116" || isMissingRelationError(error, "agents")) return null;
     throw error;
   }
   return data;
@@ -8503,47 +8903,25 @@ async function deleteAgent(id, userId) {
   const db2 = createAdminDbClient();
   const { error } = await db2.from("agents").delete().eq("id", id).eq("user_id", userId);
   if (error) {
-    if (!isMissingRelationError2(error, "agents")) {
+    if (!isMissingRelationError(error, "agents")) {
       throw error;
     }
   }
 }
-async function getProjectAgents(projectId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_agents").select("*").eq("project_id", projectId).order("routing_order", { ascending: true });
-  if (error) {
-    if (isMissingRelationError2(error, "project_agents")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function addProjectAgent(projectId, agentId, routingOrder) {
-  const db2 = createAdminDbClient();
-  if (routingOrder === void 0) {
-    const { data: existing } = await db2.from("project_agents").select("routing_order").eq("project_id", projectId).order("routing_order", { ascending: false }).limit(1);
-    routingOrder = (existing?.[0]?.routing_order ?? -1) + 1;
-  }
-  const { data, error } = await db2.from("project_agents").upsert({ project_id: projectId, agent_id: agentId, routing_order: routingOrder }).select().single();
-  if (error) throw error;
-  return data;
-}
-async function removeProjectAgent(projectId, agentId) {
-  const db2 = createAdminDbClient();
-  const { error } = await db2.from("project_agents").delete().eq("project_id", projectId).eq("agent_id", agentId);
-  if (error) throw error;
-}
-async function reorderProjectAgents(projectId, orderedAgentIds) {
-  const db2 = createAdminDbClient();
-  for (let i = 0; i < orderedAgentIds.length; i++) {
-    await db2.from("project_agents").update({ routing_order: i }).eq("project_id", projectId).eq("agent_id", orderedAgentIds[i]);
+var init_agents = __esm({
+  "apps/local/lib/db/agents.ts"() {
+    "use strict";
+    init_db_adapter();
+    init_shared();
   }
-  return getProjectAgents(projectId);
-}
+});
+
+// apps/local/lib/db/teams.ts
 async function getTeams(projectId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("teams").select("*").eq("project_id", projectId).order("created_at", { ascending: true });
   if (error) {
-    if (isMissingRelationError2(error, "teams")) return [];
+    if (isMissingRelationError(error, "teams")) return [];
     throw error;
   }
   return (data || []).map((row) => ({
@@ -8555,7 +8933,7 @@ async function getTeam(teamId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("teams").select("*").eq("id", teamId).limit(1).single();
   if (error) {
-    if (error.code === "PGRST116" || isMissingRelationError2(error, "teams")) return null;
+    if (error.code === "PGRST116" || isMissingRelationError(error, "teams")) return null;
     throw error;
   }
   if (!data) return null;
@@ -8566,7 +8944,7 @@ async function getTeam(teamId) {
 }
 async function createTeam(projectId, name, templateId, metadata) {
   const db2 = createAdminDbClient();
-  const id = (0, import_crypto.randomUUID)();
+  const id = (0, import_crypto3.randomUUID)();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const { data, error } = await db2.from("teams").insert({
     id,
@@ -8607,7 +8985,7 @@ async function getTeamAgents(teamId) {
   const db2 = createAdminDbClient();
   const { data, error } = await db2.from("team_agents").select("*").eq("team_id", teamId).order("routing_order", { ascending: true });
   if (error) {
-    if (isMissingRelationError2(error, "team_agents")) return [];
+    if (isMissingRelationError(error, "team_agents")) return [];
     throw error;
   }
   return data || [];
@@ -8627,90 +9005,17 @@ async function removeTeamAgent(teamId, agentId) {
   const { error } = await db2.from("team_agents").delete().eq("team_id", teamId).eq("agent_id", agentId);
   if (error) throw error;
 }
-async function getProjectSkills(projectId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_skills").select("*").eq("project_id", projectId).order("created_at", { ascending: true });
-  if (error) {
-    if (isMissingRelationError2(error, "project_skills")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function addProjectSkill(projectId, file, condition) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_skills").insert({ project_id: projectId, file, condition: condition ?? null }).select().single();
-  if (error) throw error;
-  return data;
-}
-async function removeProjectSkill(skillId) {
-  const db2 = createAdminDbClient();
-  const { error } = await db2.from("project_skills").delete().eq("id", skillId);
-  if (error) throw error;
-}
-async function getProjectVariables(projectId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_variables").select("*").eq("project_id", projectId);
-  if (error) {
-    if (isMissingRelationError2(error, "project_variables")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function setProjectVariable(projectId, key, value) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_variables").upsert({ project_id: projectId, key, value }).select().single();
-  if (error) throw error;
-  return data;
-}
-async function deleteProjectVariable(projectId, key) {
-  const db2 = createAdminDbClient();
-  const { error } = await db2.from("project_variables").delete().eq("project_id", projectId).eq("key", key);
-  if (error) throw error;
-}
-async function getProjectMemory(projectId, producer) {
-  void producer;
-  return vaultStore.getProjectMemory(projectId);
-}
-async function addProjectMemory(projectId, content, source, producer = "human") {
-  return vaultStore.addProjectMemory(projectId, content, source, producer);
-}
-async function deleteProjectMemory(memoryId) {
-  vaultStore.deleteProjectMemory(memoryId);
-}
-async function getProjectThreads(projectId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_threads").select("*").eq("project_id", projectId).order("created_at", { ascending: true });
-  if (error) {
-    if (isMissingRelationError2(error, "project_threads")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function addProjectThread(projectId, threadId) {
-  const db2 = createAdminDbClient();
-  const { error } = await db2.from("project_threads").upsert(
-    { project_id: projectId, thread_id: threadId },
-    { onConflict: "project_id,thread_id", ignoreDuplicates: true }
-  );
-  if (error) throw error;
-  const { data, error: fetchError } = await db2.from("project_threads").select("*").eq("project_id", projectId).eq("thread_id", threadId).single();
-  if (fetchError) throw fetchError;
-  return data;
-}
-async function removeProjectThread(projectId, threadId) {
-  const db2 = createAdminDbClient();
-  const { error } = await db2.from("project_threads").delete().eq("project_id", projectId).eq("thread_id", threadId);
-  if (error) throw error;
-}
-async function getProjectForThread(threadId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_threads").select("project_id").eq("thread_id", threadId).maybeSingle();
-  if (error) {
-    if (isMissingRelationError2(error, "project_threads")) return null;
-    return null;
+var import_crypto3;
+var init_teams = __esm({
+  "apps/local/lib/db/teams.ts"() {
+    "use strict";
+    import_crypto3 = require("crypto");
+    init_db_adapter();
+    init_shared();
   }
-  return data?.project_id ?? null;
-}
+});
+
+// apps/local/lib/db/resolution.ts
 function resolveSkills(agentSkills, projectSkills) {
   const result = [];
   const agentFileNames = /* @__PURE__ */ new Set();
@@ -8742,6 +9047,7 @@ async function resolveVariables(projectId) {
   return vars.map((v) => ({ key: v.key, value: v.value, source: "project" }));
 }
 async function buildExecutionProvenance(agentId, projectId, agentSkills, agentMemoryEntries) {
+  void agentId;
   const projectSkills = await getProjectSkills(projectId);
   const projectMem = await getProjectMemory(projectId);
   const variables = await resolveVariables(projectId);
@@ -8751,65 +9057,141 @@ async function buildExecutionProvenance(agentId, projectId, agentSkills, agentMe
     variables
   };
 }
-var import_crypto, UUID_REGEX, DEFAULT_SDLC_WORKFLOW_ID, DEFAULT_SYSTEM_USER_ID, DEFAULT_WORKFLOW_NODE_SEED, DEFAULT_WORKFLOW_NODE_SEED_BY_ID, defaultStagePrompts, DEFAULT_WORKFLOW_ID;
+var init_resolution = __esm({
+  "apps/local/lib/db/resolution.ts"() {
+    "use strict";
+    init_projects();
+  }
+});
+
+// apps/local/lib/db/index.ts
 var init_db = __esm({
+  "apps/local/lib/db/index.ts"() {
+    "use strict";
+    init_types();
+    init_shared();
+    init_user_settings();
+    init_tasks();
+    init_projects();
+    init_workflows();
+    init_task_logs();
+    init_task_costs();
+    init_task_comments();
+    init_learnings();
+    init_agents();
+    init_teams();
+    init_resolution();
+  }
+});
+
+// apps/local/lib/db.ts
+var db_exports = {};
+__export(db_exports, {
+  DEFAULT_WORKFLOW_ID: () => DEFAULT_WORKFLOW_ID,
+  IDENTIFIER_PREFIX_REGEX: () => IDENTIFIER_PREFIX_REGEX,
+  addLearning: () => addLearning,
+  addProjectAgent: () => addProjectAgent,
+  addProjectMemory: () => addProjectMemory,
+  addProjectSkill: () => addProjectSkill,
+  addProjectThread: () => addProjectThread,
+  addTaskComment: () => addTaskComment,
+  addTaskCostEntry: () => addTaskCostEntry,
+  addTaskLog: () => addTaskLog,
+  addTeamAgent: () => addTeamAgent,
+  appendRunToIndex: () => appendRunToIndex,
+  assignOrphanTasksToProject: () => assignOrphanTasksToProject,
+  buildExecutionProvenance: () => buildExecutionProvenance,
+  createAgent: () => createAgent,
+  createProject: () => createProject,
+  createTask: () => createTask,
+  createTeam: () => createTeam,
+  createWorkspaceEntry: () => createWorkspaceEntry,
+  defaultStagePrompts: () => defaultStagePrompts,
+  deleteAgent: () => deleteAgent,
+  deleteLearning: () => deleteLearning,
+  deleteProject: () => deleteProject,
+  deleteProjectMemory: () => deleteProjectMemory,
+  deleteProjectVariable: () => deleteProjectVariable,
+  deleteStagePrompt: () => deleteStagePrompt,
+  deleteTask: () => deleteTask,
+  deleteTaskComment: () => deleteTaskComment,
+  deleteTeam: () => deleteTeam,
+  deleteWorkspaceEntry: () => deleteWorkspaceEntry,
+  ensureNoCircularDependency: () => ensureNoCircularDependency,
+  extractTitle: () => extractTitle,
+  generateUniqueProjectSlug: () => generateUniqueProjectSlug,
+  generateUniqueSlug: () => generateUniqueSlug,
+  getAgent: () => getAgent,
+  getAgentSkills: () => getAgentSkills,
+  getAgents: () => getAgents,
+  getDbClient: () => getDbClient,
+  getDefaultWorkflowId: () => getDefaultWorkflowId,
+  getLearnings: () => getLearnings,
+  getNextQueuedTask: () => getNextQueuedTask,
+  getProjectAgents: () => getProjectAgents,
+  getProjectBySlug: () => getProjectBySlug,
+  getProjectForThread: () => getProjectForThread,
+  getProjectMemory: () => getProjectMemory,
+  getProjectRepos: () => getProjectRepos,
+  getProjectSkills: () => getProjectSkills,
+  getProjectThreads: () => getProjectThreads,
+  getProjectVariables: () => getProjectVariables,
+  getProjectWithRepos: () => getProjectWithRepos,
+  getProjectWorkspace: () => getProjectWorkspace,
+  getProjects: () => getProjects,
+  getStagePrompt: () => getStagePrompt,
+  getStagePrompts: () => getStagePrompts,
+  getTask: () => getTask,
+  getTaskBySlug: () => getTaskBySlug,
+  getTaskComments: () => getTaskComments,
+  getTaskCostEntries: () => getTaskCostEntries,
+  getTaskCostSummary: () => getTaskCostSummary,
+  getTaskLogs: () => getTaskLogs,
+  getTasks: () => getTasks,
+  getTeam: () => getTeam,
+  getTeamAgents: () => getTeamAgents,
+  getTeams: () => getTeams,
+  getUserSettings: () => getUserSettings,
+  getWorkflow: () => getWorkflow,
+  getWorkflowNodeByName: () => getWorkflowNodeByName,
+  getWorkflowNodes: () => getWorkflowNodes,
+  getWorkflowTransitions: () => getWorkflowTransitions,
+  getWorkflowTransitionsFromNode: () => getWorkflowTransitionsFromNode,
+  getWorkflowWithGraph: () => getWorkflowWithGraph,
+  getWorkflows: () => getWorkflows,
+  getWorkspaceMapForContext: () => getWorkspaceMapForContext,
+  isMissingRelationError: () => isMissingRelationError,
+  normalizeDependsOnInput: () => normalizeDependsOnInput,
+  parseDependsOnValue: () => parseDependsOnValue,
+  parseFrontmatter: () => parseFrontmatter,
+  removeProjectAgent: () => removeProjectAgent,
+  removeProjectSkill: () => removeProjectSkill,
+  removeProjectThread: () => removeProjectThread,
+  removeTeamAgent: () => removeTeamAgent,
+  reorderProjectAgents: () => reorderProjectAgents,
+  resolveMemory: () => resolveMemory,
+  resolveSkills: () => resolveSkills,
+  resolveTaskConfig: () => resolveTaskConfig,
+  resolveVariables: () => resolveVariables,
+  setAgentSkills: () => setAgentSkills,
+  setProjectVariable: () => setProjectVariable,
+  slugify: () => slugify2,
+  summarizeTaskCosts: () => summarizeTaskCosts,
+  updateAgent: () => updateAgent,
+  updateProject: () => updateProject,
+  updateTask: () => updateTask,
+  updateTeam: () => updateTeam,
+  updateWorkflow: () => updateWorkflow,
+  updateWorkflowNodes: () => updateWorkflowNodes,
+  updateWorkspaceEntry: () => updateWorkspaceEntry,
+  upsertStagePrompt: () => upsertStagePrompt,
+  upsertUserSettings: () => upsertUserSettings,
+  validateIdentifierPrefix: () => validateIdentifierPrefix
+});
+var init_db2 = __esm({
   "apps/local/lib/db.ts"() {
     "use strict";
-    init_db_adapter();
-    init_dependency_helpers();
-    init_notifications();
-    import_crypto = require("crypto");
-    init_vault_store();
-    UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    DEFAULT_SDLC_WORKFLOW_ID = "00000000-0000-0000-0000-000000000001";
-    DEFAULT_SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
-    DEFAULT_WORKFLOW_NODE_SEED = [
-      {
-        id: "00000000-0000-0000-0001-000000000001",
-        name: "INTAKE",
-        label: "Intake",
-        prompt: "New task. Triage, scope, and prepare for work.",
-        position: 0,
-        node_type: "step"
-      },
-      {
-        id: "00000000-0000-0000-0001-000000000002",
-        name: "PROGRESS",
-        label: "Progress",
-        prompt: "Task is actively being worked on.",
-        position: 1,
-        node_type: "step"
-      },
-      {
-        id: "00000000-0000-0000-0001-000000000003",
-        name: "DONE",
-        label: "Done",
-        prompt: "Task completed.",
-        position: 2,
-        node_type: "terminal"
-      }
-    ];
-    DEFAULT_WORKFLOW_NODE_SEED_BY_ID = new Map(
-      DEFAULT_WORKFLOW_NODE_SEED.map((node) => [node.id, node])
-    );
-    defaultStagePrompts = {
-      INTAKE: {
-        prompt: "New task. Triage, scope, and prepare for work.",
-        outputs: [],
-        swarm: false
-      },
-      PROGRESS: {
-        prompt: "Task is actively being worked on.",
-        outputs: [],
-        swarm: false
-      },
-      DONE: {
-        prompt: "Task completed.",
-        outputs: [],
-        swarm: false
-      }
-    };
-    DEFAULT_WORKFLOW_ID = "00000000-0000-0000-0000-000000000001";
+    init_db();
   }
 });
 
@@ -8883,7 +9265,7 @@ var SQLiteAdapter;
 var init_sqlite_adapter2 = __esm({
   "apps/local/lib/adapters/sqlite-adapter.ts"() {
     "use strict";
-    init_db();
+    init_db2();
     init_sqlite_query_adapter();
     init_errors();
     SQLiteAdapter = class {
@@ -9407,7 +9789,7 @@ async function resolveWorkflowTransition({
 var DEFAULT_STAGE_SEQUENCE, STANDARD_STAGE_SEQUENCES;
 var init_stage_machine = __esm({
   "apps/local/lib/orchestration/stage-machine.ts"() {
-    init_db();
+    init_db2();
     DEFAULT_STAGE_SEQUENCE = [
       "INTAKE",
       "PROGRESS",
@@ -9647,11 +10029,15 @@ function providerNativeCommand({
   prompt,
   systemPrompt
 }) {
+  const homeDir = import_os10.default.homedir();
   switch (provider) {
     case "claude": {
       const args = [
         "-p",
         prompt,
+        "--dangerously-skip-permissions",
+        "--add-dir",
+        homeDir,
         "--verbose",
         "--output-format",
         "stream-json",
@@ -9664,9 +10050,17 @@ function providerNativeCommand({
     case "gemini":
       return {
         command: "gemini",
-        args: ["--yolo", "-p", systemPrompt ? `${systemPrompt}
-
-${prompt}` : prompt, "-o", "stream-json"],
+        args: [
+          "--yolo",
+          "--include-directories",
+          homeDir,
+          "-p",
+          systemPrompt ? `${systemPrompt}
+
+${prompt}` : prompt,
+          "-o",
+          "stream-json"
+        ],
         parser: "gemini-stream-json"
       };
     case "ollama":
@@ -9678,7 +10072,13 @@ ${prompt}` : prompt],
         parser: "raw"
       };
     case "codex": {
-      const codexArgs = ["exec", "--json"];
+      const codexArgs = [
+        "exec",
+        "--json",
+        "--dangerously-bypass-approvals-and-sandbox",
+        "--add-dir",
+        homeDir
+      ];
       if (model) codexArgs.push("--model", model);
       codexArgs.push(systemPrompt ? `${systemPrompt}
 
@@ -9694,6 +10094,9 @@ ${prompt}` : prompt);
       const zaiArgs = [
         "-p",
         prompt,
+        "--dangerously-skip-permissions",
+        "--add-dir",
+        homeDir,
         "--verbose",
         "--output-format",
         "stream-json",
@@ -9715,10 +10118,26 @@ ${prompt}` : prompt);
       return null;
   }
 }
+function providerAccessPassthrough(provider) {
+  const homeDir = import_os10.default.homedir();
+  switch (provider) {
+    case "claude":
+    case "zai":
+    case "codex":
+      return ["--add-dir", homeDir];
+    case "gemini":
+      return ["--include-directories", homeDir];
+    default:
+      return [];
+  }
+}
 function agxStreamingPassthrough(provider) {
   switch (provider) {
     case "claude":
-      return { args: ["--output-format", "stream-json", "--include-partial-messages"], parser: "claude-stream-json" };
+      return {
+        args: ["--verbose", "--output-format", "stream-json", "--include-partial-messages"],
+        parser: "claude-stream-json"
+      };
     case "gemini":
       return { args: ["-o", "stream-json"], parser: "gemini-stream-json" };
     case "codex":
@@ -9736,7 +10155,7 @@ function agxCommandForProvider({
   const args = [provider, "-y", "--print", "--prompt", prompt];
   if (model) args.push("--model", model);
   const streaming = agxStreamingPassthrough(provider);
-  const allPassthrough = [...passthroughArgs || [], ...streaming.args];
+  const allPassthrough = [...providerAccessPassthrough(provider), ...passthroughArgs || [], ...streaming.args];
   if (allPassthrough.length > 0) {
     args.push("--", ...allPassthrough);
   }
@@ -9825,7 +10244,7 @@ function bundledAgxCommandForProvider({
   const args = [resolvedCliPath, provider, "-y", "--print", "--prompt", prompt];
   if (model) args.push("--model", model);
   const streaming = agxStreamingPassthrough(provider);
-  const allPassthrough = [...passthroughArgs || [], ...streaming.args];
+  const allPassthrough = [...providerAccessPassthrough(provider), ...passthroughArgs || [], ...streaming.args];
   if (allPassthrough.length > 0) {
     args.push("--", ...allPassthrough);
   }
@@ -10052,12 +10471,12 @@ ${skills}
 </skills>`);
   return systemParts.length > 0 ? systemParts.join("\n\n") : void 0;
 }
-var import_child_process2, import_fs10, import_path10, isNonEmptyString, CliRunError, createRawParser, extractClaudeAssistantText, createClaudeStreamJsonParser, createGeminiStreamJsonParser, extractCodexAssistantText, createCodexJsonParser, createThoughtFilterParser, AGX_WRAPPED_PROVIDERS;
+var import_child_process2, import_fs10, import_os10, import_path10, isNonEmptyString, CliRunError, createRawParser, extractClaudeAssistantText, createClaudeStreamJsonParser, createGeminiStreamJsonParser, extractCodexAssistantText, createCodexJsonParser, createThoughtFilterParser, AGX_WRAPPED_PROVIDERS;
 var init_cli_runner = __esm({
   "apps/local/lib/cli-runner.ts"() {
-    "use strict";
     import_child_process2 = require("child_process");
     import_fs10 = __toESM(require("fs"));
+    import_os10 = __toESM(require("os"));
     import_path10 = __toESM(require("path"));
     init_sanitize();
     init_debug_log();
@@ -10065,6 +10484,8 @@ var init_cli_runner = __esm({
     init_scheduled_task_skill();
     isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
     CliRunError = class extends Error {
+      exitCode;
+      logs;
       constructor(message, exitCode, logs) {
         super(message);
         this.name = "CliRunError";
@@ -10092,7 +10513,7 @@ var init_cli_runner = __esm({
       return "";
     };
     createClaudeStreamJsonParser = (onDelta) => {
-      let buffer = "";
+      let buffer2 = "";
       let emittedCharacters = 0;
       let sawJson = false;
       const processLine = (line) => {
@@ -10113,22 +10534,22 @@ var init_cli_runner = __esm({
       };
       return {
         push: (chunk) => {
-          buffer += chunk;
+          buffer2 += chunk;
           while (true) {
-            const i = buffer.indexOf("\n");
+            const i = buffer2.indexOf("\n");
             if (i === -1) break;
-            processLine(buffer.slice(0, i));
-            buffer = buffer.slice(i + 1);
+            processLine(buffer2.slice(0, i));
+            buffer2 = buffer2.slice(i + 1);
           }
         },
         flush: () => {
-          if (buffer.trim()) processLine(buffer);
-          buffer = "";
+          if (buffer2.trim()) processLine(buffer2);
+          buffer2 = "";
         }
       };
     };
     createGeminiStreamJsonParser = (onDelta) => {
-      let buffer = "";
+      let buffer2 = "";
       let sawJson = false;
       let accumulatedAssistantText = "";
       const emitGeminiText = (text, isDelta) => {
@@ -10171,17 +10592,17 @@ var init_cli_runner = __esm({
       };
       return {
         push: (chunk) => {
-          buffer += chunk;
+          buffer2 += chunk;
           while (true) {
-            const i = buffer.indexOf("\n");
+            const i = buffer2.indexOf("\n");
             if (i === -1) break;
-            processLine(buffer.slice(0, i));
-            buffer = buffer.slice(i + 1);
+            processLine(buffer2.slice(0, i));
+            buffer2 = buffer2.slice(i + 1);
           }
         },
         flush: () => {
-          if (buffer.trim()) processLine(buffer);
-          buffer = "";
+          if (buffer2.trim()) processLine(buffer2);
+          buffer2 = "";
         }
       };
     };
@@ -10196,7 +10617,7 @@ var init_cli_runner = __esm({
       return "";
     };
     createCodexJsonParser = (onDelta) => {
-      let buffer = "";
+      let buffer2 = "";
       let sawJson = false;
       const completedItems = /* @__PURE__ */ new Set();
       const processLine = (line) => {
@@ -10218,22 +10639,22 @@ var init_cli_runner = __esm({
       };
       return {
         push: (chunk) => {
-          buffer += chunk;
+          buffer2 += chunk;
           while (true) {
-            const i = buffer.indexOf("\n");
+            const i = buffer2.indexOf("\n");
             if (i === -1) break;
-            processLine(buffer.slice(0, i));
-            buffer = buffer.slice(i + 1);
+            processLine(buffer2.slice(0, i));
+            buffer2 = buffer2.slice(i + 1);
           }
         },
         flush: () => {
-          if (buffer.trim()) processLine(buffer);
-          buffer = "";
+          if (buffer2.trim()) processLine(buffer2);
+          buffer2 = "";
         }
       };
     };
     createThoughtFilterParser = (inner, onThought) => {
-      let buffer = "";
+      let buffer2 = "";
       let inThought = false;
       let thoughtStarted = false;
       let thoughtContent = "";
@@ -10246,12 +10667,12 @@ var init_cli_runner = __esm({
         /<\/think>/i
       ];
       const processBuffer = () => {
-        while (buffer.length > 0) {
+        while (buffer2.length > 0) {
           if (inThought) {
             let endIdx = -1;
             let endLen = 0;
             for (const pat of THINK_END_PATTERNS) {
-              const match = buffer.match(pat);
+              const match = buffer2.match(pat);
               if (match && match.index !== void 0) {
                 const candidate = match.index + match[0].length;
                 if (endIdx === -1 || match.index < endIdx) {
@@ -10261,26 +10682,26 @@ var init_cli_runner = __esm({
               }
             }
             if (endIdx !== -1) {
-              thoughtContent += buffer.slice(0, endIdx);
+              thoughtContent += buffer2.slice(0, endIdx);
               if (onThought && thoughtContent.trim()) {
                 onThought(thoughtContent.trim());
               }
               thoughtContent = "";
-              buffer = buffer.slice(endIdx + endLen);
+              buffer2 = buffer2.slice(endIdx + endLen);
               inThought = false;
-              buffer = buffer.replace(/^\s*\n*/, "");
+              buffer2 = buffer2.replace(/^\s*\n*/, "");
               continue;
             }
-            thoughtContent += buffer;
-            buffer = "";
+            thoughtContent += buffer2;
+            buffer2 = "";
             return;
           }
           for (const pat of THINK_START_PATTERNS) {
-            const match = buffer.match(pat);
+            const match = buffer2.match(pat);
             if (match && match.index !== void 0) {
-              const before = buffer.slice(0, match.index);
+              const before = buffer2.slice(0, match.index);
               if (before) inner.push(before);
-              buffer = buffer.slice(match.index + match[0].length);
+              buffer2 = buffer2.slice(match.index + match[0].length);
               inThought = true;
               thoughtStarted = true;
               thoughtContent = "";
@@ -10288,24 +10709,24 @@ var init_cli_runner = __esm({
             }
           }
           if (inThought) continue;
-          const safeLen = Math.max(0, buffer.length - 30);
+          const safeLen = Math.max(0, buffer2.length - 30);
           if (safeLen > 0) {
-            inner.push(buffer.slice(0, safeLen));
-            buffer = buffer.slice(safeLen);
+            inner.push(buffer2.slice(0, safeLen));
+            buffer2 = buffer2.slice(safeLen);
           }
           return;
         }
       };
       return {
         push: (chunk) => {
-          buffer += chunk;
+          buffer2 += chunk;
           processBuffer();
         },
         flush: () => {
-          if (!inThought && buffer) {
-            inner.push(buffer);
+          if (!inThought && buffer2) {
+            inner.push(buffer2);
           }
-          buffer = "";
+          buffer2 = "";
           inner.flush();
         }
       };
@@ -10433,8 +10854,8 @@ async function storeMemories(taskId, agentId, memories) {
   const now = Date.now();
   for (const mem of memories) {
     if (!VALID_TYPES_SET.has(mem.memory_type) || !mem.content?.trim()) continue;
-    const contentHash2 = (0, import_crypto2.createHash)("sha256").update(mem.content.trim()).digest("hex");
-    const result = stmt.run((0, import_crypto2.randomUUID)(), agentId, taskId, mem.memory_type, mem.content.trim(), contentHash2, now);
+    const contentHash2 = (0, import_crypto4.createHash)("sha256").update(mem.content.trim()).digest("hex");
+    const result = stmt.run((0, import_crypto4.randomUUID)(), agentId, taskId, mem.memory_type, mem.content.trim(), contentHash2, now);
     if (result.changes > 0) inserted++;
   }
   if (inserted > 0) {
@@ -10527,10 +10948,10 @@ async function extractAndStoreProjectKnowledge(taskId, projectIdOrSlug, ctx) {
     console.log(`[project-knowledge] Stored ${inserted} project knowledge entries for task ${taskId}`);
   }
 }
-var import_crypto2, VALID_TYPES, EXTRACTION_PROMPT, PROJECT_KNOWLEDGE_PROMPT, VALID_TYPES_SET, MEMORY_AGENT_KEYS;
+var import_crypto4, VALID_TYPES, EXTRACTION_PROMPT, PROJECT_KNOWLEDGE_PROMPT, VALID_TYPES_SET, MEMORY_AGENT_KEYS;
 var init_memory_extractor = __esm({
   "apps/local/lib/memory-extractor.ts"() {
-    import_crypto2 = require("crypto");
+    import_crypto4 = require("crypto");
     init_cli_runner();
     init_sqlite_query_adapter();
     init_knowledge_store();
@@ -10768,7 +11189,7 @@ var init_dependency_manager = __esm({
     init_stage_machine();
     init_db_adapter();
     init_auth_mode();
-    init_db();
+    init_db2();
     init_db_instance();
     READY_STATUS = "completed";
   }
@@ -10960,7 +11381,7 @@ async function markCancelledActivity(input) {
 }
 var init_activities = __esm({
   "apps/local/lib/orchestrator/activities.ts"() {
-    init_db();
+    init_db2();
     init_memory_extractor();
     init_db_instance();
     init_db_adapter();
@@ -11198,8 +11619,13 @@ function getDb2() {
   const hasOldTable = db2.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name='linear_runs'"
   ).get();
-  if (hasOldTable) {
+  const hasNewTable = db2.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='tracker_runs'"
+  ).get();
+  if (hasOldTable && !hasNewTable) {
     db2.exec("ALTER TABLE linear_runs RENAME TO tracker_runs");
+  } else if (hasOldTable && hasNewTable) {
+    db2.exec("DROP TABLE linear_runs");
   }
   db2.exec(`
     CREATE TABLE IF NOT EXISTS tracker_runs (
@@ -11351,15 +11777,15 @@ function killByWorkspace(workspaceId) {
   }
   return killed;
 }
-var import_path11, import_os10, import_fs11, DatabaseSyncCtor4, HISTORY_DIR, DB_PATH2;
+var import_path11, import_os11, import_fs11, DatabaseSyncCtor4, HISTORY_DIR, DB_PATH2;
 var init_agent_process_registry = __esm({
   "apps/local/lib/agent-process-registry.ts"() {
     init_sqlite_compat();
     import_path11 = __toESM(require("path"));
-    import_os10 = __toESM(require("os"));
+    import_os11 = __toESM(require("os"));
     import_fs11 = require("fs");
     ({ DatabaseSync: DatabaseSyncCtor4 } = process.getBuiltinModule("node:sqlite"));
-    HISTORY_DIR = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path11.default.join(import_os10.default.homedir(), ".agx", "group-chat");
+    HISTORY_DIR = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path11.default.join(import_os11.default.homedir(), ".agx", "group-chat");
     DB_PATH2 = import_path11.default.join(HISTORY_DIR, "history.sqlite");
   }
 });
@@ -12604,16 +13030,15 @@ async function saveThreadRepoSelections(rootMessageId, repoIds) {
     }
   });
 }
-var import_fs12, import_path12, import_os11, DatabaseSyncCtor5, HISTORY_DIR2, DB_PATH3, LEGACY_THREAD_ID, REACTION_TYPES, ACTIVE_AGENT_PROCESS_STALE_MS, ACTIVE_CHAT_RUN_STALE_MS, ALLOWED_TRANSITIONS, ReactionStoreError, withDatabase;
+var import_fs12, import_path12, import_os12, DatabaseSyncCtor5, HISTORY_DIR2, DB_PATH3, LEGACY_THREAD_ID, REACTION_TYPES, ACTIVE_AGENT_PROCESS_STALE_MS, ACTIVE_CHAT_RUN_STALE_MS, ALLOWED_TRANSITIONS, ReactionStoreError, withDatabase;
 var init_history_store = __esm({
   "apps/local/lib/history-store.ts"() {
-    "use strict";
     init_sqlite_compat();
     import_fs12 = require("fs");
     import_path12 = __toESM(require("path"));
-    import_os11 = __toESM(require("os"));
+    import_os12 = __toESM(require("os"));
     ({ DatabaseSync: DatabaseSyncCtor5 } = process.getBuiltinModule("node:sqlite"));
-    HISTORY_DIR2 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path12.default.join(import_os11.default.homedir(), ".agx", "group-chat");
+    HISTORY_DIR2 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path12.default.join(import_os12.default.homedir(), ".agx", "group-chat");
     DB_PATH3 = import_path12.default.join(HISTORY_DIR2, "history.sqlite");
     LEGACY_THREAD_ID = "global";
     REACTION_TYPES = /* @__PURE__ */ new Set([
@@ -12633,6 +13058,7 @@ var init_history_store = __esm({
       blocked: /* @__PURE__ */ new Set(["ack", "blocked", "working"])
     };
     ReactionStoreError = class extends Error {
+      status;
       constructor(message, status) {
         super(message);
         this.name = "ReactionStoreError";
@@ -12861,15 +13287,15 @@ async function getAttachmentMeta(id) {
     db2.close();
   }
 }
-var import_path13, import_os12, DatabaseSyncCtor6, HISTORY_DIR3, DB_PATH4, UPLOADS_DIR;
+var import_path13, import_os13, DatabaseSyncCtor6, HISTORY_DIR3, DB_PATH4, UPLOADS_DIR;
 var init_attachment_store = __esm({
   "apps/local/lib/attachment-store.ts"() {
     "use strict";
     init_sqlite_compat();
     import_path13 = __toESM(require("path"));
-    import_os12 = __toESM(require("os"));
+    import_os13 = __toESM(require("os"));
     ({ DatabaseSync: DatabaseSyncCtor6 } = process.getBuiltinModule("node:sqlite"));
-    HISTORY_DIR3 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path13.default.join(import_os12.default.homedir(), ".agx", "group-chat");
+    HISTORY_DIR3 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path13.default.join(import_os13.default.homedir(), ".agx", "group-chat");
     DB_PATH4 = import_path13.default.join(HISTORY_DIR3, "history.sqlite");
     UPLOADS_DIR = import_path13.default.join(HISTORY_DIR3, "uploads");
   }
@@ -12903,16 +13329,16 @@ function appendReaction(agentId, targetEntry, type3) {
   (0, import_fs13.appendFileSync)(reactionsPath(agentId), JSON.stringify(reaction) + "\n", "utf-8");
   logActivity(agentId, "mesh-reaction", { meta: { target: targetEntry, type: type3 } });
 }
-var import_fs13, import_path14, import_os13, AGENTS_DIR6;
+var import_fs13, import_path14, import_os14, AGENTS_DIR6;
 var init_reactions = __esm({
   "apps/local/lib/mesh-core/reactions.ts"() {
     "use strict";
     import_fs13 = require("fs");
     import_path14 = require("path");
-    import_os13 = require("os");
+    import_os14 = require("os");
     init_journal();
     init_activity();
-    AGENTS_DIR6 = (0, import_path14.join)((0, import_os13.homedir)(), ".agx", "agents");
+    AGENTS_DIR6 = (0, import_path14.join)((0, import_os14.homedir)(), ".agx", "agents");
   }
 });
 
@@ -13287,7 +13713,6 @@ function resolveBoundSkillFiles(bindings, prompt, provider) {
 var import_node_fs4;
 var init_agent_skill_bindings = __esm({
   "apps/local/lib/agent-skill-bindings.ts"() {
-    "use strict";
     import_node_fs4 = __toESM(require("node:fs"));
     init_sqlite_query_adapter();
     init_skills_library();
@@ -13298,6 +13723,22 @@ var init_agent_skill_bindings = __esm({
 function isKnowledgeEvidence(value) {
   return value !== null;
 }
+function buildFilesystemAccessContext(p) {
+  const homeDir = import_os15.default.homedir();
+  switch (p.provider) {
+    case "claude":
+    case "codex":
+    case "gemini":
+    case "zai":
+      return `<filesystem-access>
+Current CLI access includes the project working directory and ${homeDir}.
+Treat ~/.agx as accessible from this chat because it lives under ${homeDir}.
+Do not claim that ~/.agx is unavailable unless a tool call in this run actually fails with an access error.
+</filesystem-access>`;
+    default:
+      return null;
+  }
+}
 function normalizeRuntimeSeedText(raw, name) {
   const collapsed = raw.replace(/\s+/g, " ").trim();
   if (!collapsed) return `I am ${name}. ${DEFAULT_RUNTIME_SEED}`;
@@ -13474,8 +13915,8 @@ async function runReflection(p) {
     const now = Date.now();
     for (const memory of memoryDrafts) {
       const memoryType = memory.kind === "decision" ? "decision" : memory.kind === "gotcha" || memory.kind === "constraint" ? "gotcha" : memory.kind === "outcome" ? "outcome" : "pattern";
-      const contentHash2 = (0, import_crypto3.createHash)("sha256").update(memory.body.trim()).digest("hex");
-      stmt.run((0, import_crypto3.randomUUID)(), p.id, reflectionTaskId, memoryType, memory.body.trim(), contentHash2, now);
+      const contentHash2 = (0, import_crypto5.createHash)("sha256").update(memory.body.trim()).digest("hex");
+      stmt.run((0, import_crypto5.randomUUID)(), p.id, reflectionTaskId, memoryType, memory.body.trim(), contentHash2, now);
     }
   }
   appendJournal(p.id, {
@@ -13859,6 +14300,7 @@ ${parts.join("\n\n")}`;
   );
   const systemContext = [
     baseSystemContext,
+    buildFilesystemAccessContext(p),
     executionProvenance ? `<execution-provenance>
 Resolved skills: ${executionProvenance.skills.map((skill) => `${skill.file} (${skill.source})`).join(", ") || "none"}
 Resolved memory entries: ${executionProvenance.memory.map((entry) => `${entry.source}${entry.id ? `:${entry.id}` : ""}`).join(", ") || "none"}
@@ -14312,10 +14754,11 @@ function createMultiplexedStream({
     }
   });
 }
-var import_promises, import_crypto3, agentMessageCounts, reflectionQueues, REFLECTION_CADENCE, DEFAULT_RUNTIME_SEED, SKIP_SIGNAL, DEFAULT_MAX_ROUNDS, SIMILARITY_THRESHOLD;
+var import_promises, import_os15, import_crypto5, agentMessageCounts, reflectionQueues, REFLECTION_CADENCE, DEFAULT_RUNTIME_SEED, SKIP_SIGNAL, DEFAULT_MAX_ROUNDS, SIMILARITY_THRESHOLD;
 var init_stream_multiplexer = __esm({
   "apps/local/lib/stream-multiplexer.ts"() {
     import_promises = require("fs/promises");
+    import_os15 = __toESM(require("os"));
     init_cli_runner();
     init_agent_process_registry();
     init_history_store();
@@ -14329,7 +14772,7 @@ var init_stream_multiplexer = __esm({
     init_activity();
     init_knowledge_store();
     init_agent_skill_bindings();
-    import_crypto3 = require("crypto");
+    import_crypto5 = require("crypto");
     agentMessageCounts = /* @__PURE__ */ new Map();
     reflectionQueues = /* @__PURE__ */ new Map();
     REFLECTION_CADENCE = 10;
@@ -14400,7 +14843,7 @@ function filterActiveParticipants(participants, activeParticipantIds) {
 }
 var init_agent_participants = __esm({
   "apps/local/lib/agent-participants.ts"() {
-    init_db();
+    init_db2();
     init_agent_skill_bindings();
     init_auth_mode();
   }
@@ -14890,7 +15333,7 @@ var init_project_context = __esm({
   "apps/local/lib/chat/project-context.ts"() {
     init_sqlite_query_adapter();
     init_db_instance();
-    init_db();
+    init_db2();
     init_repo_knowledge();
     init_knowledge_notes();
     init_auth_mode();
@@ -14930,7 +15373,7 @@ var init_runtime = __esm({
 
 // apps/local/src/automations/types.ts
 var DEFAULT_OVERLAP_POLICY, DEFAULT_CATCH_UP_POLICY, DEFAULT_CANCEL_CHECK_SEC, DEFAULT_CONDITION_CHECK_EVERY_MS, DEFAULT_GRAPH_INTERVAL_MS;
-var init_types = __esm({
+var init_types2 = __esm({
   "apps/local/src/automations/types.ts"() {
     "use strict";
     DEFAULT_OVERLAP_POLICY = "skip";
@@ -24120,7 +24563,6 @@ function parseNaturalSchedule(input) {
 var PATTERNS;
 var init_nl_schedule = __esm({
   "apps/local/src/graph/nl-schedule.ts"() {
-    "use strict";
     PATTERNS = [
       // "every N seconds" → intervalMs only (sub-minute)
       {
@@ -24534,7 +24976,7 @@ var init_validation = __esm({
     "use strict";
     import_cron_parser = __toESM(require_dist());
     init_nl_schedule();
-    init_types();
+    init_types2();
   }
 });
 
@@ -24635,7 +25077,7 @@ var init_serializer = __esm({
   "apps/local/src/automations/serializer.ts"() {
     "use strict";
     import_js_yaml3 = __toESM(require_js_yaml2());
-    init_types();
+    init_types2();
     init_validation();
   }
 });
@@ -24646,7 +25088,7 @@ function resolveAgxDataDir2() {
   if (configured) {
     return import_path15.default.resolve(configured);
   }
-  return import_path15.default.join((0, import_os14.homedir)(), ".agx");
+  return import_path15.default.join((0, import_os16.homedir)(), ".agx");
 }
 function stableCopy(value) {
   if (Array.isArray(value)) {
@@ -24678,7 +25120,7 @@ function getDefaultAutomationsDir() {
   }
   if (process.env.NODE_ENV === "test") {
     if (!cachedTestAutomationsDir) {
-      cachedTestAutomationsDir = (0, import_fs14.mkdtempSync)(import_path15.default.join((0, import_os14.tmpdir)(), "agx-cloud-automations-"));
+      cachedTestAutomationsDir = (0, import_fs14.mkdtempSync)(import_path15.default.join((0, import_os16.tmpdir)(), "agx-cloud-automations-"));
     }
     return cachedTestAutomationsDir;
   }
@@ -24702,7 +25144,7 @@ function computeScheduleHash(definition) {
       activeUntil: definition.execution?.activeUntil
     }
   });
-  return (0, import_crypto4.createHash)("sha256").update(JSON.stringify(payload)).digest("hex");
+  return (0, import_crypto6.createHash)("sha256").update(JSON.stringify(payload)).digest("hex");
 }
 function computeNextRunAt(definition, nowMs2 = Date.now()) {
   if (definition.state !== "active") {
@@ -24761,16 +25203,16 @@ function isAutomationDue(definition, runtimeState, nowMs2 = Date.now()) {
   }
   return runtimeState.nextRunAt <= nowMs2;
 }
-var import_crypto4, import_fs14, import_os14, import_path15, import_cron_parser2, cachedTestAutomationsDir;
+var import_crypto6, import_fs14, import_os16, import_path15, import_cron_parser2, cachedTestAutomationsDir;
 var init_state = __esm({
   "apps/local/src/automations/state.ts"() {
     "use strict";
-    import_crypto4 = require("crypto");
+    import_crypto6 = require("crypto");
     import_fs14 = require("fs");
-    import_os14 = require("os");
+    import_os16 = require("os");
     import_path15 = __toESM(require("path"));
     import_cron_parser2 = __toESM(require_dist());
-    init_types();
+    init_types2();
     cachedTestAutomationsDir = null;
   }
 });
@@ -24816,13 +25258,14 @@ function getAutomationRepository() {
   }
   return cachedRepository;
 }
-var import_fs15, import_path16, import_crypto5, AutomationRepository, cachedRepository, cachedRootDir;
+var import_fs15, import_path16, import_crypto7, AutomationRepository, cachedRepository, cachedRootDir;
 var init_repository = __esm({
   "apps/local/src/automations/repository.ts"() {
     "use strict";
     import_fs15 = __toESM(require("fs"));
     import_path16 = __toESM(require("path"));
-    import_crypto5 = require("crypto");
+    import_crypto7 = require("crypto");
+    init_logger2();
     init_parser();
     init_serializer();
     init_state();
@@ -24851,7 +25294,7 @@ var init_repository = __esm({
             continue;
           }
           if (recordsById.has(record.definition.id)) {
-            console.error(`[automations] duplicate automation id detected: ${record.definition.id}`);
+            logger.error(`[automations] duplicate automation id detected: ${record.definition.id}`);
             continue;
           }
           recordsById.set(record.definition.id, record);
@@ -24971,7 +25414,7 @@ var init_repository = __esm({
         if (!current) {
           return null;
         }
-        const duplicateId = `${current.definition.id}-copy-${(0, import_crypto5.randomUUID)().slice(0, 8)}`;
+        const duplicateId = `${current.definition.id}-copy-${(0, import_crypto7.randomUUID)().slice(0, 8)}`;
         return this.createAutomation({
           ...cloneDefinition(current.definition),
           id: duplicateId,
@@ -25011,7 +25454,7 @@ var init_repository = __esm({
         copiedEntries += this.copyDirContents(legacyArchivedDir, this.archivedDir);
         copiedEntries += this.copyDirContents(legacyStateDir, this.stateDir);
         if (copiedEntries > 0) {
-          console.log(
+          logger.info(
             `[automations] migrated ${copiedEntries} legacy file(s) from ${legacyRootDir} to ${this.rootDir}`
           );
         }
@@ -25068,7 +25511,7 @@ var init_repository = __esm({
             archived
           };
         } catch (error) {
-          console.error(`[automations] failed to read ${filePath}:`, error);
+          logger.error(`[automations] failed to read ${filePath}`, logger.formatError(error));
           return null;
         }
       }
@@ -25079,7 +25522,7 @@ var init_repository = __esm({
           try {
             existing = JSON.parse(import_fs15.default.readFileSync(statePath, "utf8"));
           } catch (error) {
-            console.error(`[automations] failed to parse state for ${definition.id}:`, error);
+            logger.error(`[automations] failed to parse state for ${definition.id}`, logger.formatError(error));
           }
         }
         const nextState = initializeAutomationRuntimeState(definition, existing);
@@ -25161,7 +25604,7 @@ var init_repository = __esm({
 });
 
 // apps/local/src/prompt-scheduler/types.ts
-var init_types2 = __esm({
+var init_types3 = __esm({
   "apps/local/src/prompt-scheduler/types.ts"() {
   }
 });
@@ -25258,9 +25701,9 @@ function graphAutomationToDefinition(row) {
 var init_adapters = __esm({
   "apps/local/src/automations/adapters.ts"() {
     "use strict";
-    init_types2();
+    init_types3();
     init_cron();
-    init_types();
+    init_types2();
     init_state();
     init_validation();
   }
@@ -25269,7 +25712,7 @@ var init_adapters = __esm({
 // apps/local/src/automations/index.ts
 var init_automations = __esm({
   "apps/local/src/automations/index.ts"() {
-    init_types();
+    init_types2();
     init_validation();
     init_parser();
     init_serializer();
@@ -26044,7 +26487,7 @@ async function getThreadProjectContext(threadId, taskId) {
 function resolveTeamAgentsFromTask(db2, projectId, taskId) {
   if (!taskId) return null;
   try {
-    const { parseFrontmatter: parseFrontmatter2 } = (init_db(), __toCommonJS(db_exports));
+    const { parseFrontmatter: parseFrontmatter2 } = (init_db2(), __toCommonJS(db_exports));
     const taskRow = db2.prepare("SELECT content FROM tasks WHERE id = ? LIMIT 1").get(taskId);
     if (!taskRow?.content) return null;
     const { frontmatter } = parseFrontmatter2(taskRow.content);
@@ -28460,12 +28903,12 @@ var init_baseAssignIn = __esm({
 });
 
 // node_modules/lodash-es/_cloneBuffer.js
-function cloneBuffer(buffer, isDeep) {
+function cloneBuffer(buffer2, isDeep) {
   if (isDeep) {
-    return buffer.slice();
+    return buffer2.slice();
   }
-  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
-  buffer.copy(result);
+  var length = buffer2.length, result = allocUnsafe ? allocUnsafe(length) : new buffer2.constructor(length);
+  buffer2.copy(result);
   return result;
 }
 var freeExports3, freeModule3, moduleExports3, Buffer3, allocUnsafe, cloneBuffer_default;
@@ -28745,8 +29188,8 @@ var init_cloneArrayBuffer = __esm({
 
 // node_modules/lodash-es/_cloneDataView.js
 function cloneDataView(dataView, isDeep) {
-  var buffer = isDeep ? cloneArrayBuffer_default(dataView.buffer) : dataView.buffer;
-  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+  var buffer2 = isDeep ? cloneArrayBuffer_default(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer2, dataView.byteOffset, dataView.byteLength);
 }
 var cloneDataView_default;
 var init_cloneDataView = __esm({
@@ -28786,8 +29229,8 @@ var init_cloneSymbol = __esm({
 
 // node_modules/lodash-es/_cloneTypedArray.js
 function cloneTypedArray(typedArray, isDeep) {
-  var buffer = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
-  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+  var buffer2 = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer2, typedArray.byteOffset, typedArray.length);
 }
 var cloneTypedArray_default;
 var init_cloneTypedArray = __esm({
@@ -39619,7 +40062,7 @@ function createSystem(rootActor, options) {
   const timerMap = {};
   const {
     clock,
-    logger
+    logger: logger2
   } = options;
   const scheduler = {
     schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
@@ -39741,7 +40184,7 @@ function createSystem(rootActor, options) {
       }
     },
     _clock: clock,
-    _logger: logger
+    _logger: logger2
   };
   return system;
 }
@@ -41127,7 +41570,7 @@ var init_raise_b47daa89_esm = __esm({
         };
         const {
           clock,
-          logger,
+          logger: logger2,
           parent,
           syncSnapshot,
           id,
@@ -41136,7 +41579,7 @@ var init_raise_b47daa89_esm = __esm({
         } = resolvedOptions;
         this.system = parent ? parent.system : createSystem(this, {
           clock,
-          logger
+          logger: logger2
         });
         if (inspect && !parent) {
           this.system.inspect(toObserver(inspect));
@@ -42427,37 +42870,37 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, {
   collect
 }) {
   const actions = [];
-  const enqueue = function enqueue2(action) {
+  const enqueue2 = function enqueue3(action) {
     actions.push(action);
   };
-  enqueue.assign = (...args2) => {
+  enqueue2.assign = (...args2) => {
     actions.push(assign2(...args2));
   };
-  enqueue.cancel = (...args2) => {
+  enqueue2.cancel = (...args2) => {
     actions.push(cancel(...args2));
   };
-  enqueue.raise = (...args2) => {
+  enqueue2.raise = (...args2) => {
     actions.push(raise(...args2));
   };
-  enqueue.sendTo = (...args2) => {
+  enqueue2.sendTo = (...args2) => {
     actions.push(sendTo(...args2));
   };
-  enqueue.sendParent = (...args2) => {
+  enqueue2.sendParent = (...args2) => {
     actions.push(sendParent(...args2));
   };
-  enqueue.spawnChild = (...args2) => {
+  enqueue2.spawnChild = (...args2) => {
     actions.push(spawnChild(...args2));
   };
-  enqueue.stopChild = (...args2) => {
+  enqueue2.stopChild = (...args2) => {
     actions.push(stopChild(...args2));
   };
-  enqueue.emit = (...args2) => {
+  enqueue2.emit = (...args2) => {
     actions.push(emit(...args2));
   };
   collect({
     context: args.context,
     event: args.event,
-    enqueue,
+    enqueue: enqueue2,
     check: (guard) => evaluateGuard(guard, snapshot.context, args.event, snapshot),
     self: actorScope.self,
     system: actorScope.system
@@ -42482,15 +42925,15 @@ function resolveLog(_, snapshot, actionArgs, actionParams, {
   }, void 0];
 }
 function executeLog({
-  logger
+  logger: logger2
 }, {
   value,
   label
 }) {
   if (label) {
-    logger(label, value);
+    logger2(label, value);
   } else {
-    logger(value);
+    logger2(value);
   }
 }
 function log(value = ({
@@ -46255,7 +46698,7 @@ async function pollSchedules(context = {}) {
     pendingWork: []
   };
   const activeSchedules = getGraphsWithActiveSchedules();
-  console.log(`[schedules:poll] found ${activeSchedules.length} active schedule(s)`);
+  logger.info(`[schedules:poll] found ${activeSchedules.length} active schedule(s)`);
   for (const { taskId } of activeSchedules) {
     try {
       const graph = store.getGraph(taskId);
@@ -46265,29 +46708,29 @@ async function pollSchedules(context = {}) {
       }
       const tickResult = scheduleTickIfDue(graph);
       if (!tickResult.tickFired) {
-        console.log(`[schedules:poll] ${taskId} skipped (${tickResult.skipReason ?? "unknown"})`);
+        logger.info(`[schedules:poll] ${taskId} skipped (${tickResult.skipReason ?? "unknown"})`);
         result.skippedGraphIds.push(taskId);
         continue;
       }
-      console.log(`[schedules:poll] ${taskId} tick fired \u2014 resetting nodes`);
+      logger.info(`[schedules:poll] ${taskId} tick fired \u2014 resetting nodes`);
       store.updateGraphStructure(tickResult.graph.id, {
         nodes: tickResult.graph.nodes,
         schedule: tickResult.graph.schedule
       });
       const schedulerResult = schedulerTick(tickResult.graph, context);
-      console.log(`[schedules:poll] ${taskId} scheduler: fn=${schedulerResult.functionToRun.length} work=${schedulerResult.workToRun.length}`);
+      logger.info(`[schedules:poll] ${taskId} scheduler: fn=${schedulerResult.functionToRun.length} work=${schedulerResult.workToRun.length}`);
       let currentGraph = schedulerResult.graph;
       for (const nodeId of schedulerResult.functionToRun) {
         const node = currentGraph.nodes[nodeId];
         if (!node || node.type !== "function") continue;
         try {
-          console.log(`[schedules:poll] ${taskId} executing function node "${nodeId}"`);
+          logger.info(`[schedules:poll] ${taskId} executing function node "${nodeId}"`);
           const execResult = await executeNode(currentGraph, nodeId, context);
           const resultNode = execResult.graph.nodes[nodeId];
-          console.log(`[schedules:poll] ${taskId} function "${nodeId}" \u2192 ${resultNode?.status}`, resultNode && "output" in resultNode ? JSON.stringify(resultNode.output)?.slice(0, 200) : "");
+          logger.info(`[schedules:poll] ${taskId} function "${nodeId}" \u2192 ${resultNode?.status}`, resultNode && "output" in resultNode ? { output: JSON.stringify(resultNode.output)?.slice(0, 200) } : void 0);
           currentGraph = execResult.graph;
         } catch (err) {
-          console.error(`[schedules:poll] ${taskId} function "${nodeId}" error:`, err);
+          logger.error(`[schedules:poll] ${taskId} function "${nodeId}" error`, logger.formatError(err));
           result.errors.push({
             graphId: taskId,
             error: err instanceof Error ? err : new Error(String(err))
@@ -46298,7 +46741,7 @@ async function pollSchedules(context = {}) {
         nodes: currentGraph.nodes
       });
       const postFunctionResult = schedulerTick(currentGraph, context);
-      console.log(`[schedules:poll] ${taskId} post-fn scheduler: cond=${postFunctionResult.control.conditionalNodeIds.length} work=${postFunctionResult.workToRun.length}`);
+      logger.info(`[schedules:poll] ${taskId} post-fn scheduler: cond=${postFunctionResult.control.conditionalNodeIds.length} work=${postFunctionResult.workToRun.length}`);
       currentGraph = postFunctionResult.graph;
       for (const nodeId of postFunctionResult.workToRun) {
         const node = currentGraph.nodes[nodeId];
@@ -46323,17 +46766,17 @@ async function pollSchedules(context = {}) {
           nodes: currentGraph.nodes
         });
         const postWorkResult = schedulerTick(currentGraph, context);
-        console.log(`[schedules:poll] ${taskId} post-work scheduler: fn=${postWorkResult.functionToRun.length} cond=${postWorkResult.control.conditionalNodeIds.length}`);
+        logger.info(`[schedules:poll] ${taskId} post-work scheduler: fn=${postWorkResult.functionToRun.length} cond=${postWorkResult.control.conditionalNodeIds.length}`);
         currentGraph = postWorkResult.graph;
         for (const nodeId of postWorkResult.functionToRun) {
           const node = currentGraph.nodes[nodeId];
           if (!node || node.type !== "function") continue;
           try {
-            console.log(`[schedules:poll] ${taskId} executing post-work function "${nodeId}"`);
+            logger.info(`[schedules:poll] ${taskId} executing post-work function "${nodeId}"`);
             const execResult = await executeNode(currentGraph, nodeId, context);
             currentGraph = execResult.graph;
           } catch (err) {
-            console.error(`[schedules:poll] ${taskId} post-work function "${nodeId}" error:`, err);
+            logger.error(`[schedules:poll] ${taskId} post-work function "${nodeId}" error`, logger.formatError(err));
             result.errors.push({
               graphId: taskId,
               error: err instanceof Error ? err : new Error(String(err))
@@ -46345,9 +46788,9 @@ async function pollSchedules(context = {}) {
         nodes: currentGraph.nodes
       });
       const nodeStates = Object.entries(currentGraph.nodes).map(([id, n]) => `${id}:${n.status}`).join(", ");
-      console.log(`[schedules:poll] ${taskId} node states: ${nodeStates}`);
+      logger.info(`[schedules:poll] ${taskId} node states: ${nodeStates}`);
       const tickComplete = isScheduleTickComplete(currentGraph);
-      console.log(`[schedules:poll] ${taskId} tick complete? ${tickComplete}`);
+      logger.info(`[schedules:poll] ${taskId} tick complete? ${tickComplete}`);
       if (tickComplete) {
         const completed = completeScheduleTick(currentGraph);
         const hasFailedNode = completed.schedule?.resetNodeIds.some(
@@ -46370,7 +46813,7 @@ async function pollSchedules(context = {}) {
         }
         const dbGraph = store.getGraph(taskId);
         if (dbGraph?.schedule?.state === "stopped") {
-          console.log(`[schedules:poll] ${taskId} schedule was stopped mid-tick, preserving stopped state`);
+          logger.info(`[schedules:poll] ${taskId} schedule was stopped mid-tick, preserving stopped state`);
           completed.schedule = {
             ...completed.schedule,
             state: "stopped"
@@ -46384,14 +46827,14 @@ async function pollSchedules(context = {}) {
       }
       result.tickedGraphIds.push(taskId);
     } catch (err) {
-      console.error(`[schedules:poll] ${taskId} caught error:`, err);
+      logger.error(`[schedules:poll] ${taskId} caught error`, logger.formatError(err));
       result.errors.push({
         graphId: taskId,
         error: err instanceof Error ? err : new Error(String(err))
       });
       try {
         store.releaseScheduleTick(taskId);
-        console.log(`[schedules:poll] ${taskId} released concurrency slot after error`);
+        logger.info(`[schedules:poll] ${taskId} released concurrency slot after error`);
       } catch {
       }
     }
@@ -46400,6 +46843,7 @@ async function pollSchedules(context = {}) {
 }
 var init_schedule_runner = __esm({
   "apps/local/src/graph/schedule-runner.ts"() {
+    init_logger2();
     init_sqlite_query_adapter();
     init_automations();
     init_schedule();
@@ -46434,7 +46878,7 @@ function resolveProvider(raw) {
 function resolveTeamAgent(sqlite, projectId, taskId) {
   if (!taskId) return null;
   try {
-    const { parseFrontmatter: parseFrontmatter2 } = (init_db(), __toCommonJS(db_exports));
+    const { parseFrontmatter: parseFrontmatter2 } = (init_db2(), __toCommonJS(db_exports));
     const taskRow = sqlite.prepare("SELECT content FROM tasks WHERE id = ? LIMIT 1").get(taskId);
     if (!taskRow?.content) return null;
     const { frontmatter } = parseFrontmatter2(taskRow.content);
@@ -46504,7 +46948,7 @@ function createDispatchWork() {
         message: "No rootMessageId on graph schedule"
       };
     }
-    console.log(
+    logger.info(
       `[work-dispatch] Dispatching steer node "${node.title}" for graph ${graph.id} (root: ${rootMessageId})`
     );
     try {
@@ -46536,7 +46980,7 @@ function createDispatchWork() {
         const text = (m.content ?? "").slice(0, 600);
         return `[${sender}]: ${text}`;
       }).join("\n");
-      console.log(`[work-dispatch] Thread: active=${activeProcessCount}, msgs=${snapshot.messages?.length ?? 0}`);
+      logger.info(`[work-dispatch] Thread: active=${activeProcessCount}, msgs=${snapshot.messages?.length ?? 0}`);
       const assessPrompt = [
         "--- THREAD STATE ---",
         `Root request: ${snapshot.rootMessage?.content ?? "(missing root message)"}`,
@@ -46556,7 +47000,7 @@ function createDispatchWork() {
       ].filter(Boolean).join("\n");
       const { runCliResponse: runCliResponse2 } = await Promise.resolve().then(() => (init_cli_runner(), cli_runner_exports));
       const steeringAgent = await getSteeringAgentConfig(threadRef.threadId, graph.taskId);
-      console.log(
+      logger.info(
         `[work-dispatch] Calling ${steeringAgent.provider} via runCliResponse (prompt length: ${assessPrompt.length})...`
       );
       let fullResponse = "";
@@ -46569,10 +47013,10 @@ function createDispatchWork() {
           fullResponse += chunk;
         },
         onLog: (stream, line) => {
-          console.log(`[work-dispatch] [${stream}] ${line}`);
+          logger.info(`[work-dispatch] [${stream}] ${line}`);
         }
       });
-      console.log(`[work-dispatch] Raw response: ${fullResponse.slice(0, 500)}`);
+      logger.info(`[work-dispatch] Raw response: ${fullResponse.slice(0, 500)}`);
       const parsed = parseSteerResponse(fullResponse.trim());
       if (!parsed.ok) {
         return {
@@ -46581,7 +47025,7 @@ function createDispatchWork() {
           message: parsed.error
         };
       }
-      console.log(`[work-dispatch] Parsed result:`, parsed);
+      logger.info(`[work-dispatch] Parsed result: ${JSON.stringify(parsed)}`);
       return {
         status: "success",
         output: parsed.value
@@ -46627,6 +47071,7 @@ function parseSteerResponse(raw) {
 var import_node_fs5, import_node_path4, import_node_os4, ACTIVE_PROCESS_STATUSES2, DEFAULT_STEER_DIRECTIVE, STEER_OUTPUT_CONTRACT;
 var init_work_dispatcher = __esm({
   "apps/local/src/graph/work-dispatcher.ts"() {
+    init_logger2();
     import_node_fs5 = require("node:fs");
     import_node_path4 = require("node:path");
     import_node_os4 = require("node:os");