@signetai/core 0.154.6 → 0.154.7

package/dist/index.js

@@ -12523,6 +12523,133 @@ function resolveSignetDaemonUrl(opts = {}) {
   const port = normalizePort(readEnv(env, "SIGNET_PORT"), fallbackPort);
   return normalizeDaemonUrl(`http://${bracketIpv6Host(host)}:${port}`, "SIGNET_HOST/SIGNET_PORT");
 }
+// src/workspace.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname2, join as join5, resolve } from "node:path";
+var WORKSPACE_ENV_KEYS = ["SIGNET_PATH", "SIGNET_WORKSPACE"];
+var DEFAULT_AGENTS_DIRNAME = ".agents";
+function normalizeWorkspacePath(pathValue, home = homedir3()) {
+  return resolve(expandHome(pathValue.trim(), home));
+}
+function readTrimmedEnv(env, name) {
+  const value = env[name];
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function readConfigHome(env, home) {
+  const raw = env.XDG_CONFIG_HOME;
+  if (typeof raw !== "string")
+    return join5(home, ".config");
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? normalizeWorkspacePath(trimmed, home) : join5(home, ".config");
+}
+function isExistingDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getWorkspaceConfigPath(env = process.env, home = homedir3()) {
+  return join5(readConfigHome(env, home), "signet", "workspace.json");
+}
+function readConfiguredWorkspacePath(env = process.env, home = homedir3(), options = {}) {
+  const strict = options.strict ?? false;
+  const configPath = getWorkspaceConfigPath(env, home);
+  if (!existsSync4(configPath))
+    return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync3(configPath, "utf-8"));
+  } catch (err) {
+    if (strict) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(`Invalid Signet workspace config at ${configPath}: ${detail}`);
+    }
+    return null;
+  }
+  if (!isRecord4(raw) || !("workspace" in raw)) {
+    if (strict)
+      throw new Error(`Invalid Signet workspace config at ${configPath}: missing workspace`);
+    return null;
+  }
+  const workspace = raw.workspace;
+  if (typeof workspace !== "string" || workspace.trim().length === 0) {
+    if (strict)
+      throw new Error(`Invalid Signet workspace config at ${configPath}: workspace must be a non-empty string`);
+    return null;
+  }
+  return normalizeWorkspacePath(workspace, home);
+}
+function writeConfiguredWorkspacePath(pathValue, env = process.env, home = homedir3()) {
+  const path = normalizeWorkspacePath(pathValue, home);
+  const configPath = getWorkspaceConfigPath(env, home);
+  const configDir = dirname2(configPath);
+  mkdirSync2(configDir, { recursive: true });
+  const payload = {
+    version: 1,
+    workspace: path,
+    updatedAt: new Date().toISOString()
+  };
+  writeFileSync2(configPath, `${JSON.stringify(payload, null, 2)}
+`);
+  return configPath;
+}
+function clearConfiguredWorkspacePath(env = process.env) {
+  const configPath = getWorkspaceConfigPath(env);
+  if (!existsSync4(configPath))
+    return;
+  rmSync(configPath, { force: true });
+}
+function resolveWorkspacePath(options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir3();
+  const strict = options.strict ?? false;
+  const requireExistingEnvPath = options.requireExistingEnvPath ?? false;
+  const configPath = getWorkspaceConfigPath(env, home);
+  const envPath = resolveEnvWorkspace(env, home, requireExistingEnvPath);
+  const configValue = readConfiguredWorkspacePath(env, home, { strict: envPath ? false : strict });
+  if (envPath) {
+    return {
+      path: envPath,
+      source: "env",
+      configPath,
+      configuredPath: configValue
+    };
+  }
+  if (configValue) {
+    return {
+      path: configValue,
+      source: "config",
+      configPath,
+      configuredPath: configValue
+    };
+  }
+  return {
+    path: join5(home, DEFAULT_AGENTS_DIRNAME),
+    source: "default",
+    configPath,
+    configuredPath: configValue
+  };
+}
+function resolveEnvWorkspace(env, home, requireExisting) {
+  for (const key of WORKSPACE_ENV_KEYS) {
+    const raw = readTrimmedEnv(env, key);
+    if (!raw)
+      continue;
+    const normalized = normalizeWorkspacePath(raw, home);
+    if (!requireExisting || isExistingDirectory(normalized))
+      return normalized;
+    console.warn(`[signet] ${key}="${raw}" does not point to an existing workspace directory; using the default workspace resolution instead.`);
+  }
+  return null;
+}
 // src/search.ts
 import { createRequire as createRequire2 } from "node:module";
 var native = null;
@@ -13176,14 +13303,14 @@ var SIGNET_PLUGIN_REGISTRY_DIR = ".daemon/plugins";
 var SIGNET_PLUGIN_REGISTRY_FILE = "registry-v1.json";
 var SIGNET_PLUGIN_REGISTRY_VERSION = 1;
 // src/graphiq.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join5, resolve } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, join as join6, resolve as resolve2 } from "node:path";
 var SIGNET_GRAPHIQ_STATE_FILE = ".daemon/graphiq/state.json";
 function getGraphiqStatePath(basePath) {
-  return join5(basePath, SIGNET_GRAPHIQ_STATE_FILE);
+  return join6(basePath, SIGNET_GRAPHIQ_STATE_FILE);
 }
 function getGraphiqProjectDbPath(projectPath) {
-  return join5(resolve(projectPath), ".graphiq", "graphiq.db");
+  return join6(resolve2(projectPath), ".graphiq", "graphiq.db");
 }
 function emptyGraphiqState(now = new Date) {
   return {
@@ -13196,10 +13323,10 @@ function emptyGraphiqState(now = new Date) {
 }
 function readGraphiqState(basePath) {
   const path = getGraphiqStatePath(basePath);
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return emptyGraphiqState();
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
     return parseGraphiqState(parsed);
   } catch {
     return emptyGraphiqState();
@@ -13207,8 +13334,8 @@ function readGraphiqState(basePath) {
 }
 function writeGraphiqState(basePath, state) {
   const path = getGraphiqStatePath(basePath);
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync2(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
 }
 function setGraphiqActiveProject(basePath, activeProject) {
@@ -13219,7 +13346,7 @@ function setGraphiqActiveProject(basePath, activeProject) {
   let locked = false;
   for (let attempt = 0;attempt < maxAttempts; attempt++) {
     try {
-      mkdirSync2(lockDir, { recursive: false });
+      mkdirSync3(lockDir, { recursive: false });
       locked = true;
       break;
     } catch (err) {
@@ -13240,20 +13367,20 @@ function setGraphiqActiveProject(basePath, activeProject) {
     const fresh = readGraphiqState(basePath);
     const tmpPath = `${statePath}.tmp`;
     const next = { ...fresh, activeProject };
-    mkdirSync2(dirname2(statePath), { recursive: true });
-    writeFileSync2(tmpPath, `${JSON.stringify(next, null, 2)}
+    mkdirSync3(dirname3(statePath), { recursive: true });
+    writeFileSync3(tmpPath, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 });
     renameSync(tmpPath, statePath);
   } finally {
     try {
-      rmSync(lockDir, { recursive: false, force: true });
+      rmSync2(lockDir, { recursive: false, force: true });
     } catch {}
   }
 }
 function updateGraphiqActiveProject(basePath, input) {
   const current = readGraphiqState(basePath);
   const indexedAt = input.indexedAt ?? new Date;
-  const projectPath = resolve(input.projectPath);
+  const projectPath = resolve2(input.projectPath);
   const project = {
     path: projectPath,
     dbPath: getGraphiqProjectDbPath(projectPath),
@@ -13303,7 +13430,7 @@ function disableGraphiqState(basePath, now = new Date) {
   return next;
 }
 function parseGraphiqState(value) {
-  if (!isRecord4(value))
+  if (!isRecord5(value))
     return emptyGraphiqState();
   const indexedProjects = Array.isArray(value.indexedProjects) ? value.indexedProjects.map(parseIndexedProject).filter((entry) => entry !== null) : [];
   const activeProject = typeof value.activeProject === "string" ? value.activeProject : undefined;
@@ -13319,7 +13446,7 @@ function parseGraphiqState(value) {
   };
 }
 function parseIndexedProject(value) {
-  if (!isRecord4(value))
+  if (!isRecord5(value))
     return null;
   if (typeof value.path !== "string" || typeof value.dbPath !== "string" || typeof value.lastIndexedAt !== "string") {
     return null;
@@ -13336,13 +13463,13 @@ function parseIndexedProject(value) {
 function parseInstallSource(value) {
   return value === "script" || value === "homebrew" || value === "source" || value === "existing" ? value : undefined;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // src/workspace-source-repo.ts
 import { spawn, spawnSync } from "node:child_process";
-import { closeSync, existsSync as existsSync5, mkdirSync as mkdirSync3, openSync, readdirSync as readdirSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join6, resolve as resolve2 } from "node:path";
+import { closeSync, existsSync as existsSync6, mkdirSync as mkdirSync4, openSync, readdirSync as readdirSync2, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join7, resolve as resolve3 } from "node:path";
 var SIGNET_SOURCE_CHECKOUT_DIRNAME = "signetai";
 var SIGNET_SOURCE_REMOTE_URL = "https://github.com/Signet-AI/signetai.git";
 var DEFAULT_GIT_TIMEOUT_MS = 60000;
@@ -13350,7 +13477,7 @@ var SOURCE_REPO_SYNC_LOCK_FILENAME = "source-repo-sync.lock";
 var SOURCE_REPO_SYNC_LOCK_STALE_MS = 5 * 60000;
 var SOURCE_REPO_SYNC_LOCK_WAIT_MS = 15000;
 function resolveWorkspaceSourceRepoPath(workspaceDir, repoDirName = SIGNET_SOURCE_CHECKOUT_DIRNAME) {
-  return join6(resolve2(workspaceDir), repoDirName);
+  return join7(resolve3(workspaceDir), repoDirName);
 }
 function syncWorkspaceSourceRepo(workspaceDir, options = {}) {
   const timeoutMs = options.gitTimeoutMs ?? DEFAULT_GIT_TIMEOUT_MS;
@@ -13399,7 +13526,7 @@ async function syncWorkspaceSourceRepoAsync(workspaceDir, options = {}) {
   }
 }
 function syncWorkspaceSourceRepoLocked(run, workspaceDir, repoPath, remoteUrl, timeoutMs) {
-  if (!existsSync5(repoPath) || isEmptyDirectory(repoPath)) {
+  if (!existsSync6(repoPath) || isEmptyDirectory(repoPath)) {
     const workspaceReady = ensureWorkspaceDir(workspaceDir);
     if (workspaceReady.ok === false) {
       return errorResult(repoPath, workspaceReady.message);
@@ -13494,7 +13621,7 @@ function runGit(args, cwd, timeoutMs) {
   };
 }
 async function runGitAsync(args, cwd, timeoutMs) {
-  return await new Promise((resolve3) => {
+  return await new Promise((resolve4) => {
     const proc = spawn("git", args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -13515,7 +13642,7 @@ async function runGitAsync(args, cwd, timeoutMs) {
         clearTimeout(killTimer);
       if (fallbackTimer)
         clearTimeout(fallbackTimer);
-      resolve3(result);
+      resolve4(result);
     };
     const timer = setTimeout(() => {
       stderr += `
@@ -13563,10 +13690,10 @@ function killGitProcessTree(proc, signal) {
   } catch {}
 }
 function hasGitMetadata(path) {
-  return existsSync5(join6(path, ".git"));
+  return existsSync6(join7(path, ".git"));
 }
 function isEmptyDirectory(path) {
-  if (!existsSync5(path)) {
+  if (!existsSync6(path)) {
     return true;
   }
   try {
@@ -13645,13 +13772,13 @@ function readErrorCode(err) {
   return typeof maybeErrno.code === "string" ? maybeErrno.code : null;
 }
 function sourceRepoSyncLockPath(workspaceDir) {
-  return join6(resolve2(workspaceDir), ".daemon", SOURCE_REPO_SYNC_LOCK_FILENAME);
+  return join7(resolve3(workspaceDir), ".daemon", SOURCE_REPO_SYNC_LOCK_FILENAME);
 }
 function clearStaleSourceRepoSyncLock(path) {
   try {
-    const age = Date.now() - statSync(path).mtimeMs;
+    const age = Date.now() - statSync2(path).mtimeMs;
     if (age > SOURCE_REPO_SYNC_LOCK_STALE_MS) {
-      rmSync2(path, { force: true });
+      rmSync3(path, { force: true });
       return true;
     }
   } catch {
@@ -13687,7 +13814,7 @@ async function acquireSourceRepoSyncLockAsync(workspaceDir) {
   while (Date.now() < end) {
     try {
       const fd = openSync(path, "wx");
-      writeFileSync3(fd, `${process.pid}
+      writeFileSync4(fd, `${process.pid}
 ${Date.now()}
 `);
       return { status: "acquired", lock: { fd, path } };
@@ -13708,10 +13835,10 @@ function releaseSourceRepoSyncLock(lock) {
   try {
     closeSync(lock.fd);
   } catch {}
-  rmSync2(lock.path, { force: true });
+  rmSync3(lock.path, { force: true });
 }
 async function sleep(ms) {
-  await new Promise((resolve3) => setTimeout(resolve3, ms));
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function unsafeRemoteResult(repoPath) {
   return {
@@ -13750,9 +13877,9 @@ function sourceRepoSyncLockErrorResult(repoPath, detail) {
   };
 }
 function ensureDaemonDir(workspaceDir) {
-  const daemonDir = join6(resolve2(workspaceDir), ".daemon");
+  const daemonDir = join7(resolve3(workspaceDir), ".daemon");
   try {
-    mkdirSync3(daemonDir, { recursive: true });
+    mkdirSync4(daemonDir, { recursive: true });
     return { ok: true };
   } catch (err) {
     return {
@@ -13763,7 +13890,7 @@ function ensureDaemonDir(workspaceDir) {
 }
 function ensureWorkspaceDir(workspaceDir) {
   try {
-    mkdirSync3(workspaceDir, { recursive: true });
+    mkdirSync4(workspaceDir, { recursive: true });
     return { ok: true };
   } catch (err) {
     return {
@@ -13933,7 +14060,7 @@ function readTrimmedValue(result) {
 function tryAcquireSourceRepoSyncLock(path) {
   try {
     const fd = openSync(path, "wx");
-    writeFileSync3(fd, `${process.pid}
+    writeFileSync4(fd, `${process.pid}
 ${Date.now()}
 `);
     return { status: "acquired", lock: { fd, path } };
@@ -14077,9 +14204,9 @@ function escapeRegExp(value) {
 }
 // src/sources-config.ts
 import { createHash, randomUUID } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir3, platform as platform2 } from "node:os";
-import { basename, dirname as dirname3, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir4, platform as platform2 } from "node:os";
+import { basename, dirname as dirname4, resolve as resolve4 } from "node:path";
 var DEFAULT_OBSIDIAN_EXCLUDE_GLOBS = [
   "**/.obsidian/**",
   "**/.trash/**",
@@ -14100,18 +14227,18 @@ var DEFAULT_GITHUB_MAX_ITEMS_PER_REPO = 500;
 var MAX_GITHUB_MAX_ITEMS_PER_REPO = 1e4;
 var VALID_GITHUB_RESOURCE_TYPES = new Set(DEFAULT_GITHUB_RESOURCE_TYPES);
 function getAgentsDir() {
-  return process.env.SIGNET_PATH || `${homedir3()}/.agents`;
+  return process.env.SIGNET_PATH || `${homedir4()}/.agents`;
 }
 function getSourcesConfigPath(agentsDir = getAgentsDir()) {
   return `${agentsDir.replace(/\/$/, "")}/sources.json`;
 }
 function loadSourcesConfig(agentsDir = getAgentsDir()) {
   const path = getSourcesConfigPath(agentsDir);
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return emptyConfig();
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf8"));
-    if (!isRecord5(parsed) || parsed.version !== SOURCES_CONFIG_VERSION || !Array.isArray(parsed.sources)) {
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    if (!isRecord6(parsed) || parsed.version !== SOURCES_CONFIG_VERSION || !Array.isArray(parsed.sources)) {
       return emptyConfig();
     }
     return {
@@ -14124,24 +14251,24 @@ function loadSourcesConfig(agentsDir = getAgentsDir()) {
 }
 function saveSourcesConfig(config, agentsDir = getAgentsDir()) {
   const path = getSourcesConfigPath(agentsDir);
-  mkdirSync4(dirname3(path), { recursive: true });
+  mkdirSync5(dirname4(path), { recursive: true });
   const tmp = `${path}.tmp-${process.pid}-${randomUUID()}`;
-  writeFileSync4(tmp, `${JSON.stringify(config, null, 2)}
+  writeFileSync5(tmp, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   renameSync2(tmp, path);
 }
 function loadSourcesConfigForWrite(agentsDir = getAgentsDir()) {
   const path = getSourcesConfigPath(agentsDir);
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return emptyConfig();
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync4(path, "utf8"));
+    parsed = JSON.parse(readFileSync5(path, "utf8"));
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     throw new Error(`Sources config is not readable JSON; refusing to overwrite ${path}: ${detail}`);
   }
-  if (!isRecord5(parsed) || parsed.version !== SOURCES_CONFIG_VERSION || !Array.isArray(parsed.sources)) {
+  if (!isRecord6(parsed) || parsed.version !== SOURCES_CONFIG_VERSION || !Array.isArray(parsed.sources)) {
     throw new Error(`Sources config is invalid; refusing to overwrite ${path}`);
   }
   if (!parsed.sources.every(isSourceEntry)) {
@@ -14467,11 +14594,11 @@ function addObsidianSourceChecked(input, agentsDir = getAgentsDir()) {
   const trimmedRoot = input.root.trim();
   if (!trimmedRoot)
     return { ok: false, error: "Obsidian vault path is required" };
-  const root = resolve3(trimmedRoot);
-  if (!existsSync6(root))
+  const root = resolve4(trimmedRoot);
+  if (!existsSync7(root))
     return { ok: false, error: `Obsidian vault path does not exist: ${root}` };
   try {
-    if (!statSync2(root).isDirectory())
+    if (!statSync3(root).isDirectory())
       return { ok: false, error: `Obsidian vault path must be a directory: ${root}` };
   } catch {
     return { ok: false, error: `Obsidian vault path is not accessible: ${root}` };
@@ -14547,12 +14674,12 @@ function emptyConfig() {
 }
 function withSourcesConfigLock(agentsDir, fn) {
   const configPath = getSourcesConfigPath(agentsDir);
-  mkdirSync4(dirname3(configPath), { recursive: true });
+  mkdirSync5(dirname4(configPath), { recursive: true });
   const lockDir = `${configPath}.lock`;
   let locked = false;
   for (let attempt = 0;attempt < 500; attempt++) {
     try {
-      mkdirSync4(lockDir);
+      mkdirSync5(lockDir);
       locked = true;
       break;
     } catch (err) {
@@ -14566,7 +14693,7 @@ function withSourcesConfigLock(agentsDir, fn) {
   try {
     return fn();
   } finally {
-    rmSync3(lockDir, { recursive: true, force: true });
+    rmSync4(lockDir, { recursive: true, force: true });
   }
 }
 function isFileExistsError(err) {
@@ -14590,7 +14717,7 @@ function cleanDiscordChannelFilter(values) {
 }
 function cleanLocalPath(value) {
   const trimmed = value?.trim();
-  return trimmed ? resolve3(trimmed.replace(/^~(?=$|\/|\\)/, homedir3())) : undefined;
+  return trimmed ? resolve4(trimmed.replace(/^~(?=$|\/|\\)/, homedir4())) : undefined;
 }
 function cleanGitHubRepos(values) {
   return Array.from(new Set(values.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean)));
@@ -14638,11 +14765,11 @@ function isDiscordSyncMode(value) {
 function defaultDiscordDesktopCachePath() {
   switch (platform2()) {
     case "darwin":
-      return resolve3(homedir3(), "Library", "Application Support", "discord");
+      return resolve4(homedir4(), "Library", "Application Support", "discord");
     case "win32":
-      return resolve3(process.env.APPDATA || resolve3(homedir3(), "AppData", "Roaming"), "discord");
+      return resolve4(process.env.APPDATA || resolve4(homedir4(), "AppData", "Roaming"), "discord");
     default:
-      return resolve3(process.env.XDG_CONFIG_HOME || resolve3(homedir3(), ".config"), "discord");
+      return resolve4(process.env.XDG_CONFIG_HOME || resolve4(homedir4(), ".config"), "discord");
   }
 }
 function looksLikeDiscordDesktopCacheRoot(value) {
@@ -14675,14 +14802,14 @@ function isSafeGitHubDocPath(value) {
 function mergeDefaultObsidianExcludeGlobs(values) {
   return [...DEFAULT_OBSIDIAN_EXCLUDE_GLOBS, ...cleanExcludeGlobs(values) ?? []].filter((value, index, all) => all.indexOf(value) === index);
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isSourceEntry(value) {
-  return isRecord5(value) && typeof value.kind === "string" && value.kind.trim().length > 0 && typeof value.id === "string" && typeof value.name === "string" && typeof value.root === "string" && typeof value.enabled === "boolean" && value.mode === "read-only" && typeof value.createdAt === "string" && typeof value.updatedAt === "string" && (value.lastIndexedAt === undefined || typeof value.lastIndexedAt === "string") && (value.excludeGlobs === undefined || Array.isArray(value.excludeGlobs) && value.excludeGlobs.every((entry) => typeof entry === "string")) && (value.providerSettings === undefined || isJsonRecord(value.providerSettings));
+  return isRecord6(value) && typeof value.kind === "string" && value.kind.trim().length > 0 && typeof value.id === "string" && typeof value.name === "string" && typeof value.root === "string" && typeof value.enabled === "boolean" && value.mode === "read-only" && typeof value.createdAt === "string" && typeof value.updatedAt === "string" && (value.lastIndexedAt === undefined || typeof value.lastIndexedAt === "string") && (value.excludeGlobs === undefined || Array.isArray(value.excludeGlobs) && value.excludeGlobs.every((entry) => typeof entry === "string")) && (value.providerSettings === undefined || isJsonRecord(value.providerSettings));
 }
 function isJsonRecord(value) {
-  if (!isRecord5(value))
+  if (!isRecord6(value))
     return false;
   return Object.values(value).every(isJsonValue);
 }
@@ -14701,8 +14828,8 @@ function isJsonValue(value) {
 var SOURCE_CHUNK_SOURCE_TYPE = "source_chunk";
 var LEGACY_OBSIDIAN_CHUNK_SOURCE_TYPE = "source_obsidian_chunk";
 // src/export.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
+import { join as join8 } from "node:path";
 var IDENTITY_FILE_NAMES = [
   "AGENTS.md",
   "SOUL.md",
@@ -14714,15 +14841,15 @@ var IDENTITY_FILE_NAMES = [
 ];
 function collectExportData(agentsDir, db, options = {}) {
   let agentYaml = null;
-  const yamlPath = join7(agentsDir, "agent.yaml");
-  if (existsSync7(yamlPath)) {
-    agentYaml = readFileSync5(yamlPath, "utf-8");
+  const yamlPath = join8(agentsDir, "agent.yaml");
+  if (existsSync8(yamlPath)) {
+    agentYaml = readFileSync6(yamlPath, "utf-8");
   }
   const identityFiles = [];
   for (const name of IDENTITY_FILE_NAMES) {
-    const path = join7(agentsDir, name);
-    if (existsSync7(path)) {
-      identityFiles.push({ name, content: readFileSync5(path, "utf-8") });
+    const path = join8(agentsDir, name);
+    if (existsSync8(path)) {
+      identityFiles.push({ name, content: readFileSync6(path, "utf-8") });
     }
   }
   const memories = db.prepare(`SELECT id, content, type, category, confidence, source_type,
@@ -14740,14 +14867,14 @@ function collectExportData(agentsDir, db, options = {}) {
 			 ORDER BY created_at ASC`).all();
   const skills = [];
   if (options.includeSkills !== false) {
-    const skillsDir = join7(agentsDir, "skills");
-    if (existsSync7(skillsDir)) {
+    const skillsDir = join8(agentsDir, "skills");
+    if (existsSync8(skillsDir)) {
       try {
         const entries = readdirSync3(skillsDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isDirectory())
             continue;
-          const skillDir = join7(skillsDir, entry.name);
+          const skillDir = join8(skillsDir, entry.name);
           const skillFiles = [];
           collectSkillFiles(skillDir, "", skillFiles);
           skills.push({ name: entry.name, files: skillFiles });
@@ -14778,16 +14905,16 @@ function collectSkillFiles(dir, prefix, out) {
   try {
     const entries = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join7(dir, entry.name);
+      const fullPath = join8(dir, entry.name);
       const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         collectSkillFiles(fullPath, relPath, out);
       } else {
-        const stat = statSync3(fullPath);
+        const stat = statSync4(fullPath);
         if (stat.size > 1e6)
           continue;
         try {
-          out.push({ path: relPath, content: readFileSync5(fullPath, "utf-8") });
+          out.push({ path: relPath, content: readFileSync6(fullPath, "utf-8") });
         } catch {}
       }
     }
@@ -14919,14 +15046,14 @@ function importRelations(db, relationsJsonl) {
 }
 // src/identity.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync8, readdirSync as readdirSync4, realpathSync, statSync as statSync4 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { dirname as dirname6, join as join10 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, readdirSync as readdirSync4, realpathSync, statSync as statSync5 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname7, join as join11 } from "node:path";
 
 // src/oh-my-pi.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, join as join8, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync7, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname5, join as join9, resolve as resolve5 } from "node:path";
 function readTrimmed(env, name) {
   const raw = env[name];
   if (typeof raw !== "string")
@@ -14935,21 +15062,21 @@ function readTrimmed(env, name) {
   return trimmed.length > 0 ? trimmed : null;
 }
 function normalizePath(pathValue) {
-  return resolve4(expandHome(pathValue.trim()));
+  return resolve5(expandHome(pathValue.trim()));
 }
-function readConfigHome(env) {
+function readConfigHome2(env) {
   const configured = readTrimmed(env, "XDG_CONFIG_HOME");
-  return configured ? normalizePath(configured) : join8(homedir4(), ".config");
+  return configured ? normalizePath(configured) : join9(homedir5(), ".config");
 }
 function getOhMyPiConfigPath(env = process.env) {
-  return join8(readConfigHome(env), "signet", "oh-my-pi.json");
+  return join9(readConfigHome2(env), "signet", "oh-my-pi.json");
 }
 function readConfiguredOhMyPiAgentDir(env = process.env) {
   const configPath = getOhMyPiConfigPath(env);
-  if (!existsSync8(configPath))
+  if (!existsSync9(configPath))
     return null;
   try {
-    const raw = JSON.parse(readFileSync6(configPath, "utf-8"));
+    const raw = JSON.parse(readFileSync7(configPath, "utf-8"));
     if (typeof raw !== "object" || raw === null)
       return null;
     const agentDir = Reflect.get(raw, "agentDir");
@@ -14962,10 +15089,10 @@ function resolveOhMyPiAgentDir(env = process.env) {
   const configured = readTrimmed(env, "PI_CODING_AGENT_DIR");
   if (configured)
     return normalizePath(configured);
-  return readConfiguredOhMyPiAgentDir(env) ?? join8(homedir4(), ".omp", "agent");
+  return readConfiguredOhMyPiAgentDir(env) ?? join9(homedir5(), ".omp", "agent");
 }
 function resolveOhMyPiExtensionsDir(env = process.env) {
-  return join8(resolveOhMyPiAgentDir(env), "extensions");
+  return join9(resolveOhMyPiAgentDir(env), "extensions");
 }
 function listOhMyPiAgentDirCandidates(env = process.env) {
   const candidates = new Set;
@@ -14975,38 +15102,38 @@ function listOhMyPiAgentDirCandidates(env = process.env) {
   const persisted = readConfiguredOhMyPiAgentDir(env);
   if (persisted)
     candidates.add(persisted);
-  candidates.add(join8(homedir4(), ".omp", "agent"));
+  candidates.add(join9(homedir5(), ".omp", "agent"));
   return Array.from(candidates);
 }
 function writeConfiguredOhMyPiAgentDir(pathValue, env = process.env) {
   const agentDir = normalizePath(pathValue);
   const configPath = getOhMyPiConfigPath(env);
-  if (readConfiguredOhMyPiAgentDir(env) === agentDir && existsSync8(configPath)) {
+  if (readConfiguredOhMyPiAgentDir(env) === agentDir && existsSync9(configPath)) {
     return configPath;
   }
-  mkdirSync5(dirname4(configPath), { recursive: true });
+  mkdirSync6(dirname5(configPath), { recursive: true });
   const payload = {
     version: 1,
     agentDir,
     updatedAt: new Date().toISOString()
   };
-  writeFileSync5(configPath, `${JSON.stringify(payload, null, 2)}
+  writeFileSync6(configPath, `${JSON.stringify(payload, null, 2)}
 `);
   return configPath;
 }
 function clearConfiguredOhMyPiAgentDir(env = process.env) {
   const configPath = getOhMyPiConfigPath(env);
-  if (!existsSync8(configPath))
+  if (!existsSync9(configPath))
     return;
   try {
-    rmSync4(configPath, { force: true });
+    rmSync5(configPath, { force: true });
   } catch {}
 }
 
 // src/pi.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync7, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname5, join as join9, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname6, join as join10, resolve as resolve6 } from "node:path";
 function readTrimmed2(env, name) {
   const raw = env[name];
   if (typeof raw !== "string")
@@ -15017,29 +15144,29 @@ function readTrimmed2(env, name) {
 function expandUserPath(pathValue) {
   const trimmed = pathValue.trim();
   if (trimmed === "~")
-    return homedir5();
+    return homedir6();
   if (trimmed.startsWith("~/"))
-    return join9(homedir5(), trimmed.slice(2));
+    return join10(homedir6(), trimmed.slice(2));
   if (trimmed.startsWith("~"))
-    return join9(homedir5(), trimmed.slice(1));
+    return join10(homedir6(), trimmed.slice(1));
   return trimmed;
 }
 function normalizePath2(pathValue) {
-  return resolve5(expandUserPath(pathValue));
+  return resolve6(expandUserPath(pathValue));
 }
-function readConfigHome2(env) {
+function readConfigHome3(env) {
   const configured = readTrimmed2(env, "XDG_CONFIG_HOME");
-  return configured ? normalizePath2(configured) : join9(homedir5(), ".config");
+  return configured ? normalizePath2(configured) : join10(homedir6(), ".config");
 }
 function getPiConfigPath(env = process.env) {
-  return join9(readConfigHome2(env), "signet", "pi.json");
+  return join10(readConfigHome3(env), "signet", "pi.json");
 }
 function readConfiguredPiAgentDir(env = process.env) {
   const configPath = getPiConfigPath(env);
-  if (!existsSync9(configPath))
+  if (!existsSync10(configPath))
     return null;
   try {
-    const raw = JSON.parse(readFileSync7(configPath, "utf-8"));
+    const raw = JSON.parse(readFileSync8(configPath, "utf-8"));
     if (typeof raw !== "object" || raw === null)
       return null;
     const agentDir = Reflect.get(raw, "agentDir");
@@ -15052,10 +15179,10 @@ function resolvePiAgentDir(env = process.env) {
   const configured = readTrimmed2(env, "PI_CODING_AGENT_DIR");
   if (configured)
     return normalizePath2(configured);
-  return readConfiguredPiAgentDir(env) ?? join9(homedir5(), ".pi", "agent");
+  return readConfiguredPiAgentDir(env) ?? join10(homedir6(), ".pi", "agent");
 }
 function resolvePiExtensionsDir(env = process.env) {
-  return join9(resolvePiAgentDir(env), "extensions");
+  return join10(resolvePiAgentDir(env), "extensions");
 }
 function listPiAgentDirCandidates(env = process.env) {
   const candidates = new Set;
@@ -15065,31 +15192,31 @@ function listPiAgentDirCandidates(env = process.env) {
   const persisted = readConfiguredPiAgentDir(env);
   if (persisted)
     candidates.add(persisted);
-  candidates.add(join9(homedir5(), ".pi", "agent"));
+  candidates.add(join10(homedir6(), ".pi", "agent"));
   return Array.from(candidates);
 }
 function writeConfiguredPiAgentDir(pathValue, env = process.env) {
   const agentDir = normalizePath2(pathValue);
   const configPath = getPiConfigPath(env);
-  if (readConfiguredPiAgentDir(env) === agentDir && existsSync9(configPath)) {
+  if (readConfiguredPiAgentDir(env) === agentDir && existsSync10(configPath)) {
     return configPath;
   }
-  mkdirSync6(dirname5(configPath), { recursive: true });
+  mkdirSync7(dirname6(configPath), { recursive: true });
   const payload = {
     version: 1,
     agentDir,
     updatedAt: new Date().toISOString()
   };
-  writeFileSync6(configPath, `${JSON.stringify(payload, null, 2)}
+  writeFileSync7(configPath, `${JSON.stringify(payload, null, 2)}
 `);
   return configPath;
 }
 function clearConfiguredPiAgentDir(env = process.env) {
   const configPath = getPiConfigPath(env);
-  if (!existsSync9(configPath))
+  if (!existsSync10(configPath))
     return;
   try {
-    rmSync5(configPath, { force: true });
+    rmSync6(configPath, { force: true });
   } catch {}
 }
 
@@ -15103,7 +15230,7 @@ var PI_MANAGED_MARKER = "SIGNET_MANAGED_PI_EXTENSION";
 function resolveAgentBasePath(agentName, workspaceDir) {
   if (agentName === "default")
     return workspaceDir;
-  return join10(workspaceDir, "agents", agentName);
+  return join11(workspaceDir, "agents", agentName);
 }
 var IDENTITY_MODES = ["managed", "passthrough", "off"];
 var IDENTITY_FILES = {
@@ -15202,13 +15329,13 @@ var REQUIRED_IDENTITY_KEYS = Object.entries(IDENTITY_FILES).filter(([, spec]) =>
 var OPTIONAL_IDENTITY_KEYS = Object.entries(IDENTITY_FILES).filter(([, spec]) => spec.optional).map(([key]) => key);
 function isSignetManagedOhMyPiInstall() {
   for (const agentDir of listOhMyPiAgentDirCandidates()) {
-    const extensionsDir = join10(agentDir, "extensions");
+    const extensionsDir = join11(agentDir, "extensions");
     for (const filename of [OH_MY_PI_MANAGED_EXTENSION_FILENAME, OH_MY_PI_LEGACY_MANAGED_EXTENSION_FILENAME]) {
-      const extensionPath = join10(extensionsDir, filename);
-      if (!existsSync10(extensionPath))
+      const extensionPath = join11(extensionsDir, filename);
+      if (!existsSync11(extensionPath))
         continue;
       try {
-        const content = readFileSync8(extensionPath, "utf8");
+        const content = readFileSync9(extensionPath, "utf8");
         if (content.includes(OH_MY_PI_MANAGED_MARKER))
           return true;
       } catch {}
@@ -15218,13 +15345,13 @@ function isSignetManagedOhMyPiInstall() {
 }
 function isSignetManagedPiInstall() {
   for (const agentDir of listPiAgentDirCandidates()) {
-    const extensionsDir = join10(agentDir, "extensions");
+    const extensionsDir = join11(agentDir, "extensions");
     for (const filename of [PI_MANAGED_EXTENSION_FILENAME, PI_LEGACY_MANAGED_EXTENSION_FILENAME]) {
-      const extensionPath = join10(extensionsDir, filename);
-      if (!existsSync10(extensionPath))
+      const extensionPath = join11(extensionsDir, filename);
+      if (!existsSync11(extensionPath))
         continue;
       try {
-        const content = readFileSync8(extensionPath, "utf8");
+        const content = readFileSync9(extensionPath, "utf8");
         if (content.includes(PI_MANAGED_MARKER))
           return true;
       } catch {}
@@ -15233,31 +15360,31 @@ function isSignetManagedPiInstall() {
   return false;
 }
 function userHome() {
-  return process.env.HOME?.trim() || homedir6();
+  return process.env.HOME?.trim() || homedir7();
 }
 function resolveHermesHomePath() {
   const hermesHome = process.env.HERMES_HOME?.trim();
-  return hermesHome || join10(userHome(), ".hermes");
+  return hermesHome || join11(userHome(), ".hermes");
 }
 function hermesAgentCandidateDirs() {
   const home = userHome();
   const hermesHome = resolveHermesHomePath();
   return [
     hermesHome,
-    join10(hermesHome, "hermes-agent"),
-    join10(home, "hermes-agent"),
-    join10(home, ".local", "share", "hermes-agent"),
-    join10(home, "src", "hermes-agent"),
+    join11(hermesHome, "hermes-agent"),
+    join11(home, "hermes-agent"),
+    join11(home, ".local", "share", "hermes-agent"),
+    join11(home, "src", "hermes-agent"),
     "/opt/hermes-agent"
   ];
 }
 function resolveHermesRepoPath() {
   const hermesRepo = process.env.HERMES_REPO?.trim();
-  if (hermesRepo && existsSync10(join10(hermesRepo, "plugins", "memory"))) {
+  if (hermesRepo && existsSync11(join11(hermesRepo, "plugins", "memory"))) {
     return hermesRepo;
   }
   for (const base of hermesAgentCandidateDirs()) {
-    if (existsSync10(join10(base, "plugins", "memory")))
+    if (existsSync11(join11(base, "plugins", "memory")))
       return base;
   }
   try {
@@ -15267,19 +15394,19 @@ function resolveHermesRepoPath() {
       timeout: 3000
     }).trim();
     if (hermesPath) {
-      const repoDir = dirname6(realpathSync(hermesPath));
-      if (existsSync10(join10(repoDir, "plugins", "memory")))
+      const repoDir = dirname7(realpathSync(hermesPath));
+      if (existsSync11(join11(repoDir, "plugins", "memory")))
         return repoDir;
     }
   } catch {}
   return null;
 }
 function resolveHermesRepoPluginPath() {
-  const pluginFile = join10("plugins", "memory", "signet", "__init__.py");
+  const pluginFile = join11("plugins", "memory", "signet", "__init__.py");
   const hermesRepo = resolveHermesRepoPath();
   if (hermesRepo !== null) {
-    const candidate = join10(hermesRepo, pluginFile);
-    if (existsSync10(candidate))
+    const candidate = join11(hermesRepo, pluginFile);
+    if (existsSync11(candidate))
       return candidate;
   }
   return null;
@@ -15288,52 +15415,52 @@ function detectExistingSetup(basePath) {
   const identityFileNames = Object.values(IDENTITY_FILES).map((spec) => spec.path);
   const foundFiles = [];
   for (const fileName of identityFileNames) {
-    if (existsSync10(join10(basePath, fileName))) {
+    if (existsSync11(join11(basePath, fileName))) {
       foundFiles.push(fileName);
     }
   }
-  const memoryDir = join10(basePath, "memory");
+  const memoryDir = join11(basePath, "memory");
   let memoryLogCount = 0;
-  if (existsSync10(memoryDir)) {
+  if (existsSync11(memoryDir)) {
     try {
       const files = readdirSync4(memoryDir);
       memoryLogCount = files.filter((f) => f.endsWith(".md") && !f.startsWith("TEMPLATE")).length;
     } catch {}
   }
-  const home = homedir6();
+  const home = homedir7();
   return {
     basePath,
-    agentsDir: existsSync10(basePath),
-    agentYaml: existsSync10(join10(basePath, "agent.yaml")),
-    agentsMd: existsSync10(join10(basePath, "AGENTS.md")),
-    configYaml: existsSync10(join10(basePath, "config.yaml")),
-    memoryDb: existsSync10(join10(basePath, "memory", "memories.db")),
+    agentsDir: existsSync11(basePath),
+    agentYaml: existsSync11(join11(basePath, "agent.yaml")),
+    agentsMd: existsSync11(join11(basePath, "AGENTS.md")),
+    configYaml: existsSync11(join11(basePath, "config.yaml")),
+    memoryDb: existsSync11(join11(basePath, "memory", "memories.db")),
     identityFiles: foundFiles,
-    hasMemoryDir: existsSync10(memoryDir),
+    hasMemoryDir: existsSync11(memoryDir),
     memoryLogCount,
-    hasClawdhub: existsSync10(join10(basePath, ".clawdhub", "lock.json")),
-    hasClaudeSkills: existsSync10(join10(home, ".claude", "skills")),
+    hasClawdhub: existsSync11(join11(basePath, ".clawdhub", "lock.json")),
+    hasClaudeSkills: existsSync11(join11(home, ".claude", "skills")),
     harnesses: {
-      claudeCode: existsSync10(join10(home, ".claude", "settings.json")),
-      openclaw: existsSync10(join10(home, ".openclaw", "openclaw.json")) || existsSync10(join10(home, ".clawdbot", "clawdbot.json")),
-      opencode: existsSync10(join10(home, ".config", "opencode", "config.json")),
-      forge: existsSync10(join10(home, ".forge", ".mcp.json")) || existsSync10(join10(home, "forge", ".mcp.json")) || existsSync10(join10(home, ".forge", ".forge.toml")) || existsSync10(join10(home, "forge", ".forge.toml")),
-      codex: existsSync10(join10(home, ".codex", "config.toml")) || existsSync10(join10(home, ".config", "signet", "bin", "codex")),
-      ohMyPi: isSignetManagedOhMyPiInstall() || existsSync10(resolveOhMyPiAgentDir()),
-      pi: isSignetManagedPiInstall() || existsSync10(resolvePiAgentDir()),
+      claudeCode: existsSync11(join11(home, ".claude", "settings.json")),
+      openclaw: existsSync11(join11(home, ".openclaw", "openclaw.json")) || existsSync11(join11(home, ".clawdbot", "clawdbot.json")),
+      opencode: existsSync11(join11(home, ".config", "opencode", "config.json")),
+      forge: existsSync11(join11(home, ".forge", ".mcp.json")) || existsSync11(join11(home, "forge", ".mcp.json")) || existsSync11(join11(home, ".forge", ".forge.toml")) || existsSync11(join11(home, "forge", ".forge.toml")),
+      codex: existsSync11(join11(home, ".codex", "config.toml")) || existsSync11(join11(home, ".config", "signet", "bin", "codex")),
+      ohMyPi: isSignetManagedOhMyPiInstall() || existsSync11(resolveOhMyPiAgentDir()),
+      pi: isSignetManagedPiInstall() || existsSync11(resolvePiAgentDir()),
       hermesAgent: resolveHermesRepoPath() !== null,
-      gemini: existsSync10(join10(home, ".gemini", "settings.json"))
+      gemini: existsSync11(join11(home, ".gemini", "settings.json"))
     }
   };
 }
 async function loadIdentityFiles(basePath) {
   const result = {};
   for (const [key, spec] of Object.entries(IDENTITY_FILES)) {
-    const filePath = join10(basePath, spec.path);
-    if (existsSync10(filePath)) {
+    const filePath = join11(basePath, spec.path);
+    if (existsSync11(filePath)) {
       try {
-        const content = readFileSync8(filePath, "utf-8");
-        const stats = statSync4(filePath);
+        const content = readFileSync9(filePath, "utf-8");
+        const stats = statSync5(filePath);
         result[key] = {
           path: spec.path,
           content,
@@ -15354,11 +15481,11 @@ async function loadIdentityFiles(basePath) {
 function loadIdentityFilesSync(basePath) {
   const result = {};
   for (const [key, spec] of Object.entries(IDENTITY_FILES)) {
-    const filePath = join10(basePath, spec.path);
-    if (existsSync10(filePath)) {
+    const filePath = join11(basePath, spec.path);
+    if (existsSync11(filePath)) {
       try {
-        const content = readFileSync8(filePath, "utf-8");
-        const stats = statSync4(filePath);
+        const content = readFileSync9(filePath, "utf-8");
+        const stats = statSync5(filePath);
         result[key] = {
           path: spec.path,
           content,
@@ -15382,7 +15509,7 @@ function hasValidIdentity(basePath) {
     return true;
   for (const key of REQUIRED_IDENTITY_KEYS) {
     const spec = IDENTITY_FILES[key];
-    if (!existsSync10(join10(basePath, spec.path))) {
+    if (!existsSync11(join11(basePath, spec.path))) {
       return false;
     }
   }
@@ -15395,7 +15522,7 @@ function getMissingIdentityFiles(basePath) {
   const missing = [];
   for (const key of REQUIRED_IDENTITY_KEYS) {
     const spec = IDENTITY_FILES[key];
-    if (!existsSync10(join10(basePath, spec.path))) {
+    if (!existsSync11(join11(basePath, spec.path))) {
       missing.push(spec.path);
     }
   }
@@ -15443,11 +15570,11 @@ function resolveIdentityModeFromConfig(config) {
   return "managed";
 }
 function loadIdentityMode(agentsDir) {
-  const agentYaml = join10(agentsDir, "agent.yaml");
-  if (!existsSync10(agentYaml))
+  const agentYaml = join11(agentsDir, "agent.yaml");
+  if (!existsSync11(agentYaml))
     return "managed";
   try {
-    return resolveIdentityModeFromConfig(parseSimpleYaml(readFileSync8(agentYaml, "utf-8")));
+    return resolveIdentityModeFromConfig(parseSimpleYaml(readFileSync9(agentYaml, "utf-8")));
   } catch {
     return "managed";
   }
@@ -15498,11 +15625,11 @@ function identityHeaderFor(path, role) {
   return STATIC_HEADER_BY_FILE[filename] ?? role ?? filename.replace(/\.md$/i, "");
 }
 function resolveStartupIdentityFiles(agentsDir) {
-  const agentYaml = join10(agentsDir, "agent.yaml");
-  if (!existsSync10(agentYaml))
+  const agentYaml = join11(agentsDir, "agent.yaml");
+  if (!existsSync11(agentYaml))
     return STATIC_BUDGETS.map(({ file, budget }) => ({ path: file, budget }));
   try {
-    const config = parseSimpleYaml(readFileSync8(agentYaml, "utf-8"));
+    const config = parseSimpleYaml(readFileSync9(agentYaml, "utf-8"));
     if (!identityModeReadsFiles(resolveIdentityModeFromConfig(config)))
       return [];
     const identity = readRecord(config.identity);
@@ -15518,12 +15645,12 @@ function resolveStartupIdentityFiles(agentsDir) {
   return STATIC_BUDGETS.map(({ file, budget }) => ({ path: file, budget }));
 }
 function resolveSpecialIdentityFiles(agentsDir, kind) {
-  const agentYaml = join10(agentsDir, "agent.yaml");
-  if (!existsSync10(agentYaml)) {
+  const agentYaml = join11(agentsDir, "agent.yaml");
+  if (!existsSync11(agentYaml)) {
     return IDENTITY_PRESETS.minimal.special.filter((entry) => entry.kind === kind);
   }
   try {
-    const config = parseSimpleYaml(readFileSync8(agentYaml, "utf-8"));
+    const config = parseSimpleYaml(readFileSync9(agentYaml, "utf-8"));
     if (!identityModeReadsFiles(resolveIdentityModeFromConfig(config)))
       return [];
     const identity = readRecord(config.identity);
@@ -15560,17 +15687,17 @@ function resolvePromptSubmitTimeoutMs(raw) {
   return ms;
 }
 function readStaticIdentity(agentsDir, status = STATIC_IDENTITY_OFFLINE_STATUS) {
-  if (!existsSync10(agentsDir))
+  if (!existsSync11(agentsDir))
     return null;
   if (!identityModeReadsFiles(loadIdentityMode(agentsDir)))
     return null;
   const parts = [];
   for (const entry of resolveStartupIdentityFiles(agentsDir)) {
-    const path = join10(agentsDir, entry.path);
-    if (!existsSync10(path))
+    const path = join11(agentsDir, entry.path);
+    if (!existsSync11(path))
       continue;
     try {
-      const raw = readFileSync8(path, "utf-8").trim();
+      const raw = readFileSync9(path, "utf-8").trim();
       if (!raw)
         continue;
       const budget = entry.budget ?? STATIC_BUDGETS.find((candidate) => candidate.file === entry.path)?.budget ?? 4000;
@@ -15605,8 +15732,8 @@ function summarizeIdentity(identity) {
 `);
 }
 // src/agents.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readdirSync as readdirSync5, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join12 } from "node:path";
 var IDENTITY_FILES2 = [
   "AGENTS.md",
   "SOUL.md",
@@ -15618,37 +15745,37 @@ var IDENTITY_FILES2 = [
   "BOOTSTRAP.md"
 ];
 function discoverAgents(agentsDir) {
-  const root = join11(agentsDir, "agents");
-  if (!existsSync11(root))
+  const root = join12(agentsDir, "agents");
+  if (!existsSync12(root))
     return [];
   return readdirSync5(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => ({ name: d.name }));
 }
 function scaffoldAgent(name, agentsDir) {
-  const dir = join11(agentsDir, "agents", name);
-  if (!existsSync11(dir))
-    mkdirSync7(dir, { recursive: true });
-  const soul = join11(dir, "SOUL.md");
-  if (!existsSync11(soul))
-    writeFileSync7(soul, `# Soul
+  const dir = join12(agentsDir, "agents", name);
+  if (!existsSync12(dir))
+    mkdirSync8(dir, { recursive: true });
+  const soul = join12(dir, "SOUL.md");
+  if (!existsSync12(soul))
+    writeFileSync8(soul, `# Soul
 
 Add ${name}'s personality here.
 `);
-  const identity = join11(dir, "IDENTITY.md");
-  if (!existsSync11(identity))
-    writeFileSync7(identity, `# Identity
+  const identity = join12(dir, "IDENTITY.md");
+  if (!existsSync12(identity))
+    writeFileSync8(identity, `# Identity
 
 name: ${name}
 `);
 }
 function getAgentIdentityFiles(name, agentsDir) {
   const result = {};
-  const agentDir = join11(agentsDir, "agents", name);
+  const agentDir = join12(agentsDir, "agents", name);
   for (const file of IDENTITY_FILES2) {
-    const specific = join11(agentDir, file);
-    const fallback = join11(agentsDir, file);
-    if (existsSync11(specific))
+    const specific = join12(agentDir, file);
+    const fallback = join12(agentsDir, file);
+    if (existsSync12(specific))
       result[file] = specific;
-    else if (existsSync11(fallback))
+    else if (existsSync12(fallback))
       result[file] = fallback;
   }
   return result;
@@ -15696,13 +15823,13 @@ function resolveAgentSkills(agentDef, allSkills) {
   return allSkills.filter((s) => allowed.has(s));
 }
 // src/skills.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync9, readdirSync as readdirSync7, statSync as statSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join13 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync10, readdirSync as readdirSync7, statSync as statSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join14 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 
 // src/symlinks.ts
-import { existsSync as existsSync12, lstatSync, mkdirSync as mkdirSync8, readdirSync as readdirSync6, symlinkSync, unlinkSync } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync13, lstatSync, mkdirSync as mkdirSync9, readdirSync as readdirSync6, symlinkSync, unlinkSync } from "node:fs";
+import { join as join13 } from "node:path";
 function linkDirSync(target, path) {
   const type = process.platform === "win32" ? "junction" : "dir";
   symlinkSync(target, path, type);
@@ -15713,15 +15840,15 @@ function symlinkSkills(sourceDir, targetDir, options = {}) {
     skipped: [],
     errors: []
   };
-  if (!existsSync12(sourceDir)) {
+  if (!existsSync13(sourceDir)) {
     return result;
   }
-  const targetParent = join12(targetDir, "..");
-  if (!existsSync12(targetParent)) {
-    mkdirSync8(targetParent, { recursive: true });
+  const targetParent = join13(targetDir, "..");
+  if (!existsSync13(targetParent)) {
+    mkdirSync9(targetParent, { recursive: true });
   }
-  if (!existsSync12(targetDir)) {
-    mkdirSync8(targetDir, { recursive: true });
+  if (!existsSync13(targetDir)) {
+    mkdirSync9(targetDir, { recursive: true });
   }
   let entries;
   try {
@@ -15734,8 +15861,8 @@ function symlinkSkills(sourceDir, targetDir, options = {}) {
     return result;
   }
   for (const entry of entries) {
-    const srcPath = join12(sourceDir, entry);
-    const destPath = join12(targetDir, entry);
+    const srcPath = join13(sourceDir, entry);
+    const destPath = join13(targetDir, entry);
     try {
       const src = lstatSync(srcPath);
       if (src.isSymbolicLink() || !src.isDirectory()) {
@@ -15777,10 +15904,10 @@ function symlinkSkills(sourceDir, targetDir, options = {}) {
   return result;
 }
 function symlinkDir(src, dest, options = {}) {
-  if (!existsSync12(src)) {
+  if (!existsSync13(src)) {
     return false;
   }
-  if (existsSync12(dest)) {
+  if (existsSync13(dest)) {
     try {
       const stat = lstatSync(dest);
       if (stat.isSymbolicLink()) {
@@ -15806,36 +15933,36 @@ function symlinkDir(src, dest, options = {}) {
 }
 
 // src/skills.ts
-var home = homedir7();
+var home = homedir8();
 function loadClawdhubLock(basePath) {
-  const lockPath = join13(basePath, ".clawdhub", "lock.json");
-  if (!existsSync13(lockPath)) {
+  const lockPath = join14(basePath, ".clawdhub", "lock.json");
+  if (!existsSync14(lockPath)) {
     return null;
   }
   try {
-    const content = readFileSync9(lockPath, "utf-8");
+    const content = readFileSync10(lockPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function symlinkClaudeSkills(basePath) {
-  const claudeSkillsDir = join13(home, ".claude", "skills");
-  const targetSkillsDir = join13(basePath, "skills");
-  if (!existsSync13(claudeSkillsDir)) {
+  const claudeSkillsDir = join14(home, ".claude", "skills");
+  const targetSkillsDir = join14(basePath, "skills");
+  if (!existsSync14(claudeSkillsDir)) {
     return { symlinked: 0, skills: [] };
   }
-  if (!existsSync13(targetSkillsDir)) {
-    mkdirSync9(targetSkillsDir, { recursive: true });
+  if (!existsSync14(targetSkillsDir)) {
+    mkdirSync10(targetSkillsDir, { recursive: true });
   }
   const symlinkedSkills = [];
   try {
     const skills = readdirSync7(claudeSkillsDir);
     for (const skill of skills) {
-      const src = join13(claudeSkillsDir, skill);
-      const dest = join13(targetSkillsDir, skill);
+      const src = join14(claudeSkillsDir, skill);
+      const dest = join14(targetSkillsDir, skill);
       try {
-        if (!statSync5(src).isDirectory())
+        if (!statSync6(src).isDirectory())
           continue;
       } catch {
         continue;
@@ -15848,12 +15975,12 @@ function symlinkClaudeSkills(basePath) {
   return { symlinked: symlinkedSkills.length, skills: symlinkedSkills };
 }
 function writeRegistry(basePath, registry) {
-  const skillsDir = join13(basePath, "skills");
-  const registryPath = join13(skillsDir, "registry.json");
-  if (!existsSync13(skillsDir)) {
-    mkdirSync9(skillsDir, { recursive: true });
+  const skillsDir = join14(basePath, "skills");
+  const registryPath = join14(skillsDir, "registry.json");
+  if (!existsSync14(skillsDir)) {
+    mkdirSync10(skillsDir, { recursive: true });
   }
-  writeFileSync8(registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  writeFileSync9(registryPath, JSON.stringify(registry, null, 2), "utf-8");
 }
 async function unifySkills(basePath, config = {}) {
   const registry = {
@@ -15867,7 +15994,7 @@ async function unifySkills(basePath, config = {}) {
   if (clawdhubLock) {
     registry.sources.push({
       type: "openclaw",
-      path: join13(basePath, ".clawdhub")
+      path: join14(basePath, ".clawdhub")
     });
     const skillsData = clawdhubLock.skills || clawdhubLock;
     for (const [name, data] of Object.entries(skillsData)) {
@@ -15889,10 +16016,10 @@ async function unifySkills(basePath, config = {}) {
     }
   }
   const claudeResult = symlinkClaudeSkills(basePath);
-  if (claudeResult.symlinked > 0 || existsSync13(join13(home, ".claude", "skills"))) {
+  if (claudeResult.symlinked > 0 || existsSync14(join14(home, ".claude", "skills"))) {
     registry.sources.push({
       type: "claude-code",
-      path: join13(home, ".claude", "skills")
+      path: join14(home, ".claude", "skills")
     });
     for (const skillName of claudeResult.skills) {
       if (!registry.skills[skillName]) {
@@ -15900,7 +16027,7 @@ async function unifySkills(basePath, config = {}) {
           name: skillName,
           source: "claude-code",
           symlinked: true,
-          path: join13(basePath, "skills", skillName)
+          path: join14(basePath, "skills", skillName)
         };
         symlinked++;
       } else {
@@ -15910,7 +16037,7 @@ async function unifySkills(basePath, config = {}) {
   }
   if (config.registries) {
     for (const reg of config.registries) {
-      if (!existsSync13(reg.path)) {
+      if (!existsSync14(reg.path)) {
         continue;
       }
       registry.sources.push({
@@ -15920,9 +16047,9 @@ async function unifySkills(basePath, config = {}) {
       try {
         const entries = readdirSync7(reg.path);
         for (const entry of entries) {
-          const entryPath = join13(reg.path, entry);
+          const entryPath = join14(reg.path, entry);
           try {
-            if (!statSync5(entryPath).isDirectory())
+            if (!statSync6(entryPath).isDirectory())
               continue;
           } catch {
             continue;
@@ -15932,9 +16059,9 @@ async function unifySkills(basePath, config = {}) {
             continue;
           }
           if (reg.symlink) {
-            const targetPath = join13(basePath, "skills", entry);
-            if (!existsSync13(join13(basePath, "skills"))) {
-              mkdirSync9(join13(basePath, "skills"), { recursive: true });
+            const targetPath = join14(basePath, "skills", entry);
+            if (!existsSync14(join14(basePath, "skills"))) {
+              mkdirSync10(join14(basePath, "skills"), { recursive: true });
             }
             if (symlinkDir(entryPath, targetPath)) {
               registry.skills[entry] = {
@@ -15969,7 +16096,7 @@ async function unifySkills(basePath, config = {}) {
   };
 }
 // src/skill-transcript.ts
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toMs(ts) {
@@ -15994,20 +16121,20 @@ function parseTranscriptSkills(content) {
     } catch {
       continue;
     }
-    if (!isRecord6(row))
+    if (!isRecord7(row))
       continue;
     const message = row.message;
-    if (!isRecord6(message))
+    if (!isRecord7(message))
       continue;
     const contentBlocks = message.content;
     if (!Array.isArray(contentBlocks))
       continue;
     const at = toMs(row.timestamp);
     for (const part of contentBlocks) {
-      if (!isRecord6(part))
+      if (!isRecord7(part))
         continue;
       if (part.type === "tool_use" && part.name === "Skill") {
-        const input = isRecord6(part.input) ? part.input : {};
+        const input = isRecord7(part.input) ? part.input : {};
         const skillName = toStr(input.skill) || toStr(input.name) || toStr(input.skill_name);
         if (!skillName)
           continue;
@@ -16050,8 +16177,8 @@ function parseTranscriptSkills(content) {
   return { records, skipped };
 }
 // src/import.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, readdirSync as readdirSync8 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync11, readdirSync as readdirSync8 } from "node:fs";
+import { join as join15 } from "node:path";
 var DATE_FILENAME_PATTERN = /^(\d{4}-\d{2}-\d{2})\.md$/;
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
@@ -16258,8 +16385,8 @@ function importMemoryLogs(basePath, db) {
     skipped: 0,
     errors: []
   };
-  const memoryDir = join14(basePath, "memory");
-  if (!existsSync14(memoryDir)) {
+  const memoryDir = join15(basePath, "memory");
+  if (!existsSync15(memoryDir)) {
     result.errors.push(`Memory directory not found: ${memoryDir}`);
     return result;
   }
@@ -16272,7 +16399,7 @@ function importMemoryLogs(basePath, db) {
     return result;
   }
   for (const file of files) {
-    const filePath = join14(memoryDir, file);
+    const filePath = join15(memoryDir, file);
     const date = extractDateFromFilename(file);
     if (!date) {
       result.skipped++;
@@ -16281,7 +16408,7 @@ function importMemoryLogs(basePath, db) {
     }
     let content;
     try {
-      content = readFileSync10(filePath, "utf-8");
+      content = readFileSync11(filePath, "utf-8");
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       result.errors.push(`Failed to read file ${file}: ${message}`);
@@ -16482,7 +16609,7 @@ function ok(value) {
 function err(code, message, details) {
   return { ok: false, error: { code, message, ...details ? { details } : {} } };
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asString(value) {
@@ -16512,7 +16639,7 @@ function asNonNegativeInt(value) {
   return Math.floor(value);
 }
 function asRecordOfStrings(value) {
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     return {};
   const next = {};
   for (const [key, raw] of Object.entries(value)) {
@@ -16523,7 +16650,7 @@ function asRecordOfStrings(value) {
   return next;
 }
 function asRecordOfStringArrays(value) {
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     return {};
   const next = {};
   for (const [key, raw] of Object.entries(value)) {
@@ -16661,7 +16788,7 @@ function parseRoutingTargetRef(value) {
   });
 }
 function parseAccountConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return null;
   const kind = asString(raw.kind);
   if (!kind || !ROUTING_ACCOUNT_KINDS.includes(kind))
@@ -16679,7 +16806,7 @@ function parseAccountConfig(raw) {
   };
 }
 function parseModelConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return null;
   const model = asString(raw.model);
   if (!model)
@@ -16697,7 +16824,7 @@ function parseModelConfig(raw) {
   };
 }
 function parseCommandConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return;
   const bin = asString(raw.bin ?? raw.command);
   if (!bin)
@@ -16735,9 +16862,9 @@ function asAcpxModelSelection(value) {
   return typeof value === "string" && ["acp", "agent"].includes(value) ? value : undefined;
 }
 function parseAcpxConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return;
-  const nested = isRecord7(raw.acpx) ? raw.acpx : raw;
+  const nested = isRecord8(raw.acpx) ? raw.acpx : raw;
   const agent = asString(nested.agent ?? nested.harness);
   if (!agent)
     return;
@@ -16765,10 +16892,10 @@ function parseAcpxConfig(raw) {
   };
 }
 function parseOpenRouterConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return;
-  const nested = isRecord7(raw.openrouter) ? raw.openrouter : raw;
-  const reasoningRaw = isRecord7(nested.reasoning) ? nested.reasoning : undefined;
+  const nested = isRecord8(raw.openrouter) ? raw.openrouter : raw;
+  const reasoningRaw = isRecord8(nested.reasoning) ? nested.reasoning : undefined;
   if (!reasoningRaw)
     return;
   const enabled = asBool(reasoningRaw.enabled);
@@ -16780,12 +16907,12 @@ function parseOpenRouterConfig(raw) {
   return Object.keys(reasoning).length > 0 ? { reasoning } : undefined;
 }
 function parseTargetConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return null;
   const executor = asString(raw.executor);
   if (!executor || !ROUTING_EXECUTOR_PATTERN.test(executor))
     return null;
-  const modelsRaw = isRecord7(raw.models) ? raw.models : null;
+  const modelsRaw = isRecord8(raw.models) ? raw.models : null;
   if (!modelsRaw)
     return null;
   const models = {};
@@ -16820,7 +16947,7 @@ function parseTargetConfig(raw) {
   };
 }
 function parsePolicyConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return null;
   return {
     mode: asRoutingMode(raw.mode, "automatic"),
@@ -16834,7 +16961,7 @@ function parsePolicyConfig(raw) {
   };
 }
 function parseTaskClassConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return null;
   return {
     reasoning: asRoutingReasoningDepth(raw.reasoning, "medium"),
@@ -16851,7 +16978,7 @@ function parseTaskClassConfig(raw) {
   };
 }
 function parseAgentRoutingConfig(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return null;
   return {
     defaultPolicy: asString(raw.defaultPolicy ?? raw.default_policy),
@@ -16861,7 +16988,7 @@ function parseAgentRoutingConfig(raw) {
   };
 }
 function parseWorkloadBinding(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return;
   const policy = asString(raw.policy);
   const taskClass = asString(raw.taskClass ?? raw.task_class);
@@ -17122,17 +17249,17 @@ function validateRoutingReferences(config) {
 }
 function parseRoutingConfig(raw, legacyConfig) {
   const base = legacyConfig ?? emptyRoutingConfig("explicit");
-  if (!isRecord7(raw)) {
+  if (!isRecord8(raw)) {
     return ok(base);
   }
-  const embeddedInference = isRecord7(raw.inference) ? raw.inference : null;
+  const embeddedInference = isRecord8(raw.inference) ? raw.inference : null;
   const standaloneInference = embeddedInference ? null : hasStandaloneRoutingShape(raw) ? raw : null;
   const routingRaw = embeddedInference ?? standaloneInference;
   if (!routingRaw) {
     return ok(base);
   }
   const accounts = { ...base.accounts };
-  if (isRecord7(routingRaw.accounts)) {
+  if (isRecord8(routingRaw.accounts)) {
     for (const [accountId, accountRaw] of Object.entries(routingRaw.accounts)) {
       const parsed = parseAccountConfig(accountRaw);
       if (parsed)
@@ -17140,7 +17267,7 @@ function parseRoutingConfig(raw, legacyConfig) {
     }
   }
   const targets = { ...base.targets };
-  const targetsRaw = isRecord7(routingRaw.targets) ? routingRaw.targets : isRecord7(routingRaw.providers) ? routingRaw.providers : null;
+  const targetsRaw = isRecord8(routingRaw.targets) ? routingRaw.targets : isRecord8(routingRaw.providers) ? routingRaw.providers : null;
   if (targetsRaw) {
     for (const [targetId, targetRaw] of Object.entries(targetsRaw)) {
       const parsed = parseTargetConfig(targetRaw);
@@ -17149,7 +17276,7 @@ function parseRoutingConfig(raw, legacyConfig) {
     }
   }
   const policies = { ...base.policies };
-  if (isRecord7(routingRaw.policies)) {
+  if (isRecord8(routingRaw.policies)) {
     for (const [policyId, policyRaw] of Object.entries(routingRaw.policies)) {
       const parsed = parsePolicyConfig(policyRaw);
       if (parsed)
@@ -17157,8 +17284,8 @@ function parseRoutingConfig(raw, legacyConfig) {
     }
   }
   const taskClasses = { ...base.taskClasses };
-  if (isRecord7(routingRaw.taskClasses ?? routingRaw.task_classes)) {
-    const taskClassRaw = isRecord7(routingRaw.taskClasses) ? routingRaw.taskClasses : routingRaw.task_classes;
+  if (isRecord8(routingRaw.taskClasses ?? routingRaw.task_classes)) {
+    const taskClassRaw = isRecord8(routingRaw.taskClasses) ? routingRaw.taskClasses : routingRaw.task_classes;
     for (const [taskId, taskRaw] of Object.entries(taskClassRaw)) {
       const parsed = parseTaskClassConfig(taskRaw);
       if (parsed)
@@ -17166,7 +17293,7 @@ function parseRoutingConfig(raw, legacyConfig) {
     }
   }
   const agents = { ...base.agents };
-  if (isRecord7(routingRaw.agents)) {
+  if (isRecord8(routingRaw.agents)) {
     for (const [agentId, agentRaw] of Object.entries(routingRaw.agents)) {
       const parsed = parseAgentRoutingConfig(agentRaw);
       if (parsed)
@@ -17176,7 +17303,7 @@ function parseRoutingConfig(raw, legacyConfig) {
   const workloads = {
     ...base.workloads ?? {}
   };
-  if (isRecord7(routingRaw.workloads)) {
+  if (isRecord8(routingRaw.workloads)) {
     const defaultBinding = parseWorkloadBinding(routingRaw.workloads.default);
     const interactive = parseWorkloadBinding(routingRaw.workloads.interactive);
     const memoryExtraction = parseWorkloadBinding(routingRaw.workloads.memoryExtraction ?? routingRaw.workloads.memory_extraction);
@@ -17564,16 +17691,16 @@ function resolveRoutingDecision(config, request, runtimeSnapshot) {
   });
 }
 // src/pipeline-pause.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join16 } from "node:path";
 var PIPELINE_CONFIG_FILES = ["agent.yaml", "AGENT.yaml", "config.yaml"];
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function findPipelineConfigFile(dir) {
   for (const name of PIPELINE_CONFIG_FILES) {
-    const file = join15(dir, name);
-    if (existsSync15(file)) {
+    const file = join16(dir, name);
+    if (existsSync16(file)) {
       return file;
     }
   }
@@ -17584,15 +17711,15 @@ function readCfg(dir) {
   if (file === null) {
     return { file: null, cfg: null };
   }
-  const parsed = parseSimpleYaml(readFileSync11(file, "utf-8"));
-  return { file, cfg: isRecord8(parsed) ? parsed : {} };
+  const parsed = parseSimpleYaml(readFileSync12(file, "utf-8"));
+  return { file, cfg: isRecord9(parsed) ? parsed : {} };
 }
 function readMem(cfg) {
-  return isRecord8(cfg.memory) ? cfg.memory : null;
+  return isRecord9(cfg.memory) ? cfg.memory : null;
 }
 function readPipeline(cfg) {
   const mem = readMem(cfg);
-  return mem && isRecord8(mem.pipelineV2) ? mem.pipelineV2 : null;
+  return mem && isRecord9(mem.pipelineV2) ? mem.pipelineV2 : null;
 }
 function readPipelineConfigData(dir) {
   const { cfg: root, file } = readCfg(dir);
@@ -17627,7 +17754,7 @@ function setPipelinePaused(dir, paused) {
   const nextP2 = { ...pipeline ?? {}, paused };
   const nextMem = { ...memory ?? {}, pipelineV2: nextP2 };
   const next = { ...root, memory: nextMem };
-  writeFileSync9(file, formatYaml(next));
+  writeFileSync10(file, formatYaml(next));
   return {
     file,
     exists: true,
@@ -17637,12 +17764,12 @@ function setPipelinePaused(dir, paused) {
 }
 // src/package-manager.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync12 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join17 } from "node:path";
 
 // src/package-manager-path.ts
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir9 } from "node:os";
 import { posix, win32 } from "node:path";
 function normalizeExecutablePath(path, platform3) {
   const normalized = (platform3 === "win32" ? win32 : posix).resolve(path).replaceAll("\\", "/");
@@ -17657,7 +17784,7 @@ function inferPackageManagerFromExecutable(executablePath, options = {}) {
   if (!executablePath)
     return null;
   const env = options.env ?? process.env;
-  const home2 = options.home ?? homedir8();
+  const home2 = options.home ?? homedir9();
   const platform3 = options.platform ?? process.platform;
   const pathApi = platform3 === "win32" ? win32 : posix;
   const candidate = normalizeExecutablePath(executablePath, platform3);
@@ -17738,12 +17865,12 @@ function pickFirstAvailable(available, order) {
 function readConfiguredPackageManager(agentsDir) {
   if (!agentsDir)
     return null;
-  const configPaths = [join16(agentsDir, "agent.yaml"), join16(agentsDir, "AGENT.yaml"), join16(agentsDir, "config.yaml")];
+  const configPaths = [join17(agentsDir, "agent.yaml"), join17(agentsDir, "AGENT.yaml"), join17(agentsDir, "config.yaml")];
   for (const path of configPaths) {
-    if (!existsSync16(path))
+    if (!existsSync17(path))
       continue;
     try {
-      const yaml = parseSimpleYaml(readFileSync12(path, "utf-8"));
+      const yaml = parseSimpleYaml(readFileSync13(path, "utf-8"));
       const install = yaml.install;
       const source = install?.source;
       if (source === "fallback")
@@ -17855,8 +17982,8 @@ function resolveGlobalPackagePath(family, packageName) {
   try {
     switch (family) {
       case "bun": {
-        const bunGlobal = join16(process.env.BUN_INSTALL ?? join16(homedir9(), ".bun"), "install", "global", "node_modules", packageName);
-        if (existsSync16(bunGlobal))
+        const bunGlobal = join17(process.env.BUN_INSTALL ?? join17(homedir10(), ".bun"), "install", "global", "node_modules", packageName);
+        if (existsSync17(bunGlobal))
           return bunGlobal;
         return;
       }
@@ -17867,8 +17994,8 @@ function resolveGlobalPackagePath(family, packageName) {
           windowsHide: true
         });
         if (result.status === 0 && result.stdout.trim()) {
-          const candidate = join16(result.stdout.trim(), packageName);
-          if (existsSync16(candidate))
+          const candidate = join17(result.stdout.trim(), packageName);
+          if (existsSync17(candidate))
             return candidate;
         }
         return;
@@ -17880,8 +18007,8 @@ function resolveGlobalPackagePath(family, packageName) {
           windowsHide: true
         });
         if (result.status === 0 && result.stdout.trim()) {
-          const candidate = join16(result.stdout.trim(), packageName);
-          if (existsSync16(candidate))
+          const candidate = join17(result.stdout.trim(), packageName);
+          if (existsSync17(candidate))
             return candidate;
         }
         return;
@@ -17900,13 +18027,13 @@ function resolveGlobalPackagePath(family, packageName) {
             windowsHide: true
           });
           if (result.status === 0 && result.stdout.trim()) {
-            const candidate = join16(result.stdout.trim(), "node_modules", packageName);
-            if (existsSync16(candidate))
+            const candidate = join17(result.stdout.trim(), "node_modules", packageName);
+            if (existsSync17(candidate))
               return candidate;
           }
         } else {
-          const berryGlobal = join16(process.env.YARN_GLOBAL_FOLDER ?? join16(homedir9(), ".yarn", "berry", "global"), "node_modules", packageName);
-          if (existsSync16(berryGlobal))
+          const berryGlobal = join17(process.env.YARN_GLOBAL_FOLDER ?? join17(homedir10(), ".yarn", "berry", "global"), "node_modules", packageName);
+          if (existsSync17(berryGlobal))
             return berryGlobal;
         }
         return;
@@ -17929,8 +18056,8 @@ function getGlobalInstallCommand(family, packageName) {
   }
 }
 // src/signet-installation.ts
-import { existsSync as existsSync17, realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
+import { existsSync as existsSync18, realpathSync as realpathSync2 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
 import { posix as posix2, win32 as win322 } from "node:path";
 var PACKAGE_MANAGERS = ["npm", "pnpm", "bun", "yarn"];
 function safeRealpath(path, platform3, realpath) {
@@ -17976,10 +18103,10 @@ function packageManagerRemovalCommand(family) {
 }
 function detectSignetInstallations(options = {}) {
   const env = options.env ?? process.env;
-  const home2 = options.home ?? homedir10();
+  const home2 = options.home ?? homedir11();
   const platform3 = options.platform ?? process.platform;
   const activeExecutablePath = options.execPath ?? process.execPath;
-  const pathExists = options.exists ?? existsSync17;
+  const pathExists = options.exists ?? existsSync18;
   const realpath = options.realpath ?? realpathSync2;
   const activeRealPath = safeRealpath(activeExecutablePath, platform3, realpath);
   const signetDir = env.SIGNET_DIR?.trim();
@@ -18040,15 +18167,15 @@ function inactivePackageManagerInstallations(report) {
   return report.inactive.filter((installation) => PACKAGE_MANAGERS.includes(installation.method) && installation.removalCommand);
 }
 // src/ingest/index.ts
-import { existsSync as existsSync23, statSync as statSync10, readdirSync as readdirSync12 } from "fs";
-import { join as join21, extname as extname3, resolve as resolve6, basename as basename8 } from "path";
-import { readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync24, statSync as statSync11, readdirSync as readdirSync12 } from "fs";
+import { join as join22, extname as extname3, resolve as resolve7, basename as basename8 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
 
 // src/ingest/markdown-parser.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { basename as basename3 } from "path";
 function parseMarkdown(filePath) {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   return parseMarkdownContent(raw, basename3(filePath));
 }
 function parseMarkdownContent(content, title = null) {
@@ -18172,7 +18299,7 @@ function parseMarkdownContent(content, title = null) {
   };
 }
 function parseTxt(filePath) {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   const paragraphs = raw.split(/\n\n+/).filter((p) => p.trim().length > 0);
   const sections = paragraphs.map((para) => ({
     heading: null,
@@ -18191,7 +18318,7 @@ function parseTxt(filePath) {
   };
 }
 function parseCode(filePath) {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   const ext = filePath.split(".").pop() || "";
   const langMap = {
     ts: "typescript",
@@ -18242,7 +18369,7 @@ function parseCode(filePath) {
 }
 
 // src/ingest/pdf-parser.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 import { basename as basename4 } from "path";
 async function parsePdf(filePath) {
   let text;
@@ -18252,7 +18379,7 @@ async function parsePdf(filePath) {
     const pdfParseModule = "pdf-parse";
     const mod = await import(pdfParseModule);
     const { PDFParse } = mod;
-    const buffer = readFileSync14(filePath);
+    const buffer = readFileSync15(filePath);
     const parser = new PDFParse({ data: new Uint8Array(buffer) });
     try {
       const textResult = await parser.getText();
@@ -18382,8 +18509,8 @@ function isLikelyHeading(line) {
 }
 
 // src/ingest/slack-parser.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync9 } from "fs";
-import { join as join17, basename as basename5 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync16, readdirSync as readdirSync9 } from "fs";
+import { join as join18, basename as basename5 } from "path";
 
 // src/ingest/chat-utils.ts
 var TIME_GAP_MS = 30 * 60 * 1000;
@@ -18477,11 +18604,11 @@ function parseSlackExport(dirPath, options) {
 }
 function loadUsers(dirPath) {
   const usersMap = new Map;
-  const usersPath = join17(dirPath, "users.json");
-  if (!existsSync18(usersPath))
+  const usersPath = join18(dirPath, "users.json");
+  if (!existsSync19(usersPath))
     return usersMap;
   try {
-    const raw = JSON.parse(readFileSync15(usersPath, "utf-8"));
+    const raw = JSON.parse(readFileSync16(usersPath, "utf-8"));
     if (!Array.isArray(raw))
       return usersMap;
     const users_arr = raw.filter((u) => typeof u === "object" && u !== null && ("id" in u) && ("name" in u));
@@ -18494,11 +18621,11 @@ function loadUsers(dirPath) {
 }
 function loadChannels(dirPath) {
   const channelsMap = new Map;
-  const channelsPath = join17(dirPath, "channels.json");
-  if (!existsSync18(channelsPath))
+  const channelsPath = join18(dirPath, "channels.json");
+  if (!existsSync19(channelsPath))
     return channelsMap;
   try {
-    const raw = JSON.parse(readFileSync15(channelsPath, "utf-8"));
+    const raw = JSON.parse(readFileSync16(channelsPath, "utf-8"));
     if (!Array.isArray(raw))
       return channelsMap;
     const channels_arr = raw.filter((c) => typeof c === "object" && c !== null && ("id" in c) && ("name" in c));
@@ -18516,7 +18643,7 @@ function findChannelDirs(dirPath) {
       continue;
     if (entry.name.startsWith("."))
       continue;
-    const fullPath = join17(dirPath, entry.name);
+    const fullPath = join18(dirPath, entry.name);
     const files = readdirSync9(fullPath);
     if (files.some((f) => f.endsWith(".json"))) {
       dirs.push(fullPath);
@@ -18529,7 +18656,7 @@ function loadChannelMessages(channelDir) {
   const messages = [];
   for (const file of files) {
     try {
-      const raw = JSON.parse(readFileSync15(join17(channelDir, file), "utf-8"));
+      const raw = JSON.parse(readFileSync16(join18(channelDir, file), "utf-8"));
       if (Array.isArray(raw)) {
         messages.push(...raw);
       }
@@ -18653,8 +18780,8 @@ function resolveUserMentions(text, users) {
 }
 
 // src/ingest/discord-parser.ts
-import { readFileSync as readFileSync16, readdirSync as readdirSync10, statSync as statSync7 } from "fs";
-import { join as join18, extname } from "path";
+import { readFileSync as readFileSync17, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
+import { join as join19, extname } from "path";
 var SKIP_TYPES = new Set([
   "RecipientAdd",
   "RecipientRemove",
@@ -18675,7 +18802,7 @@ var SKIP_TYPES = new Set([
   "ApplicationCommand"
 ]);
 function parseDiscordExport(path, options) {
-  const stat = statSync7(path);
+  const stat = statSync8(path);
   const exports = [];
   if (stat.isFile() && extname(path).toLowerCase() === ".json") {
     const parsed = loadExportFile(path);
@@ -18684,7 +18811,7 @@ function parseDiscordExport(path, options) {
   } else if (stat.isDirectory()) {
     const files = readdirSync10(path).filter((f) => f.endsWith(".json")).sort();
     for (const file of files) {
-      const parsed = loadExportFile(join18(path, file));
+      const parsed = loadExportFile(join19(path, file));
       if (parsed)
         exports.push(parsed);
     }
@@ -18744,7 +18871,7 @@ function isDiscordMessageShape(m) {
 }
 function loadExportFile(filePath) {
   try {
-    const raw = JSON.parse(readFileSync16(filePath, "utf-8"));
+    const raw = JSON.parse(readFileSync17(filePath, "utf-8"));
     if (raw && Array.isArray(raw.messages) && (raw.messages.length === 0 || isDiscordMessageShape(raw.messages[0]))) {
       return raw;
     }
@@ -18879,19 +19006,19 @@ function threadToSection2(thread, channelName) {
 }
 
 // src/ingest/code-parser.ts
-import { existsSync as existsSync21, readFileSync as readFileSync17, readdirSync as readdirSync11, statSync as statSync8 } from "fs";
-import { join as join19, basename as basename7, extname as extname2, relative } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync18, readdirSync as readdirSync11, statSync as statSync9 } from "fs";
+import { join as join20, basename as basename7, extname as extname2, relative } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 
 // src/ingest/git-utils.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
 function findGit() {
   const isWindows = process.platform === "win32";
   if (!isWindows) {
     const candidates = ["/usr/bin/git", "/usr/local/bin/git", "/opt/homebrew/bin/git"];
     for (const candidate of candidates) {
-      if (existsSync20(candidate))
+      if (existsSync21(candidate))
         return candidate;
     }
   }
@@ -18903,7 +19030,7 @@ function findGit() {
       windowsHide: true
     });
     const path = result.trim().split(/\r?\n/)[0];
-    if (path && existsSync20(path))
+    if (path && existsSync21(path))
       return path;
   } catch {}
   return null;
@@ -19012,7 +19139,7 @@ function parseCodeRepository(repoPath, options) {
     sections.push(section);
     totalChars += section.content.length;
   }
-  if (includeGitLog && existsSync21(join19(repoPath, ".git"))) {
+  if (includeGitLog && existsSync22(join20(repoPath, ".git"))) {
     const gitSections = parseGitLog(repoPath, gitLogDepth);
     for (const section of gitSections) {
       sections.push(section);
@@ -19070,9 +19197,9 @@ function countExtensions(dirPath, counts, depth) {
       continue;
     if (SKIP_DIRS.has(name))
       continue;
-    const fullPath = join19(dirPath, name);
+    const fullPath = join20(dirPath, name);
     try {
-      const stat = statSync8(fullPath);
+      const stat = statSync9(fullPath);
       if (stat.isDirectory()) {
         countExtensions(fullPath, counts, depth + 1);
       } else if (stat.isFile()) {
@@ -19101,16 +19228,16 @@ function buildLanguageSection(languages) {
 function parseImportantFiles(repoPath) {
   const sections = [];
   for (const fileName of IMPORTANT_FILES) {
-    const filePath = join19(repoPath, fileName);
-    if (!existsSync21(filePath))
+    const filePath = join20(repoPath, fileName);
+    if (!existsSync22(filePath))
       continue;
     try {
-      const stat = statSync8(filePath);
+      const stat = statSync9(filePath);
       if (!stat.isFile())
         continue;
       if (stat.size > MAX_FILE_CHARS)
         continue;
-      const content = readFileSync17(filePath, "utf-8").slice(0, MAX_FILE_CHARS);
+      const content = readFileSync18(filePath, "utf-8").slice(0, MAX_FILE_CHARS);
       const lowerName = fileName.toLowerCase();
       if (lowerName.endsWith(".json")) {
         const section = parseJsonConfig(fileName, content);
@@ -19367,9 +19494,9 @@ function scanDefinitions(dirPath, extensions, depth) {
       continue;
     if (SKIP_DIRS.has(name))
       continue;
-    const fullPath = join19(dirPath, name);
+    const fullPath = join20(dirPath, name);
     try {
-      const stat = statSync8(fullPath);
+      const stat = statSync9(fullPath);
       if (stat.isDirectory()) {
         definitions.push(...scanDefinitions(fullPath, extensions, depth + 1));
       } else if (stat.isFile()) {
@@ -19378,7 +19505,7 @@ function scanDefinitions(dirPath, extensions, depth) {
           continue;
         if (stat.size > MAX_FILE_CHARS)
           continue;
-        const content = readFileSync17(fullPath, "utf-8");
+        const content = readFileSync18(fullPath, "utf-8");
         const fileDefs = extractDefinitions(fullPath, content, ext);
         definitions.push(...fileDefs);
       }
@@ -19515,13 +19642,13 @@ function groupDefinitionsByFile(definitions, repoPath) {
 }
 
 // src/ingest/entire-parser.ts
-import { existsSync as existsSync22 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { join as join21 } from "path";
 import { execFileSync as execFileSync4 } from "child_process";
 var ENTIRE_BRANCH = "entire/checkpoints/v1";
 var MAX_TRANSCRIPT_CHARS = 200000;
 function hasEntireBranch(repoPath) {
-  if (!existsSync22(join20(repoPath, ".git"))) {
+  if (!existsSync23(join21(repoPath, ".git"))) {
     return false;
   }
   try {
@@ -20496,10 +20623,10 @@ function parseExtractionResponse2(raw, minConfidence) {
 
 // src/ingest/provenance.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync18, statSync as statSync9 } from "fs";
+import { readFileSync as readFileSync19, statSync as statSync10 } from "fs";
 function computeFileHash(filePath) {
   try {
-    const content = readFileSync18(filePath);
+    const content = readFileSync19(filePath);
     return createHash2("sha256").update(content).digest("hex");
   } catch {
     return createHash2("sha256").update(filePath).digest("hex");
@@ -20623,9 +20750,9 @@ function isSlackExport(dirPath) {
       return false;
     }
     for (const entry of entries) {
-      const fullPath = join21(dirPath, entry);
+      const fullPath = join22(dirPath, entry);
       try {
-        if (statSync10(fullPath).isDirectory() && !entry.startsWith(".")) {
+        if (statSync11(fullPath).isDirectory() && !entry.startsWith(".")) {
           const subFiles = readdirSync12(fullPath);
           if (subFiles.some((f) => f.endsWith(".json")))
             return true;
@@ -20639,20 +20766,20 @@ function isSlackExport(dirPath) {
 }
 function isDiscordExport(filePath) {
   try {
-    const stat = statSync10(filePath);
+    const stat = statSync11(filePath);
     if (stat.isFile() && extname3(filePath).toLowerCase() === ".json") {
-      const raw = readFileSync19(filePath, "utf-8").slice(0, 4096);
+      const raw = readFileSync20(filePath, "utf-8").slice(0, 4096);
       return (raw.includes('"guild"') || raw.includes('"channel"')) && raw.includes('"messages"');
     }
     if (stat.isDirectory()) {
       const entries = readdirSync12(filePath);
       if (entries.includes("index.json")) {
-        const indexContent = readFileSync19(join21(filePath, "index.json"), "utf-8").slice(0, 2048);
+        const indexContent = readFileSync20(join22(filePath, "index.json"), "utf-8").slice(0, 2048);
         return indexContent.includes('"guild"') || indexContent.includes('"channel"');
       }
       const jsonFile = entries.find((f) => f.endsWith(".json"));
       if (jsonFile) {
-        const content = readFileSync19(join21(filePath, jsonFile), "utf-8").slice(0, 4096);
+        const content = readFileSync20(join22(filePath, jsonFile), "utf-8").slice(0, 4096);
         return (content.includes('"guild"') || content.includes('"channel"')) && content.includes('"messages"');
       }
     }
@@ -20662,14 +20789,14 @@ function isDiscordExport(filePath) {
   }
 }
 function isGitRepo(dirPath) {
-  return existsSync23(join21(dirPath, ".git"));
+  return existsSync24(join22(dirPath, ".git"));
 }
 function collectFiles(inputPath, forcedType) {
-  const absPath = resolve6(inputPath);
-  if (!existsSync23(absPath)) {
+  const absPath = resolve7(inputPath);
+  if (!existsSync24(absPath)) {
     throw new Error(`Path does not exist: ${absPath}`);
   }
-  const stat = statSync10(absPath);
+  const stat = statSync11(absPath);
   if (forcedType === "slack" || forcedType === "discord" || forcedType === "repo" || forcedType === "entire") {
     return [{ path: absPath, type: forcedType }];
   }
@@ -20703,7 +20830,7 @@ function collectDirectory(dirPath, forcedType) {
   const files = [];
   const entries = readdirSync12(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join21(dirPath, entry.name);
+    const fullPath = join22(dirPath, entry.name);
     if (entry.name.startsWith(".") || SKIP_FILES.has(entry.name))
       continue;
     if (entry.isDirectory()) {
@@ -20853,7 +20980,7 @@ async function ingestPath(inputPath, options = {}, provider, onProgress) {
 var MAX_INGEST_FILE_BYTES = 50 * 1024 * 1024;
 async function ingestSingleFile(filePath, fileType, provider, extractionOpts, options, onProgress) {
   try {
-    const fileStat = statSync10(filePath);
+    const fileStat = statSync11(filePath);
     if (fileStat.isFile() && fileStat.size > MAX_INGEST_FILE_BYTES) {
       const sizeMB = Math.round(fileStat.size / (1024 * 1024));
       console.warn(`[ingest] Skipping ${filePath}: file size ${sizeMB} MB exceeds ${MAX_INGEST_FILE_BYTES / (1024 * 1024)} MB limit`);
@@ -20983,6 +21110,7 @@ var DEFAULT_APP_SIZE = { w: 4, h: 3 };
 export {
   writeRegistry,
   writeGraphiqState,
+  writeConfiguredWorkspacePath,
   writeConfiguredPiAgentDir,
   writeConfiguredOhMyPiAgentDir,
   withHookRecallCompat,
@@ -21006,6 +21134,7 @@ export {
   saveSourcesConfig,
   runMigrations,
   resolveWorkspaceSourceRepoPath,
+  resolveWorkspacePath,
   resolveStartupIdentityFiles,
   resolveSpecialIdentityFiles,
   resolveSignetDaemonUrl,
@@ -21035,6 +21164,7 @@ export {
   readNetworkMode,
   readMemoriesFtsSql,
   readGraphiqState,
+  readConfiguredWorkspacePath,
   readConfiguredPiAgentDir,
   readConfiguredOhMyPiAgentDir,
   partitionRecallRows,
@@ -21053,6 +21183,7 @@ export {
   parseGitHubSettings,
   parseDiscordSettings,
   packageManagerRemovalCommand,
+  normalizeWorkspacePath,
   normalizeStructuredMemoryPayload,
   normalizeNetworkMode,
   normalizeAgentRosterEntry,
@@ -21092,6 +21223,7 @@ export {
   hasValidIdentity,
   hasSignetBlock,
   hasPendingMigrations,
+  getWorkspaceConfigPath,
   getSourcesConfigPath,
   getSkillsRunnerCommand,
   getPiConfigPath,
@@ -21127,6 +21259,7 @@ export {
   cosineSimilarity,
   compileLegacyRoutingConfig,
   collectExportData,
+  clearConfiguredWorkspacePath,
   clearConfiguredPiAgentDir,
   clearConfiguredOhMyPiAgentDir,
   chunkMarkdownHierarchically,
@@ -21142,6 +21275,7 @@ export {
   addObsidianSource,
   addGitHubSource,
   addDiscordSource,
+  WORKSPACE_ENV_KEYS,
   UNIFIED_SCHEMA,
   TASK_STATUSES,
   TASK_HARNESSES,