@vectorize-io/self-driving-agents 0.0.5 → 0.0.7

package/dist/cli.js

@@ -104,7 +104,7 @@ async function resolveAgentDir(input, spinner) {
 }
 // ── Skill ───────────────────────────────────────────────
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const SKILL_PATH = join(__dirname, "..", "skill", "SKILL.md");
+const SKILL_PATH = join(__dirname, "skill", "SKILL.md");
 const SKILL_MD = readFileSync(SKILL_PATH, "utf-8");
 // ── Plugin management ───────────────────────────────────
 const OPENCLAW_CONFIG_PATH = join(homedir(), ".openclaw", "openclaw.json");
@@ -125,7 +125,7 @@ function enableKnowledgeTools() {
     pc.enableKnowledgeTools = true;
     writeFileSync(OPENCLAW_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
 }
-const MIN_PLUGIN_VERSION = "0.7.0";
+const MIN_PLUGIN_VERSION = "0.7.2";
 function getInstalledPluginVersion() {
     try {
         // Check the installed plugin's package.json
@@ -153,8 +153,11 @@ function isPluginInstalled() {
     const config = readOpenClawConfig();
     if (!config)
         return false;
-    return (config.plugins?.entries?.["hindsight-openclaw"]?.enabled !== false &&
-        config.plugins?.entries?.["hindsight-openclaw"] !== undefined);
+    const hasConfig = config.plugins?.entries?.["hindsight-openclaw"]?.enabled !== false &&
+        config.plugins?.entries?.["hindsight-openclaw"] !== undefined;
+    // Also check the extension dir actually exists (may have been deleted during a failed upgrade)
+    const extDir = join(homedir(), ".openclaw", "extensions", "hindsight-openclaw");
+    return hasConfig && existsSync(extDir);
 }
 function isPluginConfigured() {
     const config = readOpenClawConfig();
@@ -217,13 +220,28 @@ async function ensurePlugin() {
             p.log.warn("Hindsight plugin not found. Installing...");
         }
         try {
+            // Remove old extension if present — openclaw doesn't support in-place upgrade
+            const extDir = join(homedir(), ".openclaw", "extensions", "hindsight-openclaw");
+            rmSync(extDir, { recursive: true, force: true });
+            // Temporarily clear plugins.slots.memory so openclaw doesn't reject
+            // the config while the extension is missing
+            const cfg = readOpenClawConfig();
+            if (cfg?.plugins?.slots?.memory === "hindsight-openclaw") {
+                delete cfg.plugins.slots.memory;
+                writeFileSync(OPENCLAW_CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+            }
             execSync("openclaw plugins install @vectorize-io/hindsight-openclaw", { stdio: "inherit" });
+            const newVersion = getInstalledPluginVersion();
+            p.log.success(`Hindsight plugin v${newVersion} installed`);
         }
         catch {
             p.cancel("Failed to install plugin. Run manually:\n  openclaw plugins install @vectorize-io/hindsight-openclaw");
             process.exit(1);
         }
     }
+    else if (currentVersion) {
+        p.log.info(`Hindsight plugin v${currentVersion}`);
+    }
     if (!isPluginConfigured()) {
         p.log.warn("Hindsight plugin needs configuration.");
         try {
@@ -262,6 +280,370 @@ async function ensurePlugin() {
         }
     }
 }
+// ── NemoClaw plugin management ─────────────────────────
+function listNemoClawSandboxes() {
+    try {
+        const out = execSync("nemoclaw list", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        return out
+            .split("\n")
+            .filter((l) => /^\s{4}\S/.test(l) && !l.includes("model:") && !l.includes("dashboard:"))
+            .map((l) => l.trim().replace(/\s*\*$/, ""));
+    }
+    catch {
+        return [];
+    }
+}
+async function detectNemoClawSandbox() {
+    const sandboxes = listNemoClawSandboxes();
+    if (sandboxes.length === 0) {
+        p.cancel("No NemoClaw sandboxes found. Create one with: nemoclaw onboard");
+        process.exit(1);
+    }
+    if (sandboxes.length === 1) {
+        p.log.info(`Using sandbox: ${color.cyan(sandboxes[0])}`);
+        return sandboxes[0];
+    }
+    const selected = await p.select({
+        message: "Select a NemoClaw sandbox:",
+        options: sandboxes.map((s) => ({ value: s, label: s })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    return selected;
+}
+async function ensureNemoClawPlugin(sandboxName, agentId) {
+    // Check nemoclaw is installed
+    try {
+        execSync("which nemoclaw", { stdio: "pipe" });
+    }
+    catch {
+        p.cancel("nemoclaw not found. Install it: curl -fsSL https://www.nvidia.com/nemoclaw.sh | bash");
+        process.exit(1);
+    }
+    // Check sandbox exists
+    try {
+        execSync(`nemoclaw ${sandboxName} status`, { stdio: "pipe" });
+    }
+    catch {
+        p.cancel(`Sandbox '${sandboxName}' not found. Create one with: nemoclaw onboard`);
+        process.exit(1);
+    }
+    // NemoClaw runs OpenClaw inside a sandbox with read-only config (Landlock).
+    // hindsight-nemoclaw setup handles everything:
+    //   1. Installs the openclaw plugin
+    //   2. Writes plugin config to host ~/.openclaw/openclaw.json
+    //   3. Adds the Hindsight network policy to the sandbox
+    //   4. Restarts the gateway
+    // We always run it — it's idempotent and ensures the sandbox has the
+    // network policy even if the host already has the plugin configured.
+    const config = readOpenClawConfig();
+    const pc = config?.plugins?.entries?.["hindsight-openclaw"]?.config || {};
+    if (!pc.hindsightApiUrl || !pc.hindsightApiToken) {
+        // No Hindsight config at all — run interactive setup
+        p.log.warn("Hindsight plugin needs configuration for NemoClaw.");
+        try {
+            execSync(`npx --yes --package @vectorize-io/hindsight-nemoclaw hindsight-nemoclaw setup --sandbox ${sandboxName}`, { stdio: "inherit" });
+        }
+        catch {
+            p.cancel("Plugin setup failed. Run manually:\n  npx --yes --package @vectorize-io/hindsight-nemoclaw hindsight-nemoclaw setup --sandbox " +
+                sandboxName);
+            process.exit(1);
+        }
+    }
+    else {
+        // Config exists — run non-interactive setup to ensure network policy + plugin are in place
+        const apiUrl = pc.hindsightApiUrl;
+        const apiToken = pc.hindsightApiToken;
+        const bankPrefix = pc.bankIdPrefix || "nemoclaw";
+        p.log.info(`Hindsight: ${color.cyan(`External: ${apiUrl}`)}`);
+        try {
+            execSync(`npx --yes --package @vectorize-io/hindsight-nemoclaw hindsight-nemoclaw setup` +
+                ` --sandbox ${sandboxName}` +
+                ` --api-url ${apiUrl}` +
+                ` --api-token ${apiToken}` +
+                ` --bank-prefix ${bankPrefix}` +
+                ` --skip-plugin-install`, { stdio: "inherit" });
+        }
+        catch {
+            p.cancel(`Failed to apply sandbox network policy.\n` +
+                `  The sandbox may have been destroyed. Check with: nemoclaw list\n` +
+                `  Recreate with: nemoclaw onboard`);
+            process.exit(1);
+        }
+    }
+    enableKnowledgeTools();
+    // Rebuild sandbox so it picks up the latest host config
+    p.log.info("Rebuilding sandbox to apply config...");
+    try {
+        execSync(`nemoclaw ${sandboxName} rebuild --yes`, { stdio: "inherit" });
+        p.log.success("Sandbox rebuilt");
+    }
+    catch {
+        p.cancel(`Failed to rebuild sandbox '${sandboxName}'.\n` +
+            `  Check with: nemoclaw list\n` +
+            `  Recreate with: nemoclaw onboard`);
+        process.exit(1);
+    }
+}
+// ── Hermes plugin management ───────────────────────────
+function ensureHermesPlugin(agentId, apiUrl, bankId, apiToken) {
+    // Check hermes is installed
+    try {
+        execSync("which hermes", { stdio: "pipe" });
+    }
+    catch {
+        p.cancel("hermes not found. Install it: curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash");
+        process.exit(1);
+    }
+    // Create a Hermes profile for this agent (or reuse if exists)
+    let profileHome;
+    try {
+        const showOut = execSync(`hermes profile show ${agentId}`, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const pathMatch = showOut.match(/Path:\s+(\S+)/);
+        profileHome = pathMatch ? pathMatch[1] : join(homedir(), ".hermes", "profiles", agentId);
+        p.log.info(`Hermes profile '${agentId}' already exists`);
+    }
+    catch {
+        // Profile doesn't exist — create it (clone config from default)
+        try {
+            execSync(`hermes profile create ${agentId} --clone`, {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            const showOut = execSync(`hermes profile show ${agentId}`, {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            const pathMatch = showOut.match(/Path:\s+(\S+)/);
+            profileHome = pathMatch ? pathMatch[1] : join(homedir(), ".hermes", "profiles", agentId);
+            p.log.success(`Hermes profile '${agentId}' created`);
+        }
+        catch (err) {
+            const msg = err?.stderr?.toString?.()?.trim() || err?.message || String(err);
+            p.cancel(`Failed to create Hermes profile: ${msg}`);
+            process.exit(1);
+        }
+    }
+    // Install plugin into the profile
+    const pluginDir = join(profileHome, "plugins", "hindsight-sda");
+    const sdaPluginSrc = join(__dirname, "..", "hermes-plugin");
+    mkdirSync(pluginDir, { recursive: true });
+    for (const file of ["plugin.yaml", "__init__.py"]) {
+        const src = join(sdaPluginSrc, file);
+        if (existsSync(src)) {
+            writeFileSync(join(pluginDir, file), readFileSync(src, "utf-8"));
+        }
+    }
+    p.log.success("Hermes plugin installed");
+    // Write hindsight/config.json in the profile — single source of truth for
+    // both the bundled hindsight provider (auto-retain) and our tool plugin.
+    // Static bank_id, no template — both read the same bank.
+    const hindsightCfgDir = join(profileHome, "hindsight");
+    mkdirSync(hindsightCfgDir, { recursive: true });
+    writeFileSync(join(hindsightCfgDir, "config.json"), JSON.stringify({
+        mode: "cloud",
+        api_url: apiUrl,
+        api_key: apiToken,
+        bank_id: bankId,
+        bank_id_template: "",
+        recall_budget: "mid",
+        memory_mode: "hybrid",
+    }, null, 2) + "\n");
+    // Set the bundled hindsight as memory provider + enable our plugin in config.yaml
+    const hermesConfigPath = join(profileHome, "config.yaml");
+    if (existsSync(hermesConfigPath)) {
+        let config = readFileSync(hermesConfigPath, "utf-8");
+        // Set memory.provider to hindsight (bundled provider for auto-retain)
+        const lines = config.split("\n");
+        let inMemory = false;
+        for (let i = 0; i < lines.length; i++) {
+            if (/^memory:/.test(lines[i]))
+                inMemory = true;
+            else if (/^\S/.test(lines[i]) && inMemory)
+                inMemory = false;
+            if (inMemory && /^\s+provider:\s/.test(lines[i])) {
+                lines[i] = lines[i].replace(/provider:\s*\S+/, "provider: hindsight");
+                break;
+            }
+        }
+        config = lines.join("\n");
+        // Enable our tool plugin in plugins.enabled
+        if (!config.includes("hindsight-sda")) {
+            if (/plugins:\s*\n\s+enabled:/.test(config)) {
+                config = config.replace(/(plugins:\s*\n\s+enabled:\s*\n)/, "$1    - hindsight-sda\n");
+            }
+            else if (/plugins:/.test(config)) {
+                config = config.replace(/(plugins:)/, "$1\n  enabled:\n    - hindsight-sda");
+            }
+            else {
+                config += "\nplugins:\n  enabled:\n    - hindsight-sda\n";
+            }
+        }
+        writeFileSync(hermesConfigPath, config);
+    }
+    p.log.success("Hindsight memory + knowledge tools configured");
+    // Install skill into the profile
+    const skillDir = join(profileHome, "skills", "agent-knowledge");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), SKILL_MD);
+    p.log.success("Knowledge skill installed");
+}
+// ── Claude skill generation ────────────────────────────
+const CLAUDE_SKILLS_DIR = join(homedir(), "self-driving-agents", "claude");
+const HINDSIGHT_CLOUD_API_URL = "https://api.hindsight.vectorize.io";
+async function generateClaudeSkill(agentId, apiUrl, bankId, apiToken) {
+    const authHeader = apiToken ? `-H "Authorization: Bearer ${apiToken}" \\\n      ` : "";
+    const skillMd = `# Hindsight Memory — ${agentId}
+
+## Mandatory Startup Sequence
+
+On every new conversation, run these commands **before doing anything else**:
+
+### 1. List all knowledge pages
+\`\`\`bash
+curl -s ${apiUrl}/v1/default/banks/${bankId}/knowledge/pages \\
+  ${authHeader}-H "Content-Type: application/json"
+\`\`\`
+
+### 2. Read each page (replace PAGE_ID)
+\`\`\`bash
+curl -s ${apiUrl}/v1/default/banks/${bankId}/knowledge/pages/PAGE_ID \\
+  ${authHeader}-H "Content-Type: application/json"
+\`\`\`
+
+Read **every** page listed in step 1 to load the agent's full knowledge base.
+
+## Creating Knowledge Pages
+
+\`\`\`bash
+curl -s -X POST ${apiUrl}/v1/default/banks/${bankId}/knowledge/pages \\
+  ${authHeader}-H "Content-Type: application/json" \\
+  -d '{"title": "Page Title", "content": "Markdown content here"}'
+\`\`\`
+
+## Searching Memories
+
+\`\`\`bash
+curl -s -X POST ${apiUrl}/v1/default/banks/${bankId}/memories/recall \\
+  ${authHeader}-H "Content-Type: application/json" \\
+  -d '{"query": "your search query"}'
+\`\`\`
+
+## Ingesting Documents
+
+\`\`\`bash
+curl -s -X POST ${apiUrl}/v1/default/banks/${bankId}/memories/retain \\
+  ${authHeader}-H "Content-Type: application/json" \\
+  -d '{"content": "Document content to remember"}'
+\`\`\`
+
+## Updating Knowledge Pages
+
+\`\`\`bash
+curl -s -X PUT ${apiUrl}/v1/default/banks/${bankId}/knowledge/pages/PAGE_ID \\
+  ${authHeader}-H "Content-Type: application/json" \\
+  -d '{"title": "Updated Title", "content": "Updated content"}'
+\`\`\`
+
+## Deleting Knowledge Pages
+
+\`\`\`bash
+curl -s -X DELETE ${apiUrl}/v1/default/banks/${bankId}/knowledge/pages/PAGE_ID \\
+  ${authHeader}-H "Content-Type: application/json"
+\`\`\`
+
+## Retaining Conversations
+
+Claude Chat and Cowork do not have automatic hooks. You must **self-retain** important conversation content.
+
+After any significant exchange (decisions, new information, task outcomes), retain it:
+
+\`\`\`bash
+curl -s -X POST ${apiUrl}/v1/default/banks/${bankId}/memories/retain \\
+  ${authHeader}-H "Content-Type: application/json" \\
+  -d '{"content": "Summary of the conversation or key information learned"}'
+\`\`\`
+
+**When to self-retain:**
+- After learning user preferences or project context
+- After completing a task (retain the outcome)
+- After receiving corrections or feedback
+- After discovering important facts during research
+
+## Important Notes
+
+- Always run the startup sequence at the beginning of every conversation
+- Knowledge pages are persistent — they survive across conversations
+- Use recall to search existing memories before creating duplicates
+- Self-retain is essential since there are no automatic hooks in Claude Chat/Cowork
+`;
+    const outDir = join(CLAUDE_SKILLS_DIR, agentId);
+    mkdirSync(outDir, { recursive: true });
+    const skillPath = join(outDir, "SKILL.md");
+    writeFileSync(skillPath, skillMd);
+    // Create a zip of the skill directory
+    const zipPath = join(outDir, `${agentId}-skill.zip`);
+    execSync(`cd "${outDir}" && zip -j "${zipPath}" SKILL.md`, { stdio: "pipe" });
+    return zipPath;
+}
+async function promptClaudeConfig(agentId) {
+    const deploymentType = await p.select({
+        message: "Hindsight deployment:",
+        options: [
+            { value: "cloud", label: "Cloud (api.hindsight.vectorize.io)" },
+            { value: "self-hosted", label: "Self-hosted" },
+        ],
+    });
+    if (p.isCancel(deploymentType)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    let apiUrl;
+    if (deploymentType === "cloud") {
+        apiUrl = HINDSIGHT_CLOUD_API_URL;
+    }
+    else {
+        const urlInput = await p.text({
+            message: "Hindsight API URL:",
+            placeholder: "https://your-hindsight.example.com",
+            validate: (val) => {
+                if (!val)
+                    return "URL is required";
+                if (val.startsWith("http://localhost") || val.startsWith("http://127.0.0.1")) {
+                    return "Claude cannot reach localhost. Use a publicly accessible URL.";
+                }
+                return undefined;
+            },
+        });
+        if (p.isCancel(urlInput)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        apiUrl = urlInput;
+        p.log.warn("Make sure your Hindsight instance is publicly accessible from Claude's servers.");
+    }
+    const tokenInput = await p.text({ message: "Hindsight API token:" });
+    if (p.isCancel(tokenInput)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const apiToken = tokenInput || undefined;
+    const bankInput = await p.text({
+        message: "Bank ID:",
+        initialValue: agentId,
+    });
+    if (p.isCancel(bankInput)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const bankId = bankInput.trim() || agentId;
+    return { apiUrl, bankId, apiToken };
+}
 // ── Main ────────────────────────────────────────────────
 async function main() {
     const args = process.argv.slice(2);
@@ -278,8 +660,9 @@ async function main() {
     ${color.cyan("./local-dir")}                 → local directory
 
   ${color.dim("Options:")}
-    ${color.cyan("--harness <h>")}      Required. openclaw | hermes | claude-code
+    ${color.cyan("--harness <h>")}      Required. openclaw | nemoclaw | hermes | claude | claude-code
     ${color.cyan("--agent <name>")}     Agent name (defaults to directory name)
+    ${color.cyan("--sandbox <name>")}   NemoClaw sandbox (auto-detected if only one exists)
 `);
         process.exit(0);
     }
@@ -291,30 +674,204 @@ async function main() {
     }
     let harness;
     let agentName;
+    let sandbox;
     for (let i = 0; i < restArgs.length; i++) {
         if (restArgs[i] === "--harness" && restArgs[i + 1])
             harness = restArgs[++i];
         else if (restArgs[i] === "--agent" && restArgs[i + 1])
             agentName = restArgs[++i];
+        else if (restArgs[i] === "--sandbox" && restArgs[i + 1])
+            sandbox = restArgs[++i];
     }
     if (!harness) {
-        p.cancel("--harness required (openclaw | hermes | claude-code)");
+        p.cancel("--harness required (openclaw | nemoclaw | hermes | claude | claude-code)");
         process.exit(1);
     }
+    if (harness === "nemoclaw" && !sandbox) {
+        sandbox = await detectNemoClawSandbox();
+    }
     p.intro(color.bgCyan(color.black(` self-driving-agents `)));
     // Step 0: Resolve agent directory (local or GitHub)
     const spin = p.spinner();
     const { dir, source, defaultName, cleanup } = await resolveAgentDir(dirArg, spin);
     try {
-        const agentId = agentName || defaultName;
+        let agentId;
+        if (agentName) {
+            agentId = agentName;
+        }
+        else if (process.stdin.isTTY) {
+            const nameInput = await p.text({
+                message: "Agent name:",
+                initialValue: defaultName,
+            });
+            if (p.isCancel(nameInput)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            agentId = nameInput.trim() || defaultName;
+        }
+        else {
+            agentId = defaultName;
+        }
         // Step 1: Ensure plugin
+        let apiUrl;
+        let bankId;
+        let apiToken;
+        let claudeSkillZip;
         if (harness === "openclaw") {
             await ensurePlugin();
             enableKnowledgeTools();
+            ({ apiUrl, bankId, apiToken } = resolveFromPlugin(agentId));
+        }
+        else if (harness === "nemoclaw") {
+            await ensureNemoClawPlugin(sandbox, agentId);
+            ({ apiUrl, bankId, apiToken } = resolveFromPlugin(agentId));
+        }
+        else if (harness === "hermes") {
+            // Resolve Hindsight connection: hermes config > openclaw config > prompt
+            const hermesHsCfgPath = join(homedir(), ".hermes", "hindsight", "config.json");
+            let defaultUrl = "https://api.hindsight.vectorize.io";
+            let defaultToken = "";
+            // Check existing hermes hindsight config first
+            if (existsSync(hermesHsCfgPath)) {
+                try {
+                    const hsCfg = JSON.parse(readFileSync(hermesHsCfgPath, "utf-8"));
+                    if (hsCfg.api_url)
+                        defaultUrl = hsCfg.api_url;
+                    if (hsCfg.api_key)
+                        defaultToken = hsCfg.api_key;
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            // Fall back to openclaw config
+            if (!defaultToken) {
+                const config = readOpenClawConfig();
+                const pc = config?.plugins?.entries?.["hindsight-openclaw"]?.config;
+                if (pc?.hindsightApiUrl)
+                    defaultUrl = pc.hindsightApiUrl;
+                if (pc?.hindsightApiToken)
+                    defaultToken = pc.hindsightApiToken;
+            }
+            // If we have credentials, confirm; otherwise prompt
+            if (defaultUrl && defaultToken) {
+                const ok = await p.confirm({
+                    message: `Hindsight: ${color.cyan(defaultUrl)}. Use this?`,
+                });
+                if (p.isCancel(ok)) {
+                    p.cancel("Cancelled.");
+                    process.exit(0);
+                }
+                if (ok) {
+                    apiUrl = defaultUrl;
+                    apiToken = defaultToken;
+                }
+                else {
+                    const urlInput = await p.text({
+                        message: "Hindsight API URL:",
+                        initialValue: defaultUrl,
+                    });
+                    if (p.isCancel(urlInput)) {
+                        p.cancel("Cancelled.");
+                        process.exit(0);
+                    }
+                    const tokenInput = await p.text({ message: "Hindsight API token:" });
+                    if (p.isCancel(tokenInput)) {
+                        p.cancel("Cancelled.");
+                        process.exit(0);
+                    }
+                    apiUrl = urlInput;
+                    apiToken = tokenInput;
+                }
+            }
+            else {
+                const urlInput = await p.text({ message: "Hindsight API URL:", initialValue: defaultUrl });
+                if (p.isCancel(urlInput)) {
+                    p.cancel("Cancelled.");
+                    process.exit(0);
+                }
+                const tokenInput = await p.text({ message: "Hindsight API token:" });
+                if (p.isCancel(tokenInput)) {
+                    p.cancel("Cancelled.");
+                    process.exit(0);
+                }
+                apiUrl = urlInput;
+                apiToken = tokenInput;
+            }
+            bankId = agentId;
+            ensureHermesPlugin(agentId, apiUrl, bankId, apiToken);
         }
-        // Step 2: Resolve bank + API from plugin config
-        const { apiUrl, bankId, apiToken } = resolveFromPlugin(agentId);
-        const workspaceDir = join(homedir(), ".self-driving-agents", "openclaw", agentId);
+        else if (harness === "claude") {
+            const claudeConfig = await promptClaudeConfig(agentId);
+            apiUrl = claudeConfig.apiUrl;
+            bankId = claudeConfig.bankId;
+            apiToken = claudeConfig.apiToken;
+        }
+        else if (harness === "claude-code") {
+            // Claude Code: just save content locally, Claude handles the rest via skill
+            const contentDir = join(homedir(), ".self-driving-agents", "claude-code", agentId);
+            mkdirSync(contentDir, { recursive: true });
+            // Copy content files to the local dir
+            const contentFiles = findContentFiles(dir);
+            for (const relPath of contentFiles) {
+                const destPath = join(contentDir, relPath);
+                mkdirSync(join(destPath, ".."), { recursive: true });
+                writeFileSync(destPath, readFileSync(join(dir, relPath), "utf-8"));
+            }
+            // Copy bank-template.json if present (has mental model definitions)
+            const templateSrc = join(dir, "bank-template.json");
+            if (existsSync(templateSrc)) {
+                writeFileSync(join(contentDir, "bank-template.json"), readFileSync(templateSrc, "utf-8"));
+            }
+            p.log.success(`Content saved to ${color.dim(contentDir)} (${contentFiles.length} files)`);
+            // Auto-approve hindsight MCP tools and skills in user settings
+            const userSettingsPath = join(homedir(), ".claude", "settings.json");
+            let userSettings = {};
+            if (existsSync(userSettingsPath)) {
+                try {
+                    userSettings = JSON.parse(readFileSync(userSettingsPath, "utf-8"));
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            const allowedTools = userSettings.allowedTools || [];
+            const toolsToAllow = [
+                "mcp__hindsight__*",
+                "Skill(hindsight-memory:create-agent)",
+                `Bash(ls ~/.self-driving-agents/*)`,
+                `Bash(cat ~/.self-driving-agents/*)`,
+            ];
+            let updated = false;
+            for (const tool of toolsToAllow) {
+                if (!allowedTools.includes(tool)) {
+                    allowedTools.push(tool);
+                    updated = true;
+                }
+            }
+            if (updated) {
+                userSettings.allowedTools = allowedTools;
+                writeFileSync(userSettingsPath, JSON.stringify(userSettings, null, 2) + "\n");
+                p.log.success("Auto-approved hindsight tools in Claude Code");
+            }
+            const hasBankTemplate = existsSync(join(contentDir, "bank-template.json"));
+            const prompt = hasBankTemplate
+                ? `Use /hindsight-memory:create-agent to create a "${agentId}" agent. Then ingest all files from ${contentDir}/ (skip bank-template.json). Read ${contentDir}/bank-template.json and create the exact mental models (knowledge pages) defined in its "mental_models" array using agent_knowledge_create_page for each one.`
+                : `Use /hindsight-memory:create-agent to create a "${agentId}" agent. Then ingest all files from ${contentDir}/ and create 3 knowledge pages that make sense based on the content.`;
+            p.note([
+                `${color.dim("1.")} Start Claude Code`,
+                `${color.dim("2.")} Say: ${color.cyan(prompt)}`,
+            ].join("\n"), "Next steps");
+            p.outro(color.green(`'${agentId}' content ready`));
+            cleanup?.();
+            return;
+        }
+        else {
+            p.cancel(`Unknown harness: ${harness}`);
+            process.exit(1);
+        }
+        const workspaceDir = join(homedir(), ".self-driving-agents", harness, agentId);
         p.log.info([
             `Agent:     ${color.bold(agentId)}`,
             `Source:    ${color.dim(source)}`,
@@ -372,19 +929,49 @@ async function main() {
             }
             spin.stop(`Ingested ${contentFiles.length} file(s)`);
         }
-        // Step 6: Create agent + install skill
-        mkdirSync(workspaceDir, { recursive: true });
-        const skillDir = join(workspaceDir, "skills", "agent-knowledge");
-        mkdirSync(skillDir, { recursive: true });
-        writeFileSync(join(skillDir, "SKILL.md"), SKILL_MD);
-        p.log.success("Knowledge skill installed");
-        if (harness === "openclaw") {
+        // Step 6: Create agent + install skill (hermes handled in ensureHermesPlugin)
+        if (harness === "claude") {
+            claudeSkillZip = await generateClaudeSkill(agentId, apiUrl, bankId, apiToken);
+        }
+        else if (harness === "hermes") {
+            // Skill + plugin already installed by ensureHermesPlugin
+        }
+        else if (harness === "nemoclaw") {
+            // NemoClaw: install skill into the sandbox via nemoclaw CLI
+            const tmpSkillDir = join(tmpdir(), `sda-skill-${Date.now()}`);
+            const tmpSkill = join(tmpSkillDir, "agent-knowledge");
+            mkdirSync(tmpSkill, { recursive: true });
+            writeFileSync(join(tmpSkill, "SKILL.md"), SKILL_MD);
+            try {
+                execSync(`nemoclaw ${sandbox} skill install ${tmpSkill}`, { stdio: "inherit" });
+                p.log.success("Knowledge skill installed in sandbox");
+            }
+            catch (err) {
+                const stderr = err?.stderr?.toString?.()?.trim() || "";
+                const msg = stderr || err?.message || String(err);
+                p.log.warn(`Failed to install skill: ${msg}\n  Install manually:\n  nemoclaw ${sandbox} skill install <skill-dir>`);
+            }
+            finally {
+                rmSync(tmpSkillDir, { recursive: true, force: true });
+            }
+        }
+        else {
+            // OpenClaw: install skill locally + create agent
+            mkdirSync(workspaceDir, { recursive: true });
+            const skillDir = join(workspaceDir, "skills", "agent-knowledge");
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, "SKILL.md"), SKILL_MD);
+            p.log.success("Knowledge skill installed");
             try {
-                const listOut = execSync("openclaw agents list --json 2>/dev/null", { encoding: "utf-8" });
+                const listOut = execSync("openclaw agents list --json", {
+                    encoding: "utf-8",
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
                 const agents = parseAgentsJson(listOut);
                 if (!agents.some((a) => a.name === agentId || a.id === agentId)) {
                     execSync(`openclaw agents add ${agentId} --workspace ${workspaceDir} --non-interactive`, {
-                        stdio: "pipe",
+                        encoding: "utf-8",
+                        stdio: ["pipe", "pipe", "pipe"],
                     });
                     p.log.success(`Agent '${agentId}' created`);
                 }
@@ -392,24 +979,49 @@ async function main() {
                     p.log.info(`Agent '${agentId}' already exists`);
                 }
             }
-            catch {
-                p.log.warn(`Create agent manually:\n  openclaw agents add ${agentId} --workspace ${workspaceDir} --non-interactive`);
+            catch (err) {
+                const stderr = err?.stderr?.toString?.()?.trim() || "";
+                const msg = stderr || err?.message || String(err);
+                p.log.warn(`Failed to manage agent: ${msg}\n  Create manually:\n  openclaw agents add ${agentId} --workspace ${workspaceDir} --non-interactive`);
             }
-        }
-        // Step 7: Patch startup
-        const startupFile = join(workspaceDir, "AGENTS.md");
-        if (existsSync(startupFile)) {
-            let text = readFileSync(startupFile, "utf-8");
-            if (!text.includes("agent-knowledge")) {
-                text = text.replace("Don't ask permission. Just do it.", "5. Read `skills/agent-knowledge/SKILL.md` and **execute its mandatory startup sequence**\n\nDon't ask permission. Just do it.");
-                writeFileSync(startupFile, text);
-                p.log.success("Startup patched");
+            // Patch startup
+            const startupFile = join(workspaceDir, "AGENTS.md");
+            if (existsSync(startupFile)) {
+                let text = readFileSync(startupFile, "utf-8");
+                if (!text.includes("agent-knowledge")) {
+                    text = text.replace("Don't ask permission. Just do it.", "5. Read `skills/agent-knowledge/SKILL.md` and **execute its mandatory startup sequence**\n\nDon't ask permission. Just do it.");
+                    writeFileSync(startupFile, text);
+                    p.log.success("Startup patched");
+                }
             }
         }
-        p.note([
-            `${color.dim("1.")} openclaw gateway restart`,
-            `${color.dim("2.")} openclaw tui --session agent:${agentId}:main:session1`,
-        ].join("\n"), "Next steps");
+        // Next steps
+        let nextSteps;
+        if (harness === "claude") {
+            const apiHost = new URL(apiUrl).hostname;
+            nextSteps = [
+                `${color.dim("1.")} Open Claude → Customize → Skills → Upload skill`,
+                `${color.dim("2.")} Select: ${color.cyan(claudeSkillZip)}`,
+                `${color.dim("3.")} Allowlist the API host: Settings → Capabilities → add ${color.cyan(apiHost)}`,
+                `${color.dim("4.")} Start a conversation and type ${color.cyan(`/${agentId}`)} to activate the agent`,
+            ];
+        }
+        else if (harness === "hermes") {
+            nextSteps = [`${color.dim("1.")} hermes -p ${agentId} chat`];
+        }
+        else if (harness === "nemoclaw") {
+            nextSteps = [
+                `${color.dim("1.")} nemoclaw ${sandbox} connect`,
+                `${color.dim("2.")} openclaw tui --session agent:main:main:session1`,
+            ];
+        }
+        else {
+            nextSteps = [
+                `${color.dim("1.")} openclaw gateway restart`,
+                `${color.dim("2.")} openclaw tui --session agent:${agentId}:main:session1`,
+            ];
+        }
+        p.note(nextSteps.join("\n"), "Next steps");
         p.outro(color.green(`'${agentId}' is ready`));
     }
     finally {