@baselane/packs 0.1.0

package/dist/render/graph.js

@@ -0,0 +1,245 @@
+// Methods that render real scaffolding today. `treesitter` and `embeddings` intentionally have
+// no adapter yet — unlike graphify/aider/lsp/sourcegraph, there is no canonical local
+// tree-sitter-symbols tool or embeddings-search tool wired up here yet, so both stay an honest
+// "coming soon" (via render/capabilities.ts's generic fallback) rather than a fabricated one.
+const REAL_METHODS = new Set(["imports", "graphify", "aider", "lsp", "sourcegraph"]);
+/** `.baselane/graph/README.md` (repo) / `graph/README.md` (bundle) — the `imports` method protocol. */
+const GRAPH_README = `# Graph protocol (method: imports)
+
+A queryable map of this repo's module dependencies, generated by lexical import scanning — so an
+agent can answer "what imports this" / "what does this import" from a file instead of guessing
+from grep.
+
+## Schema
+
+\`\`\`json
+{
+  "version": 1,
+  "generated": "<ISO 8601 timestamp>",
+  "nodes": [
+    { "id": "<repo-relative-posix-path>", "kind": "module", "language": "<optional>" },
+    { "id": "pkg:<name>", "kind": "external" }
+  ],
+  "edges": [
+    { "from": "<node id>", "to": "<node id>", "kind": "import", "confidence": "extracted" }
+  ]
+}
+\`\`\`
+
+\`edges[].kind\` is one of \`import\`, \`require\`, or \`export-from\`.
+
+## The query-before-grep rule
+
+Before cross-module or refactoring work, consult \`.baselane/graph.json\` (or the human-readable
+\`.baselane/graph/GRAPH.md\`) to answer what imports a file or what a file imports — do not reach
+for grep first. The graph is generated from real import/require/export statements, so it is
+authoritative for that question; grep is not (it also matches comments, strings, and unrelated
+substrings).
+
+## Regenerating
+
+Run \`baselane graph .\` from the repo root whenever modules are added, removed, or moved. This
+overwrites \`.baselane/graph.json\` and \`.baselane/graph/GRAPH.md\` in place — commit the refreshed
+files alongside the change that caused them to go stale.
+
+## Extracted vs inferred
+
+Every edge here has \`confidence: "extracted"\` — it came from a direct lexical match, never a
+guess. A future \`confidence: "inferred"\` tier is reserved for LLM-based enrichment (e.g. a
+dependency that only shows up through dynamic dispatch); nothing in this repo fabricates an
+inferred edge today.
+`;
+const GRAPH_COMMAND = {
+    name: "graph",
+    description: "Query the module dependency graph, or regenerate it after moving/adding modules.",
+    argument_hint: '<module path to query | "regenerate">',
+    prompt: "Follow the graph protocol in `.baselane/graph/README.md` for $ARGUMENTS. If this is a " +
+        "lookup, read `.baselane/graph.json` (or `.baselane/graph/GRAPH.md`) to answer what imports " +
+        "$ARGUMENTS or what $ARGUMENTS imports — do not grep for it. If $ARGUMENTS is " +
+        '"regenerate" (or modules were just added, removed, or moved), run `baselane graph .` from ' +
+        "the repo root and commit the refreshed `.baselane/graph.json` and `.baselane/graph/GRAPH.md`.",
+};
+const GRAPH_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Reminds the agent to regenerate the graph after adding or moving modules.",
+    action: "print-reminder",
+    message: "Before finishing, if you added, removed, or moved modules, regenerate the graph " +
+        "(`baselane graph .` for the imports method, or your configured adapter's own step) — " +
+        "see .baselane/graph/README.md.",
+};
+const GRAPHIFY_HOOK = {
+    event: "SessionStart",
+    matcher: "",
+    description: "Regenerates the graphify graph if the tool is installed; otherwise points at setup docs.",
+    action: "run-command",
+    command: 'command -v graphify >/dev/null 2>&1 && graphify build . || echo "graphify not installed — ' +
+        'see .baselane/graph/graphify/README.md for setup"',
+};
+/** The AGENTS.md capabilities-section note for a graph capability, regardless of store or method. */
+export const GRAPH_AGENTS_NOTE = "### Graph\n\n" +
+    "`.baselane/graph.json` / `.baselane/graph/GRAPH.md` is a generated module-dependency graph — " +
+    "consult it before cross-module or refactoring work instead of grepping, and regenerate it via " +
+    "`baselane graph .` (or `/graph regenerate`) whenever modules are added, removed, or moved.";
+const GRAPHIFY_README = `# Graph adapter: graphify
+
+## Setup
+
+Install graphify (check the tool's own install docs for the current command, e.g.
+\`npm install -g graphify\` or \`pipx install graphify\`), then verify it's on PATH:
+
+\`\`\`
+graphify --version
+\`\`\`
+
+## Usage
+
+Run \`graphify build .\` to produce graphify's own graph — it tags edges as \`EXTRACTED\` or
+\`INFERRED\`, going beyond this repo's zero-dep lexical scan. If graphify exposes an MCP server,
+prefer querying it directly over reading its graph.json by hand.
+
+A hook in this pack already guards on availability so it never fails silently when the tool
+isn't installed:
+
+\`\`\`
+command -v graphify >/dev/null 2>&1 && graphify build . || echo "graphify not installed — see this file for setup"
+\`\`\`
+
+## How this maps to the baselane protocol
+
+Same rule as the \`imports\` method: consult the graph before cross-module changes, not grep.
+graphify's \`EXTRACTED\`/\`INFERRED\` split lines up with this repo's \`confidence\` field — treat
+\`INFERRED\` edges as lower-confidence hints, not ground truth.
+`;
+const AIDER_README = `# Graph adapter: aider
+
+## Setup
+
+Install aider: \`pip install aider-chat\` (or \`pipx install aider-chat\`). There is no separate
+graph-build step — aider computes its repo map automatically each session.
+
+## Usage
+
+Aider ranks and includes a "repo map" (signatures plus a relevance ordering) in its own context
+automatically; there is nothing to run to regenerate it. When working through aider specifically,
+trust its repo map for "what's relevant to this file" instead of asking it to grep.
+
+## How this maps to the baselane protocol
+
+Aider's repo map answers the same question this repo's \`imports\` method answers ("what's
+connected to what"), just scoped to aider's own session rather than a checked-in graph.json. If
+this repo also has an \`imports\`-method graph checked in, prefer that as the durable,
+tool-agnostic source of truth; use aider's repo map as a live supplement while working in aider.
+`;
+const LSP_README = `# Graph adapter: lsp (Serena MCP)
+
+## Setup
+
+This adapter wires up [Serena](https://github.com/oraios/serena), an MCP server that gives an
+agent LSP-grade semantic navigation (find-references, go-to-definition, symbol search) instead of
+a static graph file.
+
+A ready-to-merge MCP server entry is scaffolded at \`.baselane/mcp/serena.json\`. Merge its
+contents into this repo's \`.mcp.json\` under the top-level \`"mcpServers"\` key — **never
+overwrite an existing \`.mcp.json\`**; add the \`"serena"\` key alongside whatever servers are
+already configured there. If there is no \`.mcp.json\` yet, the scaffolded file's contents can be
+used as the entire \`.mcp.json\` body.
+
+## Usage
+
+Once merged and the MCP connection is available, prefer Serena's semantic tools (references,
+definitions, symbol search) over lexical grep for any "what calls this" / "what implements this"
+question — it understands the language's actual structure, not just import statements.
+
+## How this maps to the baselane protocol
+
+Same query-before-grep rule as the \`imports\` method, but answered with live semantic queries
+instead of a generated graph.json. The two are complementary: \`imports\` is a durable, checked-in
+snapshot; Serena is a live, more precise, but session-only index.
+`;
+const SERENA_MCP_SNIPPET = JSON.stringify({
+    mcpServers: {
+        serena: {
+            command: "uvx",
+            args: ["--from", "git+https://github.com/oraios/serena", "serena-mcp-server"],
+        },
+    },
+}, null, 2) + "\n";
+const SOURCEGRAPH_README = `# Graph adapter: sourcegraph
+
+## Setup
+
+Install the Sourcegraph CLI (\`src\`) — see https://sourcegraph.com/docs/cli — then point it at
+your instance:
+
+\`\`\`
+src login <your-sourcegraph-endpoint>
+\`\`\`
+
+(or set \`SRC_ENDPOINT\` / \`SRC_ACCESS_TOKEN\` in the environment instead of an interactive login).
+
+## Usage
+
+Use \`src search\` for cross-repo code search, and \`src api\` (or the GraphQL API directly) to ask
+"what references this symbol" across every repo the instance indexes — not just this one.
+
+## How this maps to the baselane protocol
+
+Same query-before-grep rule as the \`imports\` method, scoped to an entire Sourcegraph instance
+rather than one checked-out repo. Reach for this adapter specifically when the question spans
+multiple repos; use \`imports\` (or another local adapter) for single-repo questions.
+`;
+function graphCapabilities(pack, store) {
+    return (pack.capabilities ?? []).filter((c) => c.type === "graph" && c.store === store && REAL_METHODS.has(c.method));
+}
+export function hasRepoGraphCapability(pack) {
+    return graphCapabilities(pack, "repo").length > 0;
+}
+export function hasOrgGraphCapability(pack) {
+    return graphCapabilities(pack, "org").length > 0;
+}
+/** Adds the /graph command + Stop-hook reminder (and, if configured, the graphify hook). */
+export function withGraphScaffolding(pack) {
+    const hasGraphify = (pack.capabilities ?? []).some((c) => c.type === "graph" && c.method === "graphify");
+    return {
+        ...pack,
+        commands: [...pack.commands, GRAPH_COMMAND],
+        hooks: [...pack.hooks, GRAPH_STOP_HOOK, ...(hasGraphify ? [GRAPHIFY_HOOK] : [])],
+    };
+}
+/** Files for one graph method, rooted at `baseDir` (`.baselane/graph` for repo, `graph` for bundle). */
+function methodFiles(baseDir, method, isRepo) {
+    switch (method) {
+        case "imports":
+            return { [`${baseDir}/README.md`]: GRAPH_README };
+        case "graphify":
+            return { [`${baseDir}/graphify/README.md`]: GRAPHIFY_README };
+        case "aider":
+            return { [`${baseDir}/aider/README.md`]: AIDER_README };
+        case "lsp":
+            // The MCP snippet is repo-local by nature (it merges into this repo's own .mcp.json), so
+            // it's only rendered on the repo side, never into the laptop bundle.
+            return {
+                [`${baseDir}/lsp/README.md`]: LSP_README,
+                ...(isRepo ? { ".baselane/mcp/serena.json": SERENA_MCP_SNIPPET } : {}),
+            };
+        case "sourcegraph":
+            return { [`${baseDir}/sourcegraph/README.md`]: SOURCEGRAPH_README };
+        default:
+            return {};
+    }
+}
+function renderGraphFilesFor(capabilities, baseDir, isRepo) {
+    const files = {};
+    for (const c of capabilities)
+        Object.assign(files, methodFiles(baseDir, c.method, isRepo));
+    return files;
+}
+/** `.baselane/graph/...` files, for every real-method repo-store graph capability the pack declares. */
+export function renderRepoGraphFiles(pack) {
+    return renderGraphFilesFor(graphCapabilities(pack, "repo"), ".baselane/graph", true);
+}
+/** `graph/...` files in the laptop bundle, for every real-method org-store graph capability. */
+export function renderBundleGraphFiles(pack) {
+    return renderGraphFilesFor(graphCapabilities(pack, "org"), "graph", false);
+}

package/dist/render/memory.d.ts

@@ -0,0 +1,35 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+/** The AGENTS.md capabilities-section note for a memory+files capability, regardless of store. */
+export declare const MEMORY_AGENTS_NOTE: string;
+export declare const MEMORY_NATIVE_AGENTS_NOTE: string;
+export declare const MEMORY_CLAUDE_MEM_AGENTS_NOTE: string;
+export declare const MEMORY_VECTOR_AGENTS_NOTE: string;
+export declare const MEMORY_LETTA_AGENTS_NOTE: string;
+/** Despite the name — kept for compatibility with the existing gate call sites in
+ * render-pack.ts/bundle.ts/capabilities.ts — this now guards `withMemoryScaffolding` for every
+ * wired-up memory method in the repo store, not `files` alone. */
+export declare function hasRepoMemoryFiles(pack: WorkflowPack): boolean;
+/** Org-store counterpart of {@link hasRepoMemoryFiles}. */
+export declare function hasOrgMemoryFiles(pack: WorkflowPack): boolean;
+/** #9: `MEMORY_AGENTS_NOTE` describes the `files` method specifically (`.baselane/memory/`,
+ * `/remember`). Unlike {@link hasRepoMemoryFiles} (which gates scaffolding for ANY memory method),
+ * this gates only that note — so a native/vector/letta/claude-mem pack isn't handed a note pointing
+ * at a `.baselane/memory/` path it never created. */
+export declare function hasRepoMemoryFilesMethod(pack: WorkflowPack): boolean;
+/** #9: narrow, note-only gates for each sibling method — same rationale as
+ * {@link hasRepoMemoryFilesMethod} above, one per method so each note is only shown when its own
+ * method is actually present. */
+export declare function hasRepoMemoryNativeMethod(pack: WorkflowPack): boolean;
+export declare function hasRepoMemoryClaudeMemMethod(pack: WorkflowPack): boolean;
+export declare function hasRepoMemoryVectorMethod(pack: WorkflowPack): boolean;
+export declare function hasRepoMemoryLettaMethod(pack: WorkflowPack): boolean;
+/** Adds the present memory method(s)' command(s) + Stop-hook reminder(s) for one store to a
+ * pack, without disturbing what it already declares. `store` defaults to "repo" for
+ * compatibility with pre-multi-method call sites; render-pack.ts passes "repo" and bundle.ts
+ * passes "org" explicitly so a method declared in one store never leaks scaffolding into the
+ * other's file map. */
+export declare function withMemoryScaffolding(pack: WorkflowPack, store?: "org" | "repo"): WorkflowPack;
+/** `.baselane/memory/...`, for whichever repo-store memory methods the pack declares. */
+export declare function renderRepoMemoryFiles(pack: WorkflowPack): FileMap;
+/** `memory/...` in the laptop bundle, for whichever org-store memory methods the pack declares. */
+export declare function renderBundleMemoryFiles(pack: WorkflowPack): FileMap;

package/dist/render/memory.js

@@ -0,0 +1,353 @@
+/** `.baselane/memory/README.md` (repo) / `memory/README.md` (bundle) — same body either way. */
+const MEMORY_README = `# Memory protocol
+
+This directory holds durable facts the AI has learned while working on this project —
+one fact per file, plus an index. Consult the index before acting; add a fact after
+learning something durable (a decision, a correction, a constraint that isn't obvious
+from the code).
+
+## Format
+
+Each fact is a single markdown file with simple frontmatter:
+
+\`\`\`markdown
+---
+name: <short-kebab-case-slug>
+description: <one-line summary — used to decide relevance during recall>
+---
+
+<the fact, in a sentence or two.>
+\`\`\`
+
+## Index
+
+\`MEMORY.md\` in this directory lists every fact, one line per file, so the index alone
+can be scanned without opening each one:
+
+\`\`\`markdown
+- [Title](file.md) — one-line hook
+\`\`\`
+
+## Rule
+
+- Consult \`MEMORY.md\` before acting — recall what's already known.
+- After learning something durable, write a new fact file and add a line to
+  \`MEMORY.md\`. Use \`/remember <fact>\` to do both in one step.
+`;
+const REMEMBER_COMMAND = {
+    name: "remember",
+    description: "Append a durable fact to .baselane/memory/ and update its index.",
+    argument_hint: "<fact>",
+    prompt: "Write $ARGUMENTS as a new fact file under `.baselane/memory/` (kebab-case name, " +
+        "frontmatter with `name` and `description`, then the fact itself). Then add a " +
+        "one-line entry for it to `.baselane/memory/MEMORY.md` (create the index if it " +
+        "doesn't exist yet). Keep the fact to one durable, non-obvious sentence or two.",
+};
+const MEMORY_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Reminds the agent to capture durable decisions to memory before ending the session.",
+    action: "print-reminder",
+    message: "Before finishing, capture any durable decisions or facts from this session to " +
+        ".baselane/memory/ (use /remember) and update its MEMORY.md index.",
+};
+/** `.baselane/memory/native/README.md` (repo) / `memory/native/README.md` (bundle) — native Claude Code memory. */
+const NATIVE_MEMORY_README = `# Memory adapter: native (Claude Code)
+
+This project uses Claude Code's own built-in persistent memory instead of an in-repo
+\`.baselane/memory/\` store. Facts live under \`~/.claude/projects/<project>/memory/\` on the
+machine running the agent — one fact per file, plus a \`MEMORY.md\` index — and are recalled
+automatically at the start of a session.
+
+## Setup
+
+No install step: native memory ships with Claude Code itself. There is nothing to add to
+\`.mcp.json\` and no package to install.
+
+## Usage
+
+- **Save a fact fast:** type \`# <fact>\` at the start of a chat message. Claude Code writes
+  it straight to the memory directory with frontmatter (\`name\`, \`description\`) and appends
+  a line to \`MEMORY.md\` — no extra step needed.
+- **Save a fact deliberately:** ask the agent to write a new file under
+  \`~/.claude/projects/<project>/memory/\` with the same one-fact-per-file, frontmatter +
+  index convention, for facts that need more than a sentence.
+- **CLAUDE.md memory hierarchy:** \`CLAUDE.md\` (project) and \`~/.claude/CLAUDE.md\` (user,
+  global across all projects) are read every session and take precedence for standing
+  instructions; the memory directory is for facts learned *during* work, not standing
+  preferences — put those in \`CLAUDE.md\` instead.
+- **Recall:** memories relevant to the current work surface automatically; \`MEMORY.md\` can
+  also be read directly for the full index.
+
+## How this maps to the baselane protocol
+
+Native memory replaces \`.baselane/memory/README.md\` + \`MEMORY.md\` — Claude Code manages the
+store itself, so there is no separate baselane-owned directory to keep in sync. Org-store
+sync (pushing memory to a shared org-level store) does not apply to this method: native
+memory is entirely tool-managed and local to the machine, so declaring it at \`org\` scope
+only documents that fact rather than provisioning any additional sync.
+`;
+const NATIVE_REMEMBER_COMMAND = {
+    name: "remember",
+    description: "Save a durable fact to Claude Code's native memory.",
+    argument_hint: "<fact>",
+    prompt: "Save $ARGUMENTS as a durable fact using Claude Code's native memory: write it as a " +
+        "new file under `~/.claude/projects/<project>/memory/` with frontmatter (`name`, " +
+        "`description`) and the fact itself, then add a one-line entry to that directory's " +
+        "`MEMORY.md` index. For a short fact, the `# <fact>` chat shortcut does both steps in " +
+        "one. Keep the fact to one durable, non-obvious sentence or two.",
+};
+const NATIVE_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Reminds the agent to capture durable decisions to native memory before ending the session.",
+    action: "print-reminder",
+    message: "Before finishing, capture any durable decisions or facts from this session to " +
+        "Claude Code's native memory (use `# <fact>` or /remember).",
+};
+/** `.baselane/memory/claude-mem/README.md` (repo) / `memory/claude-mem/README.md` (bundle) — claude-mem. */
+const CLAUDE_MEM_README = `# Memory adapter: claude-mem
+
+This project uses \`claude-mem\` for durable memory: a companion tool that captures Claude
+Code session transcripts, compresses them into semantic summaries, and stores them locally
+so future sessions can search past decisions instead of re-deriving them.
+
+## Setup
+
+\`\`\`bash
+npm install -g claude-mem
+claude-mem install
+\`\`\`
+
+\`claude-mem install\` wires its own hooks into this project's Claude Code configuration —
+it does not touch or replace any hooks already declared by this pack; both run.
+
+## Usage
+
+- Memory capture happens automatically at the end of a session (or compaction) via the
+  installed hooks — no manual save step for ordinary work.
+- To inspect what has been stored, search the local memory store from the CLI:
+  \`claude-mem search "<topic>"\` lists past compressed summaries relevant to a query.
+- Captures are compressed, not raw transcripts — expect a short summary of the decision or
+  fact, not the full conversation.
+
+## How this maps to the baselane protocol
+
+\`claude-mem\`'s captured-and-compressed summaries are the equivalent of a
+\`.baselane/memory/\` fact file: durable, one-topic, written after learning something. The
+read-before/write-after loop still applies — search claude-mem's store for relevant context
+before acting, and let its Stop-time hook capture what changed after.
+`;
+const CLAUDE_MEM_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Confirms claude-mem is installed and available to capture this session's memory.",
+    action: "run-command",
+    command: 'command -v claude-mem >/dev/null 2>&1 && echo "claude-mem will capture this session\'s memory automatically." || echo "claude-mem not installed — see .baselane/memory/claude-mem/README.md for setup (npm install -g claude-mem && claude-mem install)"',
+};
+/** `.baselane/memory/vector/README.md` (repo) / `memory/vector/README.md` (bundle) — mem0 vector memory. */
+const VECTOR_README = `# Memory adapter: vector (mem0)
+
+This project uses mem0 for durable memory: facts are embedded and stored in a vector store,
+then recalled by semantic similarity rather than an exact filename or index lookup.
+
+## Setup
+
+\`\`\`bash
+pip install mem0ai
+export MEM0_API_KEY=<your-key>   # or configure a self-hosted vector store per mem0's docs
+\`\`\`
+
+## Usage
+
+\`\`\`python
+from mem0 import Memory
+m = Memory()
+
+# recall — read before acting
+relevant = m.search(query="<what you're about to do>", user_id="<project-or-agent-id>")
+
+# write — after learning something durable
+m.add("<the fact>", user_id="<project-or-agent-id>")
+\`\`\`
+
+Facts are retrieved by meaning, not by filename — a search for "database migration
+strategy" can surface a fact that never used those exact words.
+
+## How this maps to the baselane protocol
+
+\`m.search(...)\` before acting is the same discipline as reading
+\`.baselane/memory/MEMORY.md\` before acting; \`m.add(...)\` after learning is the same
+discipline as writing a new fact file. The read-before/write-after loop is identical — only
+the storage and retrieval mechanism (embeddings + similarity search vs. flat files + an
+index) differs.
+`;
+const VECTOR_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Confirms mem0 is installed and reminds the agent to write durable facts to it.",
+    action: "run-command",
+    command: 'python3 -c "import mem0" >/dev/null 2>&1 && echo "Before finishing, write any durable facts from this session to mem0 (m.add(...))." || echo "mem0 not installed — see .baselane/memory/vector/README.md for setup (pip install mem0ai)"',
+};
+/** `.baselane/memory/letta/README.md` (repo) / `memory/letta/README.md` (bundle) — Letta tiered memory. */
+const LETTA_README = `# Memory adapter: letta
+
+This project uses Letta (formerly MemGPT) for durable memory: a local server manages
+tiered memory for the agent, inspectable and editable through Letta's ADE (Agent
+Development Environment) UI.
+
+## Setup
+
+\`\`\`bash
+pip install letta
+letta server
+\`\`\`
+
+Then open the ADE at http://localhost:8283 to inspect or edit memory directly, or drive it
+programmatically with the Letta client SDK.
+
+## Usage
+
+Letta's memory is tiered:
+
+- **Core memory** — a small set of always-in-context editable blocks (e.g. persona, current
+  task); update these for facts that should be visible on every turn.
+- **Recall memory** — the full conversation history, searchable but not always in context.
+- **Archival memory** — a long-term vector store for facts that don't need to be in every
+  context window; write here for durable, occasionally-needed facts.
+
+## How this maps to the baselane protocol
+
+Writing a durable fact to archival memory after learning it is the write-after half of the
+loop; querying archival/recall memory (or checking the relevant core memory block) before
+acting is the read-before half. Core memory blocks are the closest analog to \`MEMORY.md\`'s
+index — small, always-visible, and worth keeping current.
+`;
+const LETTA_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Confirms the Letta server is available and reminds the agent to archive durable facts.",
+    action: "run-command",
+    command: 'command -v letta >/dev/null 2>&1 && echo "Before finishing, write any durable facts from this session to Letta\'s archival memory." || echo "letta not installed — see .baselane/memory/letta/README.md for setup (pip install letta && letta server)"',
+};
+/** The AGENTS.md capabilities-section note for a memory+files capability, regardless of store. */
+export const MEMORY_AGENTS_NOTE = "### Memory\n\n" +
+    "Consult `.baselane/memory/` and its `MEMORY.md` index before acting — it holds " +
+    "durable facts from past sessions. Use `/remember` to add one after learning " +
+    "something durable.";
+// #9: each sibling method gets its own note naming the path/command it actually scaffolds,
+// instead of memory+files' note being handed to every method (see hasRepoMemoryFilesMethod).
+export const MEMORY_NATIVE_AGENTS_NOTE = "### Memory (native)\n\n" +
+    "This project uses Claude Code's native memory instead of `.baselane/memory/` — facts live " +
+    "under `~/.claude/projects/<project>/memory/` and are recalled automatically each session. " +
+    "Use `/remember` (or the `# <fact>` chat shortcut) to add one after learning something durable.";
+export const MEMORY_CLAUDE_MEM_AGENTS_NOTE = "### Memory (claude-mem)\n\n" +
+    "This project uses claude-mem to capture and compress session transcripts into searchable " +
+    "summaries (see `.baselane/memory/claude-mem/README.md`) — run `claude-mem search \"<topic>\"` " +
+    "before acting; capture happens automatically at session end via its own hooks.";
+export const MEMORY_VECTOR_AGENTS_NOTE = "### Memory (vector)\n\n" +
+    "This project uses mem0 for durable memory (see `.baselane/memory/vector/README.md`) — recall " +
+    "by semantic similarity with `m.search(...)` before acting, and `m.add(...)` after learning " +
+    "something durable.";
+export const MEMORY_LETTA_AGENTS_NOTE = "### Memory (letta)\n\n" +
+    "This project uses Letta's tiered memory (see `.baselane/memory/letta/README.md`) — write " +
+    "durable facts to archival memory after learning them, and query archival/recall memory (or " +
+    "the relevant core memory block) before acting.";
+function memoryCapabilitiesFor(pack, store) {
+    return (pack.capabilities ?? []).filter((c) => c.type === "memory" && c.store === store);
+}
+function hasMemoryMethod(pack, store, method) {
+    return memoryCapabilitiesFor(pack, store).some((c) => c.method === method);
+}
+/** True if this store has any wired-up memory method (files, native, claude-mem, vector, letta)
+ * that needs scaffolding spliced into the pack via `withMemoryScaffolding`. */
+function hasMemoryScaffoldingNeed(pack, store) {
+    return (hasMemoryMethod(pack, store, "files") ||
+        hasMemoryMethod(pack, store, "native") ||
+        hasMemoryMethod(pack, store, "claude-mem") ||
+        hasMemoryMethod(pack, store, "vector") ||
+        hasMemoryMethod(pack, store, "letta"));
+}
+/** Despite the name — kept for compatibility with the existing gate call sites in
+ * render-pack.ts/bundle.ts/capabilities.ts — this now guards `withMemoryScaffolding` for every
+ * wired-up memory method in the repo store, not `files` alone. */
+export function hasRepoMemoryFiles(pack) {
+    return hasMemoryScaffoldingNeed(pack, "repo");
+}
+/** Org-store counterpart of {@link hasRepoMemoryFiles}. */
+export function hasOrgMemoryFiles(pack) {
+    return hasMemoryScaffoldingNeed(pack, "org");
+}
+/** #9: `MEMORY_AGENTS_NOTE` describes the `files` method specifically (`.baselane/memory/`,
+ * `/remember`). Unlike {@link hasRepoMemoryFiles} (which gates scaffolding for ANY memory method),
+ * this gates only that note — so a native/vector/letta/claude-mem pack isn't handed a note pointing
+ * at a `.baselane/memory/` path it never created. */
+export function hasRepoMemoryFilesMethod(pack) {
+    return hasMemoryMethod(pack, "repo", "files");
+}
+/** #9: narrow, note-only gates for each sibling method — same rationale as
+ * {@link hasRepoMemoryFilesMethod} above, one per method so each note is only shown when its own
+ * method is actually present. */
+export function hasRepoMemoryNativeMethod(pack) {
+    return hasMemoryMethod(pack, "repo", "native");
+}
+export function hasRepoMemoryClaudeMemMethod(pack) {
+    return hasMemoryMethod(pack, "repo", "claude-mem");
+}
+export function hasRepoMemoryVectorMethod(pack) {
+    return hasMemoryMethod(pack, "repo", "vector");
+}
+export function hasRepoMemoryLettaMethod(pack) {
+    return hasMemoryMethod(pack, "repo", "letta");
+}
+/** Adds the present memory method(s)' command(s) + Stop-hook reminder(s) for one store to a
+ * pack, without disturbing what it already declares. `store` defaults to "repo" for
+ * compatibility with pre-multi-method call sites; render-pack.ts passes "repo" and bundle.ts
+ * passes "org" explicitly so a method declared in one store never leaks scaffolding into the
+ * other's file map. */
+export function withMemoryScaffolding(pack, store = "repo") {
+    const methods = new Set(memoryCapabilitiesFor(pack, store).map((c) => c.method));
+    const commands = [...pack.commands];
+    const hooks = [...pack.hooks];
+    if (methods.has("files")) {
+        commands.push(REMEMBER_COMMAND);
+        hooks.push(MEMORY_STOP_HOOK);
+    }
+    if (methods.has("native")) {
+        commands.push(NATIVE_REMEMBER_COMMAND);
+        hooks.push(NATIVE_STOP_HOOK);
+    }
+    if (methods.has("claude-mem"))
+        hooks.push(CLAUDE_MEM_STOP_HOOK);
+    if (methods.has("vector"))
+        hooks.push(VECTOR_STOP_HOOK);
+    if (methods.has("letta"))
+        hooks.push(LETTA_STOP_HOOK);
+    return { ...pack, commands, hooks };
+}
+/** File map for one store's memory capabilities — `files`' README at the top-level slot, every
+ * other real method under its own subdirectory so multiple methods can coexist without one
+ * silently clobbering another's docs. `pathFor` picks repo vs bundle path shape for a leaf. */
+function memoryFilesFor(pack, store, pathFor) {
+    const methods = new Set(memoryCapabilitiesFor(pack, store).map((c) => c.method));
+    const files = {};
+    if (methods.has("files"))
+        files[pathFor("memory/README.md")] = MEMORY_README;
+    if (methods.has("native"))
+        files[pathFor("memory/native/README.md")] = NATIVE_MEMORY_README;
+    if (methods.has("claude-mem"))
+        files[pathFor("memory/claude-mem/README.md")] = CLAUDE_MEM_README;
+    if (methods.has("vector"))
+        files[pathFor("memory/vector/README.md")] = VECTOR_README;
+    if (methods.has("letta"))
+        files[pathFor("memory/letta/README.md")] = LETTA_README;
+    return files;
+}
+/** `.baselane/memory/...`, for whichever repo-store memory methods the pack declares. */
+export function renderRepoMemoryFiles(pack) {
+    return memoryFilesFor(pack, "repo", (leaf) => `.baselane/${leaf}`);
+}
+/** `memory/...` in the laptop bundle, for whichever org-store memory methods the pack declares. */
+export function renderBundleMemoryFiles(pack) {
+    return memoryFilesFor(pack, "org", (leaf) => leaf);
+}

package/dist/render/render-pack.d.ts

@@ -0,0 +1,3 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+/** Full deterministic file map for one pack: canonical AGENTS.md + all tool targets. */
+export declare function renderPack(pack: WorkflowPack): FileMap;