reasonix 0.4.19 → 0.4.21

package/dist/index.js

@@ -47,8 +47,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve5, reject) => {
-    const timer = setTimeout(resolve5, ms);
+  return new Promise((resolve7, reject) => {
+    const timer = setTimeout(resolve7, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -1537,8 +1537,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve5) => {
-              waiter = resolve5;
+            const sample = queue.shift() ?? await new Promise((resolve7) => {
+              waiter = resolve7;
             });
             yield {
               turn: this._turn,
@@ -1950,6 +1950,448 @@ ${mem.content}
 `;
 }
 
+// src/user-memory.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve as resolve2 } from "path";
+
+// src/skills.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve } from "path";
+var SKILLS_DIRNAME = "skills";
+var SKILL_FILE = "SKILL.md";
+var SKILLS_INDEX_MAX_CHARS = 4e3;
+var VALID_SKILL_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+function parseFrontmatter(raw) {
+  const lines = raw.split(/\r?\n/);
+  if (lines[0] !== "---") return { data: {}, body: raw };
+  const end = lines.indexOf("---", 1);
+  if (end < 0) return { data: {}, body: raw };
+  const data = {};
+  for (let i = 1; i < end; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const m = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/);
+    if (m?.[1]) data[m[1]] = (m[2] ?? "").trim();
+  }
+  return {
+    data,
+    body: lines.slice(end + 1).join("\n").replace(/^\n+/, "")
+  };
+}
+function isValidSkillName(name) {
+  return VALID_SKILL_NAME.test(name);
+}
+var SkillStore = class {
+  homeDir;
+  projectRoot;
+  constructor(opts = {}) {
+    this.homeDir = opts.homeDir ?? homedir2();
+    this.projectRoot = opts.projectRoot ? resolve(opts.projectRoot) : void 0;
+  }
+  /** True iff this store was configured with a project root. */
+  hasProjectScope() {
+    return this.projectRoot !== void 0;
+  }
+  /**
+   * Root directories scanned, in priority order. Project scope first
+   * so a per-repo skill overrides a global one with the same name —
+   * users expect the local copy to win when both exist.
+   */
+  roots() {
+    const out = [];
+    if (this.projectRoot) {
+      out.push({
+        dir: join3(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
+        scope: "project"
+      });
+    }
+    out.push({ dir: join3(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
+    return out;
+  }
+  /**
+   * List every skill visible to this store. On name collisions the
+   * higher-priority root (project over global) wins. Sorted by name
+   * for stable prefix hashing.
+   */
+  list() {
+    const byName = /* @__PURE__ */ new Map();
+    for (const { dir, scope } of this.roots()) {
+      if (!existsSync3(dir)) continue;
+      let entries;
+      try {
+        entries = readdirSync2(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const skill = this.readEntry(dir, scope, entry);
+        if (!skill) continue;
+        if (!byName.has(skill.name)) byName.set(skill.name, skill);
+      }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+  }
+  /** Resolve one skill by name. Returns `null` if not found or malformed. */
+  read(name) {
+    if (!isValidSkillName(name)) return null;
+    for (const { dir, scope } of this.roots()) {
+      if (!existsSync3(dir)) continue;
+      const dirCandidate = join3(dir, name, SKILL_FILE);
+      if (existsSync3(dirCandidate) && statSync2(dirCandidate).isFile()) {
+        return this.parse(dirCandidate, name, scope);
+      }
+      const flatCandidate = join3(dir, `${name}.md`);
+      if (existsSync3(flatCandidate) && statSync2(flatCandidate).isFile()) {
+        return this.parse(flatCandidate, name, scope);
+      }
+    }
+    return null;
+  }
+  readEntry(dir, scope, entry) {
+    if (entry.isDirectory()) {
+      if (!isValidSkillName(entry.name)) return null;
+      const file = join3(dir, entry.name, SKILL_FILE);
+      if (!existsSync3(file)) return null;
+      return this.parse(file, entry.name, scope);
+    }
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      const stem = entry.name.slice(0, -3);
+      if (!isValidSkillName(stem)) return null;
+      return this.parse(join3(dir, entry.name), stem, scope);
+    }
+    return null;
+  }
+  parse(path, stem, scope) {
+    let raw;
+    try {
+      raw = readFileSync3(path, "utf8");
+    } catch {
+      return null;
+    }
+    const { data, body } = parseFrontmatter(raw);
+    const name = data.name && isValidSkillName(data.name) ? data.name : stem;
+    return {
+      name,
+      description: (data.description ?? "").trim(),
+      body: body.trim(),
+      scope,
+      path,
+      allowedTools: data["allowed-tools"]
+    };
+  }
+};
+function skillIndexLine(s) {
+  const safeDesc = s.description.replace(/\n/g, " ").trim();
+  const max = 130 - s.name.length;
+  const clipped = safeDesc.length > max ? `${safeDesc.slice(0, Math.max(1, max - 1))}\u2026` : safeDesc;
+  return clipped ? `- ${s.name} \u2014 ${clipped}` : `- ${s.name}`;
+}
+function applySkillsIndex(basePrompt, opts = {}) {
+  const store = new SkillStore(opts);
+  const skills = store.list().filter((s) => s.description);
+  if (skills.length === 0) return basePrompt;
+  const lines = skills.map(skillIndexLine);
+  const joined = lines.join("\n");
+  const truncated = joined.length > SKILLS_INDEX_MAX_CHARS ? `${joined.slice(0, SKILLS_INDEX_MAX_CHARS)}
+\u2026 (truncated ${joined.length - SKILLS_INDEX_MAX_CHARS} chars)` : joined;
+  return [
+    basePrompt,
+    "",
+    "# Skills \u2014 user-defined prompt packs",
+    "",
+    'One-liner index. Each skill is a self-contained instruction block (plus optional tool hints) the user or an earlier session saved. To load the full body, call `run_skill({ name: "<skill-name>" })` \u2014 the body is NOT in this prompt, only the name and description are. The user can also invoke a skill directly as `/skill <name>`.',
+    "",
+    "```",
+    truncated,
+    "```"
+  ].join("\n");
+}
+
+// src/user-memory.ts
+var USER_MEMORY_DIR = "memory";
+var MEMORY_INDEX_FILE = "MEMORY.md";
+var MEMORY_INDEX_MAX_CHARS = 4e3;
+var VALID_NAME = /^[a-zA-Z0-9_-][a-zA-Z0-9_.-]{1,38}[a-zA-Z0-9]$/;
+function sanitizeMemoryName(raw) {
+  const trimmed = String(raw ?? "").trim();
+  if (!VALID_NAME.test(trimmed)) {
+    throw new Error(
+      `invalid memory name: ${JSON.stringify(raw)} \u2014 must be 3-40 chars, alnum/_/-, no path separators`
+    );
+  }
+  return trimmed;
+}
+function projectHash(rootDir) {
+  const abs = resolve2(rootDir);
+  return createHash2("sha1").update(abs).digest("hex").slice(0, 16);
+}
+function scopeDir(opts) {
+  if (opts.scope === "global") {
+    return join4(opts.homeDir, USER_MEMORY_DIR, "global");
+  }
+  if (!opts.projectRoot) {
+    throw new Error("scope=project requires a projectRoot on MemoryStore");
+  }
+  return join4(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
+}
+function ensureDir(p) {
+  if (!existsSync4(p)) mkdirSync2(p, { recursive: true });
+}
+function parseFrontmatter2(raw) {
+  const lines = raw.split(/\r?\n/);
+  if (lines[0] !== "---") return { data: {}, body: raw };
+  const end = lines.indexOf("---", 1);
+  if (end < 0) return { data: {}, body: raw };
+  const data = {};
+  for (let i = 1; i < end; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const m = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/);
+    if (m?.[1]) data[m[1]] = (m[2] ?? "").trim();
+  }
+  return {
+    data,
+    body: lines.slice(end + 1).join("\n").replace(/^\n+/, "")
+  };
+}
+function formatFrontmatter(e) {
+  return [
+    "---",
+    `name: ${e.name}`,
+    `description: ${e.description.replace(/\n/g, " ")}`,
+    `type: ${e.type}`,
+    `scope: ${e.scope}`,
+    `created: ${e.createdAt}`,
+    "---",
+    ""
+  ].join("\n");
+}
+function todayIso() {
+  const d = /* @__PURE__ */ new Date();
+  return d.toISOString().slice(0, 10);
+}
+function indexLine(e) {
+  const safeDesc = e.description.replace(/\n/g, " ").trim();
+  const max = 130 - e.name.length;
+  const clipped = safeDesc.length > max ? `${safeDesc.slice(0, Math.max(1, max - 1))}\u2026` : safeDesc;
+  return `- [${e.name}](${e.name}.md) \u2014 ${clipped}`;
+}
+var MemoryStore = class {
+  homeDir;
+  projectRoot;
+  constructor(opts = {}) {
+    this.homeDir = opts.homeDir ?? join4(homedir3(), ".reasonix");
+    this.projectRoot = opts.projectRoot ? resolve2(opts.projectRoot) : void 0;
+  }
+  /** Directory this store writes `scope` files into, creating it if needed. */
+  dir(scope) {
+    const d = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
+    ensureDir(d);
+    return d;
+  }
+  /** Absolute path to a memory file (no existence check). */
+  pathFor(scope, name) {
+    return join4(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
+  }
+  /** True iff this store is configured with a project scope available. */
+  hasProjectScope() {
+    return this.projectRoot !== void 0;
+  }
+  /**
+   * Read the `MEMORY.md` index for a scope. Returns post-cap content
+   * (with a truncation marker if clipped), or `null` when absent / empty.
+   */
+  loadIndex(scope) {
+    if (scope === "project" && !this.projectRoot) return null;
+    const file = join4(
+      scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot }),
+      MEMORY_INDEX_FILE
+    );
+    if (!existsSync4(file)) return null;
+    let raw;
+    try {
+      raw = readFileSync4(file, "utf8");
+    } catch {
+      return null;
+    }
+    const trimmed = raw.trim();
+    if (!trimmed) return null;
+    const originalChars = trimmed.length;
+    const truncated = originalChars > MEMORY_INDEX_MAX_CHARS;
+    const content = truncated ? `${trimmed.slice(0, MEMORY_INDEX_MAX_CHARS)}
+\u2026 (truncated ${originalChars - MEMORY_INDEX_MAX_CHARS} chars)` : trimmed;
+    return { content, originalChars, truncated };
+  }
+  /** Read one memory file's body (frontmatter stripped). Throws if missing. */
+  read(scope, name) {
+    const file = this.pathFor(scope, name);
+    if (!existsSync4(file)) {
+      throw new Error(`memory not found: scope=${scope} name=${name}`);
+    }
+    const raw = readFileSync4(file, "utf8");
+    const { data, body } = parseFrontmatter2(raw);
+    return {
+      name: data.name ?? name,
+      type: data.type ?? "project",
+      scope: data.scope ?? scope,
+      description: data.description ?? "",
+      body: body.trim(),
+      createdAt: data.created ?? ""
+    };
+  }
+  /**
+   * List every memory in this store. Scans both scopes (skips project
+   * scope if unconfigured). Silently skips malformed files; the index
+   * must stay queryable even if one file is hand-edited into nonsense.
+   */
+  list() {
+    const out = [];
+    const scopes = this.projectRoot ? ["global", "project"] : ["global"];
+    for (const scope of scopes) {
+      const dir = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
+      if (!existsSync4(dir)) continue;
+      let entries;
+      try {
+        entries = readdirSync3(dir);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (entry === MEMORY_INDEX_FILE) continue;
+        if (!entry.endsWith(".md")) continue;
+        const name = entry.slice(0, -3);
+        try {
+          out.push(this.read(scope, name));
+        } catch {
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * Write a new memory (or overwrite existing). Creates the scope dir,
+   * writes the `.md` file, and regenerates `MEMORY.md`. Returns the
+   * absolute path written to.
+   */
+  write(input) {
+    if (input.scope === "project" && !this.projectRoot) {
+      throw new Error("cannot write project-scoped memory: no projectRoot configured");
+    }
+    const name = sanitizeMemoryName(input.name);
+    const desc = String(input.description ?? "").trim();
+    if (!desc) throw new Error("memory description cannot be empty");
+    const body = String(input.body ?? "").trim();
+    if (!body) throw new Error("memory body cannot be empty");
+    const entry = {
+      ...input,
+      name,
+      description: desc,
+      body,
+      createdAt: todayIso()
+    };
+    const dir = this.dir(input.scope);
+    const file = join4(dir, `${name}.md`);
+    const content = `${formatFrontmatter(entry)}${body}
+`;
+    writeFileSync2(file, content, "utf8");
+    this.regenerateIndex(input.scope);
+    return file;
+  }
+  /** Delete one memory + its index line. No-op if the file is already gone. */
+  delete(scope, rawName) {
+    if (scope === "project" && !this.projectRoot) {
+      throw new Error("cannot delete project-scoped memory: no projectRoot configured");
+    }
+    const file = this.pathFor(scope, rawName);
+    if (!existsSync4(file)) return false;
+    unlinkSync2(file);
+    this.regenerateIndex(scope);
+    return true;
+  }
+  /**
+   * Rebuild `MEMORY.md` from the `.md` files currently in the scope dir.
+   * Called after every write/delete. Sorted by name for stable prefix
+   * hashing — two stores with the same set of files produce byte-identical
+   * MEMORY.md content, keeping the cache prefix reproducible.
+   */
+  regenerateIndex(scope) {
+    const dir = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
+    if (!existsSync4(dir)) return;
+    let files;
+    try {
+      files = readdirSync3(dir);
+    } catch {
+      return;
+    }
+    const mdFiles = files.filter((f) => f !== MEMORY_INDEX_FILE && f.endsWith(".md")).sort((a, b) => a.localeCompare(b));
+    const indexPath = join4(dir, MEMORY_INDEX_FILE);
+    if (mdFiles.length === 0) {
+      if (existsSync4(indexPath)) unlinkSync2(indexPath);
+      return;
+    }
+    const lines = [];
+    for (const f of mdFiles) {
+      const name = f.slice(0, -3);
+      try {
+        const entry = this.read(scope, name);
+        lines.push(indexLine({ name: entry.name || name, description: entry.description }));
+      } catch {
+        lines.push(`- [${name}](${name}.md) \u2014 (malformed, check frontmatter)`);
+      }
+    }
+    writeFileSync2(indexPath, `${lines.join("\n")}
+`, "utf8");
+  }
+};
+function applyUserMemory(basePrompt, opts = {}) {
+  if (!memoryEnabled()) return basePrompt;
+  const store = new MemoryStore(opts);
+  const global = store.loadIndex("global");
+  const project = store.hasProjectScope() ? store.loadIndex("project") : null;
+  if (!global && !project) return basePrompt;
+  const parts = [basePrompt];
+  if (global) {
+    parts.push(
+      "",
+      "# User memory \u2014 global (~/.reasonix/memory/global/MEMORY.md)",
+      "",
+      "Cross-project facts and preferences the user has told you in prior sessions. TREAT AS AUTHORITATIVE \u2014 don't re-verify via filesystem or web. One-liners index detail files; call `recall_memory` for full bodies only when the one-liner isn't enough.",
+      "",
+      "```",
+      global.content,
+      "```"
+    );
+  }
+  if (project) {
+    parts.push(
+      "",
+      "# User memory \u2014 this project",
+      "",
+      "Per-project facts the user established in prior sessions (not committed to the repo). TREAT AS AUTHORITATIVE. Same recall pattern as global memory.",
+      "",
+      "```",
+      project.content,
+      "```"
+    );
+  }
+  return parts.join("\n");
+}
+function applyMemoryStack(basePrompt, rootDir) {
+  const withProject = applyProjectMemory(basePrompt, rootDir);
+  const withMemory = applyUserMemory(withProject, { projectRoot: rootDir });
+  return applySkillsIndex(withMemory, { projectRoot: rootDir });
+}
+
 // src/tools/filesystem.ts
 import { promises as fs } from "fs";
 import * as pathMod from "path";
@@ -2173,7 +2615,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: {
@@ -2290,6 +2732,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;
@@ -2337,7 +2900,7 @@ function registerPlanTool(registry, opts = {}) {
 
 // src/tools/shell.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { existsSync as existsSync5, statSync as statSync3 } from "fs";
 import * as pathMod2 from "path";
 var DEFAULT_TIMEOUT_SEC = 60;
 var DEFAULT_MAX_OUTPUT_CHARS = 32e3;
@@ -2457,7 +3020,7 @@ async function runCommand(cmd, opts) {
   };
   const { bin, args, spawnOverrides } = prepareSpawn(argv);
   const effectiveSpawnOpts = { ...spawnOpts, ...spawnOverrides };
-  return await new Promise((resolve5, reject) => {
+  return await new Promise((resolve7, reject) => {
     let child;
     try {
       child = spawn(bin, args, effectiveSpawnOpts);
@@ -2490,7 +3053,7 @@ async function runCommand(cmd, opts) {
       const output = buf.length > maxChars ? `${buf.slice(0, maxChars)}
 
 [\u2026 truncated ${buf.length - maxChars} chars \u2026]` : buf;
-      resolve5({ exitCode: code, output, timedOut });
+      resolve7({ exitCode: code, output, timedOut });
     });
   });
 }
@@ -2507,7 +3070,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;
     }
   }
@@ -2515,7 +3078,7 @@ function resolveExecutable(cmd, opts = {}) {
 }
 function defaultIsFile(full) {
   try {
-    return existsSync3(full) && statSync2(full).isFile();
+    return existsSync5(full) && statSync3(full).isFile();
   } catch {
     return false;
   }
@@ -2540,8 +3103,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;
@@ -2561,11 +3139,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
@@ -2574,14 +3155,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",
@@ -2593,7 +3174,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));
@@ -2800,12 +3381,12 @@ ${i + 1}. ${r.title}`);
 }
 
 // src/env.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve3 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve5 } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync3(resolve3(process.cwd(), path), "utf8");
+    raw = readFileSync5(resolve5(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -2824,7 +3405,7 @@ function loadDotenv(path = ".env") {
 }
 
 // src/transcript.ts
-import { createWriteStream, readFileSync as readFileSync4 } from "fs";
+import { createWriteStream, readFileSync as readFileSync6 } from "fs";
 function recordFromLoopEvent(ev, extra) {
   const rec = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2875,7 +3456,7 @@ function openTranscriptFile(path, meta) {
   return stream;
 }
 function readTranscript(path) {
-  const raw = readFileSync4(path, "utf8");
+  const raw = readFileSync6(path, "utf8");
   return parseTranscript(raw);
 }
 function isPlanStateEmptyShape(s) {
@@ -3487,7 +4068,7 @@ var McpClient = class {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
     let abortHandler = null;
-    const promise = new Promise((resolve5, reject) => {
+    const promise = new Promise((resolve7, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
@@ -3496,7 +4077,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve5,
+        resolve: resolve7,
         reject,
         timeout
       });
@@ -3619,12 +4200,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve7, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve5();
+        else resolve7();
       });
     });
   }
@@ -3635,8 +4216,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve5) => {
-        this.waiters.push(resolve5);
+      const next = await new Promise((resolve7) => {
+        this.waiters.push(resolve7);
       });
       if (next === null) return;
       yield next;
@@ -3702,8 +4283,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve5, reject) => {
-      this.resolveEndpoint = resolve5;
+    this.endpointReady = new Promise((resolve7, reject) => {
+      this.resolveEndpoint = resolve7;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -3730,8 +4311,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve5) => {
-        this.waiters.push(resolve5);
+      const next = await new Promise((resolve7) => {
+        this.waiters.push(resolve7);
       });
       if (next === null) return;
       yield next;
@@ -3930,8 +4511,8 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, resolve as resolve4 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve6 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -3949,8 +4530,8 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve4(rootDir);
-  const absTarget = resolve4(absRoot, block.path);
+  const absRoot = resolve6(rootDir);
+  const absTarget = resolve6(absRoot, block.path);
   if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
     return {
       path: block.path,
@@ -3959,7 +4540,7 @@ function applyEditBlock(block, rootDir) {
     };
   }
   const searchEmpty = block.search.length === 0;
-  const exists = existsSync4(absTarget);
+  const exists = existsSync6(absTarget);
   try {
     if (!exists) {
       if (!searchEmpty) {
@@ -3969,11 +4550,11 @@ function applyEditBlock(block, rootDir) {
           message: "file does not exist; to create it, use an empty SEARCH block"
         };
       }
-      mkdirSync2(dirname3(absTarget), { recursive: true });
-      writeFileSync2(absTarget, block.replace, "utf8");
+      mkdirSync3(dirname3(absTarget), { recursive: true });
+      writeFileSync3(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
-    const content = readFileSync5(absTarget, "utf8");
+    const content = readFileSync7(absTarget, "utf8");
     if (searchEmpty) {
       return {
         path: block.path,
@@ -3990,7 +4571,7 @@ function applyEditBlock(block, rootDir) {
       };
     }
     const replaced = `${content.slice(0, idx)}${block.replace}${content.slice(idx + block.search.length)}`;
-    writeFileSync2(absTarget, replaced, "utf8");
+    writeFileSync3(absTarget, replaced, "utf8");
     return { path: block.path, status: "applied" };
   } catch (err) {
     return { path: block.path, status: "error", message: err.message };
@@ -4000,19 +4581,19 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve4(rootDir);
+  const absRoot = resolve6(rootDir);
   const seen = /* @__PURE__ */ new Set();
   const snapshots = [];
   for (const b of blocks) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
-    const abs = resolve4(absRoot, b.path);
-    if (!existsSync4(abs)) {
+    const abs = resolve6(absRoot, b.path);
+    if (!existsSync6(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync5(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync7(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -4020,9 +4601,9 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve4(rootDir);
+  const absRoot = resolve6(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve4(absRoot, snap.path);
+    const abs = resolve6(absRoot, snap.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
       return {
         path: snap.path,
@@ -4032,14 +4613,14 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync4(abs)) unlinkSync2(abs);
+        if (existsSync6(abs)) unlinkSync3(abs);
         return {
           path: snap.path,
           status: "applied",
           message: "removed (the edit had created it)"
         };
       }
-      writeFileSync2(abs, snap.prevContent, "utf8");
+      writeFileSync3(abs, snap.prevContent, "utf8");
       return {
         path: snap.path,
         status: "applied",
@@ -4055,8 +4636,8 @@ function sep() {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { join as join6 } from "path";
 var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, list_directory, search_files, etc.) rooted at the user's working directory.
 
 # When to propose a plan (submit_plan)
@@ -4070,13 +4651,13 @@ You have a \`submit_plan\` tool that shows the user a markdown plan and lets the
 
 Skip submit_plan for small, obvious changes: one-line typo, clear bug with a clear fix, adding a missing import, renaming a local variable. Just do those.
 
-Plan body: one-sentence summary, then a file-by-file breakdown of what you'll change and why, and any risks or open questions. If some decisions are genuinely up to the user (naming, tradeoffs, out-of-scope possibilities), list them in an "Open questions" or "\u5F85\u786E\u8BA4" section \u2014 the user sees the plan in a picker and has a text input to answer your questions before approving. Don't pretend certainty you don't have; flagged questions are how the user tells you what they care about. After calling submit_plan, STOP \u2014 don't call any more tools, wait for the user's verdict.
+Plan body: one-sentence summary, then a file-by-file breakdown of what you'll change and why, and any risks or open questions. If some decisions are genuinely up to the user (naming, tradeoffs, out-of-scope possibilities), list them in an "Open questions" section \u2014 the user sees the plan in a picker and has a text input to answer your questions before approving. Don't pretend certainty you don't have; flagged questions are how the user tells you what they care about. After calling submit_plan, STOP \u2014 don't call any more tools, wait for the user's verdict.
 
 # Plan mode (/plan)
 
 The user can ALSO enter "plan mode" via /plan, which is a stronger, explicit constraint:
 - Write tools (edit_file, write_file, create_directory, move_file) and non-allowlisted run_command calls are BOUNCED at dispatch \u2014 you'll get a tool result like "unavailable in plan mode". Don't retry them.
-- Read tools (read_file, list_directory, search_files, directory_tree, get_file_info) and allowlisted shell (git status/log/diff, ls, cat, grep, cargo check, npm test) still work \u2014 use them to investigate.
+- Read tools (read_file, list_directory, search_files, directory_tree, get_file_info) and allowlisted read-only / test shell commands still work \u2014 use them to investigate.
 - You MUST call submit_plan before anything will execute. Approve exits plan mode; Refine stays in; Cancel exits without implementing.
 
 
@@ -4114,9 +4695,13 @@ Rules:
 - Do NOT use write_file to change existing files \u2014 the user reviews your edits as SEARCH/REPLACE. write_file is only for files you explicitly want to overwrite wholesale (rare).
 - Paths are relative to the working directory. Don't use absolute paths.
 
+# Trust what you already know
+
+Before exploring the filesystem to answer a factual question, check whether the answer is already in context: the user's current message, earlier turns in this conversation (including prior tool results from \`remember\`), and the pinned memory blocks at the top of this prompt. When the user has stated a fact or you have remembered one, it outranks what the files say \u2014 don't re-derive from code what the user already told you. Explore when you genuinely don't know.
+
 # Exploration
 
-- Avoid listing or reading inside these common dependency / build directories unless the user explicitly asks about them: node_modules, dist, build, out, .next, .nuxt, .svelte-kit, .git, .venv, venv, __pycache__, target, coverage, .turbo, .cache. They're expensive and usually irrelevant.
+- Skip dependency, build, and VCS directories unless the user explicitly asks. The pinned .gitignore block (if any, below) is your authoritative denylist.
 - Prefer search_files / grep over list_directory when you know roughly what you're looking for \u2014 it saves context and avoids enumerating huge trees.
 
 # Style
@@ -4126,12 +4711,12 @@ Rules:
 - If you need to explore first (list / grep / read), do it with tool calls before writing any prose \u2014 silence while exploring is fine.
 `;
 function codeSystemPrompt(rootDir) {
-  const withMemory = applyProjectMemory(CODE_SYSTEM_PROMPT, rootDir);
-  const gitignorePath = join5(rootDir, ".gitignore");
-  if (!existsSync5(gitignorePath)) return withMemory;
+  const withMemory = applyMemoryStack(CODE_SYSTEM_PROMPT, rootDir);
+  const gitignorePath = join6(rootDir, ".gitignore");
+  if (!existsSync7(gitignorePath)) return withMemory;
   let content;
   try {
-    content = readFileSync6(gitignorePath, "utf8");
+    content = readFileSync8(gitignorePath, "utf8");
   } catch {
     return withMemory;
   }
@@ -4151,15 +4736,15 @@ ${truncated}
 }
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname4, join as join6 } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname4, join as join7 } from "path";
 function defaultConfigPath() {
-  return join6(homedir2(), ".reasonix", "config.json");
+  return join7(homedir4(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync7(path, "utf8");
+    const raw = readFileSync9(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -4167,8 +4752,8 @@ function readConfig(path = defaultConfigPath()) {
   return {};
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
-  mkdirSync3(dirname4(path), { recursive: true });
-  writeFileSync3(path, JSON.stringify(cfg, null, 2), "utf8");
+  mkdirSync4(dirname4(path), { recursive: true });
+  writeFileSync4(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
     chmodSync2(path, 384);
   } catch {
@@ -4194,7 +4779,7 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.4.19";
+var VERSION = "0.4.20";
 export {
   AppendOnlyLog,
   CODE_SYSTEM_PROMPT,
@@ -4203,7 +4788,10 @@ export {
   DeepSeekClient,
   ImmutablePrefix,
   MCP_PROTOCOL_VERSION,
+  MEMORY_INDEX_FILE,
+  MEMORY_INDEX_MAX_CHARS,
   McpClient,
+  MemoryStore,
   NeedsConfirmationError,
   PROJECT_MEMORY_FILE,
   PROJECT_MEMORY_MAX_CHARS,
@@ -4214,6 +4802,7 @@ export {
   StormBreaker,
   ToolCallRepair,
   ToolRegistry,
+  USER_MEMORY_DIR,
   Usage,
   VERSION,
   VolatileScratch,
@@ -4222,7 +4811,9 @@ export {
   appendSessionMessage,
   applyEditBlock,
   applyEditBlocks,
+  applyMemoryStack,
   applyProjectMemory,
+  applyUserMemory,
   bridgeMcpTools,
   claudeEquivalentCost,
   codeSystemPrompt,
@@ -4261,6 +4852,7 @@ export {
   parseMojeekResults,
   parseTranscript,
   prepareSpawn,
+  projectHash,
   quoteForCmdExe,
   readConfig,
   readProjectMemory,
@@ -4268,6 +4860,7 @@ export {
   recordFromLoopEvent,
   redactKey,
   registerFilesystemTools,
+  registerMemoryTools,
   registerPlanTool,
   registerShellTools,
   registerWebTools,
@@ -4279,6 +4872,7 @@ export {
   restoreSnapshots,
   runBranches,
   runCommand,
+  sanitizeMemoryName,
   sanitizeName as sanitizeSessionName,
   saveApiKey,
   scavengeToolCalls,