volute 0.36.0 → 0.37.1

package/dist/chunk-LQ6Z4FXN.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-T2TP6ZC6.js";
+import {
+  voluteSystemDir
+} from "./chunk-2NHRJ3YO.js";
+
+// packages/daemon/src/lib/bridges/bridges.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+function bridgesPath() {
+  return resolve(voluteSystemDir(), "bridges.json");
+}
+function readBridgesConfig() {
+  const path = bridgesPath();
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    logger_default.error(
+      `bridges.json is corrupt or unreadable at ${path} \u2014 all bridges disabled`,
+      logger_default.errorData(err)
+    );
+    return {};
+  }
+}
+function writeBridgesConfig(config) {
+  writeFileSync(bridgesPath(), `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function getBridgeConfig(platform) {
+  const config = readBridgesConfig();
+  return config[platform] ?? null;
+}
+function setBridgeConfig(platform, bridge) {
+  const config = readBridgesConfig();
+  config[platform] = bridge;
+  writeBridgesConfig(config);
+}
+function removeBridgeConfig(platform) {
+  const config = readBridgesConfig();
+  delete config[platform];
+  writeBridgesConfig(config);
+}
+function setChannelMapping(platform, externalChannel, voluteChannel) {
+  const config = readBridgesConfig();
+  const bridge = config[platform];
+  if (!bridge) throw new Error(`Bridge not configured for ${platform}`);
+  bridge.channelMappings[externalChannel] = voluteChannel;
+  writeBridgesConfig(config);
+}
+function removeChannelMapping(platform, externalChannel) {
+  const config = readBridgesConfig();
+  const bridge = config[platform];
+  if (!bridge) return;
+  delete bridge.channelMappings[externalChannel];
+  writeBridgesConfig(config);
+}
+function resolveChannelMapping(platform, externalChannel) {
+  const bridge = getBridgeConfig(platform);
+  if (!bridge) return null;
+  return bridge.channelMappings[externalChannel] ?? null;
+}
+function findBridgeForChannel(voluteChannelName) {
+  const config = readBridgesConfig();
+  for (const [platform, bridge] of Object.entries(config)) {
+    if (!bridge.enabled) continue;
+    for (const [external, volute] of Object.entries(bridge.channelMappings)) {
+      if (volute === voluteChannelName) {
+        return { platform, externalChannel: external };
+      }
+    }
+  }
+  return null;
+}
+
+export {
+  readBridgesConfig,
+  getBridgeConfig,
+  setBridgeConfig,
+  removeBridgeConfig,
+  setChannelMapping,
+  removeChannelMapping,
+  resolveChannelMapping,
+  findBridgeForChannel
+};

package/dist/{chunk-N2AUHW4C.js → chunk-MQRS4J24.js}

@@ -5,13 +5,13 @@ import {
   pollHealthDown,
   readDaemonConfig,
   stopService
-} from "./chunk-DJT5Y4UF.js";
+} from "./chunk-TNZ5XQA4.js";
 import {
   command
 } from "./chunk-TXSA4Q3V.js";
 import {
   voluteSystemDir
-} from "./chunk-75AJ54GM.js";
+} from "./chunk-2NHRJ3YO.js";
 
 // src/commands/down.ts
 import { existsSync, readFileSync, unlinkSync } from "fs";

package/dist/{chunk-B35VNNSS.js → chunk-N42QMDID.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-T2TP6ZC6.js";
 import {
   getDb
-} from "./chunk-75AJ54GM.js";
+} from "./chunk-2NHRJ3YO.js";
 import {
   activity
-} from "./chunk-7PTQGPJY.js";
+} from "./chunk-CJ26DXZL.js";
 
 // packages/daemon/src/lib/events/activity-events.ts
 var subscribers = /* @__PURE__ */ new Set();

package/dist/{chunk-M5RYAA5I.js → chunk-ORNY3MZR.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import {
-  logger_default
-} from "./chunk-T2TP6ZC6.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-NUX47Y2V.js";
+} from "./chunk-A6FLW5XD.js";
+import {
+  logger_default
+} from "./chunk-T2TP6ZC6.js";
 
 // packages/daemon/src/lib/ai-service.ts
 import { complete, getEnvApiKey, getModel, getModels, getProviders } from "@mariozechner/pi-ai";

package/dist/{chunk-YDBAY3NA.js → chunk-PMMHVSCR.js}

@@ -2,7 +2,7 @@
 import {
   stateDir,
   voluteSystemDir
-} from "./chunk-75AJ54GM.js";
+} from "./chunk-2NHRJ3YO.js";
 
 // packages/daemon/src/lib/config/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-GBDVNPN2.js → chunk-QJGLTPAP.js}

@@ -1,24 +1,24 @@
 #!/usr/bin/env node
-import {
-  logger_default
-} from "./chunk-T2TP6ZC6.js";
 import {
   exec,
   gitExec
-} from "./chunk-PJ4IPTIN.js";
+} from "./chunk-3F7XK5Q7.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-NUX47Y2V.js";
+} from "./chunk-A6FLW5XD.js";
+import {
+  logger_default
+} from "./chunk-T2TP6ZC6.js";
 import {
   getDb,
   mindDir,
   readRegistry,
   voluteHome
-} from "./chunk-75AJ54GM.js";
+} from "./chunk-2NHRJ3YO.js";
 import {
   sharedSkills
-} from "./chunk-7PTQGPJY.js";
+} from "./chunk-CJ26DXZL.js";
 
 // packages/daemon/src/lib/skills.ts
 import { createHash } from "crypto";
@@ -46,7 +46,7 @@ async function initDefaultSkills() {
   const config = readGlobalConfig();
   let extensionSkills = [];
   try {
-    const { getExtensionStandardSkills } = await import("./extensions-OOSFVH7U.js");
+    const { getExtensionStandardSkills } = await import("./extensions-PCOXTHNM.js");
     extensionSkills = getExtensionStandardSkills();
   } catch (err) {
     logger_default.warn("failed to load extension standard skills during init", logger_default.errorData(err));

package/dist/{chunk-DQ7VBXAP.js → chunk-RUIVWCYY.js}

@@ -1,37 +1,16 @@
 #!/usr/bin/env node
+import {
+  loadMergedEnv
+} from "./chunk-PMMHVSCR.js";
 import {
   spiritDir
-} from "./chunk-6F3YNULE.js";
+} from "./chunk-4L2Q7IP5.js";
 import {
   hashSkillDir,
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-GBDVNPN2.js";
-import {
-  markIdle
-} from "./chunk-PY557GDR.js";
-import {
-  getOrCreateMindUser,
-  getOrCreateSystemUser,
-  getUser,
-  getUserByUsername,
-  syncMindProfile
-} from "./chunk-DMV5P2LU.js";
-import {
-  addMessage,
-  createChannel,
-  createConversation,
-  findDMConversation,
-  getChannelByName,
-  getParticipants,
-  joinChannel,
-  publish as publish2
-} from "./chunk-IIWF2IPD.js";
-import {
-  publish,
-  subscribe
-} from "./chunk-B35VNNSS.js";
+} from "./chunk-QJGLTPAP.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
@@ -39,37 +18,58 @@ import {
 import {
   isSandboxEnabled,
   wrapForSandbox
-} from "./chunk-BOLJUV77.js";
+} from "./chunk-KXXJYY62.js";
 import {
   extractTextContent,
   getRoutingConfig,
   resolveDeliveryMode,
   resolveRoute
-} from "./chunk-X2J7QUFH.js";
-import {
-  loadMergedEnv
-} from "./chunk-YDBAY3NA.js";
+} from "./chunk-7AZQFSOV.js";
 import {
-  aiCompleteUtility,
-  getAiConfig,
-  resolveApiKey
-} from "./chunk-M5RYAA5I.js";
-import {
-  logger_default
-} from "./chunk-T2TP6ZC6.js";
+  markIdle
+} from "./chunk-GVVVMZ4J.js";
 import {
   exec
-} from "./chunk-PJ4IPTIN.js";
+} from "./chunk-3F7XK5Q7.js";
 import {
   chownMindDir,
   isIsolationEnabled,
   mindUserName,
   wrapForIsolation
-} from "./chunk-L72WYMF7.js";
+} from "./chunk-SNW2NPP4.js";
+import {
+  getOrCreateMindUser,
+  getOrCreateSystemUser,
+  getUser,
+  getUserByUsername,
+  syncMindProfile
+} from "./chunk-UIM5NHPP.js";
+import {
+  aiCompleteUtility,
+  getAiConfig,
+  resolveApiKey
+} from "./chunk-ORNY3MZR.js";
 import {
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-NUX47Y2V.js";
+} from "./chunk-A6FLW5XD.js";
+import {
+  addMessage,
+  createChannel,
+  createConversation,
+  findDMConversation,
+  getChannelByName,
+  getParticipants,
+  joinChannel,
+  publish as publish2
+} from "./chunk-5DPRTREW.js";
+import {
+  publish,
+  subscribe
+} from "./chunk-N42QMDID.js";
+import {
+  logger_default
+} from "./chunk-T2TP6ZC6.js";
 import {
   findMind,
   getBaseName,
@@ -79,7 +79,7 @@ import {
   stateDir,
   voluteHome,
   voluteSystemDir
-} from "./chunk-75AJ54GM.js";
+} from "./chunk-2NHRJ3YO.js";
 import {
   activity,
   conversationParticipants,
@@ -90,7 +90,7 @@ import {
   systemPrompts,
   turns,
   users
-} from "./chunk-7PTQGPJY.js";
+} from "./chunk-CJ26DXZL.js";
 
 // packages/daemon/src/lib/delivery/message-delivery.ts
 import { and as and4, desc as desc2, eq as eq6, inArray as inArray3, sql as sql3 } from "drizzle-orm";
@@ -1534,12 +1534,47 @@ var MindManager = class {
       }
     }
     if (target.template === "codex") {
-      const ai = (await import("./ai-service-GSZWIETO.js")).getAiConfig();
-      const providerConfig = ai?.providers["openai-codex"];
-      if (providerConfig?.apiKey) {
-        env.OPENAI_API_KEY = providerConfig.apiKey;
-      } else if (process.env.OPENAI_API_KEY) {
-        env.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+      try {
+        const ai = getAiConfig();
+        const codexConfig = ai?.providers["openai-codex"];
+        if (codexConfig?.oauth) {
+          const codexDir = resolve(dir, ".mind", "codex");
+          mkdirSync(codexDir, { recursive: true });
+          env.CODEX_HOME = codexDir;
+          const authPath = resolve(codexDir, "auth.json");
+          writeFileSync2(
+            authPath,
+            JSON.stringify({
+              auth_mode: "chatgpt",
+              tokens: {
+                access_token: codexConfig.oauth.access,
+                refresh_token: codexConfig.oauth.refresh,
+                id_token: codexConfig.oauth.access
+              },
+              last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+            }),
+            { mode: 384 }
+          );
+          const configTomlPath = resolve(codexDir, "config.toml");
+          if (!existsSync3(configTomlPath)) {
+            writeFileSync2(configTomlPath, 'cli_auth_credentials_store = "file"\n');
+          }
+          if (isIsolationEnabled()) {
+            chownMindDir(codexDir, baseName);
+          }
+        } else {
+          const apiKey = await resolveApiKey("openai-codex");
+          if (apiKey) {
+            env.OPENAI_API_KEY = apiKey;
+          } else if (process.env.OPENAI_API_KEY) {
+            env.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+          }
+        }
+      } catch (err) {
+        mlog.error(`failed to resolve OpenAI API key for ${name}`, logger_default.errorData(err));
+        if (process.env.OPENAI_API_KEY) {
+          env.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+        }
       }
       const homeDir = resolve(dir, "home");
       const zshenvLines = Object.entries(env).filter(([k, v]) => k.startsWith("VOLUTE_") && v != null).map(([k, v]) => `export ${k}=${JSON.stringify(v)}`);
@@ -1734,7 +1769,7 @@ var MindManager = class {
       if (this.shuttingDown || this.stopping.has(name)) return;
       mlog.error(`mind ${name} exited with code ${code}`);
       try {
-        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-WAZWMFJT.js");
+        const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-PBOIEBJZ.js");
         const sleepState = getSleepManagerIfReady2()?.getState(name);
         if (sleepState?.sleeping) {
           mlog.info(`${name} is sleeping \u2014 skipping crash recovery`);
@@ -1747,15 +1782,15 @@ var MindManager = class {
         (err) => mlog.warn(`failed to clear turn state for ${name} after crash`, logger_default.errorData(err))
       );
       try {
-        const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-WTGIPBGY.js");
+        const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-3I7CA734.js");
         getDeliveryManager2().clearMindSessions(name);
       } catch (err) {
         if (!(err instanceof Error && err.message.includes("not initialized"))) {
           mlog.warn(`failed to clear delivery state for ${name} after crash`, logger_default.errorData(err));
         }
       }
-      import("./mind-activity-tracker-66UVYIFW.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
-      import("./activity-events-PWOGSMRL.js").then(
+      import("./mind-activity-tracker-42ENM32S.js").then(({ markIdle: markIdle2 }) => markIdle2(name)).catch((err) => mlog.warn(`failed to mark ${name} idle after crash`, logger_default.errorData(err)));
+      import("./activity-events-N6HCHU4P.js").then(
         ({ publish: publish4 }) => publish4({ type: "mind_stopped", mind: name, summary: `${name} crashed (exit ${code})` })
       ).catch((err) => mlog.warn(`failed to publish crash event for ${name}`, logger_default.errorData(err)));
       const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(name);
@@ -1806,13 +1841,19 @@ var MindManager = class {
       mlog.warn(`failed to clear turn state for ${name} on stop`, logger_default.errorData(err));
     }
     try {
-      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-WTGIPBGY.js");
+      const { getDeliveryManager: getDeliveryManager2 } = await import("./delivery-manager-3I7CA734.js");
       getDeliveryManager2().clearMindSessions(name);
     } catch (err) {
       if (!(err instanceof Error && err.message.includes("not initialized"))) {
         mlog.warn(`failed to clear delivery state for ${name} on stop`, logger_default.errorData(err));
       }
     }
+    try {
+      const { clearEchoTextCache } = await import("./echo-text-IWAQKNTC.js");
+      clearEchoTextCache(name);
+    } catch (err) {
+      mlog.debug(`failed to clear echo-text cache for ${name}`, logger_default.errorData(err));
+    }
     if (this.restartTracker.reset(name)) this.saveCrashAttempts();
     rmSync(mindPidPath(name), { force: true });
     if (!this.shuttingDown) {
@@ -2291,9 +2332,9 @@ function resolveSkillsDir(manifest) {
 }
 async function discoverBuiltinExtensions(disabledIds) {
   const builtins = [
-    { id: "notes", load: async () => (await import("./src-FQE4BHRG.js")).default },
-    { id: "pages", load: async () => (await import("./src-QEOLMAYC.js")).default },
-    { id: "plan", load: async () => (await import("./src-GW6FP6VL.js")).default }
+    { id: "notes", load: async () => (await import("./src-OYWRPLC6.js")).default },
+    { id: "pages", load: async () => (await import("./src-LT6ZBYYX.js")).default },
+    { id: "plan", load: async () => (await import("./src-O4PRLMKM.js")).default }
   ];
   const results = [];
   for (const { id, load } of builtins) {
@@ -2533,7 +2574,7 @@ async function installNpmExtension(pkg) {
     throw new Error(`Extension "${pkg}" is already installed`);
   }
   const dir = ensureExtensionsNpmDir();
-  const { exec: exec2 } = await import("./exec-X3C6ZZTQ.js");
+  const { exec: exec2 } = await import("./exec-ONYZEA5B.js");
   try {
     await exec2("npm", ["install", pkg], { cwd: dir });
   } catch (err) {
@@ -2554,7 +2595,7 @@ async function uninstallNpmExtension(pkg) {
   packages.splice(idx, 1);
   writeExtensionsConfig(packages);
   try {
-    const { exec: exec2 } = await import("./exec-X3C6ZZTQ.js");
+    const { exec: exec2 } = await import("./exec-ONYZEA5B.js");
     await exec2("npm", ["uninstall", pkg], { cwd: extensionsNpmDir() });
   } catch (err) {
     logger_default.warn(
@@ -3329,7 +3370,7 @@ async function wakeMind(name) {
 async function startSpiritFull(name) {
   const entry = await findMind(name);
   if (entry?.dir) {
-    const { registerMindDir } = await import("./delivery-router-VSULHXNH.js");
+    const { registerMindDir } = await import("./delivery-router-QTFEZ26O.js");
     registerMindDir(name, entry.dir);
   }
   await getMindManager().startMind(name);
@@ -3351,8 +3392,8 @@ async function stopSpiritFull(name) {
   }).catch((err) => logger_default.error("failed to publish spirit_stopped activity", logger_default.errorData(err)));
 }
 async function ensureCreatorDM(mindName, creatorUsername) {
-  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-YTQME4EV.js");
-  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-HH3CJD4E.js");
+  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-2QOOPMBX.js");
+  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-G6YRSABR.js");
   const mindUser = await getOrCreateMindUser2(mindName);
   const creatorUser = await getUserByUsername2(creatorUsername);
   if (!creatorUser) {
@@ -3696,7 +3737,7 @@ var SleepManager = class {
       const db = await getDb();
       const rows = await db.select().from(deliveryQueue).where(and2(eq4(deliveryQueue.mind, name), eq4(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return 0;
-      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-YORUXKDQ.js");
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-NWL7XEIX.js");
       const delivered = [];
       for (const row of rows) {
         try {
@@ -4606,7 +4647,7 @@ var DeliveryManager = class {
       `To accept this channel, add a routing rule for "${channel}" to your routes.json.`,
       `Messages are being held until a route is configured.`
     ].filter((line) => line !== null).join("\n");
-    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-2IFS5HCX.js");
+    const { sendSystemMessage: sendSystemMessage2 } = await import("./system-chat-7AIN3U5M.js");
     await sendSystemMessage2(mindName, notification);
   }
   async persistToQueue(mindName, session, payload, status = "pending") {
@@ -4662,7 +4703,7 @@ var DeliveryManager = class {
     const blocks = [];
     let sharpDefault = null;
     try {
-      const mod = await import("./lib-DYEZMGW7.js");
+      const mod = await import("sharp");
       sharpDefault = mod.default ?? mod;
     } catch (err) {
       const code = err.code;
@@ -4820,7 +4861,7 @@ async function recordOutbound(mind, channel, content, opts = {}) {
       type: "outbound",
       channel,
       content,
-      turn_id: null,
+      turn_id: opts.turnId ?? null,
       message_id: opts.messageId ?? null
     }).returning({ id: mindHistory.id });
     return result[0]?.id;
@@ -5129,7 +5170,7 @@ async function generateSystemReply(conversationId, mindName, message) {
     if (config.sleep.schedule?.wake) contextParts.push(`Wake cron: ${config.sleep.schedule.wake}`);
   }
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-WAZWMFJT.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-PBOIEBJZ.js");
     const sm = getSleepManagerIfReady2();
     if (sm) {
       const state = sm.getState(mindName);
@@ -5213,6 +5254,19 @@ export {
   readSystemsConfig,
   writeSystemsConfig,
   deleteSystemsConfig,
+  parseCommandArgs,
+  loadAllExtensions,
+  getLoadedExtensions,
+  getAllDiscoveredExtensions,
+  getAllDiscoveredExtensionsDetailed,
+  setExtensionEnabled,
+  installNpmExtension,
+  uninstallNpmExtension,
+  getExtensionStandardSkills,
+  notifyExtensionsDaemonStart,
+  notifyExtensionsDaemonStop,
+  notifyExtensionsMindStart,
+  notifyExtensionsMindStop,
   initMailPoller,
   Scheduler,
   initScheduler,
@@ -5240,18 +5294,5 @@ export {
   deliverMessage,
   ensureSystemChannel,
   joinSystemChannel,
-  announceToSystem,
-  parseCommandArgs,
-  loadAllExtensions,
-  getLoadedExtensions,
-  getAllDiscoveredExtensions,
-  getAllDiscoveredExtensionsDetailed,
-  setExtensionEnabled,
-  installNpmExtension,
-  uninstallNpmExtension,
-  getExtensionStandardSkills,
-  notifyExtensionsDaemonStart,
-  notifyExtensionsDaemonStop,
-  notifyExtensionsMindStart,
-  notifyExtensionsMindStop
+  announceToSystem
 };

package/dist/{chunk-L72WYMF7.js → chunk-SNW2NPP4.js}

@@ -2,7 +2,7 @@
 import {
   getBaseName,
   validateMindName
-} from "./chunk-75AJ54GM.js";
+} from "./chunk-2NHRJ3YO.js";
 
 // packages/daemon/src/lib/mind/isolation.ts
 import { execFileSync } from "child_process";

package/dist/chunk-SZJWC2GA.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import {
+  setBridgeConfig
+} from "./chunk-LQ6Z4FXN.js";
+import {
+  readEnv,
+  sharedEnvPath,
+  writeEnv
+} from "./chunk-PMMHVSCR.js";
+
+// packages/daemon/src/lib/template/import-utils.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { basename, resolve } from "path";
+function findOpenClawSession(workspaceDir) {
+  const ocAgentsDir = resolve(homedir(), ".openclaw/agents");
+  if (!existsSync(ocAgentsDir)) return void 0;
+  const matches = [];
+  try {
+    for (const entry of readdirSync(ocAgentsDir)) {
+      const sessionsDir = resolve(ocAgentsDir, entry, "sessions");
+      if (!existsSync(sessionsDir)) continue;
+      for (const file of readdirSync(sessionsDir)) {
+        if (!file.endsWith(".jsonl")) continue;
+        const fullPath = resolve(sessionsDir, file);
+        if (sessionMatchesWorkspace(fullPath, workspaceDir)) {
+          matches.push({ path: fullPath, mtime: statSync(fullPath).mtimeMs });
+        }
+      }
+    }
+  } catch (err) {
+    console.warn("Warning: error scanning OpenClaw sessions:", err);
+    return void 0;
+  }
+  if (matches.length === 0) return void 0;
+  matches.sort((a, b) => b.mtime - a.mtime);
+  console.log(`Found session: ${matches[0].path}`);
+  return matches[0].path;
+}
+function sessionMatchesWorkspace(sessionPath, workspaceDir) {
+  try {
+    const fd = readFileSync(sessionPath, "utf-8");
+    const firstLine = fd.slice(0, fd.indexOf("\n"));
+    const header = JSON.parse(firstLine);
+    return header.type === "session" && resolve(header.cwd) === resolve(workspaceDir);
+  } catch {
+    return false;
+  }
+}
+function importPiSession(sessionFile, mindDirPath) {
+  const homeDir = resolve(mindDirPath, "home");
+  const piSessionDir = resolve(mindDirPath, ".mind/pi-sessions/main");
+  mkdirSync(piSessionDir, { recursive: true });
+  const content = readFileSync(sessionFile, "utf-8");
+  const lines = content.trim().split("\n");
+  try {
+    const header = JSON.parse(lines[0]);
+    if (header.type === "session") {
+      header.cwd = homeDir;
+      lines[0] = JSON.stringify(header);
+    }
+  } catch {
+  }
+  const filename = basename(sessionFile);
+  const destPath = resolve(piSessionDir, filename);
+  writeFileSync(destPath, `${lines.join("\n")}
+`);
+  console.log(`Imported session (${lines.length} entries)`);
+}
+function importOpenClawConnectors(name, _mindDirPath) {
+  const configPath = resolve(homedir(), ".openclaw/openclaw.json");
+  if (!existsSync(configPath)) return;
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (err) {
+    console.warn("Warning: failed to parse openclaw.json:", err);
+    return;
+  }
+  const discord = config.channels?.discord;
+  if (!discord?.enabled || !discord.token) return;
+  const envPath = sharedEnvPath();
+  const env = readEnv(envPath);
+  if (!env.DISCORD_TOKEN) {
+    env.DISCORD_TOKEN = discord.token;
+    writeEnv(envPath, env);
+  }
+  const channelMappings = {};
+  if (discord.guilds) {
+    for (const guild of Object.values(discord.guilds)) {
+      if (!guild.channels) continue;
+      for (const [channelName, ch] of Object.entries(guild.channels)) {
+        if (ch.allow) {
+          channelMappings[channelName] = channelName;
+        }
+      }
+    }
+  }
+  setBridgeConfig("discord", {
+    enabled: true,
+    defaultMind: name,
+    channelMappings
+  });
+  console.log(`Imported Discord as system bridge (default mind: ${name})`);
+  if (Object.keys(channelMappings).length > 0) {
+    console.log(`Mapped channels: ${Object.keys(channelMappings).join(", ")}`);
+  }
+}
+function parseNameFromIdentity(identity) {
+  const match = identity.match(/\*\*Name:\*\*\s*(.+)/);
+  if (match) {
+    const raw = match[1].trim();
+    if (!raw || raw.startsWith("*") || raw.startsWith("(")) return void 0;
+    return raw.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9.-]/g, "");
+  }
+  return void 0;
+}
+
+export {
+  findOpenClawSession,
+  sessionMatchesWorkspace,
+  importPiSession,
+  importOpenClawConnectors,
+  parseNameFromIdentity
+};