@baselane/packs 0.1.0

package/dist/render/render-pack.js

@@ -0,0 +1,43 @@
+import { renderAgentsMd } from "./agents-md.js";
+import { renderCapabilities } from "./capabilities.js";
+import { renderClaudeFiles } from "./claude.js";
+import { renderCopilot, renderGemini } from "./adapters.js";
+import { hasRepoMemoryFiles, renderRepoMemoryFiles, withMemoryScaffolding } from "./memory.js";
+import { hasRepoDesignAnalyze, renderRepoDesignFiles, withDesignAnalyzeScaffolding } from "./design.js";
+import { hasRepoTasksLedger, renderRepoTasksFiles, withTasksScaffolding } from "./tasks.js";
+import { hasRepoWikiBaselane, renderRepoWikiFiles, withWikiScaffolding } from "./wiki.js";
+import { hasRepoGraphCapability, renderRepoGraphFiles, withGraphScaffolding } from "./graph.js";
+import { hasRepoSystemMapCapability, renderRepoSystemMapFiles, withSystemMapScaffolding } from "./system-map.js";
+/** Full deterministic file map for one pack: canonical AGENTS.md + all tool targets. */
+export function renderPack(pack) {
+    const { manifest } = renderCapabilities(pack);
+    // A repo-store memory+files (or tasks+ledger, wiki+baselane, or graph) capability adds its
+    // command and Stop-hook reminder to the repo's own Claude Code surface; org-store versions
+    // live on the laptop instead (see render/bundle.ts), so this pack is left untouched in that case.
+    let claudePack = pack;
+    if (hasRepoMemoryFiles(pack))
+        claudePack = withMemoryScaffolding(claudePack, "repo");
+    if (hasRepoTasksLedger(pack))
+        claudePack = withTasksScaffolding(claudePack, "repo");
+    if (hasRepoWikiBaselane(pack))
+        claudePack = withWikiScaffolding(claudePack, "repo");
+    if (hasRepoDesignAnalyze(pack))
+        claudePack = withDesignAnalyzeScaffolding(claudePack, "repo");
+    if (hasRepoGraphCapability(pack))
+        claudePack = withGraphScaffolding(claudePack);
+    if (hasRepoSystemMapCapability(pack))
+        claudePack = withSystemMapScaffolding(claudePack);
+    return {
+        "AGENTS.md": renderAgentsMd(pack),
+        ...renderClaudeFiles(claudePack),
+        ".github/copilot-instructions.md": renderCopilot(pack),
+        "GEMINI.md": renderGemini(pack),
+        ...(manifest ? { ".baselane/capabilities.json": manifest } : {}),
+        ...renderRepoMemoryFiles(pack),
+        ...renderRepoDesignFiles(pack),
+        ...renderRepoTasksFiles(pack),
+        ...renderRepoWikiFiles(pack),
+        ...renderRepoGraphFiles(pack),
+        ...renderRepoSystemMapFiles(pack),
+    };
+}

package/dist/render/repo-union.d.ts

@@ -0,0 +1,14 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+export interface RepoUnion {
+    files: FileMap;
+    collisions: string[];
+}
+/**
+ * Unions every NON-entry (fully-generated) repo file `renderPack` produces across an ordered
+ * (most-specific-first) effective pack set — the repo-committed counterpart of
+ * render/bundle-union.ts's laptop-bundle union. `.claude/settings.json` hooks concatenate per
+ * event; `.baselane/capabilities.json` capabilities dedup; every other path is first-writer-wins
+ * with a collisions note on a differing later write. `renderRepoFileUnion([p]).files` is
+ * byte-identical to `renderPack(p)` minus its ENTRY_FILES keys.
+ */
+export declare function renderRepoFileUnion(packs: WorkflowPack[]): RepoUnion;

package/dist/render/repo-union.js

@@ -0,0 +1,94 @@
+import { ENTRY_FILES } from "../merge-region.js";
+import { renderPack } from "./render-pack.js";
+const SETTINGS_PATH = ".claude/settings.json";
+const MANIFEST_PATH = ".baselane/capabilities.json";
+/** Concatenates every rendered pack's hook entries per event, raw. Mirrors
+ * render/bundle-union.ts's mergeRenderedSettings but is NOT shared code with it — that module
+ * feeds a different consumer (/api/plan's laptop bundle) over bundle-relative paths; this one
+ * feeds the repo commit over repo-relative paths. Duplicated on purpose to avoid coupling two
+ * independent consumers to one shared internal. */
+function mergeSettingsJson(jsons) {
+    const byEvent = {};
+    for (const json of jsons) {
+        let parsed;
+        try {
+            parsed = JSON.parse(json);
+        }
+        catch {
+            continue;
+        }
+        const hooks = parsed.hooks;
+        if (!hooks || typeof hooks !== "object")
+            continue;
+        for (const [event, entries] of Object.entries(hooks)) {
+            if (!Array.isArray(entries))
+                continue;
+            (byEvent[event] ??= []).push(...entries);
+        }
+    }
+    return JSON.stringify({ hooks: byEvent }, null, 2) + "\n";
+}
+/** Unions each manifest's capabilities, dedup by exact JSON identity, first occurrence wins. */
+function mergeCapabilitiesManifest(jsons) {
+    const capabilities = [];
+    const seen = new Set();
+    for (const json of jsons) {
+        let parsed;
+        try {
+            parsed = JSON.parse(json);
+        }
+        catch {
+            continue;
+        }
+        const list = parsed.capabilities;
+        if (!Array.isArray(list))
+            continue;
+        for (const c of list) {
+            const key = JSON.stringify(c);
+            if (!seen.has(key)) {
+                seen.add(key);
+                capabilities.push(c);
+            }
+        }
+    }
+    return JSON.stringify({ version: 1, capabilities }, null, 2) + "\n";
+}
+/**
+ * Unions every NON-entry (fully-generated) repo file `renderPack` produces across an ordered
+ * (most-specific-first) effective pack set — the repo-committed counterpart of
+ * render/bundle-union.ts's laptop-bundle union. `.claude/settings.json` hooks concatenate per
+ * event; `.baselane/capabilities.json` capabilities dedup; every other path is first-writer-wins
+ * with a collisions note on a differing later write. `renderRepoFileUnion([p]).files` is
+ * byte-identical to `renderPack(p)` minus its ENTRY_FILES keys.
+ */
+export function renderRepoFileUnion(packs) {
+    const files = {};
+    const collisions = [];
+    const settingsJsons = [];
+    const manifestJsons = [];
+    for (const pack of packs) {
+        for (const [path, content] of Object.entries(renderPack(pack))) {
+            if (ENTRY_FILES.includes(path))
+                continue;
+            if (path === SETTINGS_PATH) {
+                settingsJsons.push(content);
+                continue;
+            }
+            if (path === MANIFEST_PATH) {
+                manifestJsons.push(content);
+                continue;
+            }
+            if (!(path in files)) {
+                files[path] = content;
+            }
+            else if (files[path] !== content && !collisions.includes(path)) {
+                collisions.push(path);
+            }
+        }
+    }
+    if (settingsJsons.length > 0)
+        files[SETTINGS_PATH] = mergeSettingsJson(settingsJsons);
+    if (manifestJsons.length > 0)
+        files[MANIFEST_PATH] = mergeCapabilitiesManifest(manifestJsons);
+    return { files, collisions };
+}

package/dist/render/rollout-files.d.ts

@@ -0,0 +1,18 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+export interface RolloutFiles {
+    files: FileMap;
+    collisions: string[];
+}
+/**
+ * Renders the full file set for the single combined `baselane/rollout` branch, given the repo's
+ * ordered (most-specific-first) effective pack set. `baseEntryFiles` is each ENTRY_FILES path's
+ * current content on the repo's default branch (or absent/undefined if the file doesn't exist
+ * there) — the caller (distributeRollout) fetches these; this function is otherwise pure.
+ *
+ * Entry files (AGENTS.md/CLAUDE.md/GEMINI.md/.github/copilot-instructions.md): strip any pack's
+ * region that isn't in `packs`, then fold `mergeManagedRegion` over `packs` in order. The result
+ * carries exactly `packs`' regions — idempotent on a repeat call with the same set and base.
+ * Every other rendered path (settings.json, agents/commands/skills, capability files) comes from
+ * `renderRepoFileUnion`.
+ */
+export declare function renderRolloutFiles(baseEntryFiles: Record<string, string | null | undefined>, packs: WorkflowPack[]): RolloutFiles;

package/dist/render/rollout-files.js

@@ -0,0 +1,39 @@
+import { ENTRY_FILES, mergeManagedRegion, stripManagedRegion, strippedManagedPackIds } from "../merge-region.js";
+import { renderPack } from "./render-pack.js";
+import { renderRepoFileUnion } from "./repo-union.js";
+/**
+ * Renders the full file set for the single combined `baselane/rollout` branch, given the repo's
+ * ordered (most-specific-first) effective pack set. `baseEntryFiles` is each ENTRY_FILES path's
+ * current content on the repo's default branch (or absent/undefined if the file doesn't exist
+ * there) — the caller (distributeRollout) fetches these; this function is otherwise pure.
+ *
+ * Entry files (AGENTS.md/CLAUDE.md/GEMINI.md/.github/copilot-instructions.md): strip any pack's
+ * region that isn't in `packs`, then fold `mergeManagedRegion` over `packs` in order. The result
+ * carries exactly `packs`' regions — idempotent on a repeat call with the same set and base.
+ * Every other rendered path (settings.json, agents/commands/skills, capability files) comes from
+ * `renderRepoFileUnion`.
+ */
+export function renderRolloutFiles(baseEntryFiles, packs) {
+    const files = {};
+    const wantedIds = new Set(packs.map((p) => p.id));
+    const rendered = packs.map((pack) => ({ pack, body: renderPack(pack) }));
+    for (const path of ENTRY_FILES) {
+        let content = baseEntryFiles[path] ?? null;
+        if (content !== null) {
+            for (const packId of strippedManagedPackIds(content)) {
+                if (!wantedIds.has(packId))
+                    content = stripManagedRegion(content, packId);
+            }
+        }
+        for (const { pack, body } of rendered) {
+            const managedBody = body[path];
+            if (managedBody === undefined)
+                continue;
+            content = mergeManagedRegion(content, managedBody, pack.id, pack.version);
+        }
+        if (content !== null)
+            files[path] = content;
+    }
+    const repoUnion = renderRepoFileUnion(packs);
+    return { files: { ...files, ...repoUnion.files }, collisions: repoUnion.collisions };
+}

package/dist/render/system-map.d.ts

@@ -0,0 +1,8 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+export declare const SYSTEM_MAP_AGENTS_NOTE: string;
+export declare function hasRepoSystemMapCapability(pack: WorkflowPack): boolean;
+export declare function hasOrgSystemMapCapability(pack: WorkflowPack): boolean;
+/** Adds the /map command + Stop-hook reminder for repo-store system-map packs. */
+export declare function withSystemMapScaffolding(pack: WorkflowPack): WorkflowPack;
+export declare function renderRepoSystemMapFiles(pack: WorkflowPack): FileMap;
+export declare function renderBundleSystemMapFiles(pack: WorkflowPack): FileMap;

package/dist/render/system-map.js

@@ -0,0 +1,73 @@
+const SYSTEM_MAP_README = `# System map
+
+\`ARCHITECTURE.md\` at the repo root carries a baselane-managed region generated from static
+analysis: languages, layout, commands, import-graph hotspots, and measured conventions —
+including **hidden rules** (conventions the code follows at >=90% consistency that no lint
+config enforces). Human prose outside the managed region is never touched.
+
+## Regenerating
+
+Run \`baselane map .\` from the repo root after structural changes (modules added/moved,
+commands changed, conventions shifted). Add \`--llm\` for an AI-narrated architecture section
+(needs BASELANE_ANTHROPIC_KEY or ANTHROPIC_API_KEY). Commit the refreshed \`ARCHITECTURE.md\`
+and \`.baselane/system-map/report.json\` together.
+
+## Reading it
+
+Consult ARCHITECTURE.md's conventions section before writing code — the hidden rules are the
+ones nobody will tell you about in review until you break them.
+`;
+const SYSTEM_MAP_COMMAND = {
+    name: "map",
+    description: "Consult or regenerate the generated ARCHITECTURE.md system map.",
+    argument_hint: '<question about the architecture | "regenerate">',
+    prompt: "Follow the protocol in `.baselane/system-map/README.md` for $ARGUMENTS. For a question, " +
+        "read `ARCHITECTURE.md` (the baselane-managed region) and answer from it — especially the " +
+        'Conventions & hidden rules section — before grepping. If $ARGUMENTS is "regenerate" (or ' +
+        "modules/commands/conventions just changed), run `baselane map .` from the repo root and " +
+        "commit the refreshed ARCHITECTURE.md and .baselane/system-map/report.json.",
+};
+const SYSTEM_MAP_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Reminds the agent to regenerate the system map after structural changes.",
+    action: "print-reminder",
+    message: "Before finishing, if you added/moved modules, changed commands, or shifted a convention, " +
+        "regenerate the system map (`baselane map .`) — see .baselane/system-map/README.md.",
+};
+export const SYSTEM_MAP_AGENTS_NOTE = "### System map\n\n" +
+    "`ARCHITECTURE.md` carries a generated, baselane-managed system map — languages, layout, " +
+    "commands, import-graph hotspots, and measured conventions including hidden rules (consistent " +
+    "but unenforced). Read its conventions section before writing code, and regenerate with " +
+    "`baselane map .` (or `/map regenerate`) after structural changes.";
+// Methods that render real scaffolding today — kept in lockstep with capabilities.ts's
+// PROVISIONED_METHODS["system-map"] entry (bug #10: an unrecognized method must stay
+// "coming soon" in BOTH the manifest AND the filesystem, never one without the other).
+const REAL_METHODS = new Set(["analyze", "analyze+llm"]);
+function systemMapCapabilities(pack, store) {
+    return (pack.capabilities ?? []).filter((c) => c.type === "system-map" && c.store === store && REAL_METHODS.has(c.method));
+}
+export function hasRepoSystemMapCapability(pack) {
+    return systemMapCapabilities(pack, "repo").length > 0;
+}
+export function hasOrgSystemMapCapability(pack) {
+    return systemMapCapabilities(pack, "org").length > 0;
+}
+/** Adds the /map command + Stop-hook reminder for repo-store system-map packs. */
+export function withSystemMapScaffolding(pack) {
+    return {
+        ...pack,
+        commands: [...pack.commands, SYSTEM_MAP_COMMAND],
+        hooks: [...pack.hooks, SYSTEM_MAP_STOP_HOOK],
+    };
+}
+export function renderRepoSystemMapFiles(pack) {
+    if (!hasRepoSystemMapCapability(pack))
+        return {};
+    return { ".baselane/system-map/README.md": SYSTEM_MAP_README };
+}
+export function renderBundleSystemMapFiles(pack) {
+    if (!hasOrgSystemMapCapability(pack))
+        return {};
+    return { "system-map/README.md": SYSTEM_MAP_README };
+}

package/dist/render/tasks.d.ts

@@ -0,0 +1,32 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+/** The AGENTS.md capabilities-section note for a tasks+ledger capability, regardless of store. */
+export declare const TASKS_AGENTS_NOTE: string;
+export declare const TASKS_SPECKIT_AGENTS_NOTE: string;
+export declare const TASKS_TASKMASTER_AGENTS_NOTE: string;
+export declare const TASKS_BEADS_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 `withTasksScaffolding` for every
+ * wired-up tasks method in the repo store, not `ledger` alone. */
+export declare function hasRepoTasksLedger(pack: WorkflowPack): boolean;
+/** Org-store counterpart of {@link hasRepoTasksLedger}. */
+export declare function hasOrgTasksLedger(pack: WorkflowPack): boolean;
+/** #9: `TASKS_AGENTS_NOTE` describes the `ledger` method (`.baselane/tasks/progress.md`,
+ * `/plan-work`). Unlike {@link hasRepoTasksLedger} (which gates scaffolding for ANY tasks method),
+ * this gates only that note — so a speckit/taskmaster/beads pack isn't handed a note pointing at a
+ * ledger it never created. */
+export declare function hasRepoTasksLedgerMethod(pack: WorkflowPack): boolean;
+/** #9: narrow, note-only gates for the sibling methods — same rationale as
+ * {@link hasRepoTasksLedgerMethod} above. */
+export declare function hasRepoTasksSpeckitMethod(pack: WorkflowPack): boolean;
+export declare function hasRepoTasksTaskmasterMethod(pack: WorkflowPack): boolean;
+export declare function hasRepoTasksBeadsMethod(pack: WorkflowPack): boolean;
+/** Adds the present tasks 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 withTasksScaffolding(pack: WorkflowPack, store?: "org" | "repo"): WorkflowPack;
+/** `.baselane/tasks/...`, for whichever repo-store tasks methods the pack declares. */
+export declare function renderRepoTasksFiles(pack: WorkflowPack): FileMap;
+/** `tasks/...` in the laptop bundle, for whichever org-store tasks methods the pack declares. */
+export declare function renderBundleTasksFiles(pack: WorkflowPack): FileMap;

package/dist/render/tasks.js

@@ -0,0 +1,327 @@
+/** `.baselane/tasks/README.md` (repo) / `tasks/README.md` (bundle) — same body either way. */
+const TASKS_README = `# Tasks & progress ledger
+
+This directory anchors multi-session AI work so it survives context compaction — the
+plan lives in one file, completed work is logged in another, and neither depends on
+what an agent remembers from a prior session.
+
+## Files
+
+- \`PLAN.md\` — at the repo root, or \`.baselane/tasks/PLAN.md\` if the root is reserved
+  for something else. The plan, as bite-size checkboxed tasks:
+
+  \`\`\`markdown
+  - [ ] Add the tasks-ledger capability
+  - [x] Wire render-pack.ts and bundle.ts
+  \`\`\`
+
+- \`.baselane/tasks/progress.md\` — an append-only ledger, one line per completed step,
+  each with a commit reference:
+
+  \`\`\`markdown
+  - 2026-07-09: Wired render-pack.ts and bundle.ts — commit \`a1b2c3d\`
+  \`\`\`
+
+  Never rewrite a line once it's committed to the ledger — only append.
+
+## Rule
+
+- **On session start, read the ledger before the plan.** \`progress.md\` says what is
+  actually done; \`PLAN.md\` says what was intended. Trust the ledger and \`git log\`
+  over either your own memory or a stale-looking checkbox — a checkbox can lag behind
+  reality, but a completed-and-committed ledger line cannot.
+- **Append after each completed step**, not in a batch at the end of the session. The
+  ledger's value is that it survives a compaction or a dropped session mid-task; a step
+  that isn't logged until "later" is a step that can be lost.
+- Use \`/plan-work\` to draft or refresh \`PLAN.md\` as checkboxed tasks from a spec or
+  requirement.
+`;
+const PLAN_WORK_COMMAND = {
+    name: "plan-work",
+    description: "Draft or refresh PLAN.md as bite-size checkboxed tasks.",
+    argument_hint: "<goal or spec>",
+    prompt: "Draft or refresh `PLAN.md` (repo root, or `.baselane/tasks/PLAN.md` if the root is " +
+        "reserved) for $ARGUMENTS: break the goal into bite-size, independently verifiable, " +
+        "checkboxed tasks (`- [ ] ...`). If `PLAN.md` already exists, first reconcile it " +
+        "against `.baselane/tasks/progress.md` — check off anything the ledger shows as " +
+        "done — then add only the tasks still remaining.",
+};
+const TASKS_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Reminds the agent to append completed steps to the progress ledger before ending.",
+    action: "print-reminder",
+    message: "Before finishing, append any steps completed this session to " +
+        ".baselane/tasks/progress.md with a commit reference, and check off finished tasks in PLAN.md.",
+};
+/** `.baselane/tasks/speckit/README.md` (repo) / `tasks/speckit/README.md` (bundle) — GitHub Spec Kit. */
+const SPECKIT_README = `# Tasks adapter: speckit (GitHub Spec Kit)
+
+This project uses GitHub's Spec Kit for spec-driven development: a spec, then a plan, then
+a task list, then implementation — each stage a file under \`.specify/\`, reviewed before the
+next stage starts.
+
+## Setup
+
+\`\`\`bash
+uv tool install specify-cli --from git+https://github.com/github/spec-kit.git
+specify init --here
+\`\`\`
+
+\`specify init --here\` scaffolds \`.specify/\` into the current repo (use \`specify init
+<project>\` instead to create a new directory).
+
+## Usage
+
+Inside Claude Code, drive the flow with Spec Kit's own slash commands, in order:
+
+1. \`/specify <what to build>\` — writes \`.specify/.../spec.md\`, the requirements.
+2. \`/plan\` — writes \`.specify/.../plan.md\`, the technical approach.
+3. \`/tasks\` — writes \`.specify/.../tasks.md\`, a checkboxed task breakdown.
+4. \`/implement\` — executes the tasks, one at a time.
+
+Use \`/speckit-flow\` in this pack to keep that flow reconciled with this repo's own ledger
+as you go, rather than running the four steps in isolation.
+
+## How this maps to the baselane protocol
+
+\`spec.md\` + \`plan.md\` together are the requirements/design half of what \`PLAN.md\` would
+otherwise hold; \`tasks.md\` is the checkboxed task list itself. Spec Kit does not keep an
+append-only, commit-referenced ledger the way \`.baselane/tasks/progress.md\` does — so as
+each task in \`tasks.md\` is completed, still append a line to
+\`.baselane/tasks/progress.md\` with a commit reference. Trust the ledger and \`git log\` over
+a checkbox in \`tasks.md\`, same as the baselane protocol's own rule.
+`;
+const SPECKIT_FLOW_COMMAND = {
+    name: "speckit-flow",
+    description: "Drive the Spec Kit spec→plan→tasks→implement flow, reconciled with the progress ledger.",
+    argument_hint: "<what to build>",
+    prompt: "Drive GitHub Spec Kit's flow for $ARGUMENTS: run `/specify $ARGUMENTS` if `spec.md` " +
+        "doesn't exist yet, then `/plan`, then `/tasks` to produce a checkboxed `tasks.md` " +
+        "under `.specify/`. Before implementing, reconcile `.specify/.../tasks.md` against " +
+        "`.baselane/tasks/progress.md` — trust the ledger over a stale-looking checkbox. Then " +
+        "run `/implement` one task at a time, and after each task completes, append a line to " +
+        "`.baselane/tasks/progress.md` with a commit reference before moving to the next.",
+};
+const SPECKIT_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Confirms Spec Kit is installed and reminds the agent to log completed tasks to the ledger.",
+    action: "run-command",
+    command: 'command -v specify >/dev/null 2>&1 && echo "Before finishing, append any tasks.md items completed this session to .baselane/tasks/progress.md with a commit reference." || echo "specify-cli not installed — see .baselane/tasks/speckit/README.md for setup (uv tool install specify-cli --from git+https://github.com/github/spec-kit.git)"',
+};
+/** `.baselane/tasks/taskmaster/README.md` (repo) / `tasks/taskmaster/README.md` (bundle) — Task Master AI. */
+const TASKMASTER_README = `# Tasks adapter: taskmaster (Task Master AI)
+
+This project uses Task Master AI to break a PRD or goal into a dependency-aware task list
+that an agent can work through directly from the CLI.
+
+## Setup
+
+\`\`\`bash
+npm install -g task-master-ai
+task-master init
+\`\`\`
+
+\`task-master init\` scaffolds a \`.taskmaster/\` directory and prompts for the model provider
+API key it should use to generate and expand tasks.
+
+## Usage
+
+- \`task-master parse-prd <file>\` — turns a requirements doc into an initial task list.
+- \`task-master list\` — shows all tasks and their status.
+- \`task-master next\` — picks the next unblocked task to work on.
+- \`task-master set-status --id=<id> --status=done\` — marks a task complete.
+
+## How this maps to the baselane protocol
+
+Task Master's task list (\`.taskmaster/tasks/\`) is the equivalent of \`PLAN.md\`'s checkboxed
+tasks, and \`task-master next\` is how you decide what to work on instead of scanning
+\`PLAN.md\` yourself. Task Master does not write a commit-referenced ledger entry when a
+task is marked done, so after every \`task-master set-status ... --status=done\`, still
+append a line to \`.baselane/tasks/progress.md\` with the commit reference — the same
+append-only discipline the baselane protocol requires, just triggered from a different CLI.
+`;
+const TASKMASTER_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Confirms Task Master is installed and reminds the agent to log completed tasks to the ledger.",
+    action: "run-command",
+    command: 'command -v task-master >/dev/null 2>&1 && echo "Before finishing, append any task-master tasks marked done this session to .baselane/tasks/progress.md with a commit reference." || echo "task-master-ai not installed — see .baselane/tasks/taskmaster/README.md for setup (npm install -g task-master-ai && task-master init)"',
+};
+/**
+ * `.baselane/tasks/beads/README.md` (repo) / `tasks/beads/README.md` (bundle) — beads (task #38).
+ *
+ * beads (`bd`, github.com/gastownhall/beads — formerly steveyegge/beads) is a real, actively
+ * maintained dependency-aware issue tracker built for coding agents: a Dolt-backed (versioned
+ * SQL, cell-level merge) local database with hash-based issue IDs specifically to avoid
+ * merge collisions when multiple agents work in parallel branches, plus JSON output so an
+ * agent can consume `bd` output programmatically. Validated via web search before adoption,
+ * per this repo's AGENTS.md rule on new external tools.
+ */
+const BEADS_README = `# Tasks adapter: beads
+
+This project uses [beads](https://github.com/gastownhall/beads) (the \`bd\` CLI) for a
+dependency-aware task ledger: issues form a DAG (not just a flat list), so \`bd\` can tell you
+exactly which tasks are actually unblocked right now — durable across sessions and safe for
+multiple agents to share, since it's backed by a version-controlled, git-friendly database
+with cell-level merge and hash-based issue IDs (built specifically to avoid ID collisions
+when parallel agents create issues on separate branches).
+
+## Setup
+
+Install \`bd\` with whichever fits this machine (see the project's docs for the full matrix):
+
+\`\`\`bash
+brew install beads                                  # macOS/Linux, via the gastownhall tap
+# or
+npm install -g @beads/bd                             # Node.js environments
+# or
+curl -fsSL https://raw.githubusercontent.com/gastownhall/beads/main/scripts/install.sh | bash
+\`\`\`
+
+Then scaffold it into this repo:
+
+\`\`\`bash
+bd init
+\`\`\`
+
+A machine that runs the desktop agent should install \`bd\` once, the same way it installs any
+other harness dependency — the Stop hook below checks for it and prints this same setup block
+if it's missing, so a session never fails silently for want of the tool.
+
+## Usage
+
+- \`bd create "<title>"\` — file a new issue (add \`--depends-on <id>\` to record a dependency).
+- \`bd list\` — see everything open.
+- \`bd ready\` — the key agent-facing command: lists only the issues with no *uncompleted*
+  dependency, i.e. what can actually be worked on right now — read this before picking a task,
+  not \`bd list\`.
+- \`bd close <id>\` — mark an issue done once its work is committed.
+- \`bd quickstart\` — beads' own interactive walkthrough, useful the first time in a repo.
+
+## How this maps to the baselane protocol
+
+\`bd\`'s issue DAG plus \`bd ready\` is a more structured version of what \`PLAN.md\` +
+\`.baselane/tasks/progress.md\` do by hand: the plan is the set of open issues, the "what's
+next" question is answered by \`bd ready\` instead of scanning checkboxes, and closing an
+issue with \`bd close <id>\` is the completion event — still append a line to
+\`.baselane/tasks/progress.md\` with the commit reference when you do, so the append-only,
+commit-referenced ledger this repo's other tasks methods rely on stays populated regardless
+of which method a given session is using.
+`;
+const BEADS_STOP_HOOK = {
+    event: "Stop",
+    matcher: "",
+    description: "Confirms beads (bd) is installed and reminds the agent to log completed tasks to the ledger.",
+    action: "run-command",
+    command: 'command -v bd >/dev/null 2>&1 && echo "Before finishing, bd close any issues completed this session and append a line to .baselane/tasks/progress.md with a commit reference." || echo "beads (bd) not installed — see .baselane/tasks/beads/README.md for setup (brew install beads, or npm install -g @beads/bd, then bd init)"',
+};
+/** The AGENTS.md capabilities-section note for a tasks+ledger capability, regardless of store. */
+export const TASKS_AGENTS_NOTE = "### Tasks\n\n" +
+    "On session start, read `.baselane/tasks/progress.md` before `PLAN.md` — trust the " +
+    "ledger and `git log` over memory. Use `/plan-work` to draft or refresh `PLAN.md`, " +
+    "and append to the ledger after each completed step.";
+// #9: each sibling method gets its own note naming the path/command it actually scaffolds,
+// instead of tasks+ledger's note being handed to every method (see hasRepoTasksLedgerMethod).
+export const TASKS_SPECKIT_AGENTS_NOTE = "### Tasks (speckit)\n\n" +
+    "This project drives GitHub Spec Kit's spec→plan→tasks→implement flow (see " +
+    "`.baselane/tasks/speckit/README.md`) — use `/speckit-flow`, and still append a line to " +
+    "`.baselane/tasks/progress.md` with a commit reference after each completed task.";
+export const TASKS_TASKMASTER_AGENTS_NOTE = "### Tasks (taskmaster)\n\n" +
+    "This project uses Task Master AI (see `.baselane/tasks/taskmaster/README.md`) — use " +
+    "`task-master next` to pick up work, and append a line to `.baselane/tasks/progress.md` with a " +
+    "commit reference after each `task-master set-status ... --status=done`.";
+export const TASKS_BEADS_AGENTS_NOTE = "### Tasks (beads)\n\n" +
+    "This project uses beads (see `.baselane/tasks/beads/README.md`) — run `bd ready` before " +
+    "picking a task, and append a line to `.baselane/tasks/progress.md` with a commit reference " +
+    "when you `bd close` an issue.";
+function tasksCapabilitiesFor(pack, store) {
+    return (pack.capabilities ?? []).filter((c) => c.type === "tasks" && c.store === store);
+}
+function hasTasksMethod(pack, store, method) {
+    return tasksCapabilitiesFor(pack, store).some((c) => c.method === method);
+}
+/** True if this store has any wired-up tasks method (ledger, speckit, taskmaster, beads) that
+ * needs scaffolding spliced into the pack via `withTasksScaffolding`. */
+function hasTasksScaffoldingNeed(pack, store) {
+    return (hasTasksMethod(pack, store, "ledger") ||
+        hasTasksMethod(pack, store, "speckit") ||
+        hasTasksMethod(pack, store, "taskmaster") ||
+        hasTasksMethod(pack, store, "beads"));
+}
+/** Despite the name — kept for compatibility with the existing gate call sites in
+ * render-pack.ts/bundle.ts/capabilities.ts — this now guards `withTasksScaffolding` for every
+ * wired-up tasks method in the repo store, not `ledger` alone. */
+export function hasRepoTasksLedger(pack) {
+    return hasTasksScaffoldingNeed(pack, "repo");
+}
+/** Org-store counterpart of {@link hasRepoTasksLedger}. */
+export function hasOrgTasksLedger(pack) {
+    return hasTasksScaffoldingNeed(pack, "org");
+}
+/** #9: `TASKS_AGENTS_NOTE` describes the `ledger` method (`.baselane/tasks/progress.md`,
+ * `/plan-work`). Unlike {@link hasRepoTasksLedger} (which gates scaffolding for ANY tasks method),
+ * this gates only that note — so a speckit/taskmaster/beads pack isn't handed a note pointing at a
+ * ledger it never created. */
+export function hasRepoTasksLedgerMethod(pack) {
+    return hasTasksMethod(pack, "repo", "ledger");
+}
+/** #9: narrow, note-only gates for the sibling methods — same rationale as
+ * {@link hasRepoTasksLedgerMethod} above. */
+export function hasRepoTasksSpeckitMethod(pack) {
+    return hasTasksMethod(pack, "repo", "speckit");
+}
+export function hasRepoTasksTaskmasterMethod(pack) {
+    return hasTasksMethod(pack, "repo", "taskmaster");
+}
+export function hasRepoTasksBeadsMethod(pack) {
+    return hasTasksMethod(pack, "repo", "beads");
+}
+/** Adds the present tasks 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 withTasksScaffolding(pack, store = "repo") {
+    const methods = new Set(tasksCapabilitiesFor(pack, store).map((c) => c.method));
+    const commands = [...pack.commands];
+    const hooks = [...pack.hooks];
+    if (methods.has("ledger")) {
+        commands.push(PLAN_WORK_COMMAND);
+        hooks.push(TASKS_STOP_HOOK);
+    }
+    if (methods.has("speckit")) {
+        commands.push(SPECKIT_FLOW_COMMAND);
+        hooks.push(SPECKIT_STOP_HOOK);
+    }
+    if (methods.has("taskmaster"))
+        hooks.push(TASKMASTER_STOP_HOOK);
+    if (methods.has("beads"))
+        hooks.push(BEADS_STOP_HOOK);
+    return { ...pack, commands, hooks };
+}
+/** File map for one store's tasks capabilities — `ledger`'s 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 tasksFilesFor(pack, store, pathFor) {
+    const methods = new Set(tasksCapabilitiesFor(pack, store).map((c) => c.method));
+    const files = {};
+    if (methods.has("ledger"))
+        files[pathFor("tasks/README.md")] = TASKS_README;
+    if (methods.has("speckit"))
+        files[pathFor("tasks/speckit/README.md")] = SPECKIT_README;
+    if (methods.has("taskmaster"))
+        files[pathFor("tasks/taskmaster/README.md")] = TASKMASTER_README;
+    if (methods.has("beads"))
+        files[pathFor("tasks/beads/README.md")] = BEADS_README;
+    return files;
+}
+/** `.baselane/tasks/...`, for whichever repo-store tasks methods the pack declares. */
+export function renderRepoTasksFiles(pack) {
+    return tasksFilesFor(pack, "repo", (leaf) => `.baselane/${leaf}`);
+}
+/** `tasks/...` in the laptop bundle, for whichever org-store tasks methods the pack declares. */
+export function renderBundleTasksFiles(pack) {
+    return tasksFilesFor(pack, "org", (leaf) => leaf);
+}