@gguf/pigbot 0.0.6 → 0.0.7

package/dist/infra/outbound/outbound-session.js

@@ -68,6 +68,7 @@ function buildBaseSessionKey(params) {
     return buildAgentSessionKey({
         agentId: params.agentId,
         channel: params.channel,
+        accountId: params.accountId,
         peer: params.peer,
         dmScope: params.cfg.session?.dmScope ?? "main",
         identityLinks: params.cfg.session?.identityLinks,
@@ -147,6 +148,7 @@ async function resolveSlackSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "slack",
+        accountId: params.accountId,
         peer,
     });
     const threadId = normalizeThreadId(params.threadId ?? params.replyToId);
@@ -181,6 +183,7 @@ function resolveDiscordSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "discord",
+        accountId: params.accountId,
         peer,
     });
     const explicitThreadId = normalizeThreadId(params.threadId);
@@ -225,6 +228,7 @@ function resolveTelegramSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "telegram",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -250,6 +254,7 @@ function resolveWhatsAppSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "whatsapp",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -273,6 +278,7 @@ function resolveSignalSession(params) {
             cfg: params.cfg,
             agentId: params.agentId,
             channel: "signal",
+            accountId: params.accountId,
             peer,
         });
         return {
@@ -307,6 +313,7 @@ function resolveSignalSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "signal",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -329,6 +336,7 @@ function resolveIMessageSession(params) {
             cfg: params.cfg,
             agentId: params.agentId,
             channel: "imessage",
+            accountId: params.accountId,
             peer,
         });
         return {
@@ -352,6 +360,7 @@ function resolveIMessageSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "imessage",
+        accountId: params.accountId,
         peer,
     });
     const toPrefix = parsed.kind === "chat_id"
@@ -379,6 +388,7 @@ function resolveMatrixSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "matrix",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -410,6 +420,7 @@ function resolveMSTeamsSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "msteams",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -443,6 +454,7 @@ function resolveMattermostSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "mattermost",
+        accountId: params.accountId,
         peer,
     });
     const threadId = normalizeThreadId(params.replyToId ?? params.threadId);
@@ -484,6 +496,7 @@ function resolveBlueBubblesSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "bluebubbles",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -508,6 +521,7 @@ function resolveNextcloudTalkSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "nextcloud-talk",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -532,6 +546,7 @@ function resolveZaloSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "zalo",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -557,6 +572,7 @@ function resolveZalouserSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "zalouser",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -577,6 +593,7 @@ function resolveNostrSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "nostr",
+        accountId: params.accountId,
         peer,
     });
     return {
@@ -635,6 +652,7 @@ function resolveTlonSession(params) {
         cfg: params.cfg,
         agentId: params.agentId,
         channel: "tlon",
+        accountId: params.accountId,
         peer,
     });
     return {

package/dist/infra/outbound/targets.js

@@ -55,7 +55,7 @@ export function resolveOutboundTarget(params) {
     if (params.channel === INTERNAL_MESSAGE_CHANNEL) {
         return {
             ok: false,
-            error: new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("moltbot agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`),
+            error: new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("openclaw agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`),
         };
     }
     const plugin = getChannelPlugin(params.channel);

package/dist/infra/path-env.js

@@ -42,20 +42,20 @@ function candidateBinDirs(opts) {
     const homeDir = opts.homeDir ?? os.homedir();
     const platform = opts.platform ?? process.platform;
     const candidates = [];
-    // Bundled macOS app: `moltbot` lives next to the executable (process.execPath).
+    // Bundled macOS app: `openclaw` lives next to the executable (process.execPath).
     try {
         const execDir = path.dirname(execPath);
-        const siblingMoltbot = path.join(execDir, "moltbot");
-        if (isExecutable(siblingMoltbot))
+        const siblingCli = path.join(execDir, "openclaw");
+        if (isExecutable(siblingCli))
             candidates.push(execDir);
     }
     catch {
         // ignore
     }
-    // Project-local installs (best effort): if a `node_modules/.bin/moltbot` exists near cwd,
+    // Project-local installs (best effort): if a `node_modules/.bin/openclaw` exists near cwd,
     // include it. This helps when running under launchd or other minimal PATH environments.
     const localBinDir = path.join(cwd, "node_modules", ".bin");
-    if (isExecutable(path.join(localBinDir, "moltbot")))
+    if (isExecutable(path.join(localBinDir, "openclaw")))
         candidates.push(localBinDir);
     const miseDataDir = process.env.MISE_DATA_DIR ?? path.join(homeDir, ".local", "share", "mise");
     const miseShims = path.join(miseDataDir, "shims");
@@ -76,13 +76,14 @@ function candidateBinDirs(opts) {
     return candidates.filter(isDirectory);
 }
 /**
- * Best-effort PATH bootstrap so skills that require the `moltbot` CLI can run
+ * Best-effort PATH bootstrap so skills that require the `openclaw` CLI can run
  * under launchd/minimal environments (and inside the macOS app bundle).
  */
-export function ensureMoltbotCliOnPath(opts = {}) {
-    if (isTruthyEnvValue(process.env.CLAWDBOT_PATH_BOOTSTRAPPED))
+export function ensureOpenClawCliOnPath(opts = {}) {
+    if (isTruthyEnvValue(process.env.OPENCLAW_PATH_BOOTSTRAPPED)) {
         return;
-    process.env.CLAWDBOT_PATH_BOOTSTRAPPED = "1";
+    }
+    process.env.OPENCLAW_PATH_BOOTSTRAPPED = "1";
     const existing = opts.pathEnv ?? process.env.PATH ?? "";
     const prepend = candidateBinDirs(opts);
     if (prepend.length === 0)

package/dist/infra/ports-format.js

@@ -1,8 +1,9 @@
 import { formatCliCommand } from "../cli/command-format.js";
 export function classifyPortListener(listener, port) {
     const raw = `${listener.commandLine ?? ""} ${listener.command ?? ""}`.trim().toLowerCase();
-    if (raw.includes("moltbot"))
+    if (raw.includes("openclaw")) {
         return "gateway";
+    }
     if (raw.includes("ssh")) {
         const portToken = String(port);
         const tunnelPattern = new RegExp(`-(l|r)\\s*${portToken}\\b|-(l|r)${portToken}\\b|:${portToken}\\b`);
@@ -18,7 +19,7 @@ export function buildPortHints(listeners, port) {
     const kinds = new Set(listeners.map((listener) => classifyPortListener(listener, port)));
     const hints = [];
     if (kinds.has("gateway")) {
-        hints.push(`Gateway already running locally. Stop it (${formatCliCommand("moltbot gateway stop")}) or use a different port.`);
+        hints.push(`Gateway already running locally. Stop it (${formatCliCommand("openclaw gateway stop")}) or use a different port.`);
     }
     if (kinds.has("ssh")) {
         hints.push("SSH tunnel already bound to this port. Close the tunnel or use a different local port in -L.");

package/dist/infra/ports.js

@@ -52,8 +52,8 @@ export async function handlePortError(err, port, context, runtime = defaultRunti
         if (details) {
             runtime.error(info("Port listener details:"));
             runtime.error(details);
-            if (/moltbot|src\/index\.ts|dist\/index\.js/.test(details)) {
-                runtime.error(warn("It looks like another moltbot instance is already running. Stop it or pick a different port."));
+            if (/openclaw|src\/index\.ts|dist\/index\.js/.test(details)) {
+                runtime.error(warn("It looks like another OpenClaw instance is already running. Stop it or pick a different port."));
             }
         }
         runtime.error(info("Resolve by stopping the process using the port or passing --port <free-port>."));

package/dist/infra/provider-usage.auth.js

@@ -79,6 +79,33 @@ function resolveMinimaxApiKey() {
     }
     return undefined;
 }
+function resolveXiaomiApiKey() {
+    const envDirect = process.env.XIAOMI_API_KEY?.trim();
+    if (envDirect)
+        return envDirect;
+    const envResolved = resolveEnvApiKey("xiaomi");
+    if (envResolved?.apiKey)
+        return envResolved.apiKey;
+    const cfg = loadConfig();
+    const key = getCustomProviderApiKey(cfg, "xiaomi");
+    if (key)
+        return key;
+    const store = ensureAuthProfileStore();
+    const apiProfile = listProfilesForProvider(store, "xiaomi").find((id) => {
+        const cred = store.profiles[id];
+        return cred?.type === "api_key" || cred?.type === "token";
+    });
+    if (!apiProfile)
+        return undefined;
+    const cred = store.profiles[apiProfile];
+    if (cred?.type === "api_key" && cred.key?.trim()) {
+        return cred.key.trim();
+    }
+    if (cred?.type === "token" && cred.token?.trim()) {
+        return cred.token.trim();
+    }
+    return undefined;
+}
 async function resolveOAuthToken(params) {
     const cfg = loadConfig();
     const store = ensureAuthProfileStore(params.agentDir, {
@@ -175,6 +202,12 @@ export async function resolveProviderAuths(params) {
                 auths.push({ provider, token: apiKey });
             continue;
         }
+        if (provider === "xiaomi") {
+            const apiKey = resolveXiaomiApiKey();
+            if (apiKey)
+                auths.push({ provider, token: apiKey });
+            continue;
+        }
         if (!oauthProviders.includes(provider))
             continue;
         const auth = await resolveOAuthToken({

package/dist/infra/provider-usage.fetch.claude.js

@@ -62,7 +62,7 @@ export async function fetchClaudeUsage(token, timeoutMs, fetchFn) {
     const res = await fetchJson("https://api.anthropic.com/api/oauth/usage", {
         headers: {
             Authorization: `Bearer ${token}`,
-            "User-Agent": "moltbot",
+            "User-Agent": "openclaw",
             Accept: "application/json",
             "anthropic-version": "2023-06-01",
             "anthropic-beta": "oauth-2025-04-20",

package/dist/infra/provider-usage.fetch.minimax.js

@@ -260,7 +260,7 @@ export async function fetchMinimaxUsage(apiKey, timeoutMs, fetchFn) {
         headers: {
             Authorization: `Bearer ${apiKey}`,
             "Content-Type": "application/json",
-            "MM-API-Source": "Moltbot",
+            "MM-API-Source": "OpenClaw",
         },
     }, timeoutMs, fetchFn);
     if (!res.ok) {

package/dist/infra/provider-usage.load.js

@@ -31,6 +31,12 @@ export async function loadProviderUsageSummary(opts = {}) {
                 return await fetchCodexUsage(auth.token, auth.accountId, timeoutMs, fetchFn);
             case "minimax":
                 return await fetchMinimaxUsage(auth.token, timeoutMs, fetchFn);
+            case "xiaomi":
+                return {
+                    provider: "xiaomi",
+                    displayName: PROVIDER_LABELS.xiaomi,
+                    windows: [],
+                };
             case "zai":
                 return await fetchZaiUsage(auth.token, timeoutMs, fetchFn);
             default:

package/dist/infra/provider-usage.shared.js

@@ -7,6 +7,7 @@ export const PROVIDER_LABELS = {
     "google-antigravity": "Antigravity",
     minimax: "MiniMax",
     "openai-codex": "Codex",
+    xiaomi: "Xiaomi",
     zai: "z.ai",
 };
 export const usageProviders = [
@@ -16,6 +17,7 @@ export const usageProviders = [
     "google-antigravity",
     "minimax",
     "openai-codex",
+    "xiaomi",
     "zai",
 ];
 export function resolveUsageProviderId(provider) {

package/dist/infra/restart-sentinel.js

@@ -4,7 +4,7 @@ import { formatCliCommand } from "../cli/command-format.js";
 import { resolveStateDir } from "../config/paths.js";
 const SENTINEL_FILENAME = "restart-sentinel.json";
 export function formatDoctorNonInteractiveHint(env = process.env) {
-    return `Run: ${formatCliCommand("moltbot doctor --non-interactive", env)}`;
+    return `Run: ${formatCliCommand("openclaw doctor --non-interactive", env)}`;
 }
 export function resolveRestartSentinelPath(env = process.env) {
     return path.join(resolveStateDir(env), SENTINEL_FILENAME);

package/dist/infra/restart.js

@@ -71,14 +71,14 @@ function normalizeSystemdUnit(raw, profile) {
     }
     return unit.endsWith(".service") ? unit : `${unit}.service`;
 }
-export function triggerMoltbotRestart() {
+export function triggerOpenClawRestart() {
     if (process.env.VITEST || process.env.NODE_ENV === "test") {
         return { ok: true, method: "supervisor", detail: "test mode" };
     }
     const tried = [];
     if (process.platform !== "darwin") {
         if (process.platform === "linux") {
-            const unit = normalizeSystemdUnit(process.env.CLAWDBOT_SYSTEMD_UNIT, process.env.CLAWDBOT_PROFILE);
+            const unit = normalizeSystemdUnit(process.env.OPENCLAW_SYSTEMD_UNIT, process.env.OPENCLAW_PROFILE);
             const userArgs = ["--user", "restart", unit];
             tried.push(`systemctl ${userArgs.join(" ")}`);
             const userRestart = spawnSync("systemctl", userArgs, {
@@ -109,8 +109,8 @@ export function triggerMoltbotRestart() {
             detail: "unsupported platform restart",
         };
     }
-    const label = process.env.CLAWDBOT_LAUNCHD_LABEL ||
-        resolveGatewayLaunchAgentLabel(process.env.CLAWDBOT_PROFILE);
+    const label = process.env.OPENCLAW_LAUNCHD_LABEL ||
+        resolveGatewayLaunchAgentLabel(process.env.OPENCLAW_PROFILE);
     const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
     const target = uid !== undefined ? `gui/${uid}/${label}` : label;
     const args = ["kickstart", "-k", target];

package/dist/infra/runtime-guard.js

@@ -50,11 +50,11 @@ export function assertSupportedRuntime(runtime = defaultRuntime, details = detec
     const runtimeLabel = details.kind === "unknown" ? "unknown runtime" : `${details.kind} ${versionLabel}`;
     const execLabel = details.execPath ?? "unknown";
     runtime.error([
-        "moltbot requires Node >=22.0.0.",
+        "openclaw requires Node >=22.0.0.",
         `Detected: ${runtimeLabel} (exec: ${execLabel}).`,
         `PATH searched: ${details.pathEnv}`,
         "Install Node: https://nodejs.org/en/download",
-        "Upgrade Node and re-run moltbot.",
+        "Upgrade Node and re-run openclaw.",
     ].join("\n"));
     runtime.exit(1);
 }

package/dist/infra/shell-env.js

@@ -53,7 +53,7 @@ export function loadShellEnvFallback(opts) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.warn(`[moltbot] shell env fallback failed: ${msg}`);
+        logger.warn(`[openclaw] shell env fallback failed: ${msg}`);
         lastAppliedKeys = [];
         return { ok: false, error: msg, applied: [] };
     }
@@ -72,13 +72,13 @@ export function loadShellEnvFallback(opts) {
     return { ok: true, applied };
 }
 export function shouldEnableShellEnvFallback(env) {
-    return isTruthyEnvValue(env.CLAWDBOT_LOAD_SHELL_ENV);
+    return isTruthyEnvValue(env.OPENCLAW_LOAD_SHELL_ENV);
 }
 export function shouldDeferShellEnvFallback(env) {
-    return isTruthyEnvValue(env.CLAWDBOT_DEFER_SHELL_ENV_FALLBACK);
+    return isTruthyEnvValue(env.OPENCLAW_DEFER_SHELL_ENV_FALLBACK);
 }
 export function resolveShellEnvFallbackTimeoutMs(env) {
-    const raw = env.CLAWDBOT_SHELL_ENV_TIMEOUT_MS?.trim();
+    const raw = env.OPENCLAW_SHELL_ENV_TIMEOUT_MS?.trim();
     if (!raw)
         return DEFAULT_TIMEOUT_MS;
     const parsed = Number.parseInt(raw, 10);

package/dist/infra/ssh-config.js

@@ -48,7 +48,8 @@ export async function resolveSshConfig(target, opts = {}) {
         args.push("-i", opts.identity.trim());
     }
     const userHost = target.user ? `${target.user}@${target.host}` : target.host;
-    args.push(userHost);
+    // Use "--" so userHost can't be parsed as an ssh option.
+    args.push("--", userHost);
     return await new Promise((resolve) => {
         const child = spawn(sshPath, args, {
             stdio: ["ignore", "pipe", "ignore"],

package/dist/infra/ssh-tunnel.js

@@ -23,10 +23,16 @@ export function parseSshTarget(raw) {
         const port = Number.parseInt(portRaw, 10);
         if (!host || !Number.isFinite(port) || port <= 0)
             return null;
+        // Security: Reject hostnames starting with '-' to prevent argument injection
+        if (host.startsWith("-"))
+            return null;
         return { user: userPart, host, port };
     }
     if (!hostPart)
         return null;
+    // Security: Reject hostnames starting with '-' to prevent argument injection
+    if (hostPart.startsWith("-"))
+        return null;
     return { user: userPart, host: hostPart, port: 22 };
 }
 async function pickEphemeralPort() {
@@ -108,7 +114,8 @@ export async function startSshPortForward(opts) {
     if (opts.identity?.trim()) {
         args.push("-i", opts.identity.trim());
     }
-    args.push(userHost);
+    // Security: Use '--' to prevent userHost from being interpreted as an option
+    args.push("--", userHost);
     const stderr = [];
     const child = spawn("/usr/bin/ssh", args, {
         stdio: ["ignore", "ignore", "pipe"],

package/dist/infra/state-migrations.js

@@ -2,13 +2,14 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
-import { resolveOAuthDir, resolveStateDir } from "../config/paths.js";
+import { resolveLegacyStateDirs, resolveNewStateDir, resolveOAuthDir, resolveStateDir, } from "../config/paths.js";
 import { saveSessionStore } from "../config/sessions.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
 import { buildAgentMainSessionKey, DEFAULT_ACCOUNT_ID, DEFAULT_MAIN_KEY, normalizeAgentId, } from "../routing/session-key.js";
 import { canonicalizeMainSessionAlias } from "../config/sessions/main-session.js";
 import { ensureDir, existsDir, fileExists, isLegacyWhatsAppAuthFile, readSessionStoreJson5, safeReadDir, } from "./state-migrations.fs.js";
 let autoMigrateChecked = false;
+let autoMigrateStateDirChecked = false;
 function isSurfaceGroupKey(key) {
     return key.includes(":group:") || key.includes(":channel:");
 }
@@ -205,6 +206,149 @@ export function resetAutoMigrateLegacyStateForTest() {
 export function resetAutoMigrateLegacyAgentDirForTest() {
     resetAutoMigrateLegacyStateForTest();
 }
+export function resetAutoMigrateLegacyStateDirForTest() {
+    autoMigrateStateDirChecked = false;
+}
+function resolveSymlinkTarget(linkPath) {
+    try {
+        const target = fs.readlinkSync(linkPath);
+        return path.resolve(path.dirname(linkPath), target);
+    }
+    catch {
+        return null;
+    }
+}
+function formatStateDirMigration(legacyDir, targetDir) {
+    return `State dir: ${legacyDir} → ${targetDir} (legacy path now symlinked)`;
+}
+function isDirPath(filePath) {
+    try {
+        return fs.statSync(filePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function autoMigrateLegacyStateDir(params) {
+    if (autoMigrateStateDirChecked) {
+        return { migrated: false, skipped: true, changes: [], warnings: [] };
+    }
+    autoMigrateStateDirChecked = true;
+    const env = params.env ?? process.env;
+    if (env.OPENCLAW_STATE_DIR?.trim()) {
+        return { migrated: false, skipped: true, changes: [], warnings: [] };
+    }
+    const homedir = params.homedir ?? os.homedir;
+    const targetDir = resolveNewStateDir(homedir);
+    const legacyDirs = resolveLegacyStateDirs(homedir);
+    let legacyDir = legacyDirs.find((dir) => {
+        try {
+            return fs.existsSync(dir);
+        }
+        catch {
+            return false;
+        }
+    });
+    const warnings = [];
+    const changes = [];
+    let legacyStat = null;
+    try {
+        legacyStat = legacyDir ? fs.lstatSync(legacyDir) : null;
+    }
+    catch {
+        legacyStat = null;
+    }
+    if (!legacyStat) {
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    if (!legacyStat.isDirectory() && !legacyStat.isSymbolicLink()) {
+        warnings.push(`Legacy state path is not a directory: ${legacyDir}`);
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    let symlinkDepth = 0;
+    while (legacyStat.isSymbolicLink()) {
+        const legacyTarget = legacyDir ? resolveSymlinkTarget(legacyDir) : null;
+        if (!legacyTarget) {
+            warnings.push(`Legacy state dir is a symlink (${legacyDir ?? "unknown"}); could not resolve target.`);
+            return { migrated: false, skipped: false, changes, warnings };
+        }
+        if (path.resolve(legacyTarget) === path.resolve(targetDir)) {
+            return { migrated: false, skipped: false, changes, warnings };
+        }
+        if (legacyDirs.some((dir) => path.resolve(dir) === path.resolve(legacyTarget))) {
+            legacyDir = legacyTarget;
+            try {
+                legacyStat = fs.lstatSync(legacyDir);
+            }
+            catch {
+                legacyStat = null;
+            }
+            if (!legacyStat) {
+                warnings.push(`Legacy state dir missing after symlink resolution: ${legacyDir}`);
+                return { migrated: false, skipped: false, changes, warnings };
+            }
+            if (!legacyStat.isDirectory() && !legacyStat.isSymbolicLink()) {
+                warnings.push(`Legacy state path is not a directory: ${legacyDir}`);
+                return { migrated: false, skipped: false, changes, warnings };
+            }
+            symlinkDepth += 1;
+            if (symlinkDepth > 2) {
+                warnings.push(`Legacy state dir symlink chain too deep: ${legacyDir}`);
+                return { migrated: false, skipped: false, changes, warnings };
+            }
+            continue;
+        }
+        warnings.push(`Legacy state dir is a symlink (${legacyDir ?? "unknown"} → ${legacyTarget}); skipping auto-migration.`);
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    if (isDirPath(targetDir)) {
+        warnings.push(`State dir migration skipped: target already exists (${targetDir}). Remove or merge manually.`);
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    try {
+        if (!legacyDir)
+            throw new Error("Legacy state dir not found");
+        fs.renameSync(legacyDir, targetDir);
+    }
+    catch (err) {
+        warnings.push(`Failed to move legacy state dir (${legacyDir ?? "unknown"} → ${targetDir}): ${String(err)}`);
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    try {
+        if (!legacyDir)
+            throw new Error("Legacy state dir not found");
+        fs.symlinkSync(targetDir, legacyDir, "dir");
+        changes.push(formatStateDirMigration(legacyDir, targetDir));
+    }
+    catch (err) {
+        try {
+            if (process.platform === "win32") {
+                if (!legacyDir)
+                    throw new Error("Legacy state dir not found");
+                fs.symlinkSync(targetDir, legacyDir, "junction");
+                changes.push(formatStateDirMigration(legacyDir, targetDir));
+            }
+            else {
+                throw err;
+            }
+        }
+        catch (fallbackErr) {
+            try {
+                if (!legacyDir)
+                    throw new Error("Legacy state dir not found");
+                fs.renameSync(targetDir, legacyDir);
+                warnings.push(`State dir migration rolled back (failed to link legacy path): ${String(fallbackErr)}`);
+                return { migrated: false, skipped: false, changes: [], warnings };
+            }
+            catch (rollbackErr) {
+                warnings.push(`State dir moved but failed to link legacy path (${legacyDir ?? "unknown"} → ${targetDir}): ${String(fallbackErr)}`);
+                warnings.push(`Rollback failed; set OPENCLAW_STATE_DIR=${targetDir} to avoid split state: ${String(rollbackErr)}`);
+                changes.push(`State dir: ${legacyDir ?? "unknown"} → ${targetDir}`);
+            }
+        }
+    }
+    return { migrated: changes.length > 0, skipped: false, changes, warnings };
+}
 export async function detectLegacyStateMigrations(params) {
     const env = params.env ?? process.env;
     const homedir = params.homedir ?? os.homedir;
@@ -466,8 +610,18 @@ export async function autoMigrateLegacyState(params) {
     }
     autoMigrateChecked = true;
     const env = params.env ?? process.env;
-    if (env.CLAWDBOT_AGENT_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim()) {
-        return { migrated: false, skipped: true, changes: [], warnings: [] };
+    const stateDirResult = await autoMigrateLegacyStateDir({
+        env,
+        homedir: params.homedir,
+        log: params.log,
+    });
+    if (env.OPENCLAW_AGENT_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim()) {
+        return {
+            migrated: stateDirResult.migrated,
+            skipped: true,
+            changes: stateDirResult.changes,
+            warnings: stateDirResult.warnings,
+        };
     }
     const detected = await detectLegacyStateMigrations({
         cfg: params.cfg,
@@ -475,13 +629,18 @@ export async function autoMigrateLegacyState(params) {
         homedir: params.homedir,
     });
     if (!detected.sessions.hasLegacy && !detected.agentDir.hasLegacy) {
-        return { migrated: false, skipped: false, changes: [], warnings: [] };
+        return {
+            migrated: stateDirResult.migrated,
+            skipped: false,
+            changes: stateDirResult.changes,
+            warnings: stateDirResult.warnings,
+        };
     }
     const now = params.now ?? (() => Date.now());
     const sessions = await migrateLegacySessions(detected, now);
     const agentDir = await migrateLegacyAgentDir(detected, now);
-    const changes = [...sessions.changes, ...agentDir.changes];
-    const warnings = [...sessions.warnings, ...agentDir.warnings];
+    const changes = [...stateDirResult.changes, ...sessions.changes, ...agentDir.changes];
+    const warnings = [...stateDirResult.warnings, ...sessions.warnings, ...agentDir.warnings];
     const logger = params.log ?? createSubsystemLogger("state-migrations");
     if (changes.length > 0) {
         logger.info(`Auto-migrated legacy state:\n${changes.map((entry) => `- ${entry}`).join("\n")}`);

package/dist/infra/system-presence.js

@@ -33,7 +33,7 @@ function resolvePrimaryIPv4() {
 function initSelfPresence() {
     const host = os.hostname();
     const ip = resolvePrimaryIPv4() ?? undefined;
-    const version = process.env.CLAWDBOT_VERSION ?? process.env.npm_package_version ?? "unknown";
+    const version = process.env.OPENCLAW_VERSION ?? process.env.npm_package_version ?? "unknown";
     const modelIdentifier = (() => {
         const p = os.platform();
         if (p === "darwin") {