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

package/dist/cli/skills-cli.js

@@ -1,12 +1,12 @@
 import path from "node:path";
 import chalk from "chalk";
-import { getSkillInfo, runSkill, verifySkill } from "../agents/skill-runner.js";
+import { getSkillInfo, verifySkill } from "../agents/skill-runner.js";
 import { getAggregateStats, getSkillStats, hasSkillUsage, recordSkillUsage, } from "../agents/skill-usage.js";
 import { getSkillMetadata, loadWorkspaceSkillEntries } from "../agents/skills.js";
 import { buildWorkspaceSkillStatus } from "../agents/skills-status.js";
 import { DEFAULT_AGENT_WORKSPACE_DIR } from "../agents/workspace.js";
 import { loadConfig } from "../config/config.js";
-import { MANAGED_SKILLS_DIR, NEXUS_ROOT, resolveUserPath } from "../utils.js";
+import { NEXUS_ROOT, SKILLS_STATE_DIR, resolveUserPath } from "../utils.js";
 const STATUS_ICON = {
     active: "✅",
     ready: "⭐",
@@ -47,6 +47,7 @@ export function registerSkillsCommand(program) {
         .description("List all available skills")
         .option("--json", "Output as JSON")
         .option("--type <type>", "Filter by type (guide|tool|connector)")
+        .option("--status <status>", "Filter by status (active|ready|needs-setup|needs-install|unavailable)")
         .option("--active", "Only show active skills")
         .option("--ready", "Only show ready skills")
         .option("--needs-setup", "Only show skills needing setup")
@@ -58,11 +59,9 @@ export function registerSkillsCommand(program) {
         const workspaceDir = resolveUserPath(config.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
         const entries = loadWorkspaceSkillEntries(workspaceDir, {
             config,
-            managedSkillsDir: MANAGED_SKILLS_DIR,
         });
         const status = buildWorkspaceSkillStatus(workspaceDir, {
             config,
-            managedSkillsDir: MANAGED_SKILLS_DIR,
             entries,
         });
         const statusMap = new Map(status.skills.map((item) => [item.name.toLowerCase(), item]));
@@ -84,6 +83,25 @@ export function registerSkillsCommand(program) {
             ? String(opts.type).toLowerCase()
             : undefined;
         const statusFilters = new Set();
+        if (opts.status) {
+            const raw = String(opts.status)
+                .split(",")
+                .map((entry) => entry.trim().toLowerCase())
+                .filter(Boolean);
+            for (const entry of raw) {
+                const normalized = entry.replace(/_/g, "-");
+                if (normalized === "needs-setup")
+                    statusFilters.add("needs_setup");
+                else if (normalized === "needs-install")
+                    statusFilters.add("needs_install");
+                else if (normalized === "active")
+                    statusFilters.add("active");
+                else if (normalized === "ready")
+                    statusFilters.add("ready");
+                else if (normalized === "unavailable")
+                    statusFilters.add("unavailable");
+            }
+        }
         if (opts.active)
             statusFilters.add("active");
         if (opts.ready)
@@ -125,8 +143,11 @@ export function registerSkillsCommand(program) {
             const icon = STATUS_ICON[item.status] ?? "•";
             console.log(`  ${icon} ${item.name}${desc}`);
         }
-        console.log(`\nSkills directory: ${MANAGED_SKILLS_DIR}`);
-        console.log(`User skills: ${path.join(NEXUS_ROOT, "home", "skills")}\n`);
+        const skillsRoot = path.join(NEXUS_ROOT, "skills");
+        console.log(`\nSkills directory: ${skillsRoot}`);
+        console.log(`Skill types: ${path.join(skillsRoot, "tools")}, ${path.join(skillsRoot, "connectors")}, ${path.join(skillsRoot, "guides")}`);
+        console.log(`Skill state: ${SKILLS_STATE_DIR}`);
+        console.log(`User skills: ${path.join(workspaceDir, "skills")}\n`);
     });
     skill
         .command("info <name>")
@@ -190,18 +211,6 @@ export function registerSkillsCommand(program) {
         console.log(info.prompt.trimEnd());
         recordSkillUsage(name, { ts: Date.now(), event: "use", ok: true });
     });
-    skill
-        .command("run <name>")
-        .description("Run a skill command with arguments")
-        .allowUnknownOption()
-        .action(async (name, _opts, command) => {
-        const args = command.args.slice(1);
-        const result = await runSkill(name, args);
-        if (!result.ok) {
-            console.error(result.error);
-            process.exit(1);
-        }
-    });
     skill
         .command("verify <name>")
         .description("Verify skill setup and dependencies")

package/dist/cli/skills-hub-cli.js

@@ -12,7 +12,7 @@ import { generateSkillManifest, writeSkillManifest, } from "../commands/skills-m
 import { loadConfig } from "../config/config.js";
 import { listCredentialEntries, resolveCredentialValue, } from "../credentials/store.js";
 import { runCommandWithTimeout } from "../process/exec.js";
-import { MANAGED_SKILLS_DIR, resolveUserPath } from "../utils.js";
+import { NEXUS_ROOT, resolveUserPath } from "../utils.js";
 function getHubBaseUrl() {
     return (process.env.NEXUS_HUB_URL ||
         process.env.NEXUS_WEBSITE_URL ||
@@ -284,23 +284,27 @@ function dirNameToSlug(dirName) {
 async function ensureDir(dir) {
     await fs.mkdir(dir, { recursive: true });
 }
-async function loadManagedSkillSlugs(managedSkillsDir) {
+async function loadInstalledSkillSlugs(skillsRoot) {
     const slugs = new Set();
-    const managedDir = path.join(managedSkillsDir, "managed");
-    let entries = [];
-    try {
-        entries = await fs.readdir(managedDir, { withFileTypes: true });
-    }
-    catch {
-        return slugs;
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const slug = dirNameToSlug(entry.name);
-        if (!slug)
+    const roots = ["tools", "connectors", "guides"].map((segment) => path.join(skillsRoot, segment));
+    for (const root of roots) {
+        let entries = [];
+        try {
+            entries = await fs.readdir(root, { withFileTypes: true });
+        }
+        catch {
             continue;
-        slugs.add(normalizeSkillKey(slug));
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith("."))
+                continue;
+            const slug = dirNameToSlug(entry.name);
+            if (!slug)
+                continue;
+            slugs.add(normalizeSkillKey(slug));
+        }
     }
     return slugs;
 }
@@ -383,6 +387,32 @@ async function normalizeSkillRoot(destDir) {
     }
     await fs.rm(nested, { recursive: true, force: true });
 }
+async function resolveInstalledSkillType(skillDir) {
+    const skillFile = path.join(skillDir, "SKILL.md");
+    let content = "";
+    try {
+        content = await fs.readFile(skillFile, "utf-8");
+    }
+    catch {
+        return "guide";
+    }
+    const { frontmatter } = parseFrontmatter(content);
+    const rawType = typeof frontmatter.type === "string" ? frontmatter.type.trim().toLowerCase() : "";
+    if (rawType === "tool" || rawType === "connector" || rawType === "guide") {
+        return rawType;
+    }
+    const metadata = normalizeMetadata(frontmatter.metadata);
+    const metaType = metadata.nexus && typeof metadata.nexus === "object"
+        ? metadata.nexus.type
+        : undefined;
+    if (typeof metaType === "string") {
+        const normalized = metaType.trim().toLowerCase();
+        if (normalized === "tool" || normalized === "connector" || normalized === "guide") {
+            return normalized;
+        }
+    }
+    return "guide";
+}
 async function resolveHubDependencyPlan(slug, installed, getDetails, onMissing) {
     const plan = [];
     const visiting = new Set();
@@ -562,28 +592,13 @@ function buildManifestPayload(input) {
 }
 async function installHubSkill(params) {
     const dirName = slugToDirName(params.slug);
-    const destDir = path.join(params.managedDir, dirName);
-    try {
-        if (!params.force) {
-            await fs.access(destDir);
-            if (params.allowSkip) {
-                return { installed: false, destDir };
-            }
-            throw new Error(`Skill already installed at ${destDir}. Use --force to overwrite.`);
-        }
-        await fs.rm(destDir, { recursive: true, force: true });
-    }
-    catch (err) {
-        if (err.code !== "ENOENT") {
-            throw err;
-        }
-    }
     const download = await downloadSkillArtifact(params.slug);
     if (!download.downloadUrl || !download.artifactSha256) {
         throw new Error("Download URL missing from hub response");
     }
     const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "nexus-skill-"));
     const artifactPath = path.join(tmpDir, "artifact.bin");
+    const extractDir = path.join(tmpDir, "skill");
     const downloadHeaders = {};
     if (download.cloudToken) {
         downloadHeaders.authorization = `Bearer ${download.cloudToken}`;
@@ -598,9 +613,29 @@ async function installHubSkill(params) {
     if (hash !== download.artifactSha256) {
         throw new Error(`Checksum mismatch (expected ${download.artifactSha256}, got ${hash})`);
     }
-    await extractArchive(artifactPath, destDir);
-    await normalizeSkillRoot(destDir);
-    const manifest = await generateSkillManifest(MANAGED_SKILLS_DIR, params.userSkillsDir);
+    await extractArchive(artifactPath, extractDir);
+    await normalizeSkillRoot(extractDir);
+    const skillType = await resolveInstalledSkillType(extractDir);
+    const targetBase = path.join(params.skillsRoot, `${skillType}s`);
+    const destDir = path.join(targetBase, dirName);
+    try {
+        if (!params.force) {
+            await fs.access(destDir);
+            if (params.allowSkip) {
+                return { installed: false, destDir };
+            }
+            throw new Error(`Skill already installed at ${destDir}. Use --force to overwrite.`);
+        }
+        await fs.rm(destDir, { recursive: true, force: true });
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+    await ensureDir(targetBase);
+    await fs.rename(extractDir, destDir);
+    const manifest = await generateSkillManifest(params.skillsRoot, params.userSkillsDir);
     await writeSkillManifest(manifest);
     return { installed: true, destDir };
 }
@@ -628,21 +663,19 @@ export function registerSkillsHubCommand(program) {
                 : 10;
         const cfg = loadConfig();
         const workspaceDir = resolveUserPath(cfg.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
-        const managedSkillsDir = MANAGED_SKILLS_DIR;
+        const skillsRoot = path.join(NEXUS_ROOT, "skills");
         const status = buildWorkspaceSkillStatus(workspaceDir, {
             config: cfg,
-            managedSkillsDir,
         });
         const metadataEntries = loadWorkspaceSkillEntries(workspaceDir, {
             config: cfg,
-            managedSkillsDir,
         });
         const metadataByName = new Map(metadataEntries.map((entry) => [
             entry.skill.name,
             getSkillMetadata(entry),
         ]));
         const installedNames = new Set(metadataEntries.map((entry) => normalizeSkillKey(entry.skill.name)));
-        const installedSlugs = await loadManagedSkillSlugs(managedSkillsDir);
+        const installedSlugs = await loadInstalledSkillSlugs(skillsRoot);
         const installedIndex = {
             names: installedNames,
             slugs: installedSlugs,
@@ -1049,14 +1082,12 @@ export function registerSkillsHubCommand(program) {
             const cfg = loadConfig();
             const workspaceDir = resolveUserPath(cfg.agent?.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR);
             const userSkillsDir = path.join(workspaceDir, "skills");
-            const managedSkillsDir = MANAGED_SKILLS_DIR;
-            const managedDir = path.join(managedSkillsDir, "managed");
+            const skillsRoot = path.join(NEXUS_ROOT, "skills");
             const metadataEntries = loadWorkspaceSkillEntries(workspaceDir, {
                 config: cfg,
-                managedSkillsDir,
             });
             const installedNames = new Set(metadataEntries.map((entry) => normalizeSkillKey(entry.skill.name)));
-            const installedSlugs = await loadManagedSkillSlugs(managedSkillsDir);
+            const installedSlugs = await loadInstalledSkillSlugs(skillsRoot);
             const installedIndex = {
                 names: installedNames,
                 slugs: installedSlugs,
@@ -1082,7 +1113,7 @@ export function registerSkillsHubCommand(program) {
                 for (const dep of plan) {
                     const result = await installHubSkill({
                         slug: dep,
-                        managedDir,
+                        skillsRoot,
                         userSkillsDir,
                         allowSkip: true,
                     });
@@ -1107,7 +1138,7 @@ export function registerSkillsHubCommand(program) {
             }
             const result = await installHubSkill({
                 slug,
-                managedDir,
+                skillsRoot,
                 userSkillsDir,
                 force: Boolean(opts.force),
             });

package/dist/commands/bootstrap-preset.js

@@ -107,15 +107,15 @@ export async function applyBootstrapPreset(params) {
     const { workspaceDir, runtime } = params;
     const stateDir = resolveStateDir();
     const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
-    const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
-    const userIdentityDir = path.join(stateDir, "user", "identity");
+    const agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
     const bootstrapPath = resolveBootstrapPath(undefined, stateDir);
     if (!(await fileExists(bootstrapPath)))
         return;
     await fs.mkdir(agentIdentityDir, { recursive: true });
     await fs.mkdir(userIdentityDir, { recursive: true });
     const identityPath = path.join(agentIdentityDir, "IDENTITY.md");
-    const userPath = path.join(userIdentityDir, "PROFILE.md");
+    const userPath = path.join(userIdentityDir, "IDENTITY.md");
     const soulPath = path.join(agentIdentityDir, "SOUL.md");
     const agentsPath = path.join(NEXUS_ROOT, "AGENTS.md");
     const preset = resolvePreset(params.preset);
@@ -173,17 +173,27 @@ export async function applyBootstrapPreset(params) {
         userName = "Test User";
     if (!preferredAddress)
         preferredAddress = firstName(userName) || "friend";
-    const identityMd = `# IDENTITY.md - Agent Identity
+    const identityMd = `---
+name: ${agentName}
+emoji: ${preset.emoji}
+creature: ${preset.creature}
+vibe: ${preset.vibe}
+---
+# IDENTITY.md - Agent Identity
 
 - Name: ${agentName}
 - Creature: ${preset.creature}
 - Vibe: ${preset.vibe}
 - Emoji: ${preset.emoji}
 `;
-    const userMd = `# PROFILE.md - User Profile
+    const userMd = `---
+name: ${userName}
+call: ${preferredAddress}
+---
+# IDENTITY.md - User Identity
 
 - Name: ${userName}
-- Preferred address: ${preferredAddress}
+- What to call them: ${preferredAddress}
 - Pronouns (optional):
 - Timezone (optional):
 - Notes:

package/dist/commands/config.js

@@ -0,0 +1,85 @@
+import { loadConfig, readConfigFileSnapshot, writeConfigFile } from "../config/config.js";
+import { defaultRuntime } from "../runtime.js";
+function getByPath(obj, key) {
+    const parts = key.split(".").filter(Boolean);
+    let current = obj;
+    for (const part of parts) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function setByPath(obj, key, value) {
+    const parts = key.split(".").filter(Boolean);
+    let current = obj;
+    for (let i = 0; i < parts.length; i += 1) {
+        const part = parts[i];
+        if (i === parts.length - 1) {
+            current[part] = value;
+            break;
+        }
+        const next = current[part];
+        if (!next || typeof next !== "object") {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    return obj;
+}
+function parseValue(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (!Number.isNaN(Number(trimmed)))
+        return Number(trimmed);
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return trimmed;
+}
+export async function configListCommand(opts, runtime = defaultRuntime) {
+    const snapshot = await readConfigFileSnapshot();
+    const payload = snapshot.valid ? snapshot.parsed : {};
+    if (opts?.json) {
+        runtime.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    runtime.log(JSON.stringify(payload, null, 2));
+}
+export async function configGetCommand(opts, runtime = defaultRuntime) {
+    const config = loadConfig();
+    const value = getByPath(config, opts.key);
+    if (opts.json) {
+        runtime.log(JSON.stringify({ key: opts.key, value }, null, 2));
+        return;
+    }
+    if (typeof value === "string") {
+        runtime.log(value);
+        return;
+    }
+    runtime.log(JSON.stringify(value ?? null, null, 2));
+}
+export async function configSetCommand(opts, runtime = defaultRuntime) {
+    const snapshot = await readConfigFileSnapshot();
+    const base = snapshot.valid && snapshot.parsed && typeof snapshot.parsed === "object"
+        ? snapshot.parsed
+        : {};
+    const next = setByPath({ ...base }, opts.key, parseValue(opts.value));
+    await writeConfigFile(next);
+    if (opts.json) {
+        runtime.log(JSON.stringify({ key: opts.key, value: getByPath(next, opts.key) }, null, 2));
+        return;
+    }
+    runtime.log(`Updated ${opts.key}`);
+}

package/dist/commands/cursor-hooks.js

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