reasonix 0.4.19 → 0.4.21

package/README.md

@@ -209,8 +209,53 @@ EOF
 
 Re-launch (or `/new`) to pick it up; the prefix is hashed once per
 session to keep the DeepSeek cache warm. `/memory` prints what's
-currently pinned. `REASONIX_MEMORY=off` disables the lookup for CI /
-offline repro.
+currently pinned. `REASONIX_MEMORY=off` disables every memory source
+(REASONIX.md + `~/.reasonix/memory/`) for CI / offline repro.
+
+### User memory — `~/.reasonix/memory/`
+
+A second, **private per-user** memory layer lives under your home
+directory. Unlike `REASONIX.md` it's never committed, and the model
+can write to it itself via the `remember` tool. Two scopes:
+
+- `~/.reasonix/memory/global/` — cross-project (your preferences, tooling).
+- `~/.reasonix/memory/<project-hash>/` — scoped to one sandbox root in
+  `reasonix code` (decisions, local facts, per-repo shortcuts).
+
+Each scope keeps an always-loaded `MEMORY.md` index of one-liners plus
+zero or more `<name>.md` detail files (loaded on demand via
+`recall_memory`). Writes land immediately; pinning into the system
+prompt takes effect on next `/new` or launch so the cache prefix stays
+stable for the current session.
+
+```
+reasonix code › 我用 bun 而不是 npm，请以后都用 bun 跑构建
+
+assistant
+  ▸ tool<remember> → project/bun_build saved
+    "Build command on this machine is `bun run build`"
+
+reasonix code › /memory list
+  project/project     bun_build       Build command on this machine is `bun run build`
+```
+
+**Slash commands:**
+
+- `/memory` — show everything pinned (REASONIX.md + both MEMORY.md scopes)
+- `/memory list` — every memory file with scope + type + description
+- `/memory show <name>` — dump one file's full body
+- `/memory forget <name>` — delete one memory (no LLM turn)
+- `/memory clear <global|project> confirm` — wipe a scope (typed literal)
+
+**Model tools** (available in every session):
+
+- `remember(type, scope, name, description, content)` — save a memory
+- `forget(scope, name)` — delete it
+- `recall_memory(scope, name)` — read the full body when the one-liner isn't enough
+
+Project scope is only available inside `reasonix code` (there has to be
+a real sandbox root to hash); plain `reasonix` / `reasonix chat` gets
+the global scope only.
 
 ```bash
 npx reasonix code src/           # narrower sandbox (only src/ is writable)

package/dist/cli/chunk-K6MR4SWS.js

@@ -0,0 +1,601 @@
+#!/usr/bin/env node
+
+// src/code/prompt.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/user-memory.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync3,
+  mkdirSync,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve2 } from "path";
+
+// src/project-memory.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var PROJECT_MEMORY_FILE = "REASONIX.md";
+var PROJECT_MEMORY_MAX_CHARS = 8e3;
+function readProjectMemory(rootDir) {
+  const path = join(rootDir, PROJECT_MEMORY_FILE);
+  if (!existsSync(path)) return null;
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const originalChars = trimmed.length;
+  const truncated = originalChars > PROJECT_MEMORY_MAX_CHARS;
+  const content = truncated ? `${trimmed.slice(0, PROJECT_MEMORY_MAX_CHARS)}
+\u2026 (truncated ${originalChars - PROJECT_MEMORY_MAX_CHARS} chars)` : trimmed;
+  return { path, content, originalChars, truncated };
+}
+function memoryEnabled() {
+  const env = process.env.REASONIX_MEMORY;
+  if (env === "off" || env === "false" || env === "0") return false;
+  return true;
+}
+function applyProjectMemory(basePrompt, rootDir) {
+  if (!memoryEnabled()) return basePrompt;
+  const mem = readProjectMemory(rootDir);
+  if (!mem) return basePrompt;
+  return `${basePrompt}
+
+# Project memory (REASONIX.md)
+
+The user pinned these notes about this project \u2014 treat them as authoritative context for every turn:
+
+\`\`\`
+${mem.content}
+\`\`\`
+`;
+}
+
+// src/skills.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { join as join2, 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 ?? homedir();
+    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: join2(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
+        scope: "project"
+      });
+    }
+    out.push({ dir: join2(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 (!existsSync2(dir)) continue;
+      let entries;
+      try {
+        entries = readdirSync(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 (!existsSync2(dir)) continue;
+      const dirCandidate = join2(dir, name, SKILL_FILE);
+      if (existsSync2(dirCandidate) && statSync(dirCandidate).isFile()) {
+        return this.parse(dirCandidate, name, scope);
+      }
+      const flatCandidate = join2(dir, `${name}.md`);
+      if (existsSync2(flatCandidate) && statSync(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 = join2(dir, entry.name, SKILL_FILE);
+      if (!existsSync2(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(join2(dir, entry.name), stem, scope);
+    }
+    return null;
+  }
+  parse(path, stem, scope) {
+    let raw;
+    try {
+      raw = readFileSync2(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 createHash("sha1").update(abs).digest("hex").slice(0, 16);
+}
+function scopeDir(opts) {
+  if (opts.scope === "global") {
+    return join3(opts.homeDir, USER_MEMORY_DIR, "global");
+  }
+  if (!opts.projectRoot) {
+    throw new Error("scope=project requires a projectRoot on MemoryStore");
+  }
+  return join3(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
+}
+function ensureDir(p) {
+  if (!existsSync3(p)) mkdirSync(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 ?? join3(homedir2(), ".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 join3(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 = join3(
+      scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot }),
+      MEMORY_INDEX_FILE
+    );
+    if (!existsSync3(file)) return null;
+    let raw;
+    try {
+      raw = readFileSync3(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 (!existsSync3(file)) {
+      throw new Error(`memory not found: scope=${scope} name=${name}`);
+    }
+    const raw = readFileSync3(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 (!existsSync3(dir)) continue;
+      let entries;
+      try {
+        entries = readdirSync2(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 = join3(dir, `${name}.md`);
+    const content = `${formatFrontmatter(entry)}${body}
+`;
+    writeFileSync(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 (!existsSync3(file)) return false;
+    unlinkSync(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 (!existsSync3(dir)) return;
+    let files;
+    try {
+      files = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    const mdFiles = files.filter((f) => f !== MEMORY_INDEX_FILE && f.endsWith(".md")).sort((a, b) => a.localeCompare(b));
+    const indexPath = join3(dir, MEMORY_INDEX_FILE);
+    if (mdFiles.length === 0) {
+      if (existsSync3(indexPath)) unlinkSync(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)`);
+      }
+    }
+    writeFileSync(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/code/prompt.ts
+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)
+
+You have a \`submit_plan\` tool that shows the user a markdown plan and lets them Approve / Refine / Cancel before you execute. Use it proactively when the task is large enough to deserve a review gate:
+
+- Multi-file refactors or renames.
+- Architecture changes (moving modules, splitting / merging files, new abstractions).
+- Anything where "undo" after the fact would be expensive \u2014 migrations, destructive cleanups, API shape changes.
+- When the user's request is ambiguous and multiple reasonable interpretations exist \u2014 propose your reading as a plan and let them confirm.
+
+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" 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 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.
+
+
+# When to edit vs. when to explore
+
+Only propose edits when the user explicitly asks you to change, fix, add, remove, refactor, or write something. Do NOT propose edits when the user asks you to:
+- analyze, read, explore, describe, or summarize a project
+- explain how something works
+- answer a question about the code
+
+In those cases, use tools to gather what you need, then reply in prose. No SEARCH/REPLACE blocks, no file changes. If you're unsure what the user wants, ask.
+
+When you do propose edits, the user will review them and decide whether to \`/apply\` or \`/discard\`. Don't assume they'll accept \u2014 write as if each edit will be audited, because it will.
+
+# Editing files
+
+When you've been asked to change a file, output one or more SEARCH/REPLACE blocks in this exact format:
+
+path/to/file.ext
+<<<<<<< SEARCH
+exact existing lines from the file, including whitespace
+=======
+the new lines
+>>>>>>> REPLACE
+
+Rules:
+- Always read_file first so your SEARCH matches byte-for-byte. If it doesn't match, the edit is rejected and you'll have to retry with the exact current content.
+- One edit per block. Multiple blocks in one response are fine.
+- To create a new file, leave SEARCH empty:
+    path/to/new.ts
+    <<<<<<< SEARCH
+    =======
+    (whole file content here)
+    >>>>>>> REPLACE
+- 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
+
+- 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
+
+- Show edits; don't narrate them in prose. "Here's the fix:" is enough.
+- One short paragraph explaining *why*, then the blocks.
+- 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 = applyMemoryStack(CODE_SYSTEM_PROMPT, rootDir);
+  const gitignorePath = join4(rootDir, ".gitignore");
+  if (!existsSync4(gitignorePath)) return withMemory;
+  let content;
+  try {
+    content = readFileSync4(gitignorePath, "utf8");
+  } catch {
+    return withMemory;
+  }
+  const MAX = 2e3;
+  const truncated = content.length > MAX ? `${content.slice(0, MAX)}
+\u2026 (truncated ${content.length - MAX} chars)` : content;
+  return `${withMemory}
+
+# Project .gitignore
+
+The user's repo ships this .gitignore \u2014 treat every pattern as "don't traverse or edit inside these paths unless explicitly asked":
+
+\`\`\`
+${truncated}
+\`\`\`
+`;
+}
+
+export {
+  PROJECT_MEMORY_FILE,
+  readProjectMemory,
+  memoryEnabled,
+  SkillStore,
+  sanitizeMemoryName,
+  MemoryStore,
+  applyMemoryStack,
+  CODE_SYSTEM_PROMPT,
+  codeSystemPrompt
+};
+//# sourceMappingURL=chunk-K6MR4SWS.js.map