@signetai/core 0.219.5 → 0.220.0

package/dist/index.js

@@ -11532,13 +11532,74 @@ function emptyHookRecallResponse(query, extras) {
 }
 
 // src/database.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { arch, platform } from "node:process";
 import { fileURLToPath } from "node:url";
 
+// src/child-process.ts
+import {
+  execFile as nodeExecFile,
+  execFileSync as nodeExecFileSync,
+  execSync as nodeExecSync,
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync
+} from "node:child_process";
+import { promisify } from "node:util";
+function withWindowsHide(options) {
+  return {
+    ...options ?? {},
+    windowsHide: options?.windowsHide ?? true
+  };
+}
+function isOptions(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function withWindowsHideArgument(args, firstOptionIndex) {
+  const normalized = [...args];
+  const optionIndex = normalized.findIndex((value, index) => index >= firstOptionIndex && isOptions(value));
+  if (optionIndex >= 0) {
+    normalized[optionIndex] = withWindowsHide(normalized[optionIndex]);
+    return normalized;
+  }
+  const placeholderIndex = normalized.findIndex((value, index) => index >= firstOptionIndex && (value === undefined || value === null));
+  if (placeholderIndex >= 0) {
+    normalized[placeholderIndex] = withWindowsHide(undefined);
+    return normalized;
+  }
+  const callbackIndex = normalized.findIndex((value, index) => index >= firstOptionIndex && typeof value === "function");
+  normalized.splice(callbackIndex >= 0 ? callbackIndex : normalized.length, 0, { windowsHide: true });
+  return normalized;
+}
+function withSpawnDefaults(options) {
+  if (options?.shell !== undefined && options.shell !== false) {
+    throw new TypeError("spawnHidden does not allow shell execution");
+  }
+  return {
+    ...withWindowsHide(options),
+    shell: false
+  };
+}
+var spawnHidden = (command, argsOrOptions, options) => {
+  if (Array.isArray(argsOrOptions))
+    return nodeSpawn(command, argsOrOptions, withSpawnDefaults(options));
+  return nodeSpawn(command, withSpawnDefaults(options ?? argsOrOptions));
+};
+var spawnSyncHidden = (command, argsOrOptions, options) => {
+  if (Array.isArray(argsOrOptions))
+    return nodeSpawnSync(command, argsOrOptions, withSpawnDefaults(options));
+  return nodeSpawnSync(command, withSpawnDefaults(options ?? argsOrOptions));
+};
+var nodeExecFileAsync = promisify(nodeExecFile);
+var execFileHiddenImpl = (...args) => Reflect.apply(nodeExecFile, undefined, withWindowsHideArgument(args, 1));
+Object.defineProperty(execFileHiddenImpl, promisify.custom, {
+  value: (...args) => Reflect.apply(nodeExecFileAsync, undefined, withWindowsHideArgument(args, 1))
+});
+var execFileHidden = execFileHiddenImpl;
+var execSyncHidden = (...args) => Reflect.apply(nodeExecSync, undefined, withWindowsHideArgument(args, 1));
+var execFileSyncHidden = (...args) => Reflect.apply(nodeExecFileSync, undefined, withWindowsHideArgument(args, 1));
+
 // src/memory-content-safety.ts
 var MEMORY_CONTENT_SAFETY_POLICY_VERSION = "memory-content-safety-v1";
 var MEMORY_CONTENT_WITHHELD_NOTICE = "[memory content withheld by safety policy]";
@@ -18534,7 +18595,6 @@ with the error message above and your signetai version.`);
 }
 
 // src/sqlite-journal.ts
-import { execFileSync } from "node:child_process";
 import { statfsSync } from "node:fs";
 var NETWORK_FILESYSTEM_TYPES = new Set(["afpfs", "nfs", "smbfs", "webdav"]);
 function isNetworkFilesystem(filesystemType) {
@@ -18553,7 +18613,7 @@ function detectFilesystemType(path, opts) {
     }
   } catch {}
   try {
-    const output = opts?.statCommand?.(path) ?? execFileSync("/usr/bin/stat", ["-f", "%T", path], { encoding: "utf8" });
+    const output = opts?.statCommand?.(path) ?? execFileSyncHidden("/usr/bin/stat", ["-f", "%T", path], { encoding: "utf8" });
     const filesystemType = output.trim();
     return filesystemType.length > 0 ? filesystemType : null;
   } catch {
@@ -18594,10 +18654,9 @@ function findNpmGlobalRoot() {
     return cachedNpmGlobalRoot;
   try {
     const command = platform === "win32" ? "npm.cmd" : "npm";
-    const root = execFileSync2(command, ["root", "-g"], {
+    const root = execFileSyncHidden(command, ["root", "-g"], {
       encoding: "utf8",
-      timeout: 3000,
-      windowsHide: true
+      timeout: 3000
     }).trim();
     cachedNpmGlobalRoot = root || null;
   } catch {
@@ -19276,7 +19335,6 @@ class Signet {
   }
 }
 // src/secrets.ts
-import { execSync, spawn } from "node:child_process";
 import { randomBytes, randomUUID } from "node:crypto";
 import {
   chmodSync,
@@ -19297,7 +19355,6 @@ import { hostname } from "node:os";
 import { join as join4 } from "node:path";
 
 // src/secrets-keyring.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import { createRequire as createRequire2 } from "node:module";
 var SERVICE = "ai.signet.secrets";
@@ -19383,7 +19440,7 @@ function linuxKeyringAvailable() {
     };
   }
   try {
-    execFileSync3("busctl", ["--user", "status", "org.freedesktop.secrets"], {
+    execFileSyncHidden("busctl", ["--user", "status", "org.freedesktop.secrets"], {
       stdio: "ignore",
       timeout: 1000
     });
@@ -19499,7 +19556,7 @@ function resolveMachineId() {
       } catch {}
     }
     try {
-      const out = execSync("ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID | awk '{print $3}'", {
+      const out = execSyncHidden("ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID | awk '{print $3}'", {
         timeout: 2000
       }).toString().trim().replace(/"/g, "");
       if (out)
@@ -19507,10 +19564,9 @@ function resolveMachineId() {
     } catch {}
   } else {
     try {
-      const out = execSync('reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid', {
+      const out = execSyncHidden('reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid', {
         encoding: "utf-8",
-        timeout: 2000,
-        windowsHide: true
+        timeout: 2000
       });
       const match = out.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
       if (match?.[1])
@@ -20228,11 +20284,10 @@ async function execWithSecrets(command, secretRefs, options = {}) {
   });
   return new Promise((resolve2, reject) => {
     const useProcessGroup = process.platform !== "win32";
-    const proc = spawn(cmd[0], cmd.slice(1), {
+    const proc = spawnHidden(cmd[0], cmd.slice(1), {
       detached: useProcessGroup,
       env: { ...process.env, ...resolved },
-      stdio: "pipe",
-      windowsHide: true
+      stdio: "pipe"
     });
     const stdoutRedactor = createStreamingRedactor();
     const stderrRedactor = createStreamingRedactor();
@@ -22336,7 +22391,6 @@ function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // src/workspace-source-repo.ts
-import { spawn as spawn2, spawnSync } from "node:child_process";
 import { closeSync as closeSync3, existsSync as existsSync8, mkdirSync as mkdirSync5, openSync as openSync3, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join9, resolve as resolve4 } from "node:path";
 var SIGNET_SOURCE_CHECKOUT_DIRNAME = "signetai";
@@ -22483,11 +22537,10 @@ async function isGitAvailableAsync(timeoutMs) {
   return (await runGitAsync(["--version"], undefined, timeoutMs)).ok;
 }
 function runGit(args, cwd, timeoutMs) {
-  const result = spawnSync("git", args, {
+  const result = spawnSyncHidden("git", args, {
     cwd,
     encoding: "utf-8",
-    timeout: timeoutMs,
-    windowsHide: true
+    timeout: timeoutMs
   });
   return {
     ok: result.status === 0 && result.error === undefined,
@@ -22499,10 +22552,9 @@ function runGit(args, cwd, timeoutMs) {
 }
 async function runGitAsync(args, cwd, timeoutMs) {
   return await new Promise((resolve5) => {
-    const proc = spawn2("git", args, {
+    const proc = spawnHidden("git", args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true,
       detached: process.platform !== "win32"
     });
     let stdout = "";
@@ -24200,192 +24252,13 @@ function importRelations(db, relationsJsonl) {
   return { imported, errors };
 }
 // src/identity.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync11, readdirSync as readdirSync5, realpathSync, statSync as statSync7 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { dirname as dirname8, join as join13 } from "node:path";
-
-// src/oh-my-pi.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync9, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9, realpathSync, statSync as statSync7 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname6, join as join11, resolve as resolve6 } from "node:path";
-function readTrimmed(env, name) {
-  const raw = env[name];
-  if (typeof raw !== "string")
-    return null;
-  const trimmed = raw.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function normalizePath(pathValue) {
-  return resolve6(expandHome(pathValue.trim()));
-}
-function readConfigHome2(env) {
-  const configured = readTrimmed(env, "XDG_CONFIG_HOME");
-  return configured ? normalizePath(configured) : join11(homedir7(), ".config");
-}
-function getOhMyPiConfigPath(env = process.env) {
-  return join11(readConfigHome2(env), "signet", "oh-my-pi.json");
-}
-function readConfiguredOhMyPiAgentDir(env = process.env) {
-  const configPath = getOhMyPiConfigPath(env);
-  if (!existsSync11(configPath))
-    return null;
-  try {
-    const raw = JSON.parse(readFileSync9(configPath, "utf-8"));
-    if (typeof raw !== "object" || raw === null)
-      return null;
-    const agentDir = Reflect.get(raw, "agentDir");
-    return typeof agentDir === "string" && agentDir.trim().length > 0 ? normalizePath(agentDir) : null;
-  } catch {
-    return null;
-  }
-}
-function resolveOhMyPiAgentDir(env = process.env) {
-  const configured = readTrimmed(env, "PI_CODING_AGENT_DIR");
-  if (configured)
-    return normalizePath(configured);
-  return readConfiguredOhMyPiAgentDir(env) ?? join11(homedir7(), ".omp", "agent");
-}
-function resolveOhMyPiExtensionsDir(env = process.env) {
-  return join11(resolveOhMyPiAgentDir(env), "extensions");
-}
-function listOhMyPiAgentDirCandidates(env = process.env) {
-  const candidates = new Set;
-  const configured = readTrimmed(env, "PI_CODING_AGENT_DIR");
-  if (configured)
-    candidates.add(normalizePath(configured));
-  const persisted = readConfiguredOhMyPiAgentDir(env);
-  if (persisted)
-    candidates.add(persisted);
-  candidates.add(join11(homedir7(), ".omp", "agent"));
-  return Array.from(candidates);
-}
-function writeConfiguredOhMyPiAgentDir(pathValue, env = process.env) {
-  const agentDir = normalizePath(pathValue);
-  const configPath = getOhMyPiConfigPath(env);
-  if (readConfiguredOhMyPiAgentDir(env) === agentDir && existsSync11(configPath)) {
-    return configPath;
-  }
-  mkdirSync7(dirname6(configPath), { recursive: true });
-  const payload = {
-    version: 1,
-    agentDir,
-    updatedAt: new Date().toISOString()
-  };
-  writeFileSync6(configPath, `${JSON.stringify(payload, null, 2)}
-`);
-  return configPath;
-}
-function clearConfiguredOhMyPiAgentDir(env = process.env) {
-  const configPath = getOhMyPiConfigPath(env);
-  if (!existsSync11(configPath))
-    return;
-  try {
-    rmSync5(configPath, { force: true });
-  } catch {}
-}
-
-// src/pi.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync10, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { dirname as dirname7, join as join12, resolve as resolve7 } from "node:path";
-function readTrimmed2(env, name) {
-  const raw = env[name];
-  if (typeof raw !== "string")
-    return null;
-  const trimmed = raw.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function expandUserPath(pathValue) {
-  const trimmed = pathValue.trim();
-  if (trimmed === "~")
-    return homedir8();
-  if (trimmed.startsWith("~/"))
-    return join12(homedir8(), trimmed.slice(2));
-  if (trimmed.startsWith("~"))
-    return join12(homedir8(), trimmed.slice(1));
-  return trimmed;
-}
-function normalizePath2(pathValue) {
-  return resolve7(expandUserPath(pathValue));
-}
-function readConfigHome3(env) {
-  const configured = readTrimmed2(env, "XDG_CONFIG_HOME");
-  return configured ? normalizePath2(configured) : join12(homedir8(), ".config");
-}
-function getPiConfigPath(env = process.env) {
-  return join12(readConfigHome3(env), "signet", "pi.json");
-}
-function readConfiguredPiAgentDir(env = process.env) {
-  const configPath = getPiConfigPath(env);
-  if (!existsSync12(configPath))
-    return null;
-  try {
-    const raw = JSON.parse(readFileSync10(configPath, "utf-8"));
-    if (typeof raw !== "object" || raw === null)
-      return null;
-    const agentDir = Reflect.get(raw, "agentDir");
-    return typeof agentDir === "string" && agentDir.trim().length > 0 ? normalizePath2(agentDir) : null;
-  } catch {
-    return null;
-  }
-}
-function resolvePiAgentDir(env = process.env) {
-  const configured = readTrimmed2(env, "PI_CODING_AGENT_DIR");
-  if (configured)
-    return normalizePath2(configured);
-  return readConfiguredPiAgentDir(env) ?? join12(homedir8(), ".pi", "agent");
-}
-function resolvePiExtensionsDir(env = process.env) {
-  return join12(resolvePiAgentDir(env), "extensions");
-}
-function listPiAgentDirCandidates(env = process.env) {
-  const candidates = new Set;
-  const configured = readTrimmed2(env, "PI_CODING_AGENT_DIR");
-  if (configured)
-    candidates.add(normalizePath2(configured));
-  const persisted = readConfiguredPiAgentDir(env);
-  if (persisted)
-    candidates.add(persisted);
-  candidates.add(join12(homedir8(), ".pi", "agent"));
-  return Array.from(candidates);
-}
-function writeConfiguredPiAgentDir(pathValue, env = process.env) {
-  const agentDir = normalizePath2(pathValue);
-  const configPath = getPiConfigPath(env);
-  if (readConfiguredPiAgentDir(env) === agentDir && existsSync12(configPath)) {
-    return configPath;
-  }
-  mkdirSync8(dirname7(configPath), { recursive: true });
-  const payload = {
-    version: 1,
-    agentDir,
-    updatedAt: new Date().toISOString()
-  };
-  writeFileSync7(configPath, `${JSON.stringify(payload, null, 2)}
-`);
-  return configPath;
-}
-function clearConfiguredPiAgentDir(env = process.env) {
-  const configPath = getPiConfigPath(env);
-  if (!existsSync12(configPath))
-    return;
-  try {
-    rmSync6(configPath, { force: true });
-  } catch {}
-}
-
-// src/identity.ts
-var OH_MY_PI_MANAGED_EXTENSION_FILENAME = "signet-oh-my-pi.js";
-var OH_MY_PI_LEGACY_MANAGED_EXTENSION_FILENAME = "signet-oh-my-pi.mjs";
-var OH_MY_PI_MANAGED_MARKER = "SIGNET_MANAGED_OH_MY_PI_EXTENSION";
-var PI_MANAGED_EXTENSION_FILENAME = "signet-pi.js";
-var PI_LEGACY_MANAGED_EXTENSION_FILENAME = "signet-pi.mjs";
-var PI_MANAGED_MARKER = "SIGNET_MANAGED_PI_EXTENSION";
+import { dirname as dirname6, join as join11 } from "node:path";
 function resolveAgentBasePath(agentName, workspaceDir) {
   if (agentName === "default")
     return workspaceDir;
-  return join13(workspaceDir, "agents", agentName);
+  return join11(workspaceDir, "agents", agentName);
 }
 var IDENTITY_MODES = ["managed", "off"];
 var IDENTITY_FILES = {
@@ -24482,40 +24355,8 @@ var IDENTITY_PRESETS = {
 };
 var REQUIRED_IDENTITY_KEYS = Object.entries(IDENTITY_FILES).filter(([, spec]) => !spec.optional).map(([key]) => key);
 var OPTIONAL_IDENTITY_KEYS = Object.entries(IDENTITY_FILES).filter(([, spec]) => spec.optional).map(([key]) => key);
-function isSignetManagedOhMyPiInstall() {
-  for (const agentDir of listOhMyPiAgentDirCandidates()) {
-    const extensionsDir = join13(agentDir, "extensions");
-    for (const filename of [OH_MY_PI_MANAGED_EXTENSION_FILENAME, OH_MY_PI_LEGACY_MANAGED_EXTENSION_FILENAME]) {
-      const extensionPath = join13(extensionsDir, filename);
-      if (!existsSync13(extensionPath))
-        continue;
-      try {
-        const content = readFileSync11(extensionPath, "utf8");
-        if (content.includes(OH_MY_PI_MANAGED_MARKER))
-          return true;
-      } catch {}
-    }
-  }
-  return false;
-}
-function isSignetManagedPiInstall() {
-  for (const agentDir of listPiAgentDirCandidates()) {
-    const extensionsDir = join13(agentDir, "extensions");
-    for (const filename of [PI_MANAGED_EXTENSION_FILENAME, PI_LEGACY_MANAGED_EXTENSION_FILENAME]) {
-      const extensionPath = join13(extensionsDir, filename);
-      if (!existsSync13(extensionPath))
-        continue;
-      try {
-        const content = readFileSync11(extensionPath, "utf8");
-        if (content.includes(PI_MANAGED_MARKER))
-          return true;
-      } catch {}
-    }
-  }
-  return false;
-}
 function userHome() {
-  return process.env.HOME?.trim() || homedir9();
+  return process.env.HOME?.trim() || homedir7();
 }
 function resolveKimiHomePath() {
   const currentOverride = process.env.KIMI_SHARE_DIR?.trim();
@@ -24524,22 +24365,18 @@ function resolveKimiHomePath() {
   const legacyOverride = process.env.KIMI_CODE_HOME?.trim();
   if (legacyOverride)
     return legacyOverride;
-  const currentHome = join13(userHome(), ".kimi");
-  const legacyHome = join13(userHome(), ".kimi-code");
-  if (existsSync13(currentHome))
+  const currentHome = join11(userHome(), ".kimi");
+  const legacyHome = join11(userHome(), ".kimi-code");
+  if (existsSync11(currentHome))
     return currentHome;
-  if (existsSync13(legacyHome))
+  if (existsSync11(legacyHome))
     return legacyHome;
   return currentHome;
 }
-function isBinaryOnPath(bin) {
-  const separator = process.platform === "win32" ? ";" : ":";
-  return (process.env.PATH ?? "").split(separator).some((directory) => directory.length > 0 && existsSync13(join13(directory, bin)));
-}
 var HERMES_PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function resolveHermesHomePath() {
   const hermesHome = process.env.HERMES_HOME?.trim();
-  return hermesHome || join13(userHome(), ".hermes");
+  return hermesHome || join11(userHome(), ".hermes");
 }
 function resolveHermesTarget(profile) {
   if (profile === undefined || profile === "") {
@@ -24551,7 +24388,7 @@ function resolveHermesTarget(profile) {
   return {
     kind: "profile",
     profile,
-    home: join13(resolveHermesHomePath(), "profiles", profile)
+    home: join11(resolveHermesHomePath(), "profiles", profile)
   };
 }
 function hermesAgentCandidateDirs() {
@@ -24559,96 +24396,53 @@ function hermesAgentCandidateDirs() {
   const hermesHome = resolveHermesHomePath();
   return [
     hermesHome,
-    join13(hermesHome, "hermes-agent"),
-    join13(home, "hermes-agent"),
-    join13(home, ".local", "share", "hermes-agent"),
-    join13(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 && existsSync13(join13(hermesRepo, "plugins", "memory"))) {
+  if (hermesRepo && existsSync11(join11(hermesRepo, "plugins", "memory"))) {
     return hermesRepo;
   }
   for (const base of hermesAgentCandidateDirs()) {
-    if (existsSync13(join13(base, "plugins", "memory")))
+    if (existsSync11(join11(base, "plugins", "memory")))
       return base;
   }
   try {
-    const hermesPath = execFileSync4("which", ["hermes"], {
+    const hermesPath = execFileSyncHidden("which", ["hermes"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 3000
     }).trim();
     if (hermesPath) {
-      const repoDir = dirname8(realpathSync(hermesPath));
-      if (existsSync13(join13(repoDir, "plugins", "memory")))
+      const repoDir = dirname6(realpathSync(hermesPath));
+      if (existsSync11(join11(repoDir, "plugins", "memory")))
         return repoDir;
     }
   } catch {}
   return null;
 }
 function resolveHermesRepoPluginPath() {
-  const pluginFile = join13("plugins", "memory", "signet", "__init__.py");
+  const pluginFile = join11("plugins", "memory", "signet", "__init__.py");
   const hermesRepo = resolveHermesRepoPath();
   if (hermesRepo !== null) {
-    const candidate = join13(hermesRepo, pluginFile);
-    if (existsSync13(candidate))
+    const candidate = join11(hermesRepo, pluginFile);
+    if (existsSync11(candidate))
       return candidate;
   }
   return null;
 }
-function detectExistingSetup(basePath) {
-  const identityFileNames = Object.values(IDENTITY_FILES).map((spec) => spec.path);
-  const foundFiles = [];
-  for (const fileName of identityFileNames) {
-    if (existsSync13(join13(basePath, fileName))) {
-      foundFiles.push(fileName);
-    }
-  }
-  const memoryDir = join13(basePath, "memory");
-  let memoryLogCount = 0;
-  if (existsSync13(memoryDir)) {
-    try {
-      const files = readdirSync5(memoryDir);
-      memoryLogCount = files.filter((f2) => f2.endsWith(".md") && !f2.startsWith("TEMPLATE")).length;
-    } catch {}
-  }
-  const home = homedir9();
-  return {
-    basePath,
-    agentsDir: existsSync13(basePath),
-    agentYaml: existsSync13(join13(basePath, "agent.yaml")),
-    agentsMd: existsSync13(join13(basePath, "AGENTS.md")),
-    configYaml: existsSync13(join13(basePath, "config.yaml")),
-    memoryDb: existsSync13(join13(basePath, "memory", "memories.db")),
-    identityFiles: foundFiles,
-    hasMemoryDir: existsSync13(memoryDir),
-    memoryLogCount,
-    hasClawdhub: existsSync13(join13(basePath, ".clawdhub", "lock.json")),
-    hasClaudeSkills: existsSync13(join13(home, ".claude", "skills")),
-    harnesses: {
-      claudeCode: existsSync13(join13(home, ".claude", "settings.json")),
-      openclaw: existsSync13(join13(home, ".openclaw", "openclaw.json")) || existsSync13(join13(home, ".clawdbot", "clawdbot.json")),
-      opencode: existsSync13(join13(home, ".config", "opencode", "config.json")),
-      forge: existsSync13(join13(home, ".forge", ".mcp.json")) || existsSync13(join13(home, "forge", ".mcp.json")) || existsSync13(join13(home, ".forge", ".forge.toml")) || existsSync13(join13(home, "forge", ".forge.toml")),
-      codex: existsSync13(join13(home, ".codex", "config.toml")) || existsSync13(join13(home, ".config", "signet", "bin", "codex")),
-      kimi: existsSync13(join13(resolveKimiHomePath(), "config.toml")) || existsSync13(join13(home, ".kimi-code", "config.toml")) || isBinaryOnPath("kimi"),
-      ohMyPi: isSignetManagedOhMyPiInstall() || existsSync13(resolveOhMyPiAgentDir()),
-      pi: isSignetManagedPiInstall() || existsSync13(resolvePiAgentDir()),
-      hermesAgent: resolveHermesRepoPath() !== null,
-      gemini: existsSync13(join13(home, ".gemini", "settings.json"))
-    }
-  };
-}
 async function loadIdentityFiles(basePath) {
   const result = {};
   for (const [key, spec] of Object.entries(IDENTITY_FILES)) {
-    const filePath = join13(basePath, spec.path);
-    if (existsSync13(filePath)) {
+    const filePath = join11(basePath, spec.path);
+    if (existsSync11(filePath)) {
       try {
-        const content = readFileSync11(filePath, "utf-8");
+        const content = readFileSync9(filePath, "utf-8");
         const stats = statSync7(filePath);
         result[key] = {
           path: spec.path,
@@ -24670,10 +24464,10 @@ async function loadIdentityFiles(basePath) {
 function loadIdentityFilesSync(basePath) {
   const result = {};
   for (const [key, spec] of Object.entries(IDENTITY_FILES)) {
-    const filePath = join13(basePath, spec.path);
-    if (existsSync13(filePath)) {
+    const filePath = join11(basePath, spec.path);
+    if (existsSync11(filePath)) {
       try {
-        const content = readFileSync11(filePath, "utf-8");
+        const content = readFileSync9(filePath, "utf-8");
         const stats = statSync7(filePath);
         result[key] = {
           path: spec.path,
@@ -24697,7 +24491,7 @@ function hasValidIdentity(basePath) {
   if (mode !== "managed")
     return true;
   for (const path of resolveRequiredIdentityPaths(basePath)) {
-    if (!existsSync13(join13(basePath, path))) {
+    if (!existsSync11(join11(basePath, path))) {
       return false;
     }
   }
@@ -24709,7 +24503,7 @@ function getMissingIdentityFiles(basePath) {
     return [];
   const missing = [];
   for (const path of resolveRequiredIdentityPaths(basePath)) {
-    if (!existsSync13(join13(basePath, path))) {
+    if (!existsSync11(join11(basePath, path))) {
       missing.push(path);
     }
   }
@@ -24717,11 +24511,11 @@ function getMissingIdentityFiles(basePath) {
 }
 function resolveRequiredIdentityPaths(basePath) {
   const legacyRequired = () => REQUIRED_IDENTITY_KEYS.map((key) => IDENTITY_FILES[key].path);
-  const agentYaml = join13(basePath, "agent.yaml");
-  if (!existsSync13(agentYaml))
+  const agentYaml = join11(basePath, "agent.yaml");
+  if (!existsSync11(agentYaml))
     return legacyRequired();
   try {
-    const config = parseSimpleYaml(readFileSync11(agentYaml, "utf-8"));
+    const config = parseSimpleYaml(readFileSync9(agentYaml, "utf-8"));
     const identity = readRecord(readRecord(config).identity);
     const configured = readIdentityEntryList(readRecord(identity.startup).load);
     if (configured.length > 0)
@@ -24778,11 +24572,11 @@ function resolveIdentityModeFromConfig(config) {
   return "managed";
 }
 function loadIdentityMode(agentsDir) {
-  const agentYaml = join13(agentsDir, "agent.yaml");
-  if (!existsSync13(agentYaml))
+  const agentYaml = join11(agentsDir, "agent.yaml");
+  if (!existsSync11(agentYaml))
     return "managed";
   try {
-    return resolveIdentityModeFromConfig(parseSimpleYaml(readFileSync11(agentYaml, "utf-8")));
+    return resolveIdentityModeFromConfig(parseSimpleYaml(readFileSync9(agentYaml, "utf-8")));
   } catch {
     return "managed";
   }
@@ -24833,11 +24627,11 @@ function identityHeaderFor(path, role) {
   return STATIC_HEADER_BY_FILE[filename] ?? role ?? filename.replace(/\.md$/i, "");
 }
 function resolveStartupIdentityFiles(agentsDir) {
-  const agentYaml = join13(agentsDir, "agent.yaml");
-  if (!existsSync13(agentYaml))
+  const agentYaml = join11(agentsDir, "agent.yaml");
+  if (!existsSync11(agentYaml))
     return STATIC_BUDGETS.map(({ file, budget }) => ({ path: file, budget }));
   try {
-    const config = parseSimpleYaml(readFileSync11(agentYaml, "utf-8"));
+    const config = parseSimpleYaml(readFileSync9(agentYaml, "utf-8"));
     if (!identityModeReadsFiles(resolveIdentityModeFromConfig(config)))
       return [];
     const identity = readRecord(config.identity);
@@ -24853,12 +24647,12 @@ function resolveStartupIdentityFiles(agentsDir) {
   return STATIC_BUDGETS.map(({ file, budget }) => ({ path: file, budget }));
 }
 function resolveSpecialIdentityFiles(agentsDir, kind) {
-  const agentYaml = join13(agentsDir, "agent.yaml");
-  if (!existsSync13(agentYaml)) {
+  const agentYaml = join11(agentsDir, "agent.yaml");
+  if (!existsSync11(agentYaml)) {
     return IDENTITY_PRESETS.minimal.special.filter((entry) => entry.kind === kind);
   }
   try {
-    const config = parseSimpleYaml(readFileSync11(agentYaml, "utf-8"));
+    const config = parseSimpleYaml(readFileSync9(agentYaml, "utf-8"));
     if (!identityModeReadsFiles(resolveIdentityModeFromConfig(config)))
       return [];
     const identity = readRecord(config.identity);
@@ -24895,17 +24689,17 @@ function resolvePromptSubmitTimeoutMs(raw) {
   return ms;
 }
 function readStaticIdentity(agentsDir, status = STATIC_IDENTITY_OFFLINE_STATUS) {
-  if (!existsSync13(agentsDir))
+  if (!existsSync11(agentsDir))
     return null;
   if (!identityModeReadsFiles(loadIdentityMode(agentsDir)))
     return null;
   const parts = [];
   for (const entry of resolveStartupIdentityFiles(agentsDir)) {
-    const path = join13(agentsDir, entry.path);
-    if (!existsSync13(path))
+    const path = join11(agentsDir, entry.path);
+    if (!existsSync11(path))
       continue;
     try {
-      const raw = readFileSync11(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;
@@ -24940,8 +24734,8 @@ function summarizeIdentity(identity) {
 `);
 }
 // src/agents.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readdirSync as readdirSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join12 } from "node:path";
 function resolveAgentMemoryPolicy(readPolicy, policyGroup) {
   if (readPolicy !== "isolated" && readPolicy !== "shared" && readPolicy !== "group") {
     throw new Error("memory must be one of: isolated, shared, group");
@@ -24966,37 +24760,37 @@ var IDENTITY_FILES2 = [
   "BOOTSTRAP.md"
 ];
 function discoverAgents(agentsDir) {
-  const root = join14(agentsDir, "agents");
-  if (!existsSync14(root))
+  const root = join12(agentsDir, "agents");
+  if (!existsSync12(root))
     return [];
-  return readdirSync6(root, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => ({ name: d2.name }));
+  return readdirSync5(root, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => ({ name: d2.name }));
 }
 function scaffoldAgent(name, agentsDir) {
-  const dir = join14(agentsDir, "agents", name);
-  if (!existsSync14(dir))
-    mkdirSync9(dir, { recursive: true });
-  const soul = join14(dir, "SOUL.md");
-  if (!existsSync14(soul))
-    writeFileSync8(soul, `# Soul
+  const dir = join12(agentsDir, "agents", name);
+  if (!existsSync12(dir))
+    mkdirSync7(dir, { recursive: true });
+  const soul = join12(dir, "SOUL.md");
+  if (!existsSync12(soul))
+    writeFileSync6(soul, `# Soul
 
 Add ${name}'s personality here.
 `);
-  const identity = join14(dir, "IDENTITY.md");
-  if (!existsSync14(identity))
-    writeFileSync8(identity, `# Identity
+  const identity = join12(dir, "IDENTITY.md");
+  if (!existsSync12(identity))
+    writeFileSync6(identity, `# Identity
 
 name: ${name}
 `);
 }
 function getAgentIdentityFiles(name, agentsDir) {
   const result = {};
-  const agentDir = join14(agentsDir, "agents", name);
+  const agentDir = join12(agentsDir, "agents", name);
   for (const file of IDENTITY_FILES2) {
-    const specific = join14(agentDir, file);
-    const fallback = join14(agentsDir, file);
-    if (existsSync14(specific))
+    const specific = join12(agentDir, file);
+    const fallback = join12(agentsDir, file);
+    if (existsSync12(specific))
       result[file] = specific;
-    else if (existsSync14(fallback))
+    else if (existsSync12(fallback))
       result[file] = fallback;
   }
   return result;
@@ -25044,13 +24838,13 @@ function resolveAgentSkills(agentDef, allSkills) {
   return allSkills.filter((s2) => allowed.has(s2));
 }
 // src/skills.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync12, readdirSync as readdirSync8, statSync as statSync8, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join16 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync10, readdirSync as readdirSync7, statSync as statSync8, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join14 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 
 // src/symlinks.ts
-import { existsSync as existsSync15, lstatSync, mkdirSync as mkdirSync10, readdirSync as readdirSync7, symlinkSync, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync13, lstatSync, mkdirSync as mkdirSync8, readdirSync as readdirSync6, symlinkSync, unlinkSync as unlinkSync2 } 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);
@@ -25061,19 +24855,19 @@ function symlinkSkills(sourceDir, targetDir, options = {}) {
     skipped: [],
     errors: []
   };
-  if (!existsSync15(sourceDir)) {
+  if (!existsSync13(sourceDir)) {
     return result;
   }
-  const targetParent = join15(targetDir, "..");
-  if (!existsSync15(targetParent)) {
-    mkdirSync10(targetParent, { recursive: true });
+  const targetParent = join13(targetDir, "..");
+  if (!existsSync13(targetParent)) {
+    mkdirSync8(targetParent, { recursive: true });
   }
-  if (!existsSync15(targetDir)) {
-    mkdirSync10(targetDir, { recursive: true });
+  if (!existsSync13(targetDir)) {
+    mkdirSync8(targetDir, { recursive: true });
   }
   let entries;
   try {
-    entries = readdirSync7(sourceDir);
+    entries = readdirSync6(sourceDir);
   } catch (e) {
     result.errors.push({
       path: sourceDir,
@@ -25082,8 +24876,8 @@ function symlinkSkills(sourceDir, targetDir, options = {}) {
     return result;
   }
   for (const entry of entries) {
-    const srcPath = join15(sourceDir, entry);
-    const destPath = join15(targetDir, entry);
+    const srcPath = join13(sourceDir, entry);
+    const destPath = join13(targetDir, entry);
     try {
       const src = lstatSync(srcPath);
       if (src.isSymbolicLink() || !src.isDirectory()) {
@@ -25125,10 +24919,10 @@ function symlinkSkills(sourceDir, targetDir, options = {}) {
   return result;
 }
 function symlinkDir(src, dest, options = {}) {
-  if (!existsSync15(src)) {
+  if (!existsSync13(src)) {
     return false;
   }
-  if (existsSync15(dest)) {
+  if (existsSync13(dest)) {
     try {
       const stat = lstatSync(dest);
       if (stat.isSymbolicLink()) {
@@ -25154,34 +24948,34 @@ function symlinkDir(src, dest, options = {}) {
 }
 
 // src/skills.ts
-var home = homedir10();
+var home = homedir8();
 function loadClawdhubLock(basePath) {
-  const lockPath = join16(basePath, ".clawdhub", "lock.json");
-  if (!existsSync16(lockPath)) {
+  const lockPath = join14(basePath, ".clawdhub", "lock.json");
+  if (!existsSync14(lockPath)) {
     return null;
   }
   try {
-    const content = readFileSync12(lockPath, "utf-8");
+    const content = readFileSync10(lockPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function symlinkClaudeSkills(basePath) {
-  const claudeSkillsDir = join16(home, ".claude", "skills");
-  const targetSkillsDir = join16(basePath, "skills");
-  if (!existsSync16(claudeSkillsDir)) {
+  const claudeSkillsDir = join14(home, ".claude", "skills");
+  const targetSkillsDir = join14(basePath, "skills");
+  if (!existsSync14(claudeSkillsDir)) {
     return { symlinked: 0, skills: [] };
   }
-  if (!existsSync16(targetSkillsDir)) {
-    mkdirSync11(targetSkillsDir, { recursive: true });
+  if (!existsSync14(targetSkillsDir)) {
+    mkdirSync9(targetSkillsDir, { recursive: true });
   }
   const symlinkedSkills = [];
   try {
-    const skills = readdirSync8(claudeSkillsDir);
+    const skills = readdirSync7(claudeSkillsDir);
     for (const skill of skills) {
-      const src = join16(claudeSkillsDir, skill);
-      const dest = join16(targetSkillsDir, skill);
+      const src = join14(claudeSkillsDir, skill);
+      const dest = join14(targetSkillsDir, skill);
       try {
         if (!statSync8(src).isDirectory())
           continue;
@@ -25196,12 +24990,12 @@ function symlinkClaudeSkills(basePath) {
   return { symlinked: symlinkedSkills.length, skills: symlinkedSkills };
 }
 function writeRegistry(basePath, registry) {
-  const skillsDir = join16(basePath, "skills");
-  const registryPath = join16(skillsDir, "registry.json");
-  if (!existsSync16(skillsDir)) {
-    mkdirSync11(skillsDir, { recursive: true });
+  const skillsDir = join14(basePath, "skills");
+  const registryPath = join14(skillsDir, "registry.json");
+  if (!existsSync14(skillsDir)) {
+    mkdirSync9(skillsDir, { recursive: true });
   }
-  writeFileSync9(registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  writeFileSync7(registryPath, JSON.stringify(registry, null, 2), "utf-8");
 }
 async function unifySkills(basePath, config = {}) {
   const registry = {
@@ -25215,7 +25009,7 @@ async function unifySkills(basePath, config = {}) {
   if (clawdhubLock) {
     registry.sources.push({
       type: "openclaw",
-      path: join16(basePath, ".clawdhub")
+      path: join14(basePath, ".clawdhub")
     });
     const skillsData = clawdhubLock.skills || clawdhubLock;
     for (const [name, data] of Object.entries(skillsData)) {
@@ -25237,10 +25031,10 @@ async function unifySkills(basePath, config = {}) {
     }
   }
   const claudeResult = symlinkClaudeSkills(basePath);
-  if (claudeResult.symlinked > 0 || existsSync16(join16(home, ".claude", "skills"))) {
+  if (claudeResult.symlinked > 0 || existsSync14(join14(home, ".claude", "skills"))) {
     registry.sources.push({
       type: "claude-code",
-      path: join16(home, ".claude", "skills")
+      path: join14(home, ".claude", "skills")
     });
     for (const skillName of claudeResult.skills) {
       if (!registry.skills[skillName]) {
@@ -25248,7 +25042,7 @@ async function unifySkills(basePath, config = {}) {
           name: skillName,
           source: "claude-code",
           symlinked: true,
-          path: join16(basePath, "skills", skillName)
+          path: join14(basePath, "skills", skillName)
         };
         symlinked++;
       } else {
@@ -25258,7 +25052,7 @@ async function unifySkills(basePath, config = {}) {
   }
   if (config.registries) {
     for (const reg of config.registries) {
-      if (!existsSync16(reg.path)) {
+      if (!existsSync14(reg.path)) {
         continue;
       }
       registry.sources.push({
@@ -25266,9 +25060,9 @@ async function unifySkills(basePath, config = {}) {
         path: reg.path
       });
       try {
-        const entries = readdirSync8(reg.path);
+        const entries = readdirSync7(reg.path);
         for (const entry of entries) {
-          const entryPath = join16(reg.path, entry);
+          const entryPath = join14(reg.path, entry);
           try {
             if (!statSync8(entryPath).isDirectory())
               continue;
@@ -25280,9 +25074,9 @@ async function unifySkills(basePath, config = {}) {
             continue;
           }
           if (reg.symlink) {
-            const targetPath = join16(basePath, "skills", entry);
-            if (!existsSync16(join16(basePath, "skills"))) {
-              mkdirSync11(join16(basePath, "skills"), { recursive: true });
+            const targetPath = join14(basePath, "skills", entry);
+            if (!existsSync14(join14(basePath, "skills"))) {
+              mkdirSync9(join14(basePath, "skills"), { recursive: true });
             }
             if (symlinkDir(entryPath, targetPath)) {
               registry.skills[entry] = {
@@ -25398,8 +25192,8 @@ function parseTranscriptSkills(content) {
   return { records, skipped };
 }
 // src/import.ts
-import { existsSync as existsSync17, readFileSync as readFileSync13, readdirSync as readdirSync9 } from "node:fs";
-import { join as join17 } 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);
@@ -25606,21 +25400,21 @@ function importMemoryLogs(basePath, db) {
     skipped: 0,
     errors: []
   };
-  const memoryDir = join17(basePath, "memory");
-  if (!existsSync17(memoryDir)) {
+  const memoryDir = join15(basePath, "memory");
+  if (!existsSync15(memoryDir)) {
     result.errors.push(`Memory directory not found: ${memoryDir}`);
     return result;
   }
   let files;
   try {
-    files = readdirSync9(memoryDir).filter((f2) => f2.endsWith(".md") && !f2.startsWith("TEMPLATE"));
+    files = readdirSync8(memoryDir).filter((f2) => f2.endsWith(".md") && !f2.startsWith("TEMPLATE"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     result.errors.push(`Failed to read memory directory: ${message}`);
     return result;
   }
   for (const file of files) {
-    const filePath = join17(memoryDir, file);
+    const filePath = join15(memoryDir, file);
     const date = extractDateFromFilename(file);
     if (!date) {
       result.skipped++;
@@ -25629,7 +25423,7 @@ function importMemoryLogs(basePath, db) {
     }
     let content;
     try {
-      content = readFileSync13(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}`);
@@ -26838,16 +26632,16 @@ function resolveRoutingDecision(config, request, runtimeSnapshot) {
   });
 }
 // src/pipeline-pause.ts
-import { existsSync as existsSync18, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join16 } from "node:path";
 var PIPELINE_CONFIG_FILES = ["agent.yaml", "AGENT.yaml", "config.yaml"];
 function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function findPipelineConfigFile(dir) {
   for (const name of PIPELINE_CONFIG_FILES) {
-    const file = join18(dir, name);
-    if (existsSync18(file)) {
+    const file = join16(dir, name);
+    if (existsSync16(file)) {
       return file;
     }
   }
@@ -26858,7 +26652,7 @@ function readCfg(dir) {
   if (file === null) {
     return { file: null, cfg: null };
   }
-  const parsed = parseSimpleYaml(readFileSync14(file, "utf-8"));
+  const parsed = parseSimpleYaml(readFileSync12(file, "utf-8"));
   return { file, cfg: isRecord10(parsed) ? parsed : {} };
 }
 function readMem(cfg) {
@@ -26901,7 +26695,7 @@ function setPipelinePaused(dir, paused) {
   const nextP2 = { ...pipeline ?? {}, paused };
   const nextMem = { ...memory ?? {}, pipelineV2: nextP2 };
   const next = { ...root, memory: nextMem };
-  writeFileSync10(file, formatYaml(next));
+  writeFileSync8(file, formatYaml(next));
   return {
     file,
     exists: true,
@@ -26910,13 +26704,12 @@ function setPipelinePaused(dir, paused) {
   };
 }
 // src/package-manager.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync19, readFileSync as readFileSync15 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { join as join19 } 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 homedir11 } 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("\\", "/");
@@ -26931,7 +26724,7 @@ function inferPackageManagerFromExecutable(executablePath, options = {}) {
   if (!executablePath)
     return null;
   const env = options.env ?? process.env;
-  const home2 = options.home ?? homedir11();
+  const home2 = options.home ?? homedir9();
   const platform3 = options.platform ?? process.platform;
   const pathApi = platform3 === "win32" ? win32 : posix;
   const candidate = normalizeExecutablePath(executablePath, platform3);
@@ -26988,7 +26781,7 @@ function parsePackageManagerUserAgent(userAgent) {
 }
 function defaultCommandExists(command) {
   try {
-    const result = spawnSync2(command, ["--version"], { stdio: "ignore", windowsHide: true });
+    const result = spawnSyncHidden(command, ["--version"], { stdio: "ignore" });
     return result.status === 0;
   } catch {
     return false;
@@ -27012,12 +26805,12 @@ function pickFirstAvailable(available, order) {
 function readConfiguredPackageManager(agentsDir) {
   if (!agentsDir)
     return null;
-  const configPaths = [join19(agentsDir, "agent.yaml"), join19(agentsDir, "AGENT.yaml"), join19(agentsDir, "config.yaml")];
+  const configPaths = [join17(agentsDir, "agent.yaml"), join17(agentsDir, "AGENT.yaml"), join17(agentsDir, "config.yaml")];
   for (const path of configPaths) {
-    if (!existsSync19(path))
+    if (!existsSync17(path))
       continue;
     try {
-      const yaml = parseSimpleYaml(readFileSync15(path, "utf-8"));
+      const yaml = parseSimpleYaml(readFileSync13(path, "utf-8"));
       const install = yaml.install;
       const source = install?.source;
       if (source === "fallback")
@@ -27043,7 +26836,7 @@ function resolvePrimaryPackageManager(options = {}) {
   if (!options.execPath && !inferFromPath(execPathForDetection)) {
     try {
       const locator = (options.platform ?? process.platform) === "win32" ? "where" : "which";
-      const result = spawnSync2(locator, ["signet"], { encoding: "utf-8", windowsHide: true });
+      const result = spawnSyncHidden(locator, ["signet"], { encoding: "utf-8" });
       if (result.status === 0 && result.stdout.trim()) {
         execPathForDetection = result.stdout.trim();
       }
@@ -27129,58 +26922,54 @@ function resolveGlobalPackagePath(family, packageName) {
   try {
     switch (family) {
       case "bun": {
-        const bunGlobal = join19(process.env.BUN_INSTALL ?? join19(homedir12(), ".bun"), "install", "global", "node_modules", packageName);
-        if (existsSync19(bunGlobal))
+        const bunGlobal = join17(process.env.BUN_INSTALL ?? join17(homedir10(), ".bun"), "install", "global", "node_modules", packageName);
+        if (existsSync17(bunGlobal))
           return bunGlobal;
         return;
       }
       case "npm": {
-        const result = spawnSync2("npm", ["root", "-g"], {
+        const result = spawnSyncHidden("npm", ["root", "-g"], {
           encoding: "utf-8",
-          timeout: 1e4,
-          windowsHide: true
+          timeout: 1e4
         });
         if (result.status === 0 && result.stdout.trim()) {
-          const candidate = join19(result.stdout.trim(), packageName);
-          if (existsSync19(candidate))
+          const candidate = join17(result.stdout.trim(), packageName);
+          if (existsSync17(candidate))
             return candidate;
         }
         return;
       }
       case "pnpm": {
-        const result = spawnSync2("pnpm", ["root", "-g"], {
+        const result = spawnSyncHidden("pnpm", ["root", "-g"], {
           encoding: "utf-8",
-          timeout: 1e4,
-          windowsHide: true
+          timeout: 1e4
         });
         if (result.status === 0 && result.stdout.trim()) {
-          const candidate = join19(result.stdout.trim(), packageName);
-          if (existsSync19(candidate))
+          const candidate = join17(result.stdout.trim(), packageName);
+          if (existsSync17(candidate))
             return candidate;
         }
         return;
       }
       case "yarn": {
-        const versionResult = spawnSync2("yarn", ["--version"], {
+        const versionResult = spawnSyncHidden("yarn", ["--version"], {
           encoding: "utf-8",
-          timeout: 5000,
-          windowsHide: true
+          timeout: 5000
         });
         const isClassic = versionResult.status === 0 && /^1\./.test(versionResult.stdout.trim());
         if (isClassic) {
-          const result = spawnSync2("yarn", ["global", "dir"], {
+          const result = spawnSyncHidden("yarn", ["global", "dir"], {
             encoding: "utf-8",
-            timeout: 1e4,
-            windowsHide: true
+            timeout: 1e4
           });
           if (result.status === 0 && result.stdout.trim()) {
-            const candidate = join19(result.stdout.trim(), "node_modules", packageName);
-            if (existsSync19(candidate))
+            const candidate = join17(result.stdout.trim(), "node_modules", packageName);
+            if (existsSync17(candidate))
               return candidate;
           }
         } else {
-          const berryGlobal = join19(process.env.YARN_GLOBAL_FOLDER ?? join19(homedir12(), ".yarn", "berry", "global"), "node_modules", packageName);
-          if (existsSync19(berryGlobal))
+          const berryGlobal = join17(process.env.YARN_GLOBAL_FOLDER ?? join17(homedir10(), ".yarn", "berry", "global"), "node_modules", packageName);
+          if (existsSync17(berryGlobal))
             return berryGlobal;
         }
         return;
@@ -27203,8 +26992,8 @@ function getGlobalInstallCommand(family, packageName) {
   }
 }
 // src/signet-installation.ts
-import { existsSync as existsSync20, realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir13 } 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) {
@@ -27263,10 +27052,10 @@ function packageManagerEntryPointRemovalCommand(path, platform3) {
 }
 function detectSignetInstallations(options = {}) {
   const env = options.env ?? process.env;
-  const home2 = options.home ?? homedir13();
+  const home2 = options.home ?? homedir11();
   const platform3 = options.platform ?? process.platform;
   const activeExecutablePath = options.execPath ?? process.execPath;
-  const pathExists = options.exists ?? existsSync20;
+  const pathExists = options.exists ?? existsSync18;
   const realpath = options.realpath ?? realpathSync2;
   const activeRealPath = safeRealpath(activeExecutablePath, platform3, realpath);
   const signetDir = env.SIGNET_DIR?.trim();
@@ -27356,8 +27145,6 @@ export {
   writeRegistry,
   writeGraphiqState,
   writeConfiguredWorkspacePath,
-  writeConfiguredPiAgentDir,
-  writeConfiguredOhMyPiAgentDir,
   wrapMemoryContext,
   withHookRecallCompat,
   vectorSearchWithMetadata,
@@ -27375,6 +27162,8 @@ export {
   stripSignetBlock,
   stripInternalMemoryContext,
   stringifyYamlDocument,
+  spawnSyncHidden,
+  spawnHidden,
   setSecretKeyringForTests,
   setSecretKeyringAdapterForTests,
   setSecretEventRecorder,
@@ -27400,10 +27189,6 @@ export {
   resolveRoutingDecision,
   resolvePromptSubmitTimeoutMs,
   resolvePrimaryPackageManager,
-  resolvePiExtensionsDir,
-  resolvePiAgentDir,
-  resolveOhMyPiExtensionsDir,
-  resolveOhMyPiAgentDir,
   resolveNetworkBinding,
   resolveLaunchdExecutable,
   resolveKimiHomePath,
@@ -27433,8 +27218,6 @@ export {
   readMemoriesFtsIndexRowCount,
   readGraphiqState,
   readConfiguredWorkspacePath,
-  readConfiguredPiAgentDir,
-  readConfiguredOhMyPiAgentDir,
   putLocalSecret,
   preflightWorkspace,
   partitionRecallRows,
@@ -27481,8 +27264,6 @@ export {
   loadIdentityFiles,
   loadConfiguredHarnesses,
   loadClawdhubLock,
-  listPiAgentDirCandidates,
-  listOhMyPiAgentDirCandidates,
   listLocalSecretNames,
   keywordSearch,
   isSynthesisProvider,
@@ -27511,8 +27292,6 @@ export {
   getSourcesConfigPath,
   getSkillsRunnerCommand,
   getSecretKeyring,
-  getPiConfigPath,
-  getOhMyPiConfigPath,
   getMissingIdentityFiles,
   getLocalSecretValue,
   getLocalSecretProviderHealth,
@@ -27532,6 +27311,9 @@ export {
   extractSignetBlock,
   expandHome,
   execWithSecrets,
+  execSyncHidden,
+  execFileSyncHidden,
+  execFileHidden,
   escapeMemoryContextForFence,
   ensureUnifiedSchema,
   ensureMigrationsTableSchema,
@@ -27543,7 +27325,6 @@ export {
   detectSignetInstallations,
   detectSchema,
   detectFilesystemType,
-  detectExistingSetup,
   detectAvailablePackageManagers,
   deleteLocalSecret,
   defaultPipelineModel,
@@ -27554,8 +27335,6 @@ export {
   composeApiUserContent,
   collectExportData,
   clearConfiguredWorkspacePath,
-  clearConfiguredPiAgentDir,
-  clearConfiguredOhMyPiAgentDir,
   chunkMarkdownHierarchically,
   chunkContent,
   buildSignetBlock,