get-tbd 0.2.2 → 0.3.0

package/dist/docs/tbd-docs.md

@@ -156,13 +156,11 @@ The recommended way to initialize tbd and configure agent integrations.
 
 ```bash
 tbd setup --auto                  # Full setup with auto-detection (recommended)
-tbd setup --interactive           # Interactive setup with prompts
 tbd setup --from-beads            # Migrate from existing Beads setup
 ```
 
 Options:
 - `--auto` - Automatic mode: auto-detect prefix, migrate beads if present
-- `--interactive` - Interactive mode: prompt for all options
 - `--from-beads` - Migrate issues from existing Beads setup
 - `--prefix <name>` - Override auto-detected prefix
 
@@ -576,6 +574,7 @@ Options:
 
 > **Note:** `tbd import --from-beads` is deprecated.
 > Use `tbd setup --auto` or `tbd setup --from-beads` instead for migrating from Beads.
+
 - `--validate` - Validate existing import against Beads source
 
 ### beads
@@ -674,12 +673,23 @@ and skips reinstallation.
 
 ### Documentation Commands
 
-Built-in documentation viewers:
+Managed docs (the `tbd docs` group):
+
+```bash
+tbd docs                                    # Status overview of managed docs
+tbd docs list                               # All docs across kinds, with state markers
+tbd docs show <name>                        # Read any doc by name (kind-agnostic)
+tbd docs show tbd-docs                      # The CLI manual (alias: tbd docs manual)
+tbd docs show tbd-docs --sections           # List the manual's sections
+tbd docs show tbd-docs --section <name>     # Read one manual section
+tbd docs sync                               # Refresh the gitignored docs cache
+tbd docs fork / unfork / update / diff / status   # Forked docs (see below)
+```
+
+Other built-in viewers:
 
 ```bash
 tbd readme                                  # Display README (same as GitHub landing page)
-tbd docs                                    # Display CLI reference documentation
-tbd docs --list                             # List available documentation sections
 tbd design                                  # Display design documentation
 tbd design --list                           # List design doc sections
 tbd closing                                 # Display session closing protocol reminder
@@ -714,6 +724,69 @@ On HTTP 403, fetching falls back to `gh api` for authenticated access.
 User-added shortcuts go to `shortcuts/custom/` (separate from bundled
 `shortcuts/standard/`).
 
+### Managing Docs: Two Modes
+
+Every managed doc is served through one search path; where the file lives is a per-doc
+choice between two modes that serve identical content:
+
+- **Hidden cache (the default).** Docs live in the gitignored `.tbd/docs/` cache: always
+  active, zero repo footprint, refreshed by `tbd docs sync` (and by setup).
+- **Forked.** `tbd docs fork <name>` (or `--all`) copies a doc into `docs/tbd/`, tracked
+  in git: visible on GitHub, reviewable in PRs, and editable; your copy shadows the
+  cache everywhere the upstream one was served.
+  `tbd docs unfork` returns to the cache; `tbd docs update` three-way merges upstream
+  changes into your copy after an upgrade.
+
+Forking changes nothing about how docs work.
+It only makes them explicit and editable.
+Four update surfaces stay deliberately separate:
+
+| Command | Scope | Touches | Modifies tracked files? |
+| --- | --- | --- | --- |
+| `tbd sync` | project data (issues/beads) | sync worktree + `tbd-sync` branch; also refreshes the doc cache and *reports* fork drift | never |
+| `tbd setup --auto` | installation + integrations | skills, hooks, settings, `AGENTS.md`; invokes a docs-cache sync | only generated integration files |
+| `tbd docs sync` | doc cache | gitignored `.tbd/docs/` only | never |
+| `tbd docs update` | your forked docs | fork dir + bases + manifest (offline, against the cache) | **yes, the only doc command that does** |
+
+Disambiguation worth stating once: `tbd update <id>` is an issue operation,
+`tbd docs update` a doc operation; the noun scope always disambiguates.
+
+### Forked Docs in Your Repo (docs/tbd/)
+
+`tbd docs fork` copies managed docs into `docs/tbd/`, laid out **by kind, flat within
+each kind**, with a generated `README.md` index (regenerated on every
+fork/unfork/update):
+
+```
+docs/tbd/
+├── README.md        # generated index — what this folder is, one line per doc
+├── guidelines/<name>.md
+├── shortcuts/<name>.md
+└── templates/<name>.md
+```
+
+Two rules make everything below predictable: **names are identity** (a doc is
+`<kind>/<name>.md`; nested subfolders are not scanned), and **tracking is derived, not
+stored** (the canonical model (copies, invariants, flows) is `tbd-design.md` §2.9; this
+table is its user-facing summary); every doc’s state is recomputed from content hashes
+(your file vs its recorded base vs current upstream), so no git operation can
+desynchronize tbd from the folder.
+Whatever you or your agent do to these files, `tbd docs status` gives a defined answer:
+
+| You (or your agent)… | State | What happens / what to do |
+| --- | --- | --- |
+| Edit a forked file | `customized` | Served as-is; `tbd docs update` three-way merges upstream changes in |
+| Delete a forked file | `missing` | Serving falls back to upstream; restore with `tbd docs fork <name> --force` or finalize with `tbd docs unfork <name>` |
+| Rename a forked file | `missing` + `local` | A rename is delete + add: finalize the old name (`unfork`), keep the new file as `local` |
+| Add a new `.md` file | `local` | Served with top precedence; nothing to update or unfork (no upstream) |
+| Move a file into a subfolder | invisible | Subfolders are not scanned; keep files at `<kind>/<name>.md` |
+| Delete `.tbd/doc-forks/` (the manifest) | all `local` | Files keep being served; re-fork with `--force` to re-establish update tracking (overwrites with upstream; re-apply edits after) |
+| Commit / pull / merge / revert any of it | recomputed | States derive from content, so collaborators see the same answers from the same files |
+
+Awareness without surprise mutations: `tbd sync` prints a one-line notice when forked
+docs are stale, conflicted, or missing, and `tbd docs status` shows the full picture,
+but only the explicit `tbd docs update` ever modifies tracked files.
+
 ### uninstall
 
 Remove tbd from a repository.
@@ -1022,8 +1095,32 @@ sync:
   branch: tbd-sync           # Sync branch name
   remote: origin             # Remote name
   auto_sync: true            # Auto-sync after writes
+
+docs_cache:
+  files:                     # Docs synced into the cache: destination -> docref
+    guidelines/python-rules.md: internal:guidelines/python-rules.md
+    guidelines/my-team-rules.md: github:my-org/docs@main//rules.md
+  lookup_path:               # Search paths for doc lookup (earlier wins)
+    - .tbd/docs/shortcuts/system
+    - .tbd/docs/shortcuts/standard
 ```
 
+`docs_cache.files` values, like the fork manifest’s `source` values in
+`.tbd/doc-forks/forks.yml`, are **docrefs**: one URI-like address grammar (`internal:…`,
+anchored local paths, URLs, `github:owner/repo@ref//path`). For the full grammar see
+`tbd docs show docref-format`; for the docmap structure that doc listings and their
+`--json` output follow, see `tbd docs show docmap-format`.
+
+Two further `docs_cache` keys:
+
+- `docs_cache.local_dirs`: an ordered list of `./`-prefixed local docrefs naming extra
+  in-repo doc directories, served between the fork dir and the cache.
+  Docs found there are first-class for reading (`list`, `show`, the per-kind readers,
+  with a `(serving local doc: …)` note) and report state `local`; they are not forkable
+  or updatable; they already live in the repo.
+- `docs_cache.fork_dir`: reserved in the f05 format era but **planned, not yet read**:
+  the fork-dir location is currently fixed at `docs/tbd/`.
+
 ## Priority Scale
 
 | Value | Alias | Meaning |
@@ -1118,6 +1215,73 @@ ls "$(git rev-parse --path-format=absolute --git-common-dir)/tbd/data-sync-workt
 ls "$(git rev-parse --path-format=absolute --git-common-dir)/tbd/data-sync-worktree/.tbd/data-sync/issues/" | sort
 ```
 
+### Aborting a Format Upgrade
+
+Upgrading tbd can bump the repository format (`tbd_format` in `.tbd/config.yml`, e.g.
+f04 → f05). The bump happens automatically on the first command after upgrading, and
+older tbd versions then refuse the repository until they are upgraded.
+If an upgrade hits unexpected bugs, you can cleanly abort and return to the previous
+version. This is everything a format upgrade can touch:
+
+| State | Location | In git? | Written by | Revert |
+| --- | --- | --- | --- | --- |
+| Project config | `.tbd/config.yml` | tracked | the migration (format stamp) | `git checkout -- .tbd/config.yml`, or `git revert` the bump commit |
+| Agent surfaces | `AGENTS.md`, `.claude/`, `.agents/`, `.codex/` | tracked | only `tbd setup --auto` (marker refresh) | `git checkout --` those paths |
+| Shared layout stamp | `$GIT_COMMON_DIR/tbd/layout.yml` | machine-local, not in git | the migration (re-stamp) | delete it; it regenerates from whatever the config says |
+| Forked docs (f05) | `docs/tbd/`, `.tbd/doc-forks/` | tracked once committed | only `tbd docs fork` | `git checkout --`/`git revert` if committed; delete if never committed |
+| Docs cache | `.tbd/docs/` | gitignored | doc sync (unchanged by migration) | none needed; always safe to delete and re-sync |
+| Issue data | `tbd-sync` branch + `$GIT_COMMON_DIR/tbd/data-sync-worktree/` | git branch | **never touched by migration** | none needed; the worktree re-materializes from the branch |
+
+**Abort recipe** (works from any state, including a crash mid-upgrade):
+
+```bash
+# 1. Restore the tracked files (or `git revert` the format-bump commit):
+git checkout -- .tbd/config.yml
+git checkout -- AGENTS.md .claude .agents .codex   # only if `tbd setup --auto` ran
+
+# 2. Delete the machine-local format stamp (regenerates from the config):
+rm "$(git rev-parse --path-format=absolute --git-common-dir)/tbd/layout.yml"
+
+# 3. Only if docs were forked and never committed:
+rm -rf docs/tbd .tbd/doc-forks
+```
+
+After this, the previous tbd version works again, and re-running the upgrade later is
+safe; the migration is idempotent from any of these states.
+
+Reverting `.tbd/config.yml` is enough to drop the format gate even if forks were already
+committed: compatibility is decided only by `tbd_format` in the config, not by the
+presence of `docs/tbd/` or `.tbd/doc-forks/`. Committed fork files simply become inert
+`local` docs under the older version; harmless to leave in place, so step 3 is only for
+cleanup, never required to abort.
+
+Notes:
+
+- **The migration never writes issue data**, so the recipe above cannot lose issues; it
+  touches only the two stamps and tracked files.
+  A bigger hammer also exists: deleting the entire `$GIT_COMMON_DIR/tbd/` directory is
+  recoverable (layout and the data-sync worktree re-materialize from the config and the
+  `tbd-sync` branch on the next command, or via `tbd doctor --fix`); **but only for
+  synced data**. Issue changes made with `--no-sync` since the last `tbd sync` live as
+  uncommitted files inside that worktree and would be lost, so run `tbd sync` first if
+  you must delete it. This is why the recipe deletes only `layout.yml`, never the whole
+  directory.
+- **Interrupted upgrades self-heal.** If the process dies between the two stamp writes
+  (layout updated but not config, or config but not layout), the next command with the
+  new version completes the migration; the abort recipe above also works from either
+  partial state.
+- **Quiesce other tbd processes first.** The same self-healing re-stamp that completes
+  an interrupted upgrade can also undo an abort.
+  Any concurrent `tbd` write (another worktree, a background agent, an editor hook)
+  re-stamps `layout.yml` from whatever `.tbd/config.yml` currently says.
+  If you delete `layout.yml` while the config is still on the new format, or before the
+  config revert in step 1 has landed, the next write recreates the stamp and reopens the
+  migration. Stop other agents and worktrees, do step 1 (revert the config) before step 2
+  (delete the stamp), and the abort sticks.
+- Teammates each migrate their own machine-local stamp automatically; only the
+  `.tbd/config.yml` change is shared (via your branch), so reverting that commit is the
+  team-wide rollback.
+
 ### Performance
 
 For large repositories with many issues:

package/dist/docs/tbd-prime.md

@@ -109,7 +109,6 @@ tbd dep add <tests-id> <feature-id>   # Tests depend on feature
 ## Setup Commands
 
 - `tbd setup --auto` - Non-interactive setup with smart defaults (for agents/scripts)
-- `tbd setup --interactive` - Interactive setup with prompts (for humans)
 - `tbd setup --from-beads` - Migrate from Beads to tbd
 
 ## Quick Reference

package/dist/docs/templates/qa-playbook.md

@@ -14,6 +14,7 @@ Manual QA playbook for [brief description of what is being tested].
 > This is a kind of “manual test”: it is not a strict end-to-end integration test,
 > because it is too costly or pass/fail is not clear.
 > Goals:
+> 
 > - Document expected behavior that are difficult to capture fully in unit, integration,
 >   or end-to-end/golden tests.
 > - Make it possible for an agent to follow the instructions and evaluate if things are
@@ -54,9 +55,10 @@ Manual QA playbook for [brief description of what is being tested].
 
 * * *
 
-## Related Documentation — Read for Context
+## Related Documentation: Read for Context
 
 > Include links to relevant documentation that provides context for this test, e.g.
+> 
 > - [spec-name.md](path/to/spec) - [Brief description]
 > - [architecture-doc.md](path/to/arch) - [Brief description]
 > - [other-qa-playbook.md](path/to/qa) - [Brief description]

package/dist/docs/templates/research-brief.md

@@ -46,7 +46,7 @@ author: Joshua Levy (github.com/jlevy) with LLM assistance
 > This section is for the “so what?”—conclusions that aren’t obvious from the individual
 > findings alone.
 
-## Comparison Matrix *(optional — for comparative research)*
+## Comparison Matrix *(optional, for comparative research)*
 
 > When evaluating multiple options or technologies, a structured comparison table is
 > often the most useful artifact.
@@ -103,7 +103,7 @@ author: Joshua Levy (github.com/jlevy) with LLM assistance
 - [ ] Action item 1
 - [ ] Action item 2
 
-## Methodology *(optional — for complex or high-stakes research)*
+## Methodology *(optional, for complex or high-stakes research)*
 
 > How the research was conducted: what searches were run, what sources were
 > cross-referenced, what information was not found or remains uncertain.

package/dist/fork-manifest-ByU7U2do.mjs

@@ -0,0 +1,253 @@
+import { s as stringifyYaml } from "./yaml-utils-BPy991by.mjs";
+import { P as resolveSharedTbdPaths } from "./paths-C1DpnZJW.mjs";
+import { n as withLockfile } from "./lockfile-BR0laSDy.mjs";
+import { n as isDocRef } from "./docref-C7g0sjvL.mjs";
+import { z } from "zod";
+import { parse } from "yaml";
+import { mkdir, readFile, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { writeFile } from "atomically";
+import { createHash } from "node:crypto";
+
+//#region src/file/fork-manifest.ts
+/**
+* Fork manifest and base snapshots for the forkable-docs workflow.
+*
+* All fork state lives under one committed directory, `.tbd/doc-forks/`:
+*   forks.yml       : the manifest (provenance, hashes, revisions)
+*   base/<kind>/<name>.md : verbatim base snapshots (the merge bases)
+*
+* The base of every fork is a stored snapshot of the upstream content the fork
+* was created from. Together with `base_hash`, this makes "customized?",
+* "stale vs upstream?", and three-way merging cheap, exact, offline operations.
+*
+* The hashing and state computation here are pure functions (see
+* {@link hashContent} and {@link computeForkStatus}); only the read/write helpers
+* touch the filesystem.
+*/
+/** Directory (repo-relative under `.tbd/`) holding all fork state. */
+const DOC_FORKS_DIR = ".tbd/doc-forks";
+/** Manifest filename within {@link DOC_FORKS_DIR}. */
+const FORKS_FILE = "forks.yml";
+/** Subdirectory within {@link DOC_FORKS_DIR} holding base snapshots. */
+const BASE_SUBDIR = "base";
+/** Doc kinds that can be forked. */
+const FORK_KINDS = [
+	"guideline",
+	"shortcut",
+	"template",
+	"reference"
+];
+/**
+* A safe doc name: no path separators, no `..`, no leading dot, no NUL.
+* Names are used to build filesystem paths (and are a doc's identity), so a
+* crafted manifest must not be able to escape the fork dir (e.g. via a
+* `../../../../victim` name through `unfork --force`). Allows the punctuation
+* real doc names use (letters, digits, `.`, `_`, `-`).
+*/
+const SAFE_DOC_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function isSafeDocName(name) {
+	return SAFE_DOC_NAME.test(name) && !name.includes("..") && !name.endsWith(".md");
+}
+const ForkEntrySchema = z.object({
+	name: z.string().min(1).refine(isSafeDocName, { message: "invalid doc name (no path separators, \"..\", or leading dot)" }),
+	kind: z.enum(FORK_KINDS),
+	path: z.string().min(1),
+	source: z.string().min(1).refine(isDocRef, { message: "source must be a valid docref" }),
+	base_hash: z.string().min(1),
+	tbd_version: z.string().optional(),
+	source_revision: z.string().optional(),
+	source_tag: z.string().optional(),
+	conflicted: z.boolean().optional()
+});
+const ForkManifestSchema = z.object({ forks: z.array(ForkEntrySchema).default([]) });
+/** An empty manifest (no forks). */
+function emptyManifest() {
+	return { forks: [] };
+}
+/** Normalize line endings to LF so hashes are stable across platforms. */
+function normalizeLineEndings(content) {
+	return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+/** sha256: hash of the LF-normalized content. */
+function hashContent(content) {
+	return `sha256:${createHash("sha256").update(normalizeLineEndings(content), "utf8").digest("hex")}`;
+}
+/**
+* The labels tbd writes into its three-way merge conflict markers. Detection of
+* an *unresolved* conflict keys off these specific labels (not generic marker
+* lines) so a forked doc that legitimately contains conflict-marker examples
+* (e.g. a git tutorial, or our own golden-testing guideline) is not stuck
+* `conflicted` forever after one unrelated `update --merge`.
+*/
+const CONFLICT_LABELS = {
+	ours: "ours (your fork)",
+	base: "base (fork point)",
+	theirs: "theirs (upstream)"
+};
+/** Whether `content` still carries tbd's own unresolved conflict markers. */
+function hasUnresolvedConflict(content) {
+	return content.includes(`<<<<<<< ${CONFLICT_LABELS.ours}`) && content.includes(`>>>>>>> ${CONFLICT_LABELS.theirs}`);
+}
+/**
+* Loose semver comparison on major.minor.patch (prerelease ignored). Returns
+* null when either version is unparseable; callers must not guard on a version
+* they cannot parse (treat null as "do not block").
+*/
+function compareVersionsLoose(a, b) {
+	const parse = (v) => {
+		const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+		return m ? [
+			Number(m[1]),
+			Number(m[2]),
+			Number(m[3])
+		] : null;
+	};
+	const pa = parse(a);
+	const pb = parse(b);
+	if (!pa || !pb) return null;
+	for (let i = 0; i < 3; i++) {
+		const x = pa[i];
+		const y = pb[i];
+		if (x < y) return -1;
+		if (x > y) return 1;
+	}
+	return 0;
+}
+/**
+* Run `fn` while holding the doc-forks manifest lock, serializing the
+* read-modify-write of `forks.yml` across concurrent fork/unfork/update so
+* entries are not lost to last-writer-wins. The lock lives in the machine-local
+* git common dir (never committed), alongside the data-sync lock.
+*/
+async function withForkManifestLock(tbdRoot, fn) {
+	const paths = await resolveSharedTbdPaths(tbdRoot);
+	await mkdir(paths.sharedLocksDir, { recursive: true });
+	return withLockfile(join(paths.sharedLocksDir, "doc-forks.lock"), fn);
+}
+/**
+* Compute a doc's fork status from hashes and flags. Pure and total; every
+* combination of inputs maps to exactly one {@link ForkStatus}.
+*/
+function computeForkStatus(input) {
+	const none = {
+		customized: false,
+		stale: false,
+		conflicted: false,
+		orphaned: false
+	};
+	if (!input.inManifest) return {
+		state: input.forkFileExists ? "local" : "upstream",
+		...none
+	};
+	if (!input.forkFileExists) return {
+		state: "missing",
+		...none
+	};
+	const customized = input.forkHash !== input.baseHash;
+	const orphaned = input.cacheHash === void 0;
+	const stale = !orphaned && input.cacheHash !== input.baseHash;
+	const conflicted = Boolean(input.conflictedFlag && input.markersPresent);
+	let state;
+	if (conflicted) state = "conflicted";
+	else if (orphaned) state = "orphaned";
+	else if (customized) state = "customized";
+	else if (stale) state = "stale";
+	else state = "forked";
+	return {
+		state,
+		customized,
+		stale,
+		conflicted,
+		orphaned
+	};
+}
+/** Find a fork entry by name, optionally constrained to a kind. */
+function findFork(manifest, name, kind) {
+	return manifest.forks.find((f) => f.name === name && (kind === void 0 || f.kind === kind));
+}
+/** Return a new manifest with `entry` inserted or replaced (matched by kind+name). */
+function upsertFork(manifest, entry) {
+	const forks = manifest.forks.filter((f) => !(f.name === entry.name && f.kind === entry.kind));
+	forks.push(entry);
+	forks.sort((a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name));
+	return { forks };
+}
+/** Return a new manifest with the matching entry removed. */
+function removeFork(manifest, name, kind) {
+	return { forks: manifest.forks.filter((f) => !(f.name === name && (kind === void 0 || f.kind === kind))) };
+}
+function forksDir(tbdRoot) {
+	return join(tbdRoot, DOC_FORKS_DIR);
+}
+function forksFilePath(tbdRoot) {
+	return join(forksDir(tbdRoot), FORKS_FILE);
+}
+function baseFilePath(tbdRoot, kind, name) {
+	return join(forksDir(tbdRoot), BASE_SUBDIR, kind, `${name}.md`);
+}
+function isNotFound(err) {
+	return err?.code === "ENOENT";
+}
+/** The outer manifest shape, before per-entry validation. */
+const ForkManifestEnvelopeSchema = z.object({ forks: z.array(z.unknown()).default([]) });
+/**
+* Read the fork manifest, returning an empty manifest if none exists.
+*
+* Parsing is tolerant per entry: a malformed or unsafe entry (bad name/kind,
+* path-traversal attempt) is dropped with a warning rather than aborting the
+* whole read. This both fails closed on a crafted entry (it is never returned,
+* so commands never act on it; no out-of-tree deletes) and keeps one corrupt
+* entry from taking down status/update for every other fork.
+*/
+async function readForkManifest(tbdRoot) {
+	let content;
+	try {
+		content = await readFile(forksFilePath(tbdRoot), "utf-8");
+	} catch (err) {
+		if (isNotFound(err)) return emptyManifest();
+		throw err;
+	}
+	const envelope = ForkManifestEnvelopeSchema.parse(parse(content) ?? { forks: [] });
+	const forks = [];
+	let dropped = 0;
+	for (const raw of envelope.forks) {
+		const parsed = ForkEntrySchema.safeParse(raw);
+		if (parsed.success) forks.push(parsed.data);
+		else dropped++;
+	}
+	if (dropped > 0) process.stderr.write(`• Ignored ${dropped} invalid fork manifest entr${dropped === 1 ? "y" : "ies"} in ${FORKS_FILE} (bad name/kind or unsafe path). Run 'tbd doctor' to review.\n`);
+	return { forks };
+}
+/** Write the fork manifest (creating `.tbd/doc-forks/` as needed). */
+async function writeForkManifest(tbdRoot, manifest) {
+	await mkdir(forksDir(tbdRoot), { recursive: true });
+	const yaml = stringifyYaml(manifest, {
+		lineWidth: 0,
+		sortMapEntries: false
+	});
+	await writeFile(forksFilePath(tbdRoot), yaml);
+}
+/** Read a base snapshot's content, or null if it is absent. */
+async function readBaseContent(tbdRoot, kind, name) {
+	try {
+		return await readFile(baseFilePath(tbdRoot, kind, name), "utf-8");
+	} catch (err) {
+		if (isNotFound(err)) return null;
+		throw err;
+	}
+}
+/** Write a base snapshot verbatim (creating parent dirs as needed). */
+async function writeBaseContent(tbdRoot, kind, name, content) {
+	const path = baseFilePath(tbdRoot, kind, name);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content);
+}
+/** Remove a base snapshot if present. */
+async function removeBaseContent(tbdRoot, kind, name) {
+	await rm(baseFilePath(tbdRoot, kind, name), { force: true });
+}
+
+//#endregion
+export { withForkManifestLock as C, upsertFork as S, writeForkManifest as T, normalizeLineEndings as _, FORK_KINDS as a, removeBaseContent as b, compareVersionsLoose as c, findFork as d, forksDir as f, isSafeDocName as g, hashContent as h, FORKS_FILE as i, computeForkStatus as l, hasUnresolvedConflict as m, CONFLICT_LABELS as n, ForkEntrySchema as o, forksFilePath as p, DOC_FORKS_DIR as r, baseFilePath as s, BASE_SUBDIR as t, emptyManifest as u, readBaseContent as v, writeBaseContent as w, removeFork as x, readForkManifest as y };
+//# sourceMappingURL=fork-manifest-ByU7U2do.mjs.map

package/dist/fork-manifest-ByU7U2do.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork-manifest-ByU7U2do.mjs","names":["parseYaml"],"sources":["../src/file/fork-manifest.ts"],"sourcesContent":["/**\n * Fork manifest and base snapshots for the forkable-docs workflow.\n *\n * All fork state lives under one committed directory, `.tbd/doc-forks/`:\n *   forks.yml       : the manifest (provenance, hashes, revisions)\n *   base/<kind>/<name>.md : verbatim base snapshots (the merge bases)\n *\n * The base of every fork is a stored snapshot of the upstream content the fork\n * was created from. Together with `base_hash`, this makes \"customized?\",\n * \"stale vs upstream?\", and three-way merging cheap, exact, offline operations.\n *\n * The hashing and state computation here are pure functions (see\n * {@link hashContent} and {@link computeForkStatus}); only the read/write helpers\n * touch the filesystem.\n */\n\nimport { createHash } from 'node:crypto';\nimport { readFile, mkdir, rm } from 'node:fs/promises';\nimport { dirname, join } from 'node:path';\n\nimport { writeFile } from 'atomically';\nimport { parse as parseYaml } from 'yaml';\nimport { z } from 'zod';\n\nimport { stringifyYaml } from '../utils/yaml-utils.js';\nimport { withLockfile } from '../utils/lockfile.js';\nimport { resolveSharedTbdPaths } from '../lib/paths.js';\nimport { isDocRef } from '../docref/index.js';\n\n/** Directory (repo-relative under `.tbd/`) holding all fork state. */\nexport const DOC_FORKS_DIR = '.tbd/doc-forks';\n/** Manifest filename within {@link DOC_FORKS_DIR}. */\nexport const FORKS_FILE = 'forks.yml';\n/** Subdirectory within {@link DOC_FORKS_DIR} holding base snapshots. */\nexport const BASE_SUBDIR = 'base';\n\n/** Doc kinds that can be forked. */\nexport const FORK_KINDS = ['guideline', 'shortcut', 'template', 'reference'] as const;\nexport type ForkKind = (typeof FORK_KINDS)[number];\n\n// =============================================================================\n// Schema\n// =============================================================================\n\n/**\n * A safe doc name: no path separators, no `..`, no leading dot, no NUL.\n * Names are used to build filesystem paths (and are a doc's identity), so a\n * crafted manifest must not be able to escape the fork dir (e.g. via a\n * `../../../../victim` name through `unfork --force`). Allows the punctuation\n * real doc names use (letters, digits, `.`, `_`, `-`).\n */\nconst SAFE_DOC_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;\nexport function isSafeDocName(name: string): boolean {\n  return SAFE_DOC_NAME.test(name) && !name.includes('..') && !name.endsWith('.md');\n}\n\nexport const ForkEntrySchema = z.object({\n  /** Doc name (e.g. \"python-rules\"). Constrained so it cannot escape the fork dir. */\n  name: z.string().min(1).refine(isSafeDocName, {\n    message: 'invalid doc name (no path separators, \"..\", or leading dot)',\n  }),\n  /** Doc kind: must be one of the known fork kinds. */\n  kind: z.enum(FORK_KINDS),\n  /** Repo-relative path of the forked file (e.g. \"docs/tbd/guidelines/python-rules.md\"). */\n  path: z.string().min(1),\n  /** Provenance docref the fork was created from (docref-everywhere rule). */\n  source: z.string().min(1).refine(isDocRef, { message: 'source must be a valid docref' }),\n  /** sha256: of the LF-normalized base content. */\n  base_hash: z.string().min(1),\n  /** tbd version when the base was last set. */\n  tbd_version: z.string().optional(),\n  /** Upstream commit at base time (git-hosted sources only). */\n  source_revision: z.string().optional(),\n  /** Exact/matching tag at base time, when one exists. */\n  source_tag: z.string().optional(),\n  /** Set by `update --merge` when it leaves conflict markers; auto-clears. */\n  conflicted: z.boolean().optional(),\n});\n\nexport type ForkEntry = z.infer<typeof ForkEntrySchema>;\n\nexport const ForkManifestSchema = z.object({\n  forks: z.array(ForkEntrySchema).default([]),\n});\n\nexport type ForkManifest = z.infer<typeof ForkManifestSchema>;\n\n/** An empty manifest (no forks). */\nexport function emptyManifest(): ForkManifest {\n  return { forks: [] };\n}\n\n// =============================================================================\n// Hashing (pure)\n// =============================================================================\n\n/** Normalize line endings to LF so hashes are stable across platforms. */\nexport function normalizeLineEndings(content: string): string {\n  return content.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n');\n}\n\n/** sha256: hash of the LF-normalized content. */\nexport function hashContent(content: string): string {\n  const hex = createHash('sha256').update(normalizeLineEndings(content), 'utf8').digest('hex');\n  return `sha256:${hex}`;\n}\n\n/**\n * Whether `content` still contains git conflict markers. Requires all three\n * standard markers so prose that merely discusses one marker is not flagged.\n */\nexport function hasConflictMarkers(content: string): boolean {\n  return /^<{7}/m.test(content) && /^={7}\\s*$/m.test(content) && /^>{7}/m.test(content);\n}\n\n/**\n * The labels tbd writes into its three-way merge conflict markers. Detection of\n * an *unresolved* conflict keys off these specific labels (not generic marker\n * lines) so a forked doc that legitimately contains conflict-marker examples\n * (e.g. a git tutorial, or our own golden-testing guideline) is not stuck\n * `conflicted` forever after one unrelated `update --merge`.\n */\nexport const CONFLICT_LABELS = {\n  ours: 'ours (your fork)',\n  base: 'base (fork point)',\n  theirs: 'theirs (upstream)',\n} as const;\n\n/** Whether `content` still carries tbd's own unresolved conflict markers. */\nexport function hasUnresolvedConflict(content: string): boolean {\n  return (\n    content.includes(`<<<<<<< ${CONFLICT_LABELS.ours}`) &&\n    content.includes(`>>>>>>> ${CONFLICT_LABELS.theirs}`)\n  );\n}\n\n/**\n * Loose semver comparison on major.minor.patch (prerelease ignored). Returns\n * null when either version is unparseable; callers must not guard on a version\n * they cannot parse (treat null as \"do not block\").\n */\nexport function compareVersionsLoose(a: string, b: string): -1 | 0 | 1 | null {\n  const parse = (v: string): [number, number, number] | null => {\n    const m = /^(\\d+)\\.(\\d+)\\.(\\d+)/.exec(v.trim());\n    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;\n  };\n  const pa = parse(a);\n  const pb = parse(b);\n  if (!pa || !pb) return null;\n  for (let i = 0; i < 3; i++) {\n    const x = pa[i]!;\n    const y = pb[i]!;\n    if (x < y) return -1;\n    if (x > y) return 1;\n  }\n  return 0;\n}\n\n/**\n * Run `fn` while holding the doc-forks manifest lock, serializing the\n * read-modify-write of `forks.yml` across concurrent fork/unfork/update so\n * entries are not lost to last-writer-wins. The lock lives in the machine-local\n * git common dir (never committed), alongside the data-sync lock.\n */\nexport async function withForkManifestLock<T>(tbdRoot: string, fn: () => Promise<T>): Promise<T> {\n  const paths = await resolveSharedTbdPaths(tbdRoot);\n  await mkdir(paths.sharedLocksDir, { recursive: true });\n  return withLockfile(join(paths.sharedLocksDir, 'doc-forks.lock'), fn);\n}\n\n// =============================================================================\n// State computation (pure)\n// =============================================================================\n\nexport type DocState =\n  | 'upstream'\n  | 'forked'\n  | 'customized'\n  | 'stale'\n  | 'conflicted'\n  | 'local'\n  | 'missing'\n  | 'orphaned';\n\n/** Inputs for {@link computeForkStatus}; all comparisons are by hash. */\nexport interface ForkStatusInput {\n  /** Whether a manifest entry exists for this doc. */\n  inManifest: boolean;\n  /** Whether the forked file is present on disk. */\n  forkFileExists: boolean;\n  /** sha256: of the current forked file (if present). */\n  forkHash?: string;\n  /** Recorded `base_hash` from the manifest entry. */\n  baseHash?: string;\n  /** sha256: of the current upstream/cache content; undefined if the source is gone. */\n  cacheHash?: string;\n  /** Manifest `conflicted` flag. */\n  conflictedFlag?: boolean;\n  /** Whether conflict markers are present in the current file. */\n  markersPresent?: boolean;\n}\n\n/**\n * Computed lifecycle status of a doc. `state` is the headline for display; the\n * booleans are orthogonal modifiers (`customized` and `stale` can combine).\n */\nexport interface ForkStatus {\n  state: DocState;\n  customized: boolean;\n  stale: boolean;\n  conflicted: boolean;\n  orphaned: boolean;\n}\n\n/**\n * Compute a doc's fork status from hashes and flags. Pure and total; every\n * combination of inputs maps to exactly one {@link ForkStatus}.\n */\nexport function computeForkStatus(input: ForkStatusInput): ForkStatus {\n  const none = { customized: false, stale: false, conflicted: false, orphaned: false };\n\n  if (!input.inManifest) {\n    // A file in the fork dir with no manifest entry is a hand-authored local doc;\n    // otherwise the doc is simply served from upstream via the cache.\n    return { state: input.forkFileExists ? 'local' : 'upstream', ...none };\n  }\n\n  if (!input.forkFileExists) {\n    return { state: 'missing', ...none };\n  }\n\n  const customized = input.forkHash !== input.baseHash;\n  const orphaned = input.cacheHash === undefined;\n  const stale = !orphaned && input.cacheHash !== input.baseHash;\n  const conflicted = Boolean(input.conflictedFlag && input.markersPresent);\n\n  // Headline state for display. `customized` and `stale` can combine; the\n  // renderer composes \"customized, stale\" from state + the stale modifier.\n  let state: DocState;\n  if (conflicted) {\n    state = 'conflicted';\n  } else if (orphaned) {\n    state = 'orphaned';\n  } else if (customized) {\n    state = 'customized';\n  } else if (stale) {\n    state = 'stale';\n  } else {\n    state = 'forked';\n  }\n\n  return { state, customized, stale, conflicted, orphaned };\n}\n\n// =============================================================================\n// Manifest helpers (pure)\n// =============================================================================\n\n/** Find a fork entry by name, optionally constrained to a kind. */\nexport function findFork(\n  manifest: ForkManifest,\n  name: string,\n  kind?: string,\n): ForkEntry | undefined {\n  return manifest.forks.find((f) => f.name === name && (kind === undefined || f.kind === kind));\n}\n\n/** Return a new manifest with `entry` inserted or replaced (matched by kind+name). */\nexport function upsertFork(manifest: ForkManifest, entry: ForkEntry): ForkManifest {\n  const forks = manifest.forks.filter((f) => !(f.name === entry.name && f.kind === entry.kind));\n  forks.push(entry);\n  forks.sort((a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name));\n  return { forks };\n}\n\n/** Return a new manifest with the matching entry removed. */\nexport function removeFork(manifest: ForkManifest, name: string, kind?: string): ForkManifest {\n  return {\n    forks: manifest.forks.filter(\n      (f) => !(f.name === name && (kind === undefined || f.kind === kind)),\n    ),\n  };\n}\n\n// =============================================================================\n// Paths\n// =============================================================================\n\nexport function forksDir(tbdRoot: string): string {\n  return join(tbdRoot, DOC_FORKS_DIR);\n}\n\nexport function forksFilePath(tbdRoot: string): string {\n  return join(forksDir(tbdRoot), FORKS_FILE);\n}\n\nexport function baseFilePath(tbdRoot: string, kind: string, name: string): string {\n  return join(forksDir(tbdRoot), BASE_SUBDIR, kind, `${name}.md`);\n}\n\n// =============================================================================\n// Filesystem I/O\n// =============================================================================\n\nfunction isNotFound(err: unknown): boolean {\n  return (err as NodeJS.ErrnoException | undefined)?.code === 'ENOENT';\n}\n\n/** The outer manifest shape, before per-entry validation. */\nconst ForkManifestEnvelopeSchema = z.object({\n  forks: z.array(z.unknown()).default([]),\n});\n\n/**\n * Read the fork manifest, returning an empty manifest if none exists.\n *\n * Parsing is tolerant per entry: a malformed or unsafe entry (bad name/kind,\n * path-traversal attempt) is dropped with a warning rather than aborting the\n * whole read. This both fails closed on a crafted entry (it is never returned,\n * so commands never act on it; no out-of-tree deletes) and keeps one corrupt\n * entry from taking down status/update for every other fork.\n */\nexport async function readForkManifest(tbdRoot: string): Promise<ForkManifest> {\n  let content: string;\n  try {\n    content = await readFile(forksFilePath(tbdRoot), 'utf-8');\n  } catch (err) {\n    if (isNotFound(err)) {\n      return emptyManifest();\n    }\n    throw err;\n  }\n  const envelope = ForkManifestEnvelopeSchema.parse(parseYaml(content) ?? { forks: [] });\n  const forks: ForkEntry[] = [];\n  let dropped = 0;\n  for (const raw of envelope.forks) {\n    const parsed = ForkEntrySchema.safeParse(raw);\n    if (parsed.success) {\n      forks.push(parsed.data);\n    } else {\n      dropped++;\n    }\n  }\n  if (dropped > 0) {\n    process.stderr.write(\n      `• Ignored ${dropped} invalid fork manifest entr${dropped === 1 ? 'y' : 'ies'} ` +\n        `in ${FORKS_FILE} (bad name/kind or unsafe path). Run 'tbd doctor' to review.\\n`,\n    );\n  }\n  return { forks };\n}\n\n/** Write the fork manifest (creating `.tbd/doc-forks/` as needed). */\nexport async function writeForkManifest(tbdRoot: string, manifest: ForkManifest): Promise<void> {\n  await mkdir(forksDir(tbdRoot), { recursive: true });\n  const yaml = stringifyYaml(manifest, { lineWidth: 0, sortMapEntries: false });\n  await writeFile(forksFilePath(tbdRoot), yaml);\n}\n\n/** Read a base snapshot's content, or null if it is absent. */\nexport async function readBaseContent(\n  tbdRoot: string,\n  kind: string,\n  name: string,\n): Promise<string | null> {\n  try {\n    return await readFile(baseFilePath(tbdRoot, kind, name), 'utf-8');\n  } catch (err) {\n    if (isNotFound(err)) {\n      return null;\n    }\n    throw err;\n  }\n}\n\n/** Write a base snapshot verbatim (creating parent dirs as needed). */\nexport async function writeBaseContent(\n  tbdRoot: string,\n  kind: string,\n  name: string,\n  content: string,\n): Promise<void> {\n  const path = baseFilePath(tbdRoot, kind, name);\n  await mkdir(dirname(path), { recursive: true });\n  await writeFile(path, content);\n}\n\n/** Remove a base snapshot if present. */\nexport async function removeBaseContent(\n  tbdRoot: string,\n  kind: string,\n  name: string,\n): Promise<void> {\n  await rm(baseFilePath(tbdRoot, kind, name), { force: true });\n}\n"],"mappings":"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"}

package/dist/fork-manifest-C7lGRq-6.mjs

@@ -0,0 +1,3 @@
+import { C as withForkManifestLock, S as upsertFork, T as writeForkManifest, _ as normalizeLineEndings, a as FORK_KINDS, b as removeBaseContent, c as compareVersionsLoose, d as findFork, f as forksDir, g as isSafeDocName, h as hashContent, i as FORKS_FILE, l as computeForkStatus, m as hasUnresolvedConflict, n as CONFLICT_LABELS, o as ForkEntrySchema, p as forksFilePath, r as DOC_FORKS_DIR, s as baseFilePath, t as BASE_SUBDIR, u as emptyManifest, v as readBaseContent, w as writeBaseContent, x as removeFork, y as readForkManifest } from "./fork-manifest-ByU7U2do.mjs";
+
+export { DOC_FORKS_DIR, FORKS_FILE, findFork, hasUnresolvedConflict, hashContent, readForkManifest, removeBaseContent, removeFork, withForkManifestLock, writeForkManifest };

package/dist/{id-mapping-mtoSP9Qt.mjs → id-mapping-D0iitY-F.mjs}

@@ -1,3 +1,3 @@
-import { a as hasShortId, c as parseIdMappingFromYaml, d as resolveToInternalId, f as saveIdMapping, i as generateUniqueShortId, l as reconcileMappings, n as calculateOptimalLength, o as loadIdMapping, r as createShortIdMapping, s as mergeIdMappings, t as addIdMapping, u as resolveIdMappingConflicts } from "./id-mapping-687_UEsy.mjs";
+import { a as hasShortId, c as parseIdMappingFromYaml, d as resolveToInternalId, f as saveIdMapping, i as generateUniqueShortId, l as reconcileMappings, n as calculateOptimalLength, o as loadIdMapping, r as createShortIdMapping, s as mergeIdMappings, t as addIdMapping, u as resolveIdMappingConflicts } from "./id-mapping-DAIeLKzm.mjs";
 
 export { loadIdMapping, mergeIdMappings, parseIdMappingFromYaml, reconcileMappings, resolveIdMappingConflicts, saveIdMapping };