@intent-systems/nexus 2026.1.5-5 → 2026.1.5-8

package/dist/commands/cursor-rules.js

@@ -1,10 +1,7 @@
-import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
-import { resolveStateDir } from "../config/paths.js";
 import { defaultRuntime } from "../runtime.js";
-import { MANAGED_SKILLS_DIR, NEXUS_ROOT, resolveUserPath } from "../utils.js";
-import { flattenManifest, generateSkillManifest, readSkillManifest, } from "./skills-manifest.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR, WORKSPACE_SKILLS_DIR, resolveUserPath, } from "../utils.js";
 /**
  * Generate and write `.cursor/rules` for a given workspace.
  *
@@ -12,8 +9,7 @@ import { flattenManifest, generateSkillManifest, readSkillManifest, } from "./sk
  *   nexus cursor-rules [--workspace <path>]
  */
 export async function cursorRulesCommand(opts, runtime = defaultRuntime) {
-    const workspaceDir = opts?.workspace?.trim() ||
-        path.join(process.env.HOME || "~", "nexus", "home");
+    const workspaceDir = opts?.workspace?.trim() || NEXUS_ROOT;
     const resolvedWorkspace = resolveUserPath(workspaceDir);
     runtime.log(`Generating .cursor/rules for workspace: ${resolvedWorkspace}`);
     const outputPath = await writeCursorRules({
@@ -24,214 +20,24 @@ export async function cursorRulesCommand(opts, runtime = defaultRuntime) {
     });
     runtime.log(`✓ Wrote ${outputPath}`);
 }
-/**
- * Group skills by category based on their description/name
- */
-function categorizeSkills(skills) {
-    const categories = {
-        "Communication & Messaging": [],
-        "Productivity & Notes": [],
-        "Google & Cloud Services": [],
-        "Media & Content": [],
-        "Smart Home & Devices": [],
-        "Development & Tools": [],
-        Other: [],
-    };
-    const categoryPatterns = [
-        [
-            "Communication & Messaging",
-            [/imsg|imessage|whatsapp|discord|slack|telegram|sms|message|chat/i],
-        ],
-        [
-            "Productivity & Notes",
-            [/note|reminder|bear|obsidian|notion|things|trello|task|todo/i],
-        ],
-        [
-            "Google & Cloud Services",
-            [/google|gmail|calendar|drive|sheets|docs|gemini|gog|places/i],
-        ],
-        [
-            "Media & Content",
-            [/image|video|audio|camera|gif|pdf|whisper|speech|photo|screenshot/i],
-        ],
-        [
-            "Smart Home & Devices",
-            [/hue|sonos|spotify|eight|sleep|smart|home|light|speaker/i],
-        ],
-        [
-            "Development & Tools",
-            [/github|git|code|coding|terminal|bash|cli|api|mcp|1password|search/i],
-        ],
-    ];
-    for (const skill of skills) {
-        const text = `${skill.name} ${skill.description || ""}`;
-        let matched = false;
-        for (const [category, patterns] of categoryPatterns) {
-            if (patterns.some((p) => p.test(text))) {
-                categories[category].push(skill);
-                matched = true;
-                break;
-            }
-        }
-        if (!matched) {
-            categories.Other.push(skill);
-        }
-    }
-    return categories;
-}
-/**
- * Format skill entries for the rules file
- */
-function formatSkillsSection(skills) {
-    const categories = categorizeSkills(skills);
-    const lines = [];
-    for (const [category, categorySkills] of Object.entries(categories)) {
-        if (categorySkills.length === 0)
-            continue;
-        lines.push(`### ${category}`);
-        for (const skill of categorySkills.sort((a, b) => a.name.localeCompare(b.name))) {
-            const desc = skill.description
-                ? skill.description.slice(0, 80) +
-                    (skill.description.length > 80 ? "..." : "")
-                : "(no description)";
-            lines.push(`- **${skill.name}**: ${desc}`);
-        }
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-/**
- * Load AGENTS.md from the Nexus root
- */
-async function loadAgentsMd(workspaceDir) {
-    const candidates = [
-        path.join(NEXUS_ROOT, "AGENTS.md"),
-        path.join(workspaceDir, "AGENTS.md"),
-        path.join(workspaceDir, ".intent", "AGENTS.md"),
-    ];
-    for (const candidate of candidates) {
-        try {
-            if (fs.existsSync(candidate)) {
-                return await fsp.readFile(candidate, "utf-8");
-            }
-        }
-        catch {
-            // continue
-        }
-    }
-    return undefined;
-}
-/**
- * Load bootstrap files (IDENTITY.md, PROFILE.md, SOUL.md) if they exist
- */
-async function loadBootstrapFiles(_workspaceDir) {
-    const files = {};
-    const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
-    const stateDir = resolveStateDir();
-    const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
-    const userIdentityDir = path.join(stateDir, "user", "identity");
-    const bootstrapFiles = ["IDENTITY.md", "PROFILE.md", "SOUL.md"];
-    for (const filename of bootstrapFiles) {
-        const candidates = filename === "PROFILE.md"
-            ? [path.join(userIdentityDir, filename)]
-            : [path.join(agentIdentityDir, filename)];
-        for (const candidate of candidates) {
-            try {
-                if (fs.existsSync(candidate)) {
-                    files[filename] = await fsp.readFile(candidate, "utf-8");
-                    break;
-                }
-            }
-            catch {
-                // continue
-            }
-        }
-    }
-    return files;
-}
 /**
  * Generate .cursor/rules content from Nexus skills and config
  */
 export async function generateCursorRules(options = {}) {
-    const workspaceDir = options.workspaceDir || process.cwd();
-    const skillsDir = options.skillsDir || MANAGED_SKILLS_DIR;
-    const userSkillsDir = options.userSkillsDir || path.join(NEXUS_ROOT, "home", "skills");
-    const managedSkillsDir = path.join(skillsDir, "managed");
-    // Try to read existing manifest, or generate one
-    let manifest = await readSkillManifest();
-    if (!manifest) {
-        manifest = await generateSkillManifest(skillsDir, userSkillsDir);
-    }
-    const skills = flattenManifest(manifest);
-    const skillsSection = formatSkillsSection(skills);
-    // Load AGENTS.md if requested
-    let agentsMdSection = "";
-    if (options.includeAgentsMd !== false) {
-        const agentsMd = await loadAgentsMd(workspaceDir);
-        if (agentsMd) {
-            agentsMdSection = `
-## Project Guidelines (from AGENTS.md)
-
-${agentsMd}
-`;
-        }
-    }
-    // Load bootstrap files if requested
-    let bootstrapSection = "";
-    if (options.includeBootstrap) {
-        const bootstrapFiles = await loadBootstrapFiles(workspaceDir);
-        if (Object.keys(bootstrapFiles).length > 0) {
-            const parts = [];
-            for (const [filename, content] of Object.entries(bootstrapFiles)) {
-                parts.push(`### ${filename}\n\n${content}`);
-            }
-            bootstrapSection = `
-## User Context
-
-${parts.join("\n\n")}
-`;
-        }
-    }
-    const rules = `# Nexus Workspace Rules
-
-This file is auto-generated by \`nexus cursor-rules\`. Regenerate with:
-\`\`\`bash
-nexus cursor-rules --output .cursor/rules
-\`\`\`
-
-## Available Skills (${skills.length} total)
-
-The following skills are available in \`${skillsDir}\`. Read the full \`SKILL.md\` when you need detailed usage instructions.
-
-${skillsSection}
-## How to Use Skills
-
-1. **When a user's request relates to a skill**, read the corresponding SKILL.md:
-   \`\`\`bash
-   cat ${path.join(skillsDir, "<skill>", "SKILL.md")}
-   \`\`\`
-
-2. **Skills provide CLI tools** - use bash to run them:
-   \`\`\`bash
-   eve db query --sql "SELECT * FROM messages LIMIT 5"
-   imsg chats --limit 10 --json
-   gog gmail search "is:unread" --max 5
-   \`\`\`
-
-3. **Most tools support \`--json\`** for structured output.
+    const skillsDir = options.skillsDir || WORKSPACE_SKILLS_DIR;
+    const agentsPath = path.join(NEXUS_ROOT, "AGENTS.md");
+    const rules = `# Nexus Workspace - Cursor Configuration
 
-4. **Check if a tool is installed** before using:
-   \`\`\`bash
-   which eve imsg gog
-   \`\`\`
-${agentsMdSection}${bootstrapSection}
-## Skill Directory Structure
+This workspace uses Nexus. Follow the root \`AGENTS.md\` file for all protocols.
 
-- **Bundled**: \`${skillsDir}\` (${manifest.bundled.count} skills)
-- **Managed**: \`${managedSkillsDir}\` (${manifest.managed.count} skills)
-- **User**: \`${userSkillsDir}\` (${manifest.user.count} skills)
+## Cursor-Specific
 
-Precedence: User > Managed > Bundled
+- 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`;
 }

package/dist/commands/identity.js

@@ -30,8 +30,8 @@ export async function identityCommand(opts, runtime = defaultRuntime) {
         },
         user: {
             name: identity.userName,
-            profilePath: identity.userProfilePath,
-            exists: identity.userProfileExists,
+            identityPath: identity.userIdentityPath,
+            exists: identity.userIdentityExists,
         },
     };
     if (opts.json) {
@@ -40,7 +40,7 @@ export async function identityCommand(opts, runtime = defaultRuntime) {
     }
     if (!opts.target || opts.target === "user") {
         runtime.log(`User: ${payload.user.name ?? "(unknown)"}`);
-        runtime.log(`  ${payload.user.profilePath}`);
+        runtime.log(`  ${payload.user.identityPath}`);
     }
     if (!opts.target || opts.target === "agent") {
         runtime.log(`Agent: ${payload.agent.name ?? "(unknown)"} (${payload.agent.id})`);

package/dist/commands/init.js

@@ -3,13 +3,18 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { ensureAgentWorkspace } from "../agents/workspace.js";
-import { CONFIG_PATH_NEXUS, writeConfigFile } from "../config/config.js";
-import { resolveStateDir } from "../config/paths.js";
+import { CONFIG_PATH_NEXUS, readConfigFileSnapshot, writeConfigFile, } from "../config/config.js";
+import { resolveGatewayPort, resolveStateDir } from "../config/paths.js";
+import { GATEWAY_LAUNCH_AGENT_LABEL } from "../daemon/constants.js";
+import { resolveGatewayProgramArguments } from "../daemon/program-args.js";
+import { resolveGatewayService } from "../daemon/service.js";
 import { defaultRuntime } from "../runtime.js";
-import { MANAGED_SKILLS_DIR, NEXUS_ROOT } from "../utils.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR, WORKSPACE_SKILLS_DIR, resolveUserPath, } from "../utils.js";
 import { scanCredentials } from "./credential.js";
+import { writeCursorHooks } from "./cursor-hooks.js";
 import { writeCursorRules } from "./cursor-rules.js";
 import { copyBundledSkills, generateSkillManifest, writeSkillManifest, } from "./skills-manifest.js";
+import { ensureSystemdUserLingerNonInteractive } from "./systemd-linger.js";
 const execFileAsync = promisify(execFile);
 /**
  * Checks if a directory is already a git repository.
@@ -78,9 +83,265 @@ build/
     await fs.writeFile(gitignorePath, gitignoreContent, "utf-8");
     runtime.log(`✓ Created .gitignore`);
 }
+function shouldCopyIdentity(env) {
+    return (env.NEXUS_INIT_COPY_IDENTITY === "1" ||
+        env.NEXUS_TEST_MODE === "1" ||
+        env.VITEST === "true" ||
+        env.NODE_ENV === "test");
+}
+function resolveIdentitySourceDir(env) {
+    const explicit = env.NEXUS_INIT_IDENTITY_SRC?.trim() || env.NEXUS_IDENTITY_DIR?.trim();
+    if (explicit)
+        return resolveUserPath(explicit);
+    if (!shouldCopyIdentity(env))
+        return null;
+    return resolveUserPath("~") + "/nexus";
+}
+function stripQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function readFrontmatterName(raw) {
+    const normalized = raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!normalized.startsWith("---"))
+        return null;
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1)
+        return null;
+    const block = normalized.slice(4, endIndex);
+    for (const line of block.split("\n")) {
+        const match = line.match(/^name\s*:\s*(.+)$/i);
+        if (match?.[1])
+            return stripQuotes(match[1].trim());
+    }
+    return null;
+}
+function extractName(raw) {
+    const frontmatterName = readFrontmatterName(raw);
+    if (frontmatterName)
+        return frontmatterName;
+    const plainMatch = raw.match(/^[-*]?\s*Name\s*:\s*(.+)$/im);
+    if (plainMatch?.[1])
+        return plainMatch[1].trim();
+    const boldMatch = raw.match(/^\s*[-*]?\s*\*\*Name:\*\*\s*(.+)$/im);
+    if (boldMatch?.[1])
+        return boldMatch[1].trim();
+    return null;
+}
+function upsertFrontmatterName(raw, name) {
+    const normalized = raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (normalized.startsWith("---")) {
+        const endIndex = normalized.indexOf("\n---", 3);
+        if (endIndex !== -1) {
+            const block = normalized.slice(4, endIndex);
+            const hasName = block.split("\n").some((line) => /^name\s*:/i.test(line));
+            if (hasName)
+                return raw;
+            const updatedBlock = `name: ${name}\n${block}`;
+            return `---\n${updatedBlock}\n---${normalized.slice(endIndex + 4)}`;
+        }
+    }
+    return `---\nname: ${name}\n---\n\n${raw}`;
+}
+async function copyIdentityFile(params) {
+    try {
+        const raw = await fs.readFile(params.sourcePath, "utf-8");
+        let next = raw;
+        if (params.ensureNameLine) {
+            const name = extractName(raw);
+            if (name && !readFrontmatterName(raw)) {
+                next = upsertFrontmatterName(raw, name);
+            }
+        }
+        await fs.mkdir(path.dirname(params.destinationPath), { recursive: true });
+        await fs.writeFile(params.destinationPath, next, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function copyIdentityForInit(params) {
+    const sourceDir = resolveIdentitySourceDir(params.env);
+    if (!sourceDir)
+        return;
+    const resolvedSource = path.resolve(sourceDir);
+    const agentIdentityPath = params.workspace.identityPath;
+    const agentSoulPath = params.workspace.soulPath;
+    const agentMemoryPath = params.workspace.memoryPath;
+    const userIdentityPath = params.workspace.userPath;
+    if (!agentIdentityPath ||
+        !userIdentityPath ||
+        !agentSoulPath ||
+        !agentMemoryPath)
+        return;
+    const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
+    const agentSources = [
+        path.join(resolvedSource, "IDENTITY.md"),
+        path.join(resolvedSource, "AGENT.md"),
+        path.join(resolvedSource, "agents", agentId, "IDENTITY.md"),
+        path.join(resolvedSource, "state", "agents", agentId, "IDENTITY.md"),
+        path.join(resolvedSource, "state", "identity", "AGENT.md"),
+        path.join(resolvedSource, "state", "identity", "IDENTITY.md"),
+    ];
+    const userSources = [
+        path.join(resolvedSource, "IDENTITY.md"),
+        path.join(resolvedSource, "PROFILE.md"),
+        path.join(resolvedSource, "USER.md"),
+        path.join(resolvedSource, "user", "IDENTITY.md"),
+        path.join(resolvedSource, "state", "user", "IDENTITY.md"),
+        path.join(resolvedSource, "state", "identity", "PROFILE.md"),
+        path.join(resolvedSource, "state", "identity", "USER.md"),
+    ];
+    const soulSources = [
+        path.join(resolvedSource, "SOUL.md"),
+        path.join(resolvedSource, "agents", agentId, "SOUL.md"),
+        path.join(resolvedSource, "state", "agents", agentId, "SOUL.md"),
+        path.join(resolvedSource, "state", "identity", "SOUL.md"),
+    ];
+    const memorySources = [
+        path.join(resolvedSource, "MEMORY.md"),
+        path.join(resolvedSource, "agents", agentId, "MEMORY.md"),
+        path.join(resolvedSource, "state", "agents", agentId, "MEMORY.md"),
+        path.join(resolvedSource, "state", "identity", "MEMORY.md"),
+    ];
+    const pickExisting = async (candidates) => {
+        for (const candidate of candidates) {
+            try {
+                await fs.access(candidate);
+                return candidate;
+            }
+            catch {
+                // continue
+            }
+        }
+        return null;
+    };
+    const agentSource = await pickExisting(agentSources);
+    const userSource = await pickExisting(userSources);
+    const wroteAgent = agentSource
+        ? await copyIdentityFile({
+            sourcePath: agentSource,
+            destinationPath: agentIdentityPath,
+            ensureNameLine: true,
+        })
+        : false;
+    const wroteUser = userSource
+        ? await copyIdentityFile({
+            sourcePath: userSource,
+            destinationPath: userIdentityPath,
+            ensureNameLine: true,
+        })
+        : false;
+    const soulSource = await pickExisting(soulSources);
+    const memorySource = await pickExisting(memorySources);
+    const wroteSoul = soulSource
+        ? await copyIdentityFile({
+            sourcePath: soulSource,
+            destinationPath: agentSoulPath,
+        })
+        : false;
+    const wroteMemory = memorySource
+        ? await copyIdentityFile({
+            sourcePath: memorySource,
+            destinationPath: agentMemoryPath,
+        })
+        : false;
+    if (wroteAgent || wroteUser || wroteSoul || wroteMemory) {
+        params.runtime.log(`✓ Copied identity files from ${resolvedSource} (bootstrap skipped)`);
+    }
+}
+function isGatewayCommandMatch(existing, expected) {
+    const existingArgs = existing.programArguments.map((arg) => arg.trim());
+    const expectedArgs = expected.programArguments.map((arg) => arg.trim());
+    if (existingArgs.length !== expectedArgs.length)
+        return false;
+    for (let i = 0; i < expectedArgs.length; i += 1) {
+        if (existingArgs[i] !== expectedArgs[i])
+            return false;
+    }
+    const existingDir = existing.workingDirectory?.trim() || "";
+    const expectedDir = expected.workingDirectory?.trim() || "";
+    return existingDir === expectedDir;
+}
+function hasGatewayEnvMismatch(existing, expected) {
+    const keysToCheck = Object.entries(expected).filter(([key]) => key !== "PATH");
+    if (!existing?.environment) {
+        return keysToCheck.some(([, value]) => Boolean(value?.trim()));
+    }
+    for (const [key, value] of keysToCheck) {
+        if (!value?.trim())
+            continue;
+        if (existing.environment[key] !== value) {
+            return true;
+        }
+    }
+    return false;
+}
+async function ensureGatewayDaemon(params) {
+    if (params.env.NEXUS_INIT_SKIP_DAEMON === "1")
+        return;
+    const runtime = params.runtime;
+    let nextConfig = params.configSnapshot.config ?? {};
+    const gateway = { ...nextConfig.gateway };
+    let updated = false;
+    if (!gateway.mode) {
+        gateway.mode = "local";
+        updated = true;
+    }
+    if (!gateway.bind) {
+        gateway.bind = "loopback";
+        updated = true;
+    }
+    const tailscaleMode = gateway.tailscale?.mode;
+    if (!tailscaleMode) {
+        gateway.tailscale = { ...gateway.tailscale, mode: "off" };
+        updated = true;
+    }
+    if (updated) {
+        nextConfig = { ...nextConfig, gateway };
+        await writeConfigFile(nextConfig);
+        runtime.log(`✓ Updated config file: ${CONFIG_PATH_NEXUS}`);
+    }
+    await ensureSystemdUserLingerNonInteractive({ runtime, env: params.env });
+    const service = resolveGatewayService();
+    const loaded = await service.isLoaded({ env: params.env });
+    const port = resolveGatewayPort(nextConfig, params.env);
+    const devMode = process.argv[1]?.includes("/src/") && process.argv[1]?.endsWith(".ts");
+    const { programArguments, workingDirectory } = await resolveGatewayProgramArguments({ port, dev: devMode });
+    const environment = {
+        PATH: params.env.PATH,
+        NEXUS_ROOT: params.env.NEXUS_ROOT,
+        NEXUS_STATE_DIR: params.env.NEXUS_STATE_DIR,
+        NEXUS_AGENT_ID: params.env.NEXUS_AGENT_ID,
+        NEXUS_PROFILE: params.env.NEXUS_PROFILE,
+        NEXUS_LAUNCHD_LABEL: process.platform === "darwin" ? GATEWAY_LAUNCH_AGENT_LABEL : undefined,
+    };
+    const existing = loaded ? await service.readCommand(params.env) : null;
+    const shouldReinstall = !existing ||
+        !isGatewayCommandMatch(existing, { programArguments, workingDirectory }) ||
+        hasGatewayEnvMismatch(existing, environment);
+    if (!loaded || shouldReinstall) {
+        await service.install({
+            env: params.env,
+            stdout: process.stdout,
+            programArguments,
+            workingDirectory,
+            environment,
+        });
+        runtime.log(`✓ Installed ${service.label} gateway daemon`);
+    }
+    else {
+        await service.restart({ stdout: process.stdout });
+        runtime.log(`✓ Restarted ${service.label} gateway daemon`);
+    }
+}
 /**
  * Creates the Nexus directory structure:
- * - ~/nexus/ (root with AGENTS.md and .cursor/rules)
+ * - ~/nexus/ (root with AGENTS.md, .cursor/rules, .cursor/hooks.json)
  * - ~/nexus/home/ (user workspace)
  * - ~/nexus/state/ (state directory)
  */
@@ -102,6 +363,7 @@ export async function initCommand(opts, runtime = defaultRuntime) {
         runtime.log(`  - ${path.basename(workspace.toolsPath)}`);
     if (workspace.bootstrapPath)
         runtime.log(`  - ${path.basename(workspace.bootstrapPath)}`);
+    await copyIdentityForInit({ env: process.env, runtime, workspace });
     // 2. Resolve user skills directory (may be created later by user)
     const userSkillsDir = path.join(workspace.dir, "skills");
     // 4. Create state directory (~/nexus/state)
@@ -127,13 +389,21 @@ export async function initCommand(opts, runtime = defaultRuntime) {
     };
     await fs.writeFile(workspaceMetaPath, JSON.stringify(workspaceMeta, null, 2), "utf-8");
     runtime.log(`✓ Created workspace metadata: ${workspaceMetaPath}`);
+    const configSnapshot = await readConfigFileSnapshot();
     // 5b. Ensure credential index
     await scanCredentials();
     runtime.log(`✓ Created credential index: ${path.join(stateDir, "credentials", "index.json")}`);
-    // 6. Create main skills directory (state/skills) and copy bundled skills
-    const skillsDir = MANAGED_SKILLS_DIR;
+    // 6. Create main skills directory (~/nexus/skills) and copy bundled skills
+    const skillsDir = WORKSPACE_SKILLS_DIR;
     await fs.mkdir(skillsDir, { recursive: true });
+    await fs.mkdir(path.join(skillsDir, "tools"), { recursive: true });
+    await fs.mkdir(path.join(skillsDir, "connectors"), { recursive: true });
+    await fs.mkdir(path.join(skillsDir, "guides"), { recursive: true });
+    await fs.mkdir(path.join(skillsDir, "managed"), { recursive: true });
     runtime.log(`✓ Created skills directory: ${skillsDir}`);
+    // 6b. Create skills state directory (state/skills)
+    await fs.mkdir(SKILLS_STATE_DIR, { recursive: true });
+    runtime.log(`✓ Created skills state directory: ${SKILLS_STATE_DIR}`);
     // Copy bundled skills from installed package to ~/nexus/skills/
     const copyResult = await copyBundledSkills(skillsDir);
     if (copyResult.copied.length > 0) {
@@ -159,6 +429,23 @@ export async function initCommand(opts, runtime = defaultRuntime) {
         includeBootstrap: false,
     });
     runtime.log(`✓ Created Cursor rules: ${cursorRulesPath}`);
+    // 8b. Write Cursor hooks (sessionStart bootstrap)
+    const cursorHooks = await writeCursorHooks({ workspaceDir: NEXUS_ROOT });
+    if (cursorHooks.hooksCreated || cursorHooks.scriptCreated) {
+        runtime.log(`✓ Created Cursor hooks: ${cursorHooks.hooksPath}`);
+        if (cursorHooks.scriptCreated) {
+            runtime.log(`  - ${cursorHooks.scriptPath}`);
+        }
+    }
+    else {
+        runtime.log(`✓ Cursor hooks already present: ${cursorHooks.hooksPath}`);
+    }
+    // 9. Install and start gateway daemon
+    await ensureGatewayDaemon({
+        runtime,
+        env: process.env,
+        configSnapshot,
+    });
     runtime.log("\nNexus initialization complete!");
     runtime.log(`\nNext steps:\n  - Run 'nexus status' to orient\n  - Open ${NEXUS_ROOT} in your editor`);
 }

package/dist/commands/onboard-eve-identity.js

@@ -91,7 +91,7 @@ export async function maybeSetupIdentityFromEve(params) {
         whoami.emails?.length ? `Emails: ${whoami.emails.join(", ")}` : undefined,
     ].filter(Boolean);
     await prompter.note(summaryLines.join("\n"), "Detected identity (Eve)");
-    // NOTE: We don't directly edit IDENTITY.md / PROFILE.md here yet; the bootstrap ritual
+    // NOTE: We don't directly edit agent/user IDENTITY.md here yet; the bootstrap ritual
     // should incorporate these values when it runs. Next step: write this into config
     // and/or workspace files once we agree on the exact schema + wording.
 }