@amanm/openpaw 0.1.0

package/agent/memory-store.ts

@@ -0,0 +1,404 @@
+/**
+ * Bounded curated memory: MEMORY.md (agent notes) and USER.md (user profile facts).
+ * Frozen snapshot at load for system prompt; mutations persist to disk and return live state in tool results.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+
+/** Same delimiter as Hermes memory_tool — entries may be multiline. */
+export const ENTRY_DELIMITER = "\n§\n";
+
+const MEMORY_CHAR_LIMIT = 2200;
+const USER_CHAR_LIMIT = 1375;
+
+const MEMORY_THREAT_PATTERNS: [RegExp, string][] = [
+  [/ignore\s+(previous|all|above|prior)\s+instructions/i, "prompt_injection"],
+  [/you\s+are\s+now\s+/i, "role_hijack"],
+  [/do\s+not\s+tell\s+the\s+user/i, "deception_hide"],
+  [/system\s+prompt\s+override/i, "sys_prompt_override"],
+  [/disregard\s+(your|all|any)\s+(instructions|rules|guidelines)/i, "disregard_rules"],
+  [
+    /act\s+as\s+(if|though)\s+you\s+(have\s+no|don't\s+have)\s+(restrictions|limits|rules)/i,
+    "bypass_restrictions",
+  ],
+  [/curl\s+[^\n]*\$\{?\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|API)/i, "exfil_curl"],
+  [/wget\s+[^\n]*\$\{?\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|API)/i, "exfil_wget"],
+  [/cat\s+[^\n]*(\.env|credentials|\.netrc|\.pgpass|\.npmrc|\.pypirc)/i, "read_secrets"],
+  [/authorized_keys/i, "ssh_backdoor"],
+  [/\$HOME\/\.ssh|~\/\.ssh/i, "ssh_access"],
+  [/\$HOME\/\.openpaw\/\.env|~\/\.openpaw\/\.env/i, "openpaw_env"],
+];
+
+const INVISIBLE_CHARS = new Set([
+  "\u200b",
+  "\u200c",
+  "\u200d",
+  "\u2060",
+  "\ufeff",
+  "\u202a",
+  "\u202b",
+  "\u202c",
+  "\u202d",
+  "\u202e",
+]);
+
+export type MemoryTarget = "memory" | "user";
+
+export type MemoryMutationResult =
+  | {
+      success: true;
+      target: MemoryTarget;
+      entries: string[];
+      usage: string;
+      entry_count: number;
+      /** Present for add/replace/remove confirmations. */
+      message?: string;
+    }
+  | {
+      success: false;
+      error: string;
+      matches?: string[];
+      current_entries?: string[];
+      usage?: string;
+    };
+
+/**
+ * Returns an error string if content should be blocked for injection/exfil patterns.
+ */
+export function scanMemoryContent(content: string): string | null {
+  for (const char of INVISIBLE_CHARS) {
+    if (content.includes(char)) {
+      return `Blocked: content contains invisible unicode character U+${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")} (possible injection).`;
+    }
+  }
+
+  for (const [re, pid] of MEMORY_THREAT_PATTERNS) {
+    if (re.test(content)) {
+      return `Blocked: content matches threat pattern '${pid}'. Memory entries are injected into the system prompt and must not contain injection or exfiltration payloads.`;
+    }
+  }
+
+  return null;
+}
+
+function splitEntries(raw: string): string[] {
+  if (!raw.trim()) {
+    return [];
+  }
+  return raw
+    .split(ENTRY_DELIMITER)
+    .map((e) => e.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Writes UTF-8 content atomically: temp file in the same directory, then rename.
+ */
+function writeFileSyncAtomic(path: string, content: string): void {
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.mem_${randomBytes(8).toString("hex")}.tmp`);
+  try {
+    writeFileSync(tmp, content, "utf-8");
+    renameSync(tmp, path);
+  } catch (e) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+      // ignore
+    }
+    throw e;
+  }
+}
+
+/**
+ * Persists curated memory files under `workspaceRoot/memories/`.
+ */
+export class MemoryStore {
+  memoryEntries: string[] = [];
+  userEntries: string[] = [];
+  private readonly memoryCharLimit = MEMORY_CHAR_LIMIT;
+  private readonly userCharLimit = USER_CHAR_LIMIT;
+  private readonly memoryPath: string;
+  private readonly userPath: string;
+  /** Frozen at {@link loadFromDisk} for system prompt injection. */
+  private systemPromptSnapshot: { memory: string; user: string } = { memory: "", user: "" };
+  private chain: Promise<void> = Promise.resolve();
+
+  constructor(workspaceRoot: string) {
+    const dir = join(workspaceRoot, "memories");
+    this.memoryPath = join(dir, "MEMORY.md");
+    this.userPath = join(dir, "USER.md");
+  }
+
+  /**
+   * Serialize mutations so concurrent tool calls do not corrupt entries.
+   */
+  private enqueue<T>(fn: () => Promise<T>): Promise<T> {
+    const run = this.chain.then(fn);
+    this.chain = run.then(
+      () => {},
+      () => {},
+    );
+    return run;
+  }
+
+  /**
+   * Loads entries from disk and captures the frozen system-prompt snapshot.
+   */
+  loadFromDisk(): void {
+    mkdirSync(join(this.memoryPath, ".."), { recursive: true });
+
+    this.memoryEntries = this.dedupe(this.readFileEntries(this.memoryPath));
+    this.userEntries = this.dedupe(this.readFileEntries(this.userPath));
+
+    this.systemPromptSnapshot = {
+      memory: this.renderBlock("memory", this.memoryEntries),
+      user: this.renderBlock("user", this.userEntries),
+    };
+  }
+
+  /**
+   * Returns the frozen snapshot for system prompt injection (not live mid-session edits).
+   */
+  formatForSystemPrompt(target: MemoryTarget): string | null {
+    const block = target === "user" ? this.systemPromptSnapshot.user : this.systemPromptSnapshot.memory;
+    return block || null;
+  }
+
+  /**
+   * Appends a new entry after validation and capacity checks.
+   */
+  async add(target: MemoryTarget, content: string): Promise<MemoryMutationResult> {
+    const trimmed = content.trim();
+    if (!trimmed) {
+      return { success: false, error: "Content cannot be empty." };
+    }
+    const scanError = scanMemoryContent(trimmed);
+    if (scanError) {
+      return { success: false, error: scanError };
+    }
+
+    return this.enqueue(async () => {
+      await this.reloadTarget(target);
+      const entries = this.entriesFor(target);
+      const limit = this.limitFor(target);
+
+      if (entries.includes(trimmed)) {
+        return this.successResponse(target, "Entry already exists (no duplicate added).");
+      }
+
+      const next = [...entries, trimmed];
+      if (this.joinedLength(next) > limit) {
+        const current = this.charCount(target);
+        return {
+          success: false,
+          error: `Memory at ${current.toLocaleString()}/${limit.toLocaleString()} chars. Adding this entry (${trimmed.length} chars) would exceed the limit. Replace or remove existing entries first.`,
+          current_entries: entries,
+          usage: `${current.toLocaleString()}/${limit.toLocaleString()}`,
+        };
+      }
+
+      this.setEntries(target, next);
+      this.saveToDisk(target);
+      return this.successResponse(target, "Entry added.");
+    });
+  }
+
+  /**
+   * Replaces the first entry containing `oldText` with `newContent`.
+   */
+  async replace(target: MemoryTarget, oldText: string, newContent: string): Promise<MemoryMutationResult> {
+    const ot = oldText.trim();
+    const nc = newContent.trim();
+    if (!ot) {
+      return { success: false, error: "old_text cannot be empty." };
+    }
+    if (!nc) {
+      return { success: false, error: "new_content cannot be empty. Use 'remove' to delete entries." };
+    }
+    const scanError = scanMemoryContent(nc);
+    if (scanError) {
+      return { success: false, error: scanError };
+    }
+
+    return this.enqueue(async () => {
+      await this.reloadTarget(target);
+      const entries = this.entriesFor(target);
+      const matches = entries.map((e, i) => ({ i, e })).filter(({ e }) => e.includes(ot));
+
+      if (matches.length === 0) {
+        return { success: false, error: `No entry matched '${ot}'.` };
+      }
+
+      if (matches.length > 1) {
+        const uniqueTexts = new Set(matches.map((m) => m.e));
+        if (uniqueTexts.size > 1) {
+          const previews = matches.map((m) =>
+            m.e.length > 80 ? `${m.e.slice(0, 80)}...` : m.e,
+          );
+          return {
+            success: false,
+            error: `Multiple entries matched '${ot}'. Be more specific.`,
+            matches: previews,
+          };
+        }
+      }
+
+      const idx = matches[0]!.i;
+      const limit = this.limitFor(target);
+      const test = [...entries];
+      test[idx] = nc;
+
+      if (this.joinedLength(test) > limit) {
+        return {
+          success: false,
+          error: `Replacement would put memory at ${this.joinedLength(test).toLocaleString()}/${limit.toLocaleString()} chars. Shorten the new content or remove other entries first.`,
+        };
+      }
+
+      entries[idx] = nc;
+      this.setEntries(target, entries);
+      this.saveToDisk(target);
+      return this.successResponse(target, "Entry replaced.");
+    });
+  }
+
+  /**
+   * Removes the first entry containing `oldText`.
+   */
+  async remove(target: MemoryTarget, oldText: string): Promise<MemoryMutationResult> {
+    const ot = oldText.trim();
+    if (!ot) {
+      return { success: false, error: "old_text cannot be empty." };
+    }
+
+    return this.enqueue(async () => {
+      await this.reloadTarget(target);
+      const entries = this.entriesFor(target);
+      const matches = entries.map((e, i) => ({ i, e })).filter(({ e }) => e.includes(ot));
+
+      if (matches.length === 0) {
+        return { success: false, error: `No entry matched '${ot}'.` };
+      }
+
+      if (matches.length > 1) {
+        const uniqueTexts = new Set(matches.map((m) => m.e));
+        if (uniqueTexts.size > 1) {
+          const previews = matches.map((m) =>
+            m.e.length > 80 ? `${m.e.slice(0, 80)}...` : m.e,
+          );
+          return {
+            success: false,
+            error: `Multiple entries matched '${ot}'. Be more specific.`,
+            matches: previews,
+          };
+        }
+      }
+
+      const idx = matches[0]!.i;
+      entries.splice(idx, 1);
+      this.setEntries(target, entries);
+      this.saveToDisk(target);
+      return this.successResponse(target, "Entry removed.");
+    });
+  }
+
+  private dedupe(entries: string[]): string[] {
+    return [...new Set(entries)];
+  }
+
+  private entriesFor(target: MemoryTarget): string[] {
+    return target === "user" ? this.userEntries : this.memoryEntries;
+  }
+
+  private setEntries(target: MemoryTarget, entries: string[]): void {
+    if (target === "user") {
+      this.userEntries = entries;
+    } else {
+      this.memoryEntries = entries;
+    }
+  }
+
+  private limitFor(target: MemoryTarget): number {
+    return target === "user" ? this.userCharLimit : this.memoryCharLimit;
+  }
+
+  private charCount(target: MemoryTarget): number {
+    const entries = this.entriesFor(target);
+    if (entries.length === 0) {
+      return 0;
+    }
+    return this.joinedLength(entries);
+  }
+
+  private joinedLength(entries: string[]): number {
+    return entries.length === 0 ? 0 : entries.join(ENTRY_DELIMITER).length;
+  }
+
+  private async reloadTarget(target: MemoryTarget): Promise<void> {
+    const path = target === "user" ? this.userPath : this.memoryPath;
+    const fresh = this.dedupe(this.readFileEntries(path));
+    this.setEntries(target, fresh);
+  }
+
+  private readFileEntries(path: string): string[] {
+    if (!existsSync(path)) {
+      return [];
+    }
+    try {
+      const raw = readFileSync(path, "utf-8");
+      return splitEntries(raw);
+    } catch {
+      return [];
+    }
+  }
+
+  private saveToDisk(target: MemoryTarget): void {
+    const path = target === "user" ? this.userPath : this.memoryPath;
+    const entries = this.entriesFor(target);
+    const content = entries.length === 0 ? "" : entries.join(ENTRY_DELIMITER);
+    writeFileSyncAtomic(path, content);
+  }
+
+  private successResponse(target: MemoryTarget, message?: string): MemoryMutationResult {
+    const entries = this.entriesFor(target);
+    const current = this.charCount(target);
+    const limit = this.limitFor(target);
+    const pct = limit > 0 ? Math.floor((current / limit) * 100) : 0;
+    const out: MemoryMutationResult = {
+      success: true,
+      target,
+      entries,
+      usage: `${pct}% — ${current.toLocaleString()}/${limit.toLocaleString()} chars`,
+      entry_count: entries.length,
+      ...(message ? { message } : {}),
+    };
+    return out;
+  }
+
+  private renderBlock(target: MemoryTarget, entries: string[]): string {
+    if (entries.length === 0) {
+      return "";
+    }
+    const limit = this.limitFor(target);
+    const content = entries.join(ENTRY_DELIMITER);
+    const current = content.length;
+    const pct = limit > 0 ? Math.floor((current / limit) * 100) : 0;
+    const header =
+      target === "user"
+        ? `USER PROFILE (who the user is) [${pct}% — ${current.toLocaleString()}/${limit.toLocaleString()} chars]`
+        : `MEMORY (your personal notes) [${pct}% — ${current.toLocaleString()}/${limit.toLocaleString()} chars]`;
+    const separator = "═".repeat(46);
+    return `${separator}\n${header}\n${separator}\n${content}`;
+  }
+}

package/agent/model.ts

@@ -0,0 +1,14 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import type { OpenPawConfig } from "../config/types";
+
+/**
+ * OpenAI-compatible chat model from persisted {@link OpenPawConfig}.
+ */
+export function createLanguageModel(config: OpenPawConfig) {
+  const provider = createOpenAICompatible({
+    baseURL: config.provider.baseUrl,
+    name: "openpaw",
+    apiKey: config.provider.apiKey,
+  });
+  return provider.chatModel(config.provider.model);
+}

package/agent/prompt-builder.ts

@@ -0,0 +1,139 @@
+import { join } from "node:path";
+import type { Personality } from "../config/types";
+import type { SkillMetadata } from "./skills/discover";
+import type { OpenPawSurface } from "./types";
+import {
+  getPersonalityProse,
+  MEMORY_GUIDANCE,
+  OPENPAW_IDENTITY,
+  PLATFORM_HINTS,
+  SESSION_NOTE,
+  USER_FACING_VOICE,
+} from "../config/personality-copy";
+import { scanContextContent, truncateContextContent } from "./context-scan";
+import { loadProjectContextFromCwd } from "./prompt-context-files";
+
+async function readUtf8(path: string): Promise<string> {
+  try {
+    const f = Bun.file(path);
+    if (!(await f.exists())) {
+      return "";
+    }
+    return await f.text();
+  } catch {
+    return "";
+  }
+}
+
+export type BuildSystemPromptOptions = {
+  workspacePath: string;
+  personality: Personality;
+  /** Where the user is chatting from — affects formatting hints. */
+  surface: OpenPawSurface;
+  /** Frozen blocks from MemoryStore (may be null if empty). */
+  memoryUserBlock: string | null;
+  memoryAgentBlock: string | null;
+  /** Discovered Agent Skills (name + description only until `load_skill` is called). */
+  skills?: SkillMetadata[];
+};
+
+const BOOTSTRAP = `## Onboarding and workspace (internal — do not expose filenames to the user)
+
+If persona/voice for this install is missing or vague, ask in plain language how they want you to sound; then persist it with the file editor (workspace persona file).
+
+For durable facts and notes, use the \`memory\` tool: new items → \`add\` + \`content\`; corrections → \`replace\` with \`old_text\` + \`content\`. Offer reminders in human terms (\"Want me to remember that?\") — never say you're writing to a specific file.
+
+For file edits: always \`view\` before \`str_replace\`; \`old_str\` must match exactly once (including whitespace).`;
+
+const STATIC_TOOL_RULES = `## Tools overview
+
+- **bash**: shell commands (cwd is the workspace when sandbox is on, or user home when sandbox is off).
+- **file_editor**: view before str_replace; \`old_str\` must match exactly once; create, insert, delete_lines, undo_edit as needed.
+- **list_dir**: list directories under the sandbox (including under loaded skill directories).
+- **load_skill**: load full markdown instructions for a named skill; use \`skillDirectory\` from the result for bundled paths (\`references/\`, \`scripts/\`, etc.).
+- **memory**: persistent facts (\`user\` / \`memory\` targets). \`add\`: \`content\`. \`replace\`: \`old_text\` + \`content\`. \`remove\`: \`old_text\`. (Live state in tool results; frozen snapshot in system prompt.) When discussing with the user, see \"How to talk with the user\" — do not name these mechanisms.`;
+
+/**
+ * Assembles the Skills section for the system prompt: short list and when to call `load_skill`,
+ * or onboarding text if nothing was discovered.
+ */
+function buildSkillsSection(skills: SkillMetadata[] | undefined): string {
+  if (skills?.length) {
+    const lines = skills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+    return `## Skills
+
+Use the \`load_skill\` tool when the user's request matches a skill below. Full instructions load on demand.
+
+Available skills:
+${lines}`;
+  }
+  return `## Skills
+
+No skills discovered. Optional: add skill folders containing \`SKILL.md\` under \`.agents/skills\` in the workspace (or \`~/.config/agent/skills\`).`;
+}
+
+/**
+ * Assembles the dynamic system prompt: identity, guidance, platform, workspace files, frozen memory, optional project context.
+ */
+export async function buildSystemPrompt(options: BuildSystemPromptOptions): Promise<string> {
+  const {
+    workspacePath,
+    personality,
+    surface,
+    memoryUserBlock,
+    memoryAgentBlock,
+    skills,
+  } = options;
+
+  const agentsRaw = (await readUtf8(join(workspacePath, "agents.md"))).trim();
+  const soulRaw = (await readUtf8(join(workspacePath, "soul.md"))).trim();
+
+  const agents = truncateContextContent(
+    scanContextContent(agentsRaw || "(empty)", "agents.md"),
+    "agents.md",
+  );
+  const soul = truncateContextContent(
+    scanContextContent(soulRaw || "(empty — consider asking the user)", "soul.md"),
+    "soul.md",
+  );
+
+  const platformBlock = PLATFORM_HINTS[surface];
+
+  let memoryInjection = "";
+  const mb = memoryAgentBlock
+    ? truncateContextContent(scanContextContent(memoryAgentBlock, "MEMORY.md"), "MEMORY.md")
+    : "";
+  const ub = memoryUserBlock
+    ? truncateContextContent(scanContextContent(memoryUserBlock, "USER.md"), "USER.md")
+    : "";
+  if (mb) {
+    memoryInjection += `\n## What you know already — agent notes (internal)\n\nUse naturally in replies; do not quote section titles or imply you \"read a file\".\n\n${mb}\n`;
+  }
+  if (ub) {
+    memoryInjection += `\n## What you know already — about the user (internal)\n\nUse naturally (\"You told me…\", \"You're in…\"); never say you saw this in a profile or markdown file.\n\n${ub}\n`;
+  }
+  if (!mb && !ub) {
+    memoryInjection = `\n## Durable facts\n\nNothing stored yet — use the \`memory\` tool when the user wants something remembered.\n`;
+  }
+
+  const projectContext = loadProjectContextFromCwd(process.cwd());
+  const projectSection = projectContext
+    ? `\n## Additional project context (from current working directory)\n\n${projectContext}\n`
+    : "";
+
+  const sections = [
+    `# Identity\n${OPENPAW_IDENTITY}`,
+    `# Personality\n${getPersonalityProse(personality)}`,
+    `# How to talk with the user\n${USER_FACING_VOICE}`,
+    `# Memory and persistence\n${MEMORY_GUIDANCE}\n\n${SESSION_NOTE}`,
+    `# Your environment\n${platformBlock}`,
+    `# Workspace (OpenPaw home)\n## Workspace rules\n\n${agents}\n\n## Persona / voice (how you should sound)\n\n${soul}\n`,
+    memoryInjection.trimEnd(),
+    projectSection.trimEnd(),
+    buildSkillsSection(skills),
+    BOOTSTRAP,
+    STATIC_TOOL_RULES,
+  ].filter(Boolean);
+
+  return sections.join("\n\n");
+}

package/agent/prompt-context-files.ts

@@ -0,0 +1,151 @@
+/**
+ * Optional project-context discovery from the process cwd (Hermes-style priority chain).
+ * OpenPaw workspace files under ~/.openpaw/workspace are handled separately in prompt-builder.
+ */
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { scanContextContent, truncateContextContent } from "./context-scan";
+
+const OPENPAW_MD_NAMES = [".openpaw.md", "OPENPAW.md"] as const;
+
+/**
+ * Walks from start through parents until a `.git` directory is found or filesystem root.
+ */
+export function findGitRoot(start: string): string | null {
+  let current = resolve(start);
+  for (;;) {
+    if (existsSync(join(current, ".git"))) {
+      return current;
+    }
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+/**
+ * Finds the nearest `.openpaw.md` or `OPENPAW.md` from cwd up to (and including) git root.
+ */
+export function findOpenpawMd(cwd: string): string | null {
+  const stopAt = findGitRoot(cwd);
+  let current = resolve(cwd);
+  const seen = new Set<string>();
+
+  for (;;) {
+    if (seen.has(current)) {
+      break;
+    }
+    seen.add(current);
+
+    for (const name of OPENPAW_MD_NAMES) {
+      const candidate = join(current, name);
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+
+    if (stopAt !== null && current === stopAt) {
+      break;
+    }
+
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+
+  return null;
+}
+
+/**
+ * Strips optional YAML frontmatter (`---` delimited) from markdown; returns body only.
+ */
+export function stripYamlFrontmatter(content: string): string {
+  if (!content.startsWith("---")) {
+    return content;
+  }
+  const end = content.indexOf("\n---", 3);
+  if (end === -1) {
+    return content;
+  }
+  const body = content.slice(end + 4).replace(/^\n+/, "");
+  return body || content;
+}
+
+function readIfExists(path: string): string | null {
+  try {
+    if (!existsSync(path)) {
+      return null;
+    }
+    return readFileSync(path, "utf-8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Loads a single prioritized project-context block from cwd (not the OpenPaw home workspace).
+ * Priority: `.openpaw.md` / `OPENPAW.md` (walk to git root), else `AGENTS.md` / `agents.md` in cwd only,
+ * else `CLAUDE.md` / `claude.md`, else `.cursorrules` and `.cursor/rules/*.mdc` in cwd only.
+ */
+export function loadProjectContextFromCwd(cwd: string): string {
+  const openpawPath = findOpenpawMd(cwd);
+  if (openpawPath) {
+    const raw = readIfExists(openpawPath);
+    if (raw) {
+      const rel = openpawPath.includes("/") ? openpawPath.split("/").slice(-2).join("/") : openpawPath;
+      let body = stripYamlFrontmatter(raw);
+      body = scanContextContent(body, rel);
+      return truncateContextContent(`## ${rel}\n\n${body}`, rel);
+    }
+  }
+
+  for (const name of ["AGENTS.md", "agents.md"] as const) {
+    const p = join(cwd, name);
+    const raw = readIfExists(p);
+    if (raw) {
+      const body = scanContextContent(raw, name);
+      return truncateContextContent(`## ${name}\n\n${body}`, name);
+    }
+  }
+
+  for (const name of ["CLAUDE.md", "claude.md"] as const) {
+    const p = join(cwd, name);
+    const raw = readIfExists(p);
+    if (raw) {
+      const body = scanContextContent(raw, name);
+      return truncateContextContent(`## ${name}\n\n${body}`, name);
+    }
+  }
+
+  const cursorParts: string[] = [];
+  const cursorrules = join(cwd, ".cursorrules");
+  const cr = readIfExists(cursorrules);
+  if (cr) {
+    cursorParts.push(`## .cursorrules\n\n${scanContextContent(cr, ".cursorrules")}`);
+  }
+
+  const rulesDir = join(cwd, ".cursor", "rules");
+  if (existsSync(rulesDir)) {
+    const entries = readdirSync(rulesDir).filter((f) => f.endsWith(".mdc")).sort();
+    for (const f of entries) {
+      const p = join(rulesDir, f);
+      const raw = readIfExists(p);
+      if (raw) {
+        const label = `.cursor/rules/${f}`;
+        cursorParts.push(`## ${label}\n\n${scanContextContent(raw, label)}`);
+      }
+    }
+  }
+
+  if (cursorParts.length === 0) {
+    return "";
+  }
+
+  const combined = cursorParts.join("\n\n");
+  return truncateContextContent(combined, ".cursorrules");
+}