@intent-systems/nexus 2026.1.5-11

package/dist/commands/cursor-hooks.js

@@ -0,0 +1,240 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { resolveUserPath } from "../utils.js";
+const DEFAULT_SCRIPT_NAME = "nexus-session-start.js";
+const HOOK_SCRIPT = `#!/usr/bin/env node
+const { execFile } = require("child_process");
+const fs = require("fs");
+const fsp = require("fs/promises");
+const os = require("os");
+const path = require("path");
+
+const MAX_IDENTITY_CHARS = 120000;
+const MAX_MEMORY_CHARS = 120000;
+const MAX_DAILY_CHARS = 40000;
+const MAX_BOOTSTRAP_CHARS = 80000;
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+  });
+}
+
+function safeJsonParse(raw) {
+  if (!raw || !raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return \`\${year}-\${month}-\${day}\`;
+}
+
+function resolveWorkspaceRoot(payload) {
+  const roots = payload?.workspace_roots;
+  if (Array.isArray(roots) && roots.length > 0 && roots[0]) {
+    return roots[0];
+  }
+  if (process.env.NEXUS_ROOT?.trim()) return process.env.NEXUS_ROOT.trim();
+  const home = os.homedir();
+  if (home) return path.join(home, "nexus");
+  return process.cwd();
+}
+
+function resolveStateDir(workspaceRoot) {
+  if (process.env.NEXUS_STATE_DIR?.trim()) {
+    return process.env.NEXUS_STATE_DIR.trim();
+  }
+  return path.join(workspaceRoot, "state");
+}
+
+function execFileAsync(command, args, options) {
+  return new Promise((resolve) => {
+    execFile(command, args, options, (error, stdout, stderr) => {
+      resolve({ error, stdout, stderr });
+    });
+  });
+}
+
+async function runStatus(env, cwd) {
+  const result = await execFileAsync("nexus", ["status", "--json"], {
+    env,
+    cwd,
+  });
+  const parsed = safeJsonParse(result.stdout);
+  if (parsed) return parsed;
+  if (result.error && result.error.stdout) {
+    const fallback = safeJsonParse(result.error.stdout.toString());
+    if (fallback) return fallback;
+  }
+  return null;
+}
+
+async function readFileSnippet(filePath, limit) {
+  if (!filePath) return null;
+  try {
+    const content = await fsp.readFile(filePath, "utf8");
+    if (!content.trim()) return null;
+    if (content.length <= limit) return content.trim();
+    const slice = content.slice(-limit).trimStart();
+    return \`\${slice}\\n\\n[truncated]\`;
+  } catch {
+    return null;
+  }
+}
+
+function addSection(sections, title, body) {
+  if (!body) return;
+  sections.push(\`## \${title}\\n\${body}\`);
+}
+
+async function main() {
+  const input = await readStdin();
+  const payload = safeJsonParse(input) || {};
+  const workspaceRoot = resolveWorkspaceRoot(payload);
+  const stateDir = resolveStateDir(workspaceRoot);
+  const env = {
+    ...process.env,
+    NEXUS_ROOT: workspaceRoot,
+    NEXUS_STATE_DIR: stateDir,
+  };
+  const status = await runStatus(env, workspaceRoot);
+  const identity = status?.identity || null;
+  const agentId = identity?.agentId || process.env.NEXUS_AGENT_ID || "default";
+  const agentIdentityPath =
+    identity?.agentIdentityPath ||
+    path.join(stateDir, "agents", agentId, "IDENTITY.md");
+  const agentSoulPath =
+    identity?.agentSoulPath || path.join(stateDir, "agents", agentId, "SOUL.md");
+  const agentMemoryPath =
+    identity?.agentMemoryPath ||
+    path.join(stateDir, "agents", agentId, "MEMORY.md");
+  const userIdentityPath =
+    identity?.userIdentityPath || path.join(stateDir, "user", "IDENTITY.md");
+  const userProfilePath = path.join(stateDir, "user", "PROFILE.md");
+  const resolvedUserPath = fs.existsSync(userIdentityPath)
+    ? userIdentityPath
+    : fs.existsSync(userProfilePath)
+      ? userProfilePath
+      : userIdentityPath;
+
+  const sections = ["# Nexus Session Bootstrap"];
+  if (identity) {
+    const summary = [
+      \`Agent: \${identity.agentName || "(unknown)"} (\${identity.agentId})\`,
+      \`User: \${identity.userName || "(unknown)"}\`,
+      \`Agent ID: \${identity.agentId}\`,
+    ];
+    addSection(sections, "Status", summary.join("\\n"));
+  }
+
+  const bootstrapPath =
+    status?.identity?.bootstrapPath ||
+    path.join(stateDir, "agents", "BOOTSTRAP.md");
+  const hasIdentity =
+    typeof identity?.hasIdentity === "boolean"
+      ? identity.hasIdentity
+      : fs.existsSync(agentIdentityPath) && fs.existsSync(resolvedUserPath);
+  let bootstrapPrompt = status?.bootstrap?.prompt || null;
+  if (!bootstrapPrompt && !hasIdentity) {
+    bootstrapPrompt = await readFileSnippet(
+      bootstrapPath,
+      MAX_BOOTSTRAP_CHARS,
+    );
+  }
+  if (bootstrapPrompt) {
+    addSection(sections, "Bootstrap Prompt", bootstrapPrompt.trim());
+  }
+
+  const agentIdentity = await readFileSnippet(
+    agentIdentityPath,
+    MAX_IDENTITY_CHARS,
+  );
+  const agentSoul = await readFileSnippet(agentSoulPath, MAX_IDENTITY_CHARS);
+  const agentMemory = await readFileSnippet(agentMemoryPath, MAX_MEMORY_CHARS);
+  const userIdentity = await readFileSnippet(
+    resolvedUserPath,
+    MAX_IDENTITY_CHARS,
+  );
+
+  addSection(sections, "Agent Identity", agentIdentity);
+  addSection(sections, "Agent Soul", agentSoul);
+  addSection(sections, "Agent Memory", agentMemory);
+  addSection(sections, "User Identity", userIdentity);
+
+  const memoryDir = path.join(workspaceRoot, "home", "memory");
+  const today = formatDate(new Date());
+  const yesterday = formatDate(new Date(Date.now() - 86400000));
+  const todayLog = await readFileSnippet(
+    path.join(memoryDir, \`\${today}.md\`),
+    MAX_DAILY_CHARS,
+  );
+  const yesterdayLog = await readFileSnippet(
+    path.join(memoryDir, \`\${yesterday}.md\`),
+    MAX_DAILY_CHARS,
+  );
+
+  addSection(sections, \`Daily Memory (\${today})\`, todayLog);
+  addSection(sections, \`Daily Memory (\${yesterday})\`, yesterdayLog);
+
+  const additional = sections.join("\\n\\n").trim();
+  const output = { continue: true, additional_context: additional };
+  const envOut = {};
+  if (!process.env.NEXUS_ROOT?.trim() && workspaceRoot) {
+    envOut.NEXUS_ROOT = workspaceRoot;
+  }
+  if (!process.env.NEXUS_STATE_DIR?.trim() && stateDir) {
+    envOut.NEXUS_STATE_DIR = stateDir;
+  }
+  if (Object.keys(envOut).length > 0) {
+    output.env = envOut;
+  }
+  process.stdout.write(JSON.stringify(output) + "\\n");
+}
+
+main().catch(() => {
+  process.stdout.write(JSON.stringify({ continue: true }) + "\\n");
+});
+`;
+async function writeFileIfMissing(filePath, content) {
+    try {
+        await fsp.writeFile(filePath, content, { encoding: "utf-8", flag: "wx" });
+        return true;
+    }
+    catch (err) {
+        const anyErr = err;
+        if (anyErr.code === "EEXIST")
+            return false;
+        throw err;
+    }
+}
+export async function writeCursorHooks(options = {}) {
+    const workspaceDir = resolveUserPath(options.workspaceDir ?? process.cwd());
+    const hooksPath = options.hooksPath ?? path.join(workspaceDir, ".cursor", "hooks.json");
+    const scriptPath = options.scriptPath ??
+        path.join(workspaceDir, ".cursor", "hooks", DEFAULT_SCRIPT_NAME);
+    await fsp.mkdir(path.dirname(hooksPath), { recursive: true });
+    await fsp.mkdir(path.dirname(scriptPath), { recursive: true });
+    const hooksConfig = JSON.stringify({
+        version: 1,
+        hooks: {
+            sessionStart: [
+                { command: `node .cursor/hooks/${DEFAULT_SCRIPT_NAME}` },
+            ],
+        },
+    }, null, 2);
+    const hooksCreated = await writeFileIfMissing(hooksPath, `${hooksConfig}\n`);
+    const scriptCreated = await writeFileIfMissing(scriptPath, HOOK_SCRIPT);
+    return { hooksPath, scriptPath, hooksCreated, scriptCreated };
+}

package/dist/commands/cursor-rules.js

@@ -0,0 +1,56 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { defaultRuntime } from "../runtime.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR, WORKSPACE_SKILLS_DIR, resolveUserPath, } from "../utils.js";
+/**
+ * Generate and write `.cursor/rules` for a given workspace.
+ *
+ * Usage:
+ *   nexus cursor-rules [--workspace <path>]
+ */
+export async function cursorRulesCommand(opts, runtime = defaultRuntime) {
+    const workspaceDir = opts?.workspace?.trim() || NEXUS_ROOT;
+    const resolvedWorkspace = resolveUserPath(workspaceDir);
+    runtime.log(`Generating .cursor/rules for workspace: ${resolvedWorkspace}`);
+    const outputPath = await writeCursorRules({
+        workspaceDir: resolvedWorkspace,
+        outputPath: path.join(resolvedWorkspace, ".cursor", "rules"),
+        includeAgentsMd: true,
+        includeBootstrap: true,
+    });
+    runtime.log(`✓ Wrote ${outputPath}`);
+}
+/**
+ * Generate .cursor/rules content from Nexus skills and config
+ */
+export async function generateCursorRules(options = {}) {
+    const skillsDir = options.skillsDir || WORKSPACE_SKILLS_DIR;
+    const agentsPath = path.join(NEXUS_ROOT, "AGENTS.md");
+    const rules = `# Nexus Workspace - Cursor Configuration
+
+This workspace uses Nexus. Follow the root \`AGENTS.md\` file for all protocols.
+
+## Cursor-Specific
+
+- Run \`nexus status\` first
+- Cursor sessionStart hook injects identity context (see \`.cursor/hooks.json\`)
+- Use the Shell tool for \`nexus\` commands
+- Skill definitions live in \`${skillsDir}\`
+- Skill state and usage logs live in \`${SKILLS_STATE_DIR}\`
+- Read \`${agentsPath}\` for full instructions
+`;
+    return `${rules.trim()}\n`;
+}
+/**
+ * Write cursor rules to the specified output path
+ */
+export async function writeCursorRules(options = {}) {
+    const workspaceDir = options.workspaceDir || process.cwd();
+    const outputPath = options.outputPath || path.join(workspaceDir, ".cursor", "rules");
+    const rules = await generateCursorRules(options);
+    // Ensure .cursor directory exists
+    const cursorDir = path.dirname(outputPath);
+    await fsp.mkdir(cursorDir, { recursive: true });
+    await fsp.writeFile(outputPath, rules, "utf-8");
+    return outputPath;
+}

package/dist/commands/doctor-state-migrations.js

@@ -0,0 +1,358 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import JSON5 from "json5";
+import { resolveOAuthDir, resolveStateDir } from "../config/paths.js";
+import { saveSessionStore } from "../config/sessions.js";
+import { buildAgentMainSessionKey, DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, normalizeAgentId, } from "../routing/session-key.js";
+function safeReadDir(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function existsDir(dir) {
+    try {
+        return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function fileExists(p) {
+    try {
+        return fs.existsSync(p) && fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isLegacyWhatsAppAuthFile(name) {
+    if (name === "creds.json" || name === "creds.json.bak")
+        return true;
+    if (!name.endsWith(".json"))
+        return false;
+    return /^(app-state-sync|session|sender-key|pre-key)-/.test(name);
+}
+function readSessionStoreJson5(storePath) {
+    try {
+        const raw = fs.readFileSync(storePath, "utf-8");
+        const parsed = JSON5.parse(raw);
+        if (parsed && typeof parsed === "object") {
+            return { store: parsed, ok: true };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return { store: {}, ok: false };
+}
+function isSurfaceGroupKey(key) {
+    return key.includes(":group:") || key.includes(":channel:");
+}
+function isLegacyGroupKey(key) {
+    return key.startsWith("group:") || key.includes("@g.us");
+}
+function normalizeSessionKeyForAgent(key, agentId) {
+    const raw = key.trim();
+    if (!raw)
+        return raw;
+    if (raw.startsWith("agent:"))
+        return raw;
+    if (raw.toLowerCase().startsWith("subagent:")) {
+        const rest = raw.slice("subagent:".length);
+        return `agent:${normalizeAgentId(agentId)}:subagent:${rest}`;
+    }
+    if (isSurfaceGroupKey(raw)) {
+        return `agent:${normalizeAgentId(agentId)}:${raw}`;
+    }
+    return raw;
+}
+function pickLatestLegacyDirectEntry(store) {
+    let best = null;
+    let bestUpdated = -1;
+    for (const [key, entry] of Object.entries(store)) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const normalized = key.trim();
+        if (!normalized)
+            continue;
+        if (normalized === "global")
+            continue;
+        if (normalized.startsWith("agent:"))
+            continue;
+        if (normalized.toLowerCase().startsWith("subagent:"))
+            continue;
+        if (isLegacyGroupKey(normalized) || isSurfaceGroupKey(normalized))
+            continue;
+        const updatedAt = typeof entry.updatedAt === "number" ? entry.updatedAt : 0;
+        if (updatedAt > bestUpdated) {
+            bestUpdated = updatedAt;
+            best = entry;
+        }
+    }
+    return best;
+}
+function normalizeSessionEntry(entry) {
+    const sessionId = typeof entry.sessionId === "string" ? entry.sessionId : null;
+    if (!sessionId)
+        return null;
+    const updatedAt = typeof entry.updatedAt === "number" && Number.isFinite(entry.updatedAt)
+        ? entry.updatedAt
+        : Date.now();
+    return { ...entry, sessionId, updatedAt };
+}
+function emptyDirOrMissing(dir) {
+    if (!existsDir(dir))
+        return true;
+    return safeReadDir(dir).length === 0;
+}
+function removeDirIfEmpty(dir) {
+    if (!existsDir(dir))
+        return;
+    if (!emptyDirOrMissing(dir))
+        return;
+    try {
+        fs.rmdirSync(dir);
+    }
+    catch {
+        // ignore
+    }
+}
+export async function detectLegacyStateMigrations(params) {
+    const env = params.env ?? process.env;
+    const homedir = params.homedir ?? os.homedir;
+    const stateDir = resolveStateDir(env, homedir);
+    const oauthDir = resolveOAuthDir(env, stateDir);
+    const targetAgentId = normalizeAgentId(params.cfg.routing?.defaultAgentId ?? DEFAULT_AGENT_ID);
+    const rawMainKey = params.cfg.session?.mainKey;
+    const targetMainKey = typeof rawMainKey === "string" && rawMainKey.trim().length > 0
+        ? rawMainKey.trim()
+        : DEFAULT_MAIN_KEY;
+    const sessionsLegacyDir = path.join(stateDir, "sessions");
+    const sessionsLegacyStorePath = path.join(sessionsLegacyDir, "sessions.json");
+    const sessionsTargetDir = path.join(stateDir, "agents", targetAgentId, "sessions");
+    const sessionsTargetStorePath = path.join(sessionsTargetDir, "sessions.json");
+    const legacySessionEntries = safeReadDir(sessionsLegacyDir);
+    const hasLegacySessions = fileExists(sessionsLegacyStorePath) ||
+        legacySessionEntries.some((e) => e.isFile() && e.name.endsWith(".jsonl"));
+    const legacyAgentDir = path.join(stateDir, "agent");
+    const targetAgentDir = path.join(stateDir, "agents", targetAgentId, "agent");
+    const hasLegacyAgentDir = existsDir(legacyAgentDir);
+    const targetWhatsAppAuthDir = path.join(oauthDir, "whatsapp", DEFAULT_ACCOUNT_ID);
+    const hasLegacyWhatsAppAuth = fileExists(path.join(oauthDir, "creds.json")) &&
+        !fileExists(path.join(targetWhatsAppAuthDir, "creds.json"));
+    const preview = [];
+    if (hasLegacySessions) {
+        preview.push(`- Sessions: ${sessionsLegacyDir} → ${sessionsTargetDir}`);
+    }
+    if (hasLegacyAgentDir) {
+        preview.push(`- Agent dir: ${legacyAgentDir} → ${targetAgentDir}`);
+    }
+    if (hasLegacyWhatsAppAuth) {
+        preview.push(`- WhatsApp auth: ${oauthDir} → ${targetWhatsAppAuthDir} (keep oauth.json)`);
+    }
+    return {
+        targetAgentId,
+        targetMainKey,
+        stateDir,
+        oauthDir,
+        sessions: {
+            legacyDir: sessionsLegacyDir,
+            legacyStorePath: sessionsLegacyStorePath,
+            targetDir: sessionsTargetDir,
+            targetStorePath: sessionsTargetStorePath,
+            hasLegacy: hasLegacySessions,
+        },
+        agentDir: {
+            legacyDir: legacyAgentDir,
+            targetDir: targetAgentDir,
+            hasLegacy: hasLegacyAgentDir,
+        },
+        whatsappAuth: {
+            legacyDir: oauthDir,
+            targetDir: targetWhatsAppAuthDir,
+            hasLegacy: hasLegacyWhatsAppAuth,
+        },
+        preview,
+    };
+}
+async function migrateLegacySessions(detected, now) {
+    const changes = [];
+    const warnings = [];
+    if (!detected.sessions.hasLegacy)
+        return { changes, warnings };
+    ensureDir(detected.sessions.targetDir);
+    const legacyParsed = fileExists(detected.sessions.legacyStorePath)
+        ? readSessionStoreJson5(detected.sessions.legacyStorePath)
+        : { store: {}, ok: true };
+    const targetParsed = fileExists(detected.sessions.targetStorePath)
+        ? readSessionStoreJson5(detected.sessions.targetStorePath)
+        : { store: {}, ok: true };
+    const legacyStore = legacyParsed.store;
+    const targetStore = targetParsed.store;
+    const normalizedLegacy = {};
+    for (const [key, entry] of Object.entries(legacyStore)) {
+        const nextKey = normalizeSessionKeyForAgent(key, detected.targetAgentId);
+        if (!nextKey)
+            continue;
+        if (!normalizedLegacy[nextKey])
+            normalizedLegacy[nextKey] = entry;
+    }
+    const merged = {
+        ...normalizedLegacy,
+        ...targetStore,
+    };
+    const mainKey = buildAgentMainSessionKey({
+        agentId: detected.targetAgentId,
+        mainKey: detected.targetMainKey,
+    });
+    if (!merged[mainKey]) {
+        const latest = pickLatestLegacyDirectEntry(legacyStore);
+        if (latest?.sessionId) {
+            merged[mainKey] = latest;
+            changes.push(`Migrated latest direct-chat session → ${mainKey}`);
+        }
+    }
+    if (!legacyParsed.ok) {
+        warnings.push(`Legacy sessions store unreadable; left in place at ${detected.sessions.legacyStorePath}`);
+    }
+    if (legacyParsed.ok &&
+        (Object.keys(legacyStore).length > 0 || Object.keys(targetStore).length > 0)) {
+        const normalized = {};
+        for (const [key, entry] of Object.entries(merged)) {
+            const normalizedEntry = normalizeSessionEntry(entry);
+            if (!normalizedEntry)
+                continue;
+            normalized[key] = normalizedEntry;
+        }
+        await saveSessionStore(detected.sessions.targetStorePath, normalized);
+        changes.push(`Merged sessions store → ${detected.sessions.targetStorePath}`);
+    }
+    const entries = safeReadDir(detected.sessions.legacyDir);
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (entry.name === "sessions.json")
+            continue;
+        const from = path.join(detected.sessions.legacyDir, entry.name);
+        const to = path.join(detected.sessions.targetDir, entry.name);
+        if (fileExists(to))
+            continue;
+        try {
+            fs.renameSync(from, to);
+            changes.push(`Moved ${entry.name} → agents/${detected.targetAgentId}/sessions`);
+        }
+        catch (err) {
+            warnings.push(`Failed moving ${from}: ${String(err)}`);
+        }
+    }
+    if (legacyParsed.ok) {
+        try {
+            if (fileExists(detected.sessions.legacyStorePath)) {
+                fs.rmSync(detected.sessions.legacyStorePath, { force: true });
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    removeDirIfEmpty(detected.sessions.legacyDir);
+    const legacyLeft = safeReadDir(detected.sessions.legacyDir).filter((e) => e.isFile());
+    if (legacyLeft.length > 0) {
+        const backupDir = `${detected.sessions.legacyDir}.legacy-${now()}`;
+        try {
+            fs.renameSync(detected.sessions.legacyDir, backupDir);
+            warnings.push(`Left legacy sessions at ${backupDir}`);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { changes, warnings };
+}
+async function migrateLegacyAgentDir(detected, now) {
+    const changes = [];
+    const warnings = [];
+    if (!detected.agentDir.hasLegacy)
+        return { changes, warnings };
+    ensureDir(detected.agentDir.targetDir);
+    const entries = safeReadDir(detected.agentDir.legacyDir);
+    for (const entry of entries) {
+        const from = path.join(detected.agentDir.legacyDir, entry.name);
+        const to = path.join(detected.agentDir.targetDir, entry.name);
+        if (fs.existsSync(to))
+            continue;
+        try {
+            fs.renameSync(from, to);
+            changes.push(`Moved agent file ${entry.name} → agents/${detected.targetAgentId}/agent`);
+        }
+        catch (err) {
+            warnings.push(`Failed moving ${from}: ${String(err)}`);
+        }
+    }
+    removeDirIfEmpty(detected.agentDir.legacyDir);
+    if (!emptyDirOrMissing(detected.agentDir.legacyDir)) {
+        const backupDir = path.join(detected.stateDir, "agents", detected.targetAgentId, `agent.legacy-${now()}`);
+        try {
+            fs.renameSync(detected.agentDir.legacyDir, backupDir);
+            warnings.push(`Left legacy agent dir at ${backupDir}`);
+        }
+        catch (err) {
+            warnings.push(`Failed relocating legacy agent dir: ${String(err)}`);
+        }
+    }
+    return { changes, warnings };
+}
+async function migrateLegacyWhatsAppAuth(detected) {
+    const changes = [];
+    const warnings = [];
+    if (!detected.whatsappAuth.hasLegacy)
+        return { changes, warnings };
+    ensureDir(detected.whatsappAuth.targetDir);
+    const entries = safeReadDir(detected.whatsappAuth.legacyDir);
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (entry.name === "oauth.json")
+            continue;
+        if (!isLegacyWhatsAppAuthFile(entry.name))
+            continue;
+        const from = path.join(detected.whatsappAuth.legacyDir, entry.name);
+        const to = path.join(detected.whatsappAuth.targetDir, entry.name);
+        if (fileExists(to))
+            continue;
+        try {
+            fs.renameSync(from, to);
+            changes.push(`Moved WhatsApp auth ${entry.name} → whatsapp/default`);
+        }
+        catch (err) {
+            warnings.push(`Failed moving ${from}: ${String(err)}`);
+        }
+    }
+    return { changes, warnings };
+}
+export async function runLegacyStateMigrations(params) {
+    const now = params.now ?? (() => Date.now());
+    const detected = params.detected;
+    const sessions = await migrateLegacySessions(detected, now);
+    const agentDir = await migrateLegacyAgentDir(detected, now);
+    const whatsappAuth = await migrateLegacyWhatsAppAuth(detected);
+    return {
+        changes: [
+            ...sessions.changes,
+            ...agentDir.changes,
+            ...whatsappAuth.changes,
+        ],
+        warnings: [
+            ...sessions.warnings,
+            ...agentDir.warnings,
+            ...whatsappAuth.warnings,
+        ],
+    };
+}