reasonix 0.4.19 → 0.4.21

package/dist/cli/index.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import {
+  MemoryStore,
   PROJECT_MEMORY_FILE,
-  applyProjectMemory,
+  SkillStore,
+  applyMemoryStack,
   memoryEnabled,
-  readProjectMemory
-} from "./chunk-HNEWBEWZ.js";
+  readProjectMemory,
+  sanitizeMemoryName
+} from "./chunk-K6MR4SWS.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -2206,7 +2209,7 @@ function registerFilesystemTools(registry, opts) {
   });
   registry.register({
     name: "edit_file",
-    description: "Apply a SEARCH/REPLACE edit to an existing file. `search` must match exactly (whitespace sensitive) \u2014 no regex. The match must be unique in the file; otherwise the edit is refused to avoid surprise rewrites. This flat-string shape replaces the `{oldText, newText}[]` JSON array form that previously triggered R1 DSML hallucinations.",
+    description: "Apply a SEARCH/REPLACE edit to an existing file. `search` must match exactly (whitespace sensitive) \u2014 no regex. The match must be unique in the file; otherwise the edit is refused to avoid surprise rewrites.",
     parameters: {
       type: "object",
       properties: {
@@ -2323,6 +2326,127 @@ function lineDiff(a, b) {
   return out;
 }
 
+// src/tools/memory.ts
+function registerMemoryTools(registry, opts = {}) {
+  const store = new MemoryStore({ homeDir: opts.homeDir, projectRoot: opts.projectRoot });
+  const hasProject = store.hasProjectScope();
+  registry.register({
+    name: "remember",
+    description: "Save a memory for future sessions. Use when the user states a preference, corrects your approach, shares a non-obvious fact about this project, or explicitly asks you to remember something. Don't remember transient task state \u2014 only things worth recalling next session. The memory is written now but won't re-load into the system prompt until the next `/new` or launch.",
+    parameters: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["user", "feedback", "project", "reference"],
+          description: "'user' = role/skills/prefs; 'feedback' = corrections or confirmed approaches; 'project' = facts/decisions about the current work; 'reference' = pointers to external systems the user uses."
+        },
+        scope: {
+          type: "string",
+          enum: ["global", "project"],
+          description: "'global' = applies across every project (preferences, tooling); 'project' = scoped to the current sandbox (decisions, local facts). Only available in `reasonix code`."
+        },
+        name: {
+          type: "string",
+          description: "filename-safe identifier, 3-40 chars, alnum + _ - . (no path separators, no leading dot)."
+        },
+        description: {
+          type: "string",
+          description: "One-line summary shown in MEMORY.md (under ~150 chars)."
+        },
+        content: {
+          type: "string",
+          description: "Full memory body in markdown. For feedback/project types, structure as: rule/fact, then **Why:** line, then **How to apply:** line."
+        }
+      },
+      required: ["type", "scope", "name", "description", "content"]
+    },
+    fn: async (args) => {
+      if (args.scope === "project" && !hasProject) {
+        return JSON.stringify({
+          error: "scope='project' is unavailable in this session (no sandbox root). Retry with scope='global', or ask the user to switch to `reasonix code` for project-scoped memory."
+        });
+      }
+      try {
+        const path = store.write({
+          name: args.name,
+          type: args.type,
+          scope: args.scope,
+          description: args.description,
+          body: args.content
+        });
+        const key = sanitizeMemoryName(args.name);
+        return [
+          `\u2713 REMEMBERED (${args.scope}/${key}): ${args.description}`,
+          "",
+          "TREAT THIS AS ESTABLISHED FACT for the rest of this session.",
+          "The user just told you \u2014 don't re-explore the filesystem to re-derive it.",
+          `(Saved to ${path}; pins into the system prompt on next /new or launch.)`
+        ].join("\n");
+      } catch (err) {
+        return JSON.stringify({ error: `remember failed: ${err.message}` });
+      }
+    }
+  });
+  registry.register({
+    name: "forget",
+    description: "Delete a memory file and remove it from MEMORY.md. Use when the user explicitly asks to forget something, or when a previously-remembered fact has become wrong. Irreversible \u2014 no tombstone.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Memory name (the identifier used in `remember`)." },
+        scope: { type: "string", enum: ["global", "project"] }
+      },
+      required: ["name", "scope"]
+    },
+    fn: async (args) => {
+      if (args.scope === "project" && !hasProject) {
+        return JSON.stringify({
+          error: "scope='project' is unavailable in this session (no sandbox root)."
+        });
+      }
+      try {
+        const existed = store.delete(args.scope, args.name);
+        return existed ? `forgot (${args.scope}/${sanitizeMemoryName(args.name)}). Re-load on next /new or launch.` : `no such memory: ${args.scope}/${args.name} (nothing to forget).`;
+      } catch (err) {
+        return JSON.stringify({ error: `forget failed: ${err.message}` });
+      }
+    }
+  });
+  registry.register({
+    name: "recall_memory",
+    description: "Read the full body of a memory file when its MEMORY.md one-liner (already in the system prompt) isn't enough detail. Most of the time the index suffices \u2014 only call this when the user's question genuinely requires the full context.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        scope: { type: "string", enum: ["global", "project"] }
+      },
+      required: ["name", "scope"]
+    },
+    fn: async (args) => {
+      if (args.scope === "project" && !hasProject) {
+        return JSON.stringify({
+          error: "scope='project' is unavailable in this session (no sandbox root)."
+        });
+      }
+      try {
+        const entry = store.read(args.scope, args.name);
+        return [
+          `# ${entry.name}  (${entry.scope}/${entry.type}, created ${entry.createdAt || "?"})`,
+          entry.description ? `> ${entry.description}` : "",
+          "",
+          entry.body
+        ].filter(Boolean).join("\n");
+      } catch (err) {
+        return JSON.stringify({ error: `recall failed: ${err.message}` });
+      }
+    }
+  });
+  return registry;
+}
+
 // src/tools/plan.ts
 var PlanProposedError = class extends Error {
   plan;
@@ -2540,7 +2664,7 @@ function resolveExecutable(cmd, opts = {}) {
   const isFile = opts.isFile ?? defaultIsFile;
   for (const dir of pathDirs) {
     for (const ext of pathExt) {
-      const full = pathMod2.join(dir, cmd + ext);
+      const full = pathMod2.win32.join(dir, cmd + ext);
       if (isFile(full)) return full;
     }
   }
@@ -2573,8 +2697,23 @@ function prepareSpawn(argv, opts = {}) {
       spawnOverrides: { windowsVerbatimArguments: true }
     };
   }
+  if (isBareWindowsName(resolved) && resolved === head) {
+    const cmdline = [head, ...tail].map(quoteForCmdExe).join(" ");
+    return {
+      bin: "cmd.exe",
+      args: ["/d", "/s", "/c", cmdline],
+      spawnOverrides: { windowsVerbatimArguments: true }
+    };
+  }
   return { bin: resolved, args: [...tail], spawnOverrides: {} };
 }
+function isBareWindowsName(s) {
+  if (!s) return false;
+  if (s.includes("/") || s.includes("\\")) return false;
+  if (pathMod2.isAbsolute(s)) return false;
+  if (pathMod2.extname(s)) return false;
+  return true;
+}
 function quoteForCmdExe(arg) {
   if (arg === "") return '""';
   if (!/[\s"&|<>^%(),;!]/.test(arg)) return arg;
@@ -2594,11 +2733,14 @@ function registerShellTools(registry, opts) {
   const rootDir = pathMod2.resolve(opts.rootDir);
   const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
   const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
-  const extraAllowed = opts.extraAllowed ?? [];
+  const getExtraAllowed = typeof opts.extraAllowed === "function" ? opts.extraAllowed : (() => {
+    const snapshot = opts.extraAllowed ?? [];
+    return () => snapshot;
+  })();
   const allowAll = opts.allowAll ?? false;
   registry.register({
     name: "run_command",
-    description: "Run a shell command in the project root and return its combined stdout+stderr. Read-only and test commands (git status, ls, npm test, pytest, cargo test, grep, etc.) run immediately. Anything that could mutate state (npm install, git commit, rm, chmod) is refused and the user has to confirm in the TUI. Prefer this over asking the user to run a command manually \u2014 after edits, run the project's tests to verify.",
+    description: "Run a shell command in the project root and return its combined stdout+stderr. Common read-only inspection and test/lint/typecheck commands run immediately; anything that could mutate state, install dependencies, or touch the network is refused until the user confirms it in the TUI. Prefer this over asking the user to run a command manually \u2014 after edits, run the project's tests to verify.",
     // Plan-mode gate: allow allowlisted commands through (git status,
     // cargo check, ls, grep …) so the model can actually investigate
     // during planning. Anything that would otherwise trigger a
@@ -2607,14 +2749,14 @@ function registerShellTools(registry, opts) {
       if (allowAll) return true;
       const cmd = typeof args?.command === "string" ? args.command.trim() : "";
       if (!cmd) return false;
-      return isAllowed(cmd, extraAllowed);
+      return isAllowed(cmd, getExtraAllowed());
     },
     parameters: {
       type: "object",
       properties: {
         command: {
           type: "string",
-          description: "Full command line, e.g. 'npm test' or 'git diff src/foo.ts'. Tokenized with POSIX-ish quoting; no shell expansion, no pipes, no redirects."
+          description: "Full command line. Tokenized with POSIX-ish quoting; no shell expansion, no pipes, no redirects."
         },
         timeoutSec: {
           type: "integer",
@@ -2626,7 +2768,7 @@ function registerShellTools(registry, opts) {
     fn: async (args, ctx) => {
       const cmd = args.command.trim();
       if (!cmd) throw new Error("run_command: empty command");
-      if (!allowAll && !isAllowed(cmd, extraAllowed)) {
+      if (!allowAll && !isAllowed(cmd, getExtraAllowed())) {
         throw new NeedsConfirmationError(cmd);
       }
       const effectiveTimeout = Math.max(1, Math.min(600, args.timeoutSec ?? timeoutSec));
@@ -4119,13 +4261,64 @@ function sep() {
 }
 
 // src/index.ts
-var VERSION = "0.4.19";
+var VERSION = "0.4.20";
 
 // src/cli/commands/chat.tsx
 import { existsSync as existsSync4, statSync as statSync3 } from "fs";
 import { render } from "ink";
 import React15, { useState as useState7 } from "react";
 
+// src/tools/skills.ts
+function registerSkillTools(registry, opts = {}) {
+  const store = new SkillStore({ homeDir: opts.homeDir, projectRoot: opts.projectRoot });
+  registry.register({
+    name: "run_skill",
+    description: "Load the full body of a user-defined skill into this conversation. Call when the pinned Skills index (in the system prompt) lists a skill whose description matches what's being asked. Returns the skill's markdown instructions \u2014 read them and continue the loop, calling whatever filesystem / shell / web tools the skill's prose requires. Skills are user content; follow their instructions, but keep Reasonix's own safety rules (no destructive ops without confirmation, etc.).",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Skill identifier as it appears in the pinned Skills index (e.g. 'review', 'security-review'). Case-sensitive."
+        },
+        arguments: {
+          type: "string",
+          description: "Optional free-form arguments the caller wants the skill to act on. Forwarded verbatim as an 'Arguments:' line appended to the skill body; the skill's own instructions decide how to consume them."
+        }
+      },
+      required: ["name"]
+    },
+    fn: async (args) => {
+      const name = typeof args.name === "string" ? args.name.trim() : "";
+      if (!name) {
+        return JSON.stringify({ error: "run_skill requires a 'name' argument" });
+      }
+      const skill = store.read(name);
+      if (!skill) {
+        const available = store.list().map((s) => s.name).join(", ");
+        return JSON.stringify({
+          error: `unknown skill: ${JSON.stringify(name)}`,
+          available: available || "(none \u2014 user has not defined any skills)"
+        });
+      }
+      const rawArgs = typeof args.arguments === "string" ? args.arguments.trim() : "";
+      const header = [
+        `# Skill: ${skill.name}`,
+        skill.description ? `> ${skill.description}` : "",
+        `(scope: ${skill.scope} \xB7 ${skill.path})`
+      ].filter(Boolean).join("\n");
+      const argsBlock = rawArgs ? `
+
+Arguments: ${rawArgs}` : "";
+      return `${header}
+
+${skill.body}${argsBlock}`;
+    }
+  });
+  return registry;
+}
+
 // src/cli/ui/App.tsx
 import { Box as Box11, Static, Text as Text11, useApp, useInput as useInput4 } from "ink";
 import React12, { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState5 } from "react";
@@ -5093,7 +5286,16 @@ var SLASH_COMMANDS = [
   { cmd: "branch", argsHint: "<N|off>", summary: "run N parallel samples per turn (N>=2)" },
   { cmd: "mcp", summary: "list MCP servers + tools attached to this session" },
   { cmd: "tool", argsHint: "[N]", summary: "dump full output of the Nth tool call (1=latest)" },
-  { cmd: "memory", summary: "show the project's REASONIX.md (pinned into the system prompt)" },
+  {
+    cmd: "memory",
+    argsHint: "[list|show <name>|forget <name>|clear <scope> confirm]",
+    summary: "show / manage pinned memory (REASONIX.md + ~/.reasonix/memory)"
+  },
+  {
+    cmd: "skill",
+    argsHint: "[list|show <name>|<name> [args]]",
+    summary: "list / run user skills (<project>/.reasonix/skills + ~/.reasonix/skills)"
+  },
   { cmd: "think", summary: "dump the last turn's full R1 reasoning (reasoner only)" },
   { cmd: "retry", summary: "truncate & resend your last message (fresh sample)" },
   { cmd: "compact", argsHint: "[cap]", summary: "shrink oversized tool results in the log" },
@@ -5173,7 +5375,10 @@ function handleSlash(cmd, args, loop, ctx = {}) {
           "  /compact [cap]           shrink large tool results in history (default 4k/result)",
           "  /think                   dump the most recent turn's full R1 reasoning (reasoner only)",
           "  /tool [N]                list tool calls (or dump full output of #N, 1=most recent)",
-          "  /memory                  show the project's REASONIX.md (pinned into the system prompt)",
+          "  /memory [sub]            show pinned memory (REASONIX.md + ~/.reasonix/memory).",
+          "                            subs: list | show <name> | forget <name> | clear <scope> confirm",
+          "  /skill [sub]             list / run user skills (project/.reasonix/skills + ~/.reasonix/skills).",
+          "                            subs: list | show <name> | <name> [args] (injects skill body as user turn)",
           "  /retry                   truncate & resend your last message (fresh sample from the model)",
           "  /apply                   (code mode) commit the pending edit blocks to disk",
           "  /discard                 (code mode) drop pending edits without writing",
@@ -5258,43 +5463,11 @@ function handleSlash(cmd, args, loop, ctx = {}) {
       };
     }
     case "memory": {
-      if (!memoryEnabled()) {
-        return {
-          info: "project memory is disabled (REASONIX_MEMORY=off in env). Unset the var to re-enable; no REASONIX.md will be pinned in the meantime."
-        };
-      }
-      if (!ctx.memoryRoot) {
-        return {
-          info: "no project root on this session \u2014 `/memory` needs a working directory to resolve REASONIX.md from."
-        };
-      }
-      const mem = readProjectMemory(ctx.memoryRoot);
-      if (!mem) {
-        return {
-          info: [
-            `no ${PROJECT_MEMORY_FILE} in ${ctx.memoryRoot}.`,
-            "",
-            "Project memory is an optional file you pin notes into \u2014 project conventions,",
-            "things the model keeps forgetting, domain glossary, setup gotchas. When present,",
-            "its contents are appended to the system prompt (the immutable-prefix region)",
-            "so every turn sees it without eating per-turn context, and the prefix cache stays",
-            "warm as long as the file is stable.",
-            "",
-            `Create it with:  echo "# Project notes for Reasonix" > ${PROJECT_MEMORY_FILE}`,
-            "Re-launch (or `/new`) to pick up changes \u2014 the prefix is hashed at session start."
-          ].join("\n")
-        };
-      }
-      const header = mem.truncated ? `\u25B8 project memory: ${mem.path} (${mem.originalChars.toLocaleString()} chars, truncated for the prefix)` : `\u25B8 project memory: ${mem.path} (${mem.originalChars.toLocaleString()} chars)`;
-      return {
-        info: [
-          header,
-          "",
-          mem.content,
-          "",
-          "Changes take effect on the next launch or `/new` \u2014 the system prompt is hashed once per session to keep the prefix cache warm."
-        ].join("\n")
-      };
+      return handleMemorySlash(args, ctx);
+    }
+    case "skill":
+    case "skills": {
+      return handleSkillSlash(args, ctx);
     }
     case "think":
     case "reasoning": {
@@ -5532,6 +5705,228 @@ ${entry.text}`
       return { unknown: true, info: `unknown command: /${cmd}  (try /help)` };
   }
 }
+function handleSkillSlash(args, ctx) {
+  const store = new SkillStore({ projectRoot: ctx.codeRoot });
+  const sub = (args[0] ?? "").toLowerCase();
+  if (sub === "" || sub === "list" || sub === "ls") {
+    const skills = store.list();
+    if (skills.length === 0) {
+      const lines2 = ["no skills found. Reasonix reads skills from:"];
+      if (store.hasProjectScope()) {
+        lines2.push(
+          "  \xB7 <project>/.reasonix/skills/<name>/SKILL.md  (or <name>.md)  \u2014 project scope"
+        );
+      }
+      lines2.push("  \xB7 ~/.reasonix/skills/<name>/SKILL.md  (or <name>.md)  \u2014 global scope");
+      if (!store.hasProjectScope()) {
+        lines2.push("  (project scope is only active in `reasonix code`)");
+      }
+      lines2.push(
+        "",
+        "Each file's frontmatter needs at least `name` and `description`.",
+        "Invoke a skill with `/skill <name> [args]` or by asking the model to call `run_skill`."
+      );
+      return { info: lines2.join("\n") };
+    }
+    const lines = [`User skills (${skills.length}):`];
+    for (const s of skills) {
+      const scope = `(${s.scope})`.padEnd(11);
+      const name2 = s.name.padEnd(24);
+      const desc = s.description.length > 70 ? `${s.description.slice(0, 69)}\u2026` : s.description;
+      lines.push(`  ${scope} ${name2}  ${desc}`);
+    }
+    lines.push("");
+    lines.push("View body: /skill show <name>   Run: /skill <name> [args]");
+    return { info: lines.join("\n") };
+  }
+  if (sub === "show" || sub === "cat") {
+    const target = args[1];
+    if (!target) return { info: "usage: /skill show <name>" };
+    const skill2 = store.read(target);
+    if (!skill2) return { info: `no skill found: ${target}` };
+    return {
+      info: [
+        `\u25B8 ${skill2.name}  (${skill2.scope})`,
+        skill2.description ? `  ${skill2.description}` : "",
+        `  ${skill2.path}`,
+        "",
+        skill2.body
+      ].filter((l) => l !== "").join("\n")
+    };
+  }
+  const name = args[0] ?? "";
+  const skill = store.read(name);
+  if (!skill) {
+    return {
+      info: `no skill found: ${name}  (try /skill list)`
+    };
+  }
+  const extra = args.slice(1).join(" ").trim();
+  const header = `# Skill: ${skill.name}${skill.description ? `
+> ${skill.description}` : ""}`;
+  const argsLine = extra ? `
+
+Arguments: ${extra}` : "";
+  const payload = `${header}
+
+${skill.body}${argsLine}`;
+  return {
+    info: `\u25B8 running skill: ${skill.name}${extra ? ` \u2014 ${extra}` : ""}`,
+    resubmit: payload
+  };
+}
+function handleMemorySlash(args, ctx) {
+  if (!memoryEnabled()) {
+    return {
+      info: "memory is disabled (REASONIX_MEMORY=off in env). Unset the var to re-enable \u2014 no REASONIX.md or ~/.reasonix/memory content will be pinned in the meantime."
+    };
+  }
+  if (!ctx.memoryRoot) {
+    return {
+      info: "no working directory on this session \u2014 `/memory` needs a root to resolve REASONIX.md from. (Running in a test harness?)"
+    };
+  }
+  const store = new MemoryStore({ projectRoot: ctx.codeRoot });
+  const sub = (args[0] ?? "").toLowerCase();
+  if (sub === "list" || sub === "ls") {
+    const entries = store.list();
+    if (entries.length === 0) {
+      return {
+        info: "no user memories yet. The model can call `remember` to save one, or you can create files by hand in ~/.reasonix/memory/global/ or the per-project subdir."
+      };
+    }
+    const lines = [`User memories (${entries.length}):`];
+    for (const e of entries) {
+      const tag = `${e.scope}/${e.type}`.padEnd(18);
+      const name = e.name.padEnd(28);
+      const desc = e.description.length > 70 ? `${e.description.slice(0, 69)}\u2026` : e.description;
+      lines.push(`  ${tag}  ${name}  ${desc}`);
+    }
+    lines.push("");
+    lines.push("View body: /memory show <name>   Delete: /memory forget <name>");
+    return { info: lines.join("\n") };
+  }
+  if (sub === "show" || sub === "cat") {
+    const target = args[1];
+    if (!target) return { info: "usage: /memory show <name>  or  /memory show <scope>/<name>" };
+    const resolved = resolveMemoryTarget(store, target);
+    if (!resolved) return { info: `no memory found: ${target}` };
+    try {
+      const entry = store.read(resolved.scope, resolved.name);
+      return {
+        info: [
+          `\u25B8 ${entry.scope}/${entry.name}  (${entry.type}, created ${entry.createdAt || "?"})`,
+          entry.description ? `  ${entry.description}` : "",
+          "",
+          entry.body
+        ].filter((l) => l !== "").concat("").join("\n")
+      };
+    } catch (err) {
+      return { info: `show failed: ${err.message}` };
+    }
+  }
+  if (sub === "forget" || sub === "rm" || sub === "delete") {
+    const target = args[1];
+    if (!target) return { info: "usage: /memory forget <name>  or  /memory forget <scope>/<name>" };
+    const resolved = resolveMemoryTarget(store, target);
+    if (!resolved) return { info: `no memory found: ${target}` };
+    try {
+      const ok = store.delete(resolved.scope, resolved.name);
+      return {
+        info: ok ? `\u25B8 forgot ${resolved.scope}/${resolved.name}. Next /new or launch won't see it.` : `could not forget ${resolved.scope}/${resolved.name} (already gone?)`
+      };
+    } catch (err) {
+      return { info: `forget failed: ${err.message}` };
+    }
+  }
+  if (sub === "clear") {
+    const rawScope = (args[1] ?? "").toLowerCase();
+    if (rawScope !== "global" && rawScope !== "project") {
+      return { info: "usage: /memory clear <global|project> confirm" };
+    }
+    if ((args[2] ?? "").toLowerCase() !== "confirm") {
+      return {
+        info: `about to delete every memory in scope=${rawScope}. Re-run with the word 'confirm' to proceed: /memory clear ${rawScope} confirm`
+      };
+    }
+    const scope = rawScope;
+    const entries = store.list().filter((e) => e.scope === scope);
+    let deleted = 0;
+    for (const e of entries) {
+      try {
+        if (store.delete(scope, e.name)) deleted++;
+      } catch {
+      }
+    }
+    return { info: `\u25B8 cleared scope=${scope} \u2014 deleted ${deleted} memory file(s).` };
+  }
+  const parts = [];
+  const projMem = readProjectMemory(ctx.memoryRoot);
+  if (projMem) {
+    const hdr = projMem.truncated ? `\u25B8 ${PROJECT_MEMORY_FILE}: ${projMem.path} (${projMem.originalChars.toLocaleString()} chars, truncated)` : `\u25B8 ${PROJECT_MEMORY_FILE}: ${projMem.path} (${projMem.originalChars.toLocaleString()} chars)`;
+    parts.push(hdr, "", projMem.content);
+  }
+  const globalIdx = store.loadIndex("global");
+  if (globalIdx) {
+    parts.push(
+      "",
+      `\u25B8 global memory (${globalIdx.originalChars.toLocaleString()} chars${globalIdx.truncated ? ", truncated" : ""})`,
+      "",
+      globalIdx.content
+    );
+  }
+  const projectIdx = store.loadIndex("project");
+  if (projectIdx) {
+    parts.push(
+      "",
+      `\u25B8 project memory (${projectIdx.originalChars.toLocaleString()} chars${projectIdx.truncated ? ", truncated" : ""})`,
+      "",
+      projectIdx.content
+    );
+  }
+  if (parts.length === 0) {
+    return {
+      info: [
+        `no memory pinned in ${ctx.memoryRoot}.`,
+        "",
+        "Three layers are available:",
+        `  1. ${PROJECT_MEMORY_FILE} \u2014 committable team memory (in the repo).`,
+        "  2. ~/.reasonix/memory/global/ \u2014 your cross-project private memory.",
+        `  3. ~/.reasonix/memory/<project-hash>/ \u2014 this project's private memory.`,
+        "",
+        "Ask the model to `remember` something, or hand-edit files directly.",
+        "Changes take effect on next /new or launch \u2014 the system prompt is hashed once per session to keep the prefix cache warm.",
+        "",
+        "Subcommands: /memory list | /memory show <name> | /memory forget <name> | /memory clear <scope> confirm"
+      ].join("\n")
+    };
+  }
+  parts.push(
+    "",
+    "Changes take effect on next /new or launch. Subcommands: /memory list | show | forget | clear"
+  );
+  return { info: parts.join("\n") };
+}
+function resolveMemoryTarget(store, raw) {
+  const slash = raw.indexOf("/");
+  if (slash > 0) {
+    const scopeRaw = raw.slice(0, slash).toLowerCase();
+    const name = raw.slice(slash + 1);
+    if (scopeRaw !== "global" && scopeRaw !== "project") return null;
+    const scope = scopeRaw;
+    if (scope === "project" && !store.hasProjectScope()) return null;
+    return { scope, name };
+  }
+  for (const scope of ["project", "global"]) {
+    if (scope === "project" && !store.hasProjectScope()) continue;
+    try {
+      store.read(scope, raw);
+      return { scope, name: raw };
+    } catch {
+    }
+  }
+  return null;
+}
 function appendSection(lines, label, section) {
   if (!section || !section.supported) {
     lines.push(
@@ -6611,6 +7006,11 @@ async function chatCommand(opts) {
     if (!tools) tools = new ToolRegistry();
     registerWebTools(tools);
   }
+  if (!opts.seedTools) {
+    if (!tools) tools = new ToolRegistry();
+    registerMemoryTools(tools, {});
+    registerSkillTools(tools);
+  }
   let sessionPreview;
   if (opts.session && !opts.forceResume && !opts.forceNew) {
     const prior = loadSessionMessages(opts.session);
@@ -6649,7 +7049,7 @@ async function chatCommand(opts) {
 // src/cli/commands/code.tsx
 import { basename, resolve as resolve5 } from "path";
 async function codeCommand(opts = {}) {
-  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-JNNNJLYF.js");
+  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-VDN5U3YE.js");
   const rootDir = resolve5(opts.dir ?? process.cwd());
   const session = opts.noSession ? void 0 : `code-${sanitizeName(basename(rootDir))}`;
   const tools = new ToolRegistry();
@@ -6658,9 +7058,14 @@ async function codeCommand(opts = {}) {
     rootDir,
     // Per-project "always allow" list persisted from prior ShellConfirm
     // choices; merged on top of the built-in allowlist in shell.ts.
-    extraAllowed: loadProjectShellAllowed(rootDir)
+    // GETTER form — re-read every dispatch so a prefix the user adds
+    // via ShellConfirm mid-session takes effect on the next shell call
+    // instead of waiting for `/new` or a relaunch.
+    extraAllowed: () => loadProjectShellAllowed(rootDir)
   });
   registerPlanTool(tools);
+  registerMemoryTools(tools, { projectRoot: rootDir });
+  registerSkillTools(tools, { projectRoot: rootDir });
   process.stderr.write(
     `\u25B8 reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}" \xB7 ${tools.size} native tool(s)
 `
@@ -7710,7 +8115,7 @@ program.action(async () => {
   const defaults = resolveDefaults({});
   await chatCommand({
     model: defaults.model,
-    system: applyProjectMemory(DEFAULT_SYSTEM, process.cwd()),
+    system: applyMemoryStack(DEFAULT_SYSTEM, process.cwd()),
     harvest: defaults.harvest,
     branch: defaults.branch,
     session: defaults.session,
@@ -7762,7 +8167,7 @@ program.command("chat").description("Interactive Ink TUI with live cache/cost pa
   });
   await chatCommand({
     model: defaults.model,
-    system: applyProjectMemory(opts.system, process.cwd()),
+    system: applyMemoryStack(opts.system, process.cwd()),
     transcript: opts.transcript,
     harvest: defaults.harvest,
     branch: defaults.branch,
@@ -7797,7 +8202,7 @@ program.command("run <task>").description("Run a single task non-interactively,
   await runCommand2({
     task,
     model: defaults.model,
-    system: applyProjectMemory(opts.system, process.cwd()),
+    system: applyMemoryStack(opts.system, process.cwd()),
     harvest: defaults.harvest,
     branch: defaults.branch,
     transcript: opts.transcript,