@ouro.bot/cli 0.1.0-alpha.361 → 0.1.0-alpha.363

package/README.md

@@ -169,6 +169,7 @@ ouro auth --agent <name>
 ouro auth --agent <name> --provider <provider>
 ouro use --agent <name> --lane <outward|inner> --provider <provider> --model <model>
 ouro hatch
+ouro clone <remote> [--agent <name>]   # clone an existing agent from a git remote (see docs/cross-machine-setup.md)
 ouro chat <agent>
 ouro msg --to <agent> [--session <id>] [--task <ref>] <message>
 ouro poke <agent> --task <task-id>
@@ -183,6 +184,10 @@ ouro mcp-serve --agent <name>             # start MCP server on stdin/stdout (us
 ouro hook <event> --agent <name>          # fire a lifecycle hook (SessionStart, Stop, PostToolUse)
 ```
 
+## Setting Up On Another Machine
+
+To clone an existing agent onto a new machine (macOS, Linux, or Windows via WSL2), see **[docs/cross-machine-setup.md](docs/cross-machine-setup.md)**. The short version: `npx ouro.bot`, pick "clone", enter the bundle's git remote URL, run `ouro auth run`, then `ouro up`.
+
 ## The Agent's Inner Life
 
 Agents in Ouroboros aren't just responders — they have an autonomous inner life.

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.363",
+      "changes": [
+        "Bootstrap first-install PATH hint is now shell-aware: shows correct source command for zsh, bash, fish, or generic fallback for unknown shells."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.362",
+      "changes": [
+        "New `ouro clone <remote>` command for cross-machine agent setup: clones bundle from git remote, creates machine identity, enables sync, guides to auth flow. Infers agent name from URL.",
+        "WSL-aware `ouro setup --tool claude-code`: detects WSL2, resolves Windows-side home, calls claude.exe with wsl-prefixed MCP serve and hook commands, writes settings to Windows .claude/ directory.",
+        "Platform detection module (detectPlatform) returning macos/linux/wsl/windows-native with injectable deps.",
+        "First-run hatch-or-clone interactive choice when no bundles exist. Manual-clone detection during `ouro up` offers to enable sync on git-cloned bundles.",
+        "npx ouro.bot bootstrap now passes through to CLI on first install instead of stopping early."
+      ]
+    },
     {
       "version": "0.1.0-alpha.361",
       "changes": [

package/dist/heart/core.js

@@ -450,6 +450,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     // Refresh system prompt at start of each turn when channel is provided.
     // If refresh fails, keep existing system prompt (or inject a minimal safe fallback)
     // so turn execution remains consistent and non-fatal.
+    let structuredSystemPrompt;
     if (channel) {
         try {
             const buildSystemOptions = {
@@ -458,7 +459,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 supportedReasoningEfforts: providerRuntime.supportedReasoningEfforts,
             };
             const refreshed = await (0, prompt_1.buildSystem)(channel, buildSystemOptions, currentContext);
-            upsertSystemPrompt(messages, refreshed);
+            structuredSystemPrompt = refreshed;
+            upsertSystemPrompt(messages, (0, prompt_1.flattenSystemPrompt)(refreshed));
         }
         catch (error) {
             const hadExistingSystemPrompt = messages[0]?.role === "system" && typeof messages[0].content === "string";
@@ -611,6 +613,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         toolChoiceRequired,
                         reasoningEffort: currentReasoningEffort,
                         eagerSettleStreaming: true,
+                        systemPrompt: structuredSystemPrompt,
                     });
                 }
                 catch (error) {

package/dist/heart/daemon/cli-exec.js

@@ -42,6 +42,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeStartupStability = mergeStartupStability;
 exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.listGithubCopilotModels = listGithubCopilotModels;
+exports.checkManualCloneBundles = checkManualCloneBundles;
 exports.runOuroCli = runOuroCli;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
@@ -54,6 +55,7 @@ const runtime_1 = require("../../nerves/runtime");
 const store_file_1 = require("../../mind/friends/store-file");
 const runtime_metadata_1 = require("./runtime-metadata");
 const runtime_mode_1 = require("./runtime-mode");
+const platform_1 = require("../platform");
 const daemon_runtime_sync_1 = require("./daemon-runtime-sync");
 const update_hooks_1 = require("../versioning/update-hooks");
 const bundle_meta_1 = require("./hooks/bundle-meta");
@@ -441,7 +443,78 @@ async function verifyProviderCredentials(provider, providers) {
         return `failed (${error instanceof Error ? error.message : String(error)})`;
     }
 }
-/* v8 ignore stop */
+async function checkManualCloneBundles(deps) {
+    if (!deps.promptInput)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(deps.bundlesRoot).filter((e) => e.endsWith(".ouro"));
+    }
+    catch {
+        return;
+    }
+    for (const agentDir of entries) {
+        const bundlePath = path.join(deps.bundlesRoot, agentDir);
+        const gitDir = path.join(bundlePath, ".git");
+        if (!fs.existsSync(gitDir))
+            continue;
+        // Check for remotes
+        let remoteOutput;
+        try {
+            remoteOutput = (0, child_process_1.execFileSync)("git", ["remote", "-v"], { cwd: bundlePath, stdio: "pipe" }).toString().trim();
+        }
+        catch {
+            continue;
+        }
+        if (!remoteOutput)
+            continue;
+        // Check if sync is already enabled
+        const agentJsonPath = path.join(bundlePath, "agent.json");
+        if (fs.existsSync(agentJsonPath)) {
+            try {
+                const raw = fs.readFileSync(agentJsonPath, "utf-8");
+                const config = JSON.parse(raw);
+                if (config.sync?.enabled)
+                    continue;
+            }
+            catch {
+                // Can't read agent.json — skip
+                continue;
+            }
+        }
+        // Parse first remote name
+        const firstLine = remoteOutput.split("\n")[0];
+        /* v8 ignore next -- defensive fallback: .trim() above strips leading tabs so empty-field path is unreachable @preserve */
+        const remoteName = firstLine.split("\t")[0] || "origin";
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.manual_clone_detected",
+            message: "bundle appears to be a manually cloned git repo",
+            meta: { agent: agentDir, remote: remoteName },
+        });
+        const answer = await deps.promptInput(`Bundle ${agentDir} appears to be a git clone with a remote. Enable sync? (y/n): `);
+        if (answer.trim().toLowerCase() === "y") {
+            const raw = fs.readFileSync(agentJsonPath, "utf-8");
+            const config = JSON.parse(raw);
+            config.sync = { enabled: true, remote: remoteName };
+            fs.writeFileSync(agentJsonPath, JSON.stringify(config, null, 2) + "\n");
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.manual_clone_sync_enabled",
+                message: "sync enabled for manually cloned bundle",
+                meta: { agent: agentDir, remote: remoteName },
+            });
+        }
+        else {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.manual_clone_sync_skipped",
+                message: "user declined sync for manually cloned bundle",
+                meta: { agent: agentDir },
+            });
+        }
+    }
+}
 // ── toDaemonCommand ──
 function toDaemonCommand(command) {
     return command;
@@ -1270,6 +1343,28 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     if (args.length === 0) {
         const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : (0, cli_defaults_1.defaultListDiscoveredAgents)());
         if (discovered.length === 0 && deps.runSerpentGuide) {
+            // Hatch-or-clone choice when promptInput is available
+            if (deps.promptInput) {
+                const choice = await deps.promptInput("No agents found. Would you like to hatch a new agent or clone an existing one? (hatch/clone): ");
+                if (choice.trim().toLowerCase() === "clone") {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "daemon",
+                        event: "daemon.first_run_choice_clone",
+                        message: "user chose clone in first-run flow",
+                        meta: {},
+                    });
+                    const remote = await deps.promptInput("Enter the git remote URL for the agent bundle: ");
+                    // Run clone execution path
+                    const cloneCommand = { kind: "clone", remote: remote.trim() };
+                    return await runOuroCli(["clone", cloneCommand.remote], deps);
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.first_run_choice_hatch",
+                    message: "user chose hatch in first-run flow",
+                    meta: {},
+                });
+            }
             // System setup first — ouro command, subagents, UTI — before the interactive specialist
             await performSystemSetup(deps);
             const hatchlingName = await deps.runSerpentGuide();
@@ -1497,6 +1592,11 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             progress.startPhase("bundle cleanup");
             progress.completePhase("bundle cleanup", `pruned ${prunedBundles.length} stale bundle${prunedBundles.length === 1 ? "" : "s"}`);
         }
+        // ── manual-clone detection: offer to enable sync for manually cloned bundles ──
+        await checkManualCloneBundles({
+            bundlesRoot: deps.bundlesRoot ?? bundlesRoot,
+            promptInput: deps.promptInput,
+        });
         progress.startPhase("starting daemon");
         const daemonResult = await ensureDaemonRunning({
             ...deps,
@@ -1908,17 +2008,57 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     // ── setup: configure dev tool integration ──
     if (command.kind === "setup") {
         const { tool, agent: setupAgent } = command;
+        const platform = (0, platform_1.detectPlatform)();
+        // Windows native is not yet supported
+        if (platform === "windows-native") {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.setup_windows_native_unsupported",
+                message: "Windows native setup not yet supported",
+                meta: { tool, agent: setupAgent },
+            });
+            const message = "Windows native is not yet supported. Please run from WSL2: https://learn.microsoft.com/en-us/windows/wsl/install";
+            deps.writeStdout(message);
+            return message;
+        }
+        // Resolve platform-specific paths and commands
+        let claudeCmd;
+        let mcpServePrefix;
+        let hookPrefix;
+        let claudeConfigDir;
+        if (platform === "wsl") {
+            const winProfile = (0, child_process_1.execFileSync)("cmd.exe", ["/C", "echo", "%USERPROFILE%"], { stdio: "pipe" }).toString().trim();
+            const windowsHome = (0, child_process_1.execFileSync)("wslpath", ["-u", winProfile], { stdio: "pipe" }).toString().trim();
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.setup_wsl_home_resolved",
+                message: "resolved Windows home from WSL",
+                meta: { windowsHome },
+            });
+            claudeCmd = "claude.exe";
+            mcpServePrefix = "wsl ";
+            hookPrefix = "wsl ";
+            claudeConfigDir = path.join(windowsHome, ".claude");
+        }
+        else {
+            // macos or linux
+            claudeCmd = "claude";
+            mcpServePrefix = "";
+            hookPrefix = "";
+            claudeConfigDir = path.join(os.homedir(), ".claude");
+        }
         const sourceRoot = (0, identity_1.getRepoRoot)();
         const runtimeMode = (0, runtime_mode_1.detectRuntimeMode)(sourceRoot);
-        const mcpServeCommand = runtimeMode === "dev"
+        const baseMcpServeCommand = runtimeMode === "dev"
             ? `node ${path.join(sourceRoot, "dist", "heart", "daemon", "ouro-bot-entry.js")} mcp-serve --agent ${setupAgent}`
             : `ouro mcp-serve --agent ${setupAgent}`;
+        const mcpServeCommand = `${mcpServePrefix}${baseMcpServeCommand}`;
         if (tool === "claude-code") {
             // 1. Register MCP server with Claude Code
-            const mcpAddCmd = `claude mcp add ouro-${setupAgent} -s user -- ${mcpServeCommand}`;
+            const mcpAddCmd = `${claudeCmd} mcp add ouro-${setupAgent} -s user -- ${mcpServeCommand}`;
             (0, child_process_1.execSync)(mcpAddCmd, { stdio: "pipe" });
-            // 2. Write hooks config to ~/.claude/settings.json
-            const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+            // 2. Write hooks config
+            const settingsPath = path.join(claudeConfigDir, "settings.json");
             let settings = {};
             if (fs.existsSync(settingsPath)) {
                 try {
@@ -1926,13 +2066,11 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 }
                 catch { /* start fresh */ }
             }
-            // Use `ouro hook <event>` — resolves the right code based on dev vs installed mode.
-            // Bare `ouro` works because ouro is on PATH via ~/.ouro-cli/bin/.
             settings.hooks = {
                 ...(settings.hooks ?? {}),
-                SessionStart: [{ hooks: [{ type: "command", command: `ouro hook session-start --agent ${setupAgent}`, timeout: 5 }] }],
-                Stop: [{ hooks: [{ type: "command", command: `ouro hook stop --agent ${setupAgent}`, timeout: 5 }] }],
-                PostToolUse: [{ matcher: "Bash|Edit|Write", hooks: [{ type: "command", command: `ouro hook post-tool-use --agent ${setupAgent}`, timeout: 5 }] }],
+                SessionStart: [{ hooks: [{ type: "command", command: `${hookPrefix}ouro hook session-start --agent ${setupAgent}`, timeout: 5 }] }],
+                Stop: [{ hooks: [{ type: "command", command: `${hookPrefix}ouro hook stop --agent ${setupAgent}`, timeout: 5 }] }],
+                PostToolUse: [{ matcher: "Bash|Edit|Write", hooks: [{ type: "command", command: `${hookPrefix}ouro hook post-tool-use --agent ${setupAgent}`, timeout: 5 }] }],
             };
             fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
             fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
@@ -1940,10 +2078,10 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 component: "daemon",
                 event: "daemon.setup_complete",
                 message: "dev tool setup complete",
-                meta: { tool, agent: setupAgent, runtimeMode },
+                meta: { tool, agent: setupAgent, runtimeMode, platform },
             });
-            // 3. Write conversation formatting instructions to ~/.claude/CLAUDE.md
-            const claudeMdPath = path.join(os.homedir(), ".claude", "CLAUDE.md");
+            // 3. Write conversation formatting instructions
+            const claudeMdPath = path.join(claudeConfigDir, "CLAUDE.md");
             const agentInstructions = `\n## Agent conversations (ouro)\nWhen using MCP \`send_message\` to talk to an ouro agent, format the exchange clearly:\n- Before the tool call, briefly say what you're asking/telling the agent\n- After the response, quote the agent's reply in a blockquote, then add your reaction\n- Example: **Me → Agent:** "question" / > **Agent:** "response" / Your synthesis here\n`;
             let existingClaudeMd = "";
             if (fs.existsSync(claudeMdPath)) {
@@ -1964,7 +2102,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 component: "daemon",
                 event: "daemon.setup_complete",
                 message: "dev tool setup complete",
-                meta: { tool, agent: setupAgent, runtimeMode },
+                meta: { tool, agent: setupAgent, runtimeMode, platform },
             });
             const message = `setup complete: codex + ${setupAgent}\n  MCP server registered`;
             deps.writeStdout(message);
@@ -2616,6 +2754,65 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         });
         return output;
     }
+    // ── clone: clone an agent bundle from a git remote ──
+    if (command.kind === "clone") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.clone_start",
+            message: "starting agent bundle clone",
+            meta: { remote: command.remote, agent: command.agent },
+        });
+        // 1. Check git is installed
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.clone_git_check", message: "checking git installation", meta: {} });
+        try {
+            (0, child_process_1.execFileSync)("git", ["--version"], { stdio: "pipe" });
+        }
+        catch (err) {
+            const message = "git is not installed -- install it from https://git-scm.com\nOn macOS: brew install git\nOn Ubuntu/Debian: sudo apt install git\nOn Windows: download from https://git-scm.com/download/win";
+            deps.writeStdout(message);
+            return message;
+        }
+        // 2. Infer agent name
+        const agentName = command.agent ?? (0, cli_parse_1.inferAgentNameFromRemote)(command.remote);
+        const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+        const targetPath = path.join(bundlesRoot, agentName + ".ouro");
+        // 3. Check target path does not exist
+        if (fs.existsSync(targetPath)) {
+            const message = `${targetPath} already exists. Remove it first or use --agent to pick a different name.`;
+            deps.writeStdout(message);
+            return message;
+        }
+        // 4. Check remote accessible
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.clone_remote_check", message: "checking remote accessibility", meta: { remote: command.remote } });
+        try {
+            (0, child_process_1.execFileSync)("git", ["ls-remote", "--exit-code", command.remote], { stdio: "pipe", timeout: 15000 });
+        }
+        catch {
+            const message = `could not reach remote: ${command.remote}\nCheck the URL and your network connection.`;
+            deps.writeStdout(message);
+            return message;
+        }
+        // 5. Clone
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.clone_git_clone", message: "cloning agent bundle", meta: { remote: command.remote, targetPath } });
+        (0, child_process_1.execFileSync)("git", ["clone", command.remote, targetPath], { stdio: "pipe" });
+        // 6. Create machine identity
+        (0, machine_identity_1.loadOrCreateMachineIdentity)();
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.clone_identity_created", message: "machine identity created", meta: {} });
+        // 7. Enable sync in agent.json
+        const agentJsonPath = path.join(targetPath, "agent.json");
+        if (fs.existsSync(agentJsonPath)) {
+            const raw = fs.readFileSync(agentJsonPath, "utf-8");
+            const config = JSON.parse(raw);
+            config.sync = { enabled: true, remote: "origin" };
+            fs.writeFileSync(agentJsonPath, JSON.stringify(config, null, 2) + "\n");
+            (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.clone_sync_enabled", message: "sync enabled in agent.json", meta: { agentName } });
+        }
+        // 8. Output success message
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.clone_complete", message: "clone complete", meta: { agentName, targetPath } });
+        const message = `cloned ${agentName} to ${targetPath}\nsync enabled (remote: origin)\nnext steps:\n  ouro auth run --agent ${agentName}`;
+        deps.writeStdout(message);
+        return message;
+    }
     const daemonCommand = toDaemonCommand(command);
     let response;
     try {

package/dist/heart/daemon/cli-help.js

@@ -67,6 +67,12 @@ exports.COMMAND_REGISTRY = {
         usage: "ouro versions",
         example: "ouro versions",
     },
+    clone: {
+        category: "Lifecycle",
+        description: "Clone an existing agent bundle from a git remote onto this machine",
+        usage: "ouro clone <remote> [--agent <name>]",
+        example: "ouro clone https://github.com/user/myagent.ouro.git",
+    },
     doctor: {
         category: "Lifecycle",
         description: "Run diagnostic checks on the ouro installation",

package/dist/heart/daemon/cli-parse.js

@@ -11,6 +11,7 @@ exports.extractFacingFlag = extractFacingFlag;
 exports.facingToProviderLane = facingToProviderLane;
 exports.isAgentProvider = isAgentProvider;
 exports.usage = usage;
+exports.inferAgentNameFromRemote = inferAgentNameFromRemote;
 exports.parseMcpServeCommand = parseMcpServeCommand;
 exports.parseOuroCommand = parseOuroCommand;
 const types_1 = require("../../mind/friends/types");
@@ -100,6 +101,7 @@ function usage() {
         "  ouro mcp call <server> <tool> [--args '{...}']",
         "  ouro rollback [<version>]",
         "  ouro versions",
+        "  ouro clone <remote> [--agent <name>]",
         "  ouro doctor",
     ].join("\n");
 }
@@ -674,6 +676,41 @@ function parseMcpCommand(args) {
     }
     throw new Error(`Usage\n${usage()}`);
 }
+function inferAgentNameFromRemote(remote) {
+    // Remove trailing slash
+    let name = remote.replace(/\/+$/, "");
+    // Handle SSH URLs (git@host:user/repo) — extract after last / or :
+    const lastSlash = name.lastIndexOf("/");
+    const lastColon = name.lastIndexOf(":");
+    const lastSep = Math.max(lastSlash, lastColon);
+    if (lastSep !== -1) {
+        name = name.slice(lastSep + 1);
+    }
+    // Strip .git suffix
+    name = name.replace(/\.git$/, "");
+    // Strip .ouro suffix
+    name = name.replace(/\.ouro$/, "");
+    return name;
+}
+function parseCloneCommand(args) {
+    let remote;
+    let agent;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--agent" && args[i + 1]) {
+            agent = args[++i];
+            continue;
+        }
+        if (!remote) {
+            remote = args[i];
+        }
+    }
+    if (!remote) {
+        throw new Error("clone requires a remote URL.\nUsage: ouro clone <remote> [--agent <name>]");
+    }
+    return agent
+        ? { kind: "clone", remote, agent }
+        : { kind: "clone", remote };
+}
 function parseMcpServeCommand(args) {
     let agent;
     let friendId;
@@ -903,6 +940,8 @@ function parseOuroCommand(args) {
         return parseMcpServeCommand(args.slice(1));
     if (head === "setup")
         return parseSetupCommand(args.slice(1));
+    if (head === "clone")
+        return parseCloneCommand(args.slice(1));
     if (head === "doctor")
         return { kind: "doctor" };
     if (head === "bluebubbles")

package/dist/heart/platform.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPlatform = detectPlatform;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+function detectPlatform(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const readFile = deps.readFileSync ?? ((p) => fs.readFileSync(p, "utf-8"));
+    let result;
+    if (platform === "darwin") {
+        result = "macos";
+    }
+    else if (platform === "win32") {
+        result = "windows-native";
+    }
+    else if (platform === "linux") {
+        result = detectLinuxOrWsl(env, readFile);
+    }
+    else {
+        // Unknown platform — treat as linux
+        result = "linux";
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.platform_detected",
+        message: "detected platform",
+        meta: { platform, result },
+    });
+    return result;
+}
+function detectLinuxOrWsl(env, readFile) {
+    // Primary: WSL_DISTRO_NAME env var
+    if (env.WSL_DISTRO_NAME && env.WSL_DISTRO_NAME.length > 0) {
+        return "wsl";
+    }
+    // Fallback: /proc/version containing "microsoft" (case-insensitive)
+    try {
+        const procVersion = readFile("/proc/version");
+        if (/microsoft/i.test(procVersion)) {
+            return "wsl";
+        }
+    }
+    catch {
+        // /proc/version not readable — not WSL
+    }
+    return "linux";
+}

package/dist/heart/providers/anthropic.js

@@ -251,12 +251,28 @@ async function streamAnthropicMessages(client, model, request) {
     // prompt when using OAuth setup tokens (sk-ant-oat01). Without it, Opus/Sonnet
     // 4.6 requests are rejected with 400. This is the API's validation that the
     // token is being used by a Claude Code client.
-    const claudeCodePreamble = { type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." };
-    if (system) {
-        params.system = [claudeCodePreamble, { type: "text", text: system }];
+    const preambleText = "You are Claude Code, Anthropic's official CLI for Claude.";
+    if (request.systemPrompt) {
+        // Structured SystemPrompt: merge preamble + stable prefix into one cached block,
+        // volatile suffix as a separate uncached block.
+        const stableBlock = {
+            type: "text",
+            text: preambleText + "\n\n" + request.systemPrompt.stable,
+            cache_control: { type: "ephemeral" },
+        };
+        if (request.systemPrompt.volatile) {
+            params.system = [stableBlock, { type: "text", text: request.systemPrompt.volatile }];
+        }
+        else {
+            params.system = [stableBlock];
+        }
+    }
+    else if (system) {
+        // Fallback: no structured prompt, extract from messages (legacy path)
+        params.system = [{ type: "text", text: preambleText }, { type: "text", text: system }];
     }
     else {
-        params.system = [claudeCodePreamble];
+        params.system = [{ type: "text", text: preambleText }];
     }
     if (anthropicTools.length > 0)
         params.tools = anthropicTools;

package/dist/mind/prompt-refresh.js

@@ -5,11 +5,12 @@ const prompt_1 = require("./prompt");
 const runtime_1 = require("../nerves/runtime");
 async function refreshSystemPrompt(messages, channel, options, context) {
     const newSystem = await (0, prompt_1.buildSystem)(channel, options, context);
+    const flattened = (0, prompt_1.flattenSystemPrompt)(newSystem);
     if (messages.length > 0 && messages[0].role === "system") {
-        messages[0] = { role: "system", content: newSystem };
+        messages[0] = { role: "system", content: flattened };
     }
     else {
-        messages.unshift({ role: "system", content: newSystem });
+        messages.unshift({ role: "system", content: flattened });
     }
     (0, runtime_1.emitNervesEvent)({
         event: "mind.system_prompt_refreshed",

package/dist/mind/prompt.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenSystemPrompt = flattenSystemPrompt;
 exports.resetPsycheCache = resetPsycheCache;
 exports.buildSessionSummary = buildSessionSummary;
 exports.bodyMapSection = bodyMapSection;
@@ -79,6 +80,10 @@ const daemon_health_1 = require("../heart/daemon/daemon-health");
 const scrutiny_1 = require("./scrutiny");
 const pulse_1 = require("../heart/daemon/pulse");
 const provider_visibility_1 = require("../heart/provider-visibility");
+function flattenSystemPrompt(sp) {
+    const parts = [sp.stable, sp.volatile].filter(Boolean);
+    return parts.join("\n\n");
+}
 // Lazy-loaded psyche text cache
 let _psycheCache = null;
 let _senseStatusLinesCache = null;
@@ -377,6 +382,7 @@ function runtimeInfoSection(channel, options) {
     lines.push(`process type: ${processTypeLabel(channel)}`);
     lines.push(`daemon: ${daemonStatus(options?.daemonRunning)}`);
     lines.push(`mcp serve: i can expose my tools to dev tools via \`ouro mcp-serve\`. see the configure-dev-tools skill for setup.`);
+    lines.push(`harness docs: the harness repo has docs/ and skills/ with guides for setup, operations, and capabilities. docs/ does NOT ship in the npm package — in production, fetch from https://github.com/ouroborosbot/ouroboros/tree/main/docs instead. in dev mode, read from ${sourceRoot}/docs/. when someone asks about setup, installation, cross-machine cloning, deployment, testing, auth, or how i work — consult the docs before guessing.`);
     if (channel === "cli") {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }
@@ -1256,7 +1262,7 @@ async function buildSystem(channel = "cli", options, context) {
     });
     // Backfill bundle-meta.json for existing agents that don't have one
     (0, bundle_manifest_1.backfillBundleMeta)((0, identity_1.getAgentRoot)());
-    const system = [
+    const stableParts = [
         // Group 1: who i am
         "# who i am",
         soulSection(),
@@ -1264,14 +1270,12 @@ async function buildSystem(channel = "cli", options, context) {
         loreSection(),
         tacitKnowledgeSection(),
         aspirationsSection(),
-        // Group 2: my body & environment
+        // Group 2: my body & environment (minus dateSection and rhythmStatusSection)
         "# my body & environment",
         bodyMapSection((0, identity_1.getAgentName)(), channel),
         runtimeInfoSection(channel, options),
-        rhythmStatusSection(options?.daemonHealth),
         channelNatureSection((0, channel_1.getChannelCapabilities)(channel)),
         providerSection(channel, options),
-        dateSection(),
         // Group 3: my tools & capabilities
         "# my tools & capabilities",
         toolsSection(channel, options, context),
@@ -1302,6 +1306,11 @@ async function buildSystem(channel = "cli", options, context) {
             groupChatParticipationSection(context),
             feedbackSignalSection(context),
         ] : []),
+    ];
+    const volatileParts = [
+        // Volatile sections from Group 2 (date and rhythm change every turn)
+        dateSection(),
+        rhythmStatusSection(options?.daemonHealth),
         // Group 7: dynamic state for this turn
         "# dynamic state for this turn",
         startOfTurnPacketSection(options),
@@ -1331,14 +1340,16 @@ async function buildSystem(channel = "cli", options, context) {
         // Group 9: task context
         "# task context",
         taskBoardSection(),
-    ]
-        .filter(Boolean)
-        .join("\n\n");
+    ];
+    const result = {
+        stable: stableParts.filter(Boolean).join("\n\n"),
+        volatile: volatileParts.filter(Boolean).join("\n\n"),
+    };
     (0, runtime_1.emitNervesEvent)({
         event: "mind.step_end",
         component: "mind",
         message: "buildSystem completed",
         meta: { channel },
     });
-    return system;
+    return result;
 }

package/dist/senses/bluebubbles/index.js

@@ -646,7 +646,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
         const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
         const sessionMessages = existing?.messages && existing.messages.length > 0
             ? existing.messages
-            : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", {}, context) }];
+            : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await resolvedDeps.buildSystem("bluebubbles", {}, context)) }];
         if (event.kind === "message") {
             const agentName = resolvedDeps.getAgentName();
             if ((0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {

package/dist/senses/cli.js

@@ -511,7 +511,7 @@ async function runCliSession(options) {
         (0, commands_1.registerDefaultCommands)(registry);
     }
     const messages = options.messages
-        ?? [{ role: "system", content: await (0, prompt_1.buildSystem)("cli") }];
+        ?? [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)("cli")) }];
     // ─── Rendering: TUI (Ink + Static) for TTY, imperative for tests/pipes ───
     const useTui = !options._testInputSource && process.stdin.isTTY === true;
     let currentAbort = null;
@@ -976,7 +976,7 @@ async function main(agentName, options) {
     const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
     const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
-        : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", {}, resolvedContext) }];
+        : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)("cli", {}, resolvedContext)) }];
     // Repair any orphaned tool calls from a crash mid-turn
     (0, core_1.repairOrphanedToolCalls)(sessionMessages);
     // Per-turn pipeline input: CLI capabilities and pending dir

package/dist/senses/inner-dialog.js

@@ -672,7 +672,7 @@ async function runInnerDialogTurn(options) {
                 // Fresh session: build system prompt
                 const systemPrompt = await (0, prompt_1.buildSystem)("inner", { toolChoiceRequired: true });
                 return {
-                    messages: [{ role: "system", content: systemPrompt }],
+                    messages: [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(systemPrompt) }],
                     sessionPath: sessionFilePath,
                 };
             },

package/dist/senses/shared-turn.js

@@ -112,7 +112,7 @@ async function runSenseTurn(options) {
     let persistPromise;
     const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
-        : [{ role: "system", content: await (0, prompt_1.buildSystem)(channel, {}, undefined) }];
+        : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)(channel, {}, undefined)) }];
     // Pending dir
     const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
     // Accumulate response text via callbacks

package/dist/senses/teams.js

@@ -655,7 +655,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                     const existing = (0, context_1.loadSession)(sessPath);
                     const messages = existing?.messages && existing.messages.length > 0
                         ? existing.messages
-                        : [{ role: "system", content: await (0, prompt_1.buildSystem)("teams", {}, resolvedContext) }];
+                        : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)("teams", {}, resolvedContext)) }];
                     (0, core_1.repairOrphanedToolCalls)(messages);
                     return {
                         messages,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.361",
+  "version": "0.1.0-alpha.363",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",

package/skills/configure-dev-tools.md

@@ -1,6 +1,6 @@
 # Configure Dev Tools for MCP Agent Bridge
 
-Set up your development tools (Claude Code, Codex) to communicate with Ouroboros agents via MCP. One command does everything.
+Set up your development tools (Claude Code, Codex) to communicate with Ouroboros agents via MCP. One command does everything — including cross-platform WSL2 bridging on Windows.
 
 ## Setup
 
@@ -15,6 +15,16 @@ This command:
 2. Configures lifecycle hooks (SessionStart, Stop, PostToolUse) for passive awareness
 3. Detects dev vs installed mode automatically and uses the correct command path
 
+**On WSL2 (Windows):** The command automatically detects the WSL environment and:
+- Calls `claude.exe` (the Windows binary) instead of `claude`
+- Prefixes MCP serve and hook commands with `wsl` so Windows-side Claude Code spawns them through WSL
+- Resolves the Windows-side home directory and writes config to the Windows-side `~/.claude/`
+- After setup, open Claude Code in PowerShell — the agent is there
+
+**On native Windows (no WSL):** Not yet supported. The command prints a message directing you to install WSL2.
+
+For the full cross-machine setup flow (including cloning an agent to a new machine), see `docs/cross-machine-setup.md` in the harness repo.
+
 ### Codex
 
 ```bash