dld-kit 1.0.0-rc.3 → 1.0.0-rc.5

package/dist/dld.mjs

@@ -4000,10 +4000,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep5, value } = collItem;
+        const { start, key, sep: sep9, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep5?.[0],
+          next: key ?? sep9?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -4017,7 +4017,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep5) {
+          if (!keyProps.anchor && !keyProps.tag && !sep9) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -4041,7 +4041,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep5 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep9 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -4057,7 +4057,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep5, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep9, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -4148,7 +4148,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep5 = "";
+        let sep9 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -4162,13 +4162,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep5 + cb;
-              sep5 = "";
+                comment += sep9 + cb;
+              sep9 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep5 += source;
+                sep9 += source;
               hasSpace = true;
               break;
             default:
@@ -4211,18 +4211,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep: sep5, value } = collItem;
+        const { start, key, sep: sep9, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep5?.[0],
+          next: key ?? sep9?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep5 && !value) {
+          if (!props.anchor && !props.tag && !sep9 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -4276,8 +4276,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap2 && !sep5 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep5, null, props, onError);
+        if (!isMap2 && !sep9 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep9, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -4289,7 +4289,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep5 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep9 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -4300,8 +4300,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap2 && !props.found && ctx.options.strict) {
-              if (sep5)
-                for (const st of sep5) {
+              if (sep9)
+                for (const st of sep9) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -4318,7 +4318,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep5, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep9, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -4498,7 +4498,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep5 = "";
+      let sep9 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -4515,24 +4515,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep5 + indent.slice(trimIndent) + content;
-          sep5 = "\n";
+          value += sep9 + indent.slice(trimIndent) + content;
+          sep9 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep5 === " ")
-            sep5 = "\n";
-          else if (!prevMoreIndented && sep5 === "\n")
-            sep5 = "\n\n";
-          value += sep5 + indent.slice(trimIndent) + content;
-          sep5 = "\n";
+          if (sep9 === " ")
+            sep9 = "\n";
+          else if (!prevMoreIndented && sep9 === "\n")
+            sep9 = "\n\n";
+          value += sep9 + indent.slice(trimIndent) + content;
+          sep9 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep5 === "\n")
+          if (sep9 === "\n")
             value += "\n";
           else
-            sep5 = "\n";
+            sep9 = "\n";
         } else {
-          value += sep5 + content;
-          sep5 = " ";
+          value += sep9 + content;
+          sep9 = " ";
           prevMoreIndented = false;
         }
       }
@@ -4715,25 +4715,25 @@ var require_resolve_flow_scalar = __commonJS({
         trimBoth = /^[ \t]+|[ \t]+$/g;
       }
       let res = match[1].replace(trimEnd, "");
-      let sep5 = " ";
+      let sep9 = " ";
       let pos = line.lastIndex;
       while (match = line.exec(source)) {
         const lm = match[1].replace(trimBoth, "");
         if (lm === "") {
-          if (sep5 === "\n")
-            res += sep5;
+          if (sep9 === "\n")
+            res += sep9;
           else
-            sep5 = "\n";
+            sep9 = "\n";
         } else {
-          res += sep5 + lm;
-          sep5 = " ";
+          res += sep9 + lm;
+          sep9 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep5 + (match?.[1] ?? "");
+      return res + sep9 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -5543,14 +5543,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep5, value }) {
+    function stringifyItem({ start, key, sep: sep9, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep5)
-        for (const st of sep5)
+      if (sep9)
+        for (const st of sep9)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -6717,18 +6717,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep5;
+          let sep9;
           if (scalar.end) {
-            sep5 = scalar.end;
-            sep5.push(this.sourceToken);
+            sep9 = scalar.end;
+            sep9.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep5 = [this.sourceToken];
+            sep9 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep5 }]
+            items: [{ start, key: scalar, sep: sep9 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -6881,15 +6881,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep5 = it.sep;
-                  sep5.push(this.sourceToken);
+                  const sep9 = it.sep;
+                  sep9.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep: sep5 }]
+                    items: [{ start: start2, key, sep: sep9 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -7083,13 +7083,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep5 = fc.end.splice(1, fc.end.length);
-            sep5.push(this.sourceToken);
+            const sep9 = fc.end.splice(1, fc.end.length);
+            sep9.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep5 }]
+              items: [{ start, key: fc, sep: sep9 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -7372,10 +7372,11 @@ import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 
 // package.json
-var version = "1.0.0-rc.3";
+var version = "1.0.0-rc.5";
 
 // src/core/errors.ts
 var EXIT_ERROR = 1;
+var EXIT_USAGE = 2;
 var DldError = class extends Error {
   exitCode;
   constructor(message, exitCode = EXIT_ERROR) {
@@ -7423,7 +7424,6 @@ var GhCommandError = class extends DldError {
 // src/cli/command.ts
 import { parseArgs } from "node:util";
 var EXIT_OK = 0;
-var EXIT_USAGE = 2;
 var UsageError = class extends DldError {
   constructor(message) {
     super(message, EXIT_USAGE);
@@ -7455,121 +7455,46 @@ function requestsHelp(config) {
   return tokens.some((token) => token.kind === "option" && token.name === "help");
 }
 
-// src/core/project.ts
-import { join as join2 } from "node:path";
+// src/core/decision-edits.ts
+import { basename as basename4, join as join3, relative as relative3, sep as sep2 } from "node:path";
 
-// src/core/config.ts
-var import_yaml = __toESM(require_dist(), 1);
-import { join } from "node:path";
-var CONFIG_FILE = "dld.config.yaml";
-function loadConfig(ctx, root) {
-  const path = join(root, CONFIG_FILE);
-  if (!ctx.fs.exists(path)) {
-    throw new DldError(`${CONFIG_FILE} not found. Run /dld-init first.`);
-  }
-  return parseConfig(ctx.fs.readFile(path));
-}
-function parseConfig(text) {
-  const doc = (0, import_yaml.parseDocument)(text, { logLevel: "silent" });
-  const problem = doc.errors[0] ?? doc.warnings[0];
-  if (problem !== void 0) throw invalid(`not valid YAML: ${problem.message}`);
-  const raw = doc.toJS();
-  if (!isRecord(raw)) throw invalid("expected a mapping of keys to values");
-  const mode = raw.mode;
-  if (mode !== "flat" && mode !== "namespaced") {
-    throw invalid("'mode' must be 'flat' or 'namespaced'");
-  }
-  const namespaces = optionalStringList(raw.namespaces, "namespaces");
-  if (mode === "namespaced" && namespaces.length === 0) {
-    throw invalid("'namespaces' must list at least one namespace when 'mode' is 'namespaced'");
-  }
-  return {
-    decisionsDir: requiredString(raw.decisions_dir, "decisions_dir"),
-    mode,
-    namespaces,
-    annotationPrefix: optionalString(raw.annotation_prefix, "annotation_prefix") ?? "@decision",
-    // @decision(DL-023)
-    annotationExclude: repoRelativePatterns(raw.annotation_exclude, "annotation_exclude"),
-    implementReview: optionalBoolean(raw.implement_review, "implement_review") ?? true,
-    snapshotArtifacts: snapshotArtifacts(raw.snapshot_artifacts)
-  };
-}
-function invalid(message) {
-  return new DldError(`${CONFIG_FILE}: ${message}`);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function requiredString(value, key) {
-  const result = optionalString(value, key);
-  if (result === void 0) throw invalid(`'${key}' is required`);
-  return result;
-}
-function optionalString(value, key) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "string" || value.trim() === "") {
-    throw invalid(`'${key}' must be a non-empty string`);
-  }
-  return value;
-}
-function optionalBoolean(value, key) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "boolean") throw invalid(`'${key}' must be true or false`);
-  return value;
-}
-function optionalStringList(value, key) {
-  if (value === void 0 || value === null) return [];
-  if (!Array.isArray(value)) throw invalid(`'${key}' must be a list of strings`);
-  return value.map((item) => {
-    if (typeof item !== "string" || item.trim() === "") {
-      throw invalid(`'${key}' must be a list of non-empty strings`);
-    }
-    return item;
-  });
+// src/core/files.ts
+import { basename, dirname, join } from "node:path";
+var TEMP_PREFIX = ".dld-tmp-";
+function tempPathFor(path) {
+  const suffix = Math.random().toString(36).slice(2, 10);
+  return join(dirname(path), `${TEMP_PREFIX}${basename(path)}.${suffix}`);
 }
-function repoRelativePatterns(value, key) {
-  const patterns = optionalStringList(value, key);
-  const outside = patterns.find((pattern) => /^([/\\]|[A-Za-z]:|\.\.([/\\]|$))/.test(pattern));
-  if (outside !== void 0) {
-    throw invalid(`'${key}' patterns must be relative to the repository root, got '${outside}'`);
+function writeFileAtomic(ctx, path, content, mode) {
+  const temp = tempPathFor(path);
+  try {
+    ctx.fs.writeFile(temp, content);
+    if (mode !== void 0) ctx.fs.chmod(temp, mode);
+    ctx.fs.rename(temp, path);
+  } catch (error) {
+    removeQuietly(ctx, temp);
+    throw error;
   }
-  return patterns;
-}
-function snapshotArtifacts(value) {
-  const key = "snapshot_artifacts";
-  if (value === void 0 || value === null) return [];
-  if (!Array.isArray(value)) throw invalid(`'${key}' must be a list of {title, prompt} entries`);
-  return value.map((item) => {
-    if (!isRecord(item)) throw invalid(`'${key}' entries must have 'title' and 'prompt'`);
-    return {
-      title: requiredString(item.title, `${key}[].title`),
-      prompt: requiredString(item.prompt, `${key}[].prompt`)
-    };
-  });
 }
-
-// src/core/project.ts
-function findProjectRoot(ctx) {
+function createFileExclusive(ctx, path, content, existsMessage) {
+  const temp = tempPathFor(path);
   try {
-    return ctx.git(["rev-parse", "--show-toplevel"]).trim();
+    ctx.fs.writeFile(temp, content);
+    ctx.fs.link(temp, path);
   } catch (error) {
-    if (error instanceof GitCommandError) throw new DldError("not a git repository");
+    if (error instanceof FsError && error.code === "EEXIST") throw new DldError(existsMessage);
     throw error;
+  } finally {
+    removeQuietly(ctx, temp);
   }
 }
-function resolvePaths(root, config) {
-  const decisionsDir = join2(root, config.decisionsDir);
-  return { root, decisionsDir, recordsDir: join2(decisionsDir, "records") };
-}
-function loadProject(ctx) {
-  const root = findProjectRoot(ctx);
-  const config = loadConfig(ctx, root);
-  return { config, paths: resolvePaths(root, config) };
+function removeQuietly(ctx, path) {
+  try {
+    ctx.fs.remove(path);
+  } catch {
+  }
 }
 
-// src/core/snapshot.ts
-import { basename as basename3, join as join6, relative as relative3 } from "node:path";
-
 // src/core/git.ts
 import { relative, sep } from "node:path";
 function gitAt(ctx, root) {
@@ -7599,8 +7524,8 @@ function resolveStateCommit(git, value) {
 }
 
 // src/core/records.ts
-var import_yaml2 = __toESM(require_dist(), 1);
-import { basename, join as join3 } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+import { basename as basename2, join as join2, relative as relative2 } from "node:path";
 var STATUSES = ["proposed", "accepted", "deprecated", "superseded"];
 var RECORD_FILE = /^DL-(\d+)\.md$/;
 var DECISION_ID = /^DL-\d+$/;
@@ -7613,7 +7538,7 @@ function listRecordFiles(ctx, recordsDir) {
   const walk = (dir) => {
     const entries = ctx.fs.readDir(dir).sort((a, b) => a.name < b.name ? -1 : 1);
     for (const entry of entries) {
-      const path = join3(dir, entry.name);
+      const path = join2(dir, entry.name);
       if (entry.isDirectory) walk(path);
       else if (entry.isFile && RECORD_FILE.test(entry.name)) found.push(path);
     }
@@ -7622,12 +7547,25 @@ function listRecordFiles(ctx, recordsDir) {
   return found;
 }
 function recordNumber(path) {
-  const digits = RECORD_FILE.exec(basename(path))?.[1];
+  const digits = RECORD_FILE.exec(basename2(path))?.[1];
   if (digits === void 0) throw new Error(`not a decision record file: ${path}`);
   return Number.parseInt(digits, 10);
 }
-function findRecordFile(ctx, recordsDir, id) {
-  return listRecordFiles(ctx, recordsDir).find((path) => basename(path) === `${id}.md`);
+function findRecordFile(ctx, recordsDir, id, root) {
+  const matches = listRecordFiles(ctx, recordsDir).filter((path) => basename2(path) === `${id}.md`);
+  if (matches.length > 1) {
+    const shown = matches.map((path) => root === void 0 ? path : relative2(root, path));
+    throw new DldError(`decision ${id} is in more than one file: ${shown.join(", ")}`);
+  }
+  return matches[0];
+}
+function duplicateRecordFiles(ctx, recordsDir) {
+  const byNumber = /* @__PURE__ */ new Map();
+  for (const path of listRecordFiles(ctx, recordsDir)) {
+    const number = recordNumber(path);
+    byNumber.set(number, [...byNumber.get(number) ?? [], path]);
+  }
+  return [...byNumber.entries()].filter(([, paths]) => paths.length > 1).sort(([a], [b]) => a - b).map(([, paths]) => paths);
 }
 var isDelimiter = (line) => line === "---" || line === "---\r";
 function frontmatterBlock(text) {
@@ -7642,15 +7580,21 @@ function recordBody(text) {
   const block = frontmatterBlock(text);
   return block === void 0 ? text : block.lines.slice(block.end + 1).join("\n");
 }
+function recordHead(text) {
+  const block = frontmatterBlock(text);
+  if (block === void 0) return void 0;
+  return `${block.lines.slice(0, block.end + 1).join("\n")}
+`;
+}
 function parseRecord(text, source) {
   const invalid2 = (message) => new DldError(`${source}: ${message}`);
   const block = frontmatterBlock(text);
   if (block === void 0) throw invalid2("no frontmatter between --- lines");
   const frontmatter = block.lines.slice(block.start + 1, block.end).map((line) => line.replace(/\r$/, ""));
-  const doc = (0, import_yaml2.parseDocument)(frontmatter.join("\n"), { logLevel: "silent" });
+  const doc = (0, import_yaml.parseDocument)(frontmatter.join("\n"), { logLevel: "silent" });
   const problem = doc.errors[0] ?? doc.warnings[0];
   const raw = problem === void 0 ? doc.toJS() : legacyFields(frontmatter);
-  if (!isRecord2(raw)) throw invalid2("frontmatter must be a mapping");
+  if (!isRecord(raw)) throw invalid2("frontmatter must be a mapping");
   const string = (key) => {
     const value = raw[key];
     if (value === void 0 || value === null) return void 0;
@@ -7707,13 +7651,13 @@ function references(value, invalid2) {
   if (value === void 0 || value === null) return [];
   if (!Array.isArray(value)) throw invalid2("'references' must be a list");
   return value.map((item) => {
-    if (!isRecord2(item) || typeof item.path !== "string") {
+    if (!isRecord(item) || typeof item.path !== "string") {
       throw invalid2("'references' entries must have a 'path'");
     }
     return typeof item.symbol === "string" ? { path: item.path, symbol: item.symbol } : { path: item.path };
   });
 }
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function setStatus(text, status, source) {
@@ -7779,267 +7723,111 @@ function formatTimestamp(date) {
   return `${date.toISOString().slice(0, 19)}Z`;
 }
 
+// src/core/reindex.ts
+import { basename as basename3 } from "node:path";
+
 // src/core/ids.ts
 function formatId(n) {
   return `DL-${String(n).padStart(3, "0")}`;
 }
+function isCanonicalId(id) {
+  return /^DL-(\d{3}|[1-9]\d{3,})$/.test(id);
+}
+function canonicalSpelling(id) {
+  const digits = /^dl-(\d+)$/i.exec(id)?.[1];
+  if (digits === void 0) return void 0;
+  const number = Number(digits);
+  return Number.isSafeInteger(number) ? formatId(number) : void 0;
+}
 function nextId(ctx, recordsDir) {
   const highest = listRecordFiles(ctx, recordsDir).map(recordNumber).reduce((max, n) => Math.max(max, n), 0);
   return formatId(highest + 1);
 }
 
-// src/core/state.ts
-var import_yaml3 = __toESM(require_dist(), 1);
-import { join as join5, relative as relative2 } from "node:path";
-
-// src/core/files.ts
-import { basename as basename2, dirname, join as join4 } from "node:path";
-var TEMP_PREFIX = ".dld-tmp-";
-function tempPathFor(path) {
-  const suffix = Math.random().toString(36).slice(2, 10);
-  return join4(dirname(path), `${TEMP_PREFIX}${basename2(path)}.${suffix}`);
-}
-function writeFileAtomic(ctx, path, content, mode) {
-  const temp = tempPathFor(path);
+// src/core/open-prs.ts
+var GITHUB_REMOTE = /github\.com[:/]/;
+var PR_LIMIT = "100";
+var COMMIT_ID = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+function openPrIds(ctx, paths, base) {
+  const skipped = (reason) => ({ claims: [], skipped: reason });
   try {
-    ctx.fs.writeFile(temp, content);
-    if (mode !== void 0) ctx.fs.chmod(temp, mode);
-    ctx.fs.rename(temp, path);
+    ctx.gh(["--version"]);
   } catch (error) {
-    removeQuietly(ctx, temp);
+    if (error instanceof ToolNotFoundError) return skipped("gh CLI not installed");
+    if (!(error instanceof GhCommandError)) throw error;
+  }
+  const git = gitAt(ctx, paths.root);
+  if (!GITHUB_REMOTE.test(gitOrEmpty(git, "remote", "get-url", "origin"))) {
+    return skipped("origin is not a GitHub remote");
+  }
+  try {
+    ctx.gh(["auth", "status"]);
+  } catch (error) {
+    if (error instanceof GhCommandError) return skipped("gh not authenticated");
     throw error;
   }
-}
-function createFileExclusive(ctx, path, content, existsMessage) {
-  const temp = tempPathFor(path);
+  const prBase = base.startsWith("origin/") ? base.slice("origin/".length) : base;
+  let output;
   try {
-    ctx.fs.writeFile(temp, content);
-    ctx.fs.link(temp, path);
+    output = ctx.gh([
+      "pr",
+      "list",
+      "--state",
+      "open",
+      `--base=${prBase}`,
+      "--json",
+      "files,headRefName,headRefOid,isCrossRepository",
+      "--limit",
+      PR_LIMIT
+    ]);
   } catch (error) {
-    if (error instanceof FsError && error.code === "EEXIST") throw new DldError(existsMessage);
+    if (error instanceof GhCommandError) {
+      return skipped(`gh pr list failed: ${firstLine(error.stderr) || "no error output"}`);
+    }
     throw error;
-  } finally {
-    removeQuietly(ctx, temp);
   }
+  const prs = parsePrList(output);
+  if (prs === void 0) return skipped("gh pr list returned unexpected output");
+  const current = gitOrEmpty(git, "rev-parse", "--abbrev-ref", "HEAD").trim();
+  const prefix = `${recordsPathspec(paths)}/`;
+  const claims = [];
+  for (const pr of prs) {
+    if (!pr.isCrossRepository && pr.headRefName === current) continue;
+    for (const path of pr.files) {
+      if (!path.startsWith(prefix)) continue;
+      for (const id of path.match(DECISION_MENTION) ?? []) claims.push({ id, head: pr.headRefOid });
+    }
+  }
+  return { claims };
 }
-function removeQuietly(ctx, path) {
+function parsePrList(output) {
+  let value;
   try {
-    ctx.fs.remove(path);
+    value = JSON.parse(output);
   } catch {
+    return void 0;
   }
-}
-
-// src/core/state.ts
-var STATE_FILE = ".dld-state.yaml";
-function statePath(paths) {
-  return join5(paths.decisionsDir, STATE_FILE);
-}
-function loadStateDocument(ctx, paths) {
-  const path = statePath(paths);
-  if (!ctx.fs.exists(path)) return new import_yaml3.Document(void 0, { schema: "failsafe" });
-  const source = relative2(paths.root, path);
-  const doc = (0, import_yaml3.parseDocument)(ctx.fs.readFile(path), { schema: "failsafe", logLevel: "error" });
-  const problem = doc.errors[0] ?? doc.warnings[0];
-  if (problem !== void 0) throw new DldError(`${source}: not valid YAML: ${problem.message}`);
-  if (doc.contents !== null && !(0, import_yaml3.isMap)(doc.contents)) {
-    throw new DldError(`${source}: expected a mapping of sections`);
+  if (!Array.isArray(value)) return void 0;
+  const prs = [];
+  for (const item of value) {
+    if (!isObject(item)) return void 0;
+    const files = Array.isArray(item.files) ? item.files : [];
+    prs.push({
+      headRefName: typeof item.headRefName === "string" ? item.headRefName : void 0,
+      headRefOid: typeof item.headRefOid === "string" && COMMIT_ID.test(item.headRefOid) ? item.headRefOid : void 0,
+      isCrossRepository: item.isCrossRepository === true,
+      files: files.flatMap(
+        (file) => isObject(file) && typeof file.path === "string" ? [file.path] : []
+      )
+    });
   }
-  return doc;
-}
-function readStateSection(ctx, paths, section) {
-  const value = loadStateDocument(ctx, paths).toJS()?.[section];
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : void 0;
-}
-function writeStateSection(ctx, paths, section, value) {
-  const doc = loadStateDocument(ctx, paths);
-  doc.set(section, value);
-  writeFileAtomic(ctx, statePath(paths), String(doc));
+  return prs;
 }
-function stateString(section, key) {
-  const value = section?.[key];
-  return typeof value === "string" && value !== "" ? value : void 0;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function shortHead(ctx, root) {
-  try {
-    return ctx.git(["-C", root, "rev-parse", "--short", "HEAD"]).trim();
-  } catch (error) {
-    if (error instanceof GitCommandError) return "unknown";
-    throw error;
-  }
-}
-
-// src/core/snapshot.ts
-var DECISION_BOUNDARY = "===DLD_DECISION_BOUNDARY===";
-var BUILT_IN_ARTIFACTS = ["SNAPSHOT.md", "OVERVIEW.md"];
-function readRecords(ctx, { paths }) {
-  return listRecordFiles(ctx, paths.recordsDir).map((path) => {
-    const text = ctx.fs.readFile(path);
-    const record = parseRecord(text, relative3(paths.root, path));
-    return { path, number: recordNumber(path), text, accepted: record.status === "accepted" };
-  }).sort((a, b) => a.number - b.number);
-}
-function collectActiveDecisions(ctx, project) {
-  if (!ctx.fs.isDirectory(project.paths.recordsDir)) {
-    throw new DldError(`records directory not found at ${project.paths.recordsDir}`);
-  }
-  return readRecords(ctx, project).filter((record) => record.accepted).map((record) => record.text).join(`${DECISION_BOUNDARY}
-`);
-}
-function detectSnapshotChanges(ctx, project) {
-  const { paths } = project;
-  const state = readStateSection(ctx, paths, "snapshot");
-  if (state === void 0) return { mode: "full" };
-  if (BUILT_IN_ARTIFACTS.some((name) => !ctx.fs.exists(join6(paths.decisionsDir, name)))) {
-    return { mode: "full" };
-  }
-  const included = stateString(state, "decisions_included");
-  if (included === void 0 || !/^\d+$/.test(included)) return { mode: "full" };
-  const includedNumber = Number.parseInt(included, 10);
-  const newDecisions = readRecords(ctx, project).filter((record) => record.number > includedNumber && record.accepted).map((record) => formatId(record.number));
-  const git = gitAt(ctx, paths.root);
-  let stored = stateString(state, "commit_hash");
-  const lastRun = stateString(state, "last_run");
-  if ((stored === void 0 || stored === "unknown") && lastRun !== void 0) {
-    stored = gitOrEmpty(git, "log", `--until=${lastRun}`, "--format=%h", "-1").trim() || void 0;
-  }
-  const commit = resolveStateCommit(git, stored);
-  let modifiedDecisions = [];
-  let commitRange = "";
-  if (commit !== void 0 && commit !== shortHead(ctx, paths.root)) {
-    commitRange = `${commit}..HEAD`;
-    const numbers = nulSeparated(
-      gitOrEmpty(git, "diff", "-z", "--name-only", commitRange, "--", recordsPathspec(paths))
-    ).map((path) => basename3(path)).filter((name) => RECORD_FILE.test(name)).map((name) => recordNumber(name)).filter((number) => number <= includedNumber);
-    modifiedDecisions = [...new Set(numbers)].sort((a, b) => a - b).map(formatId);
-  }
-  return { mode: "incremental", newDecisions, modifiedDecisions, commitRange };
-}
-function formatSnapshotChanges(changes) {
-  if (changes.mode === "full") return "mode: full\n";
-  return [
-    "mode: incremental",
-    `new_decisions: ${changes.newDecisions.join(", ")}`,
-    `modified_decisions: ${changes.modifiedDecisions.join(", ")}`,
-    `commit_range: ${changes.commitRange}`,
-    ""
-  ].join("\n");
-}
-function updateSnapshotState(ctx, project, customArtifacts) {
-  const { paths } = project;
-  const timestamp = formatTimestamp(ctx.now());
-  const commit = shortHead(ctx, paths.root);
-  const highest = readRecords(ctx, project).filter((record) => record.accepted).reduce((max, record) => Math.max(max, record.number), 0);
-  const artifacts = /* @__PURE__ */ Object.create(null);
-  for (const name of [...BUILT_IN_ARTIFACTS, ...customArtifacts]) artifacts[name] = timestamp;
-  writeStateSection(ctx, paths, "snapshot", {
-    last_run: timestamp,
-    commit_hash: commit,
-    decisions_included: String(highest),
-    artifacts
-  });
-  return { timestamp, commit, highest };
-}
-
-// src/cli/commands/collect-active-decisions.ts
-var collectActiveDecisionsCommand = {
-  name: "collect-active-decisions",
-  summary: "Print every accepted decision record",
-  internal: true,
-  usage: "Usage: dld collect-active-decisions\n\nPrint each accepted record in ID order, separated by ===DLD_DECISION_BOUNDARY=== lines.\n",
-  run(args, io, ctx) {
-    parseCommandArgs({ args: [...args], options: {} });
-    io.stdout(collectActiveDecisions(ctx, loadProject(ctx)));
-    return EXIT_OK;
-  }
-};
-
-// src/core/commit-reindex.ts
-import { join as join7, posix as posix2 } from "node:path";
-
-// src/core/reindex.ts
-import { basename as basename4 } from "node:path";
-
-// src/core/open-prs.ts
-var GITHUB_REMOTE = /github\.com[:/]/;
-var PR_LIMIT = "100";
-function openPrIds(ctx, paths, base) {
-  const skipped = (reason) => ({ ids: [], skipped: reason });
-  try {
-    ctx.gh(["--version"]);
-  } catch (error) {
-    if (error instanceof ToolNotFoundError) return skipped("gh CLI not installed");
-    if (!(error instanceof GhCommandError)) throw error;
-  }
-  const git = gitAt(ctx, paths.root);
-  if (!GITHUB_REMOTE.test(gitOrEmpty(git, "remote", "get-url", "origin"))) {
-    return skipped("origin is not a GitHub remote");
-  }
-  try {
-    ctx.gh(["auth", "status"]);
-  } catch (error) {
-    if (error instanceof GhCommandError) return skipped("gh not authenticated");
-    throw error;
-  }
-  const prBase = base.startsWith("origin/") ? base.slice("origin/".length) : base;
-  let output;
-  try {
-    output = ctx.gh([
-      "pr",
-      "list",
-      "--state",
-      "open",
-      `--base=${prBase}`,
-      "--json",
-      "files,headRefName,isCrossRepository",
-      "--limit",
-      PR_LIMIT
-    ]);
-  } catch (error) {
-    if (error instanceof GhCommandError) {
-      return skipped(`gh pr list failed: ${firstLine(error.stderr) || "no error output"}`);
-    }
-    throw error;
-  }
-  const prs = parsePrList(output);
-  if (prs === void 0) return skipped("gh pr list returned unexpected output");
-  const current = gitOrEmpty(git, "rev-parse", "--abbrev-ref", "HEAD").trim();
-  const prefix = `${recordsPathspec(paths)}/`;
-  const ids = [];
-  for (const pr of prs) {
-    if (!pr.isCrossRepository && pr.headRefName === current) continue;
-    for (const path of pr.files) {
-      if (path.startsWith(prefix)) ids.push(...path.match(DECISION_MENTION) ?? []);
-    }
-  }
-  return { ids };
-}
-function parsePrList(output) {
-  let value;
-  try {
-    value = JSON.parse(output);
-  } catch {
-    return void 0;
-  }
-  if (!Array.isArray(value)) return void 0;
-  const prs = [];
-  for (const item of value) {
-    if (!isObject(item)) return void 0;
-    const files = Array.isArray(item.files) ? item.files : [];
-    prs.push({
-      headRefName: typeof item.headRefName === "string" ? item.headRefName : void 0,
-      isCrossRepository: item.isCrossRepository === true,
-      files: files.flatMap(
-        (file) => isObject(file) && typeof file.path === "string" ? [file.path] : []
-      )
-    });
-  }
-  return prs;
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function firstLine(text) {
-  return text.split("\n", 1)[0]?.trim() ?? "";
+function firstLine(text) {
+  return text.split("\n", 1)[0]?.trim() ?? "";
 }
 
 // src/core/reindex.ts
@@ -8048,8 +7836,20 @@ var idNumber = (id) => Number.parseInt(id.slice(3), 10);
 function compareIds(a, b) {
   return idNumber(a) - idNumber(b) || (a < b ? -1 : a > b ? 1 : 0);
 }
-function resolveBase(ctx) {
+function resolveBase(ctx, baseBranch) {
   const git = (...args) => ctx.git(args);
+  const tried = [];
+  const firstExisting = (...refs) => refs.find((ref) => {
+    tried.push(ref);
+    return gitOrEmpty(git, "rev-parse", "--verify", "--quiet", `${ref}^{commit}`) !== "";
+  });
+  if (baseBranch !== void 0) {
+    const found2 = firstExisting(`origin/${baseBranch}`, baseBranch);
+    if (found2 !== void 0) return found2;
+    throw new DldError(
+      `base_branch '${baseBranch}' not found (tried ${tried.join(", ")}). Fetch first, or fix base_branch in dld.config.yaml.`
+    );
+  }
   const current = gitOrEmpty(git, "rev-parse", "--abbrev-ref", "HEAD").trim();
   const upstream = gitOrEmpty(
     git,
@@ -8058,12 +7858,26 @@ function resolveBase(ctx) {
     "--symbolic-full-name",
     "@{upstream}"
   ).trim();
+  const candidates = [];
   if (upstream !== "") {
     const slash = upstream.indexOf("/");
     const branch = slash === -1 ? upstream : upstream.slice(slash + 1);
-    if (branch !== "" && branch !== current) return upstream;
+    if (branch !== "" && branch !== current) candidates.push(upstream);
   }
-  return DEFAULT_BASE;
+  const remoteDefault = gitOrEmpty(
+    git,
+    "symbolic-ref",
+    "--quiet",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ).trim();
+  if (remoteDefault !== "") candidates.push(remoteDefault);
+  candidates.push(DEFAULT_BASE, "main");
+  const found = firstExisting(...new Set(candidates));
+  if (found !== void 0) return found;
+  throw new DldError(
+    `no base branch found (tried ${tried.join(", ")}). Set base_branch in dld.config.yaml, or run git remote set-head origin --auto.`
+  );
 }
 function verifyBase(ctx, paths, base, hint = "") {
   if (base.startsWith("-")) throw new DldError(`--base must be a git ref, got '${base}'`);
@@ -8095,24 +7909,56 @@ function takenIds(ctx, paths, base) {
     gitOrEmpty(git, "ls-tree", "-r", "-z", "--name-only", base, "--", recordsPathspec(paths))
   ).flatMap((path) => path.match(DECISION_MENTION) ?? []);
   const scan = openPrIds(ctx, paths, base);
-  const ids = [.../* @__PURE__ */ new Set([...onBase, ...scan.ids])].sort(compareIds);
-  return scan.skipped === void 0 ? { ids } : { ids, skipped: scan.skipped };
+  const ids = [.../* @__PURE__ */ new Set([...onBase, ...scan.claims.map(({ id }) => id)])].sort(compareIds);
+  const taken = { ids, onBase: new Set(onBase), claims: scan.claims };
+  return scan.skipped === void 0 ? taken : { ...taken, skipped: scan.skipped };
+}
+function isAncestor(git, ancestor, commit2) {
+  try {
+    git("merge-base", "--is-ancestor", ancestor, commit2);
+    return true;
+  } catch (error) {
+    if (error instanceof GitCommandError) return false;
+    throw error;
+  }
+}
+function collides(git, base, { path, id }, taken) {
+  if (taken.onBase.has(id)) return true;
+  const claims = taken.claims.filter((claim) => claim.id === id);
+  if (claims.length === 0) return false;
+  const added = git(
+    "--literal-pathspecs",
+    "log",
+    // log.follow or log.showSignature in the user's config would change the output.
+    "--no-follow",
+    "--no-show-signature",
+    "-1",
+    "--format=%H",
+    "--diff-filter=A",
+    `${base}..HEAD`,
+    "--",
+    path
+  ).trim();
+  return claims.some(
+    ({ head }) => head === void 0 || added === "" || !isAncestor(git, added, head)
+  );
 }
 function listTakenIds(ctx, { paths }, base) {
   verifyBase(ctx, paths, base, " Fetch first or pass --base.");
-  return takenIds(ctx, paths, base);
+  const { ids, skipped } = takenIds(ctx, paths, base);
+  return skipped === void 0 ? { ids } : { ids, skipped };
 }
 function collisionsOf(ctx, paths, base) {
-  const added = localAdditions(gitAt(ctx, paths.root), paths, base);
+  const git = gitAt(ctx, paths.root);
+  const added = localAdditions(git, paths, base);
   const local = added.flatMap((path) => {
-    const id = basename4(path, ".md");
-    return RECORD_FILE.test(basename4(path)) ? [{ path, id }] : [];
+    const id = basename3(path, ".md");
+    return RECORD_FILE.test(basename3(path)) ? [{ path, id }] : [];
   });
   if (local.length === 0) return { collisions: [], localIds: [], taken: [] };
   const taken = takenIds(ctx, paths, base);
-  const takenSet = new Set(taken.ids);
   const result = {
-    collisions: local.filter(({ id }) => takenSet.has(id)),
+    collisions: local.filter((record) => collides(git, base, record, taken)),
     localIds: local.map(({ id }) => id),
     taken: taken.ids
   };
@@ -8134,790 +7980,1151 @@ function formatRename({ path, oldId, newId }) {
   return `${path}	${oldId}	${newId}`;
 }
 
-// src/core/rename-plan.ts
-import { posix } from "node:path";
-function renameProblem(paths, rename) {
-  const { path, oldId, newId } = rename;
-  if (!DECISION_ID.test(oldId) || !DECISION_ID.test(newId)) return "IDs must match DL-[0-9]+.";
-  if (oldId === newId) return "old and new IDs are the same.";
-  const segments = path.split("/");
-  if (path.startsWith("/") || segments.some((s) => s === "" || s === "." || s === "..")) {
-    return `path '${path}' must be relative to the project root, without '.' or '..' segments.`;
-  }
-  const records = recordsPathspec(paths);
-  if (!path.startsWith(`${records}/`)) {
-    return `path '${path}' is not under ${records}/.`;
+// src/core/decision-edits.ts
+function editBase(ctx, project, base) {
+  if (base !== void 0) {
+    verifyBase(ctx, project.paths, base, " Fetch first or pass --base.");
+    return base;
   }
-  if (posix.basename(path) !== `${oldId}.md`) {
-    return `path '${path}' is not named ${oldId}.md.`;
+  return resolveBase(ctx, project.config.baseBranch);
+}
+function checkDecisionEdits(ctx, { paths }, base, ids = [], { uncommitted = false } = {}) {
+  const git = gitAt(ctx, paths.root);
+  const records = integratedRecords(ctx, paths, base);
+  const allowed = uncommitted ? /* @__PURE__ */ new Set() : trailerIds(git, records.onto);
+  const allow = (edit) => (edit.state === "edited" || edit.state === "deleted") && allowed.has(edit.id) ? { ...edit, state: "allowed" } : edit;
+  const stateOf = (id) => allow(rawStateOf(id));
+  const rawStateOf = (id) => {
+    const located = locate(ctx, paths, records, id);
+    if (located === void 0) {
+      const local = findRecordFile(ctx, paths.recordsDir, id, paths.root);
+      if (local === void 0) throw new DldError(`decision ${id} not found.`);
+      return { path: toPosix(relative3(paths.root, local)), id, state: "draft" };
+    }
+    const path = located.current ?? located.basePath;
+    if (isProposed(located.baseText, located.basePath)) return { path, id, state: "draft" };
+    const reference = uncommitted ? atHead(git, located) : { text: located.baseText, path };
+    if (reference === void 0) return { path, id, state: "integrated" };
+    if (located.current === void 0) return { path, id, state: "deleted" };
+    const now = ctx.fs.readFile(join3(paths.root, located.current));
+    const same = lockedContent(now, path) === lockedContent(reference.text, reference.path);
+    return { path, id, state: same ? "integrated" : "edited" };
+  };
+  if (ids.length > 0) return ids.map(stateOf);
+  const changed = nulSeparated(
+    gitOrEmpty(
+      git,
+      "diff",
+      "-z",
+      "--no-renames",
+      "--name-only",
+      uncommitted ? "HEAD" : records.onto,
+      "--",
+      recordsPathspec(paths)
+    )
+  );
+  const candidates = new Set(
+    changed.map((path) => basename4(path)).filter((name) => RECORD_FILE.test(name)).map((name) => basename4(name, ".md")).filter((id) => records.byId.has(id))
+  );
+  return [...candidates].map(stateOf).filter(({ state }) => state === "edited" || state === "deleted" || state === "allowed").sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+var EDIT_TRAILER = "Decision-Edit";
+function trailerIds(git, onto) {
+  const values = gitOrEmpty(
+    git,
+    "log",
+    `--format=%(trailers:key=${EDIT_TRAILER},valueonly)`,
+    `${onto}..HEAD`
+  );
+  return new Set(values.split(/[\s,]+/).filter((value) => DECISION_ID.test(value)));
+}
+function integratedRecords(ctx, paths, base) {
+  const onto = mergeBase(ctx, paths, base);
+  const byId = /* @__PURE__ */ new Map();
+  const listing = gitOrEmpty(
+    gitAt(ctx, paths.root),
+    "ls-tree",
+    "-r",
+    "-z",
+    "--name-only",
+    onto,
+    "--",
+    recordsPathspec(paths)
+  );
+  for (const path of nulSeparated(listing)) {
+    const name = basename4(path);
+    if (RECORD_FILE.test(name)) byId.set(basename4(name, ".md"), path);
+  }
+  return { onto, byId };
+}
+function locate(ctx, paths, { onto, byId }, id) {
+  const basePath = byId.get(id);
+  if (basePath === void 0) return void 0;
+  const baseText = gitAt(ctx, paths.root)("show", `${onto}:${basePath}`);
+  const moved = findRecordFile(ctx, paths.recordsDir, id, paths.root);
+  if (ctx.fs.isRegularFile(join3(paths.root, basePath))) {
+    return { id, basePath, baseText, current: basePath };
+  }
+  const current = moved === void 0 ? void 0 : toPosix(relative3(paths.root, moved));
+  return { id, basePath, baseText, current };
+}
+function atHead(git, { basePath, current }) {
+  for (const path of /* @__PURE__ */ new Set([current, basePath])) {
+    if (path === void 0) continue;
+    const listed = gitOrEmpty(
+      git,
+      "--literal-pathspecs",
+      "ls-tree",
+      "--name-only",
+      "HEAD",
+      "--",
+      path
+    );
+    if (listed !== "") return { text: git("show", `HEAD:${path}`), path };
   }
   return void 0;
 }
-function parseRenamePlan(paths, text) {
-  const renames = [];
-  const lineNumbers = [];
-  const seen = { path: /* @__PURE__ */ new Set(), old: /* @__PURE__ */ new Set(), new: /* @__PURE__ */ new Set() };
-  text.split("\n").forEach((raw, index) => {
-    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
-    if (line.trim() === "") return;
-    const fail = (message) => new DldError(`rename plan line ${index + 1}: ${message}`);
-    const fields = line.split("	");
-    const [path, oldId, newId] = fields;
-    if (fields.length !== 3 || path === void 0 || oldId === void 0 || newId === void 0) {
-      throw fail("expected <path>\\t<DL-OLD>\\t<DL-NEW>.");
-    }
-    const rename = { path, oldId, newId };
-    const problem = renameProblem(paths, rename);
-    if (problem !== void 0) throw fail(problem);
-    if (seen.path.has(path)) throw fail(`path '${path}' appears more than once.`);
-    if (seen.old.has(oldId)) throw fail(`${oldId} is renamed more than once.`);
-    if (seen.new.has(newId)) throw fail(`${newId} is the target of more than one rename.`);
-    seen.path.add(path);
-    seen.old.add(oldId);
-    seen.new.add(newId);
-    renames.push(rename);
-    lineNumbers.push(index + 1);
+function toPosix(path) {
+  return path.split(sep2).join("/");
+}
+function isProposed(text, source) {
+  try {
+    return parseRecord(text, source).status === "proposed";
+  } catch {
+    return false;
+  }
+}
+function restoreDecisionProse(ctx, { paths }, base, ids, { uncommitted = false } = {}) {
+  const git = gitAt(ctx, paths.root);
+  const records = integratedRecords(ctx, paths, base);
+  const targets = ids.map((id) => {
+    const located = locate(ctx, paths, records, id);
+    if (located === void 0 || isProposed(located.baseText, located.basePath)) {
+      throw new DldError(`${id} is a draft (not on the base branch, or still proposed there).`);
+    }
+    const reference = uncommitted ? atHead(git, located) : { text: located.baseText, path: located.basePath };
+    if (reference === void 0) throw new DldError(`${id} is not in HEAD; nothing to restore.`);
+    return { located, reference };
   });
-  renames.forEach(({ newId }, index) => {
-    if (seen.old.has(newId)) {
-      throw new DldError(
-        `rename plan line ${lineNumbers[index]}: ${newId} is both renamed and a rename target.`
-      );
+  return targets.map(({ located, reference }) => {
+    const path = located.current ?? reference.path;
+    const full = join3(paths.root, path);
+    const current = located.current === void 0 ? void 0 : recordHead(ctx.fs.readFile(full));
+    const referenceHead = recordHead(reference.text);
+    if (current === void 0 || referenceHead === void 0) {
+      writeFileAtomic(ctx, full, reference.text);
+      if (located.current === void 0) git("--literal-pathspecs", "add", "--", path);
+    } else {
+      const eol = current.includes("\r\n") ? "\r\n" : "\n";
+      const body = recordBody(reference.text).replace(/\r?\n/g, eol);
+      writeFileAtomic(ctx, full, withLockedLines(current, referenceHead, eol) + body);
     }
+    return path;
   });
-  return renames;
+}
+var LOCKED_KEYS = ["id", "timestamp"];
+function lockedContent(text, source) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  let fields;
+  try {
+    const record = parseRecord(normalized, source);
+    fields = JSON.stringify([record.id, record.timestamp ?? null]);
+  } catch {
+    fields = recordHead(normalized) ?? "";
+  }
+  return `${fields}
+${recordBody(normalized).trimEnd()}`;
+}
+function withLockedLines(head, baseHead, eol) {
+  let result = head;
+  for (const key of LOCKED_KEYS) {
+    const pattern = new RegExp(`^${key}:[^\\r\\n]*`, "m");
+    const line = baseHead.match(pattern)?.[0];
+    if (line === void 0) continue;
+    result = pattern.test(result) ? result.replace(pattern, () => line) : result.replace(/^---\r?\n/, (open) => `${open}${line}${eol}`);
+  }
+  return result;
+}
+function formatRecordEdit({ path, id, state }) {
+  return `${path}	${id}	${state}`;
 }
 
-// src/core/commit-reindex.ts
-var SUBJECT_LIST_LIMIT = 3;
-function reindexMessage(renames, originalSubjects) {
-  const pairs = renames.map(({ oldId, newId }) => `${oldId} -> ${newId}`);
-  const subject = renames.length > SUBJECT_LIST_LIMIT ? `reindex ${renames.length} local decisions to avoid base-branch collisions` : `reindex local decisions: ${pairs.join(", ")}`;
-  const message = `${subject}
-
-Renames:
-${pairs.map((pair) => `- ${pair}`).join("\n")}`;
-  return originalSubjects === "" ? message : `${message}
+// src/core/project.ts
+import { join as join5 } from "node:path";
 
-Squashed from original branch commits:
-${originalSubjects}`;
+// src/core/config.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+import { join as join4 } from "node:path";
+var CONFIG_FILE = "dld.config.yaml";
+var DECISION_EDITS = ["block", "ask", "allow"];
+var CONFIG_KEYS = [
+  "decisions_dir",
+  "mode",
+  "namespaces",
+  "annotation_prefix",
+  "annotation_exclude",
+  "implement_review",
+  "decision_edits",
+  "snapshot_artifacts",
+  "base_branch"
+];
+function loadConfig(ctx, root) {
+  const path = join4(root, CONFIG_FILE);
+  if (!ctx.fs.exists(path)) {
+    throw new DldError(`${CONFIG_FILE} not found. Run /dld-init first.`);
+  }
+  return parseConfig(ctx.fs.readFile(path), (message) => ctx.warn(message));
 }
-function commitReindex(ctx, { paths }, planText, base) {
-  const git = gitAt(ctx, paths.root);
-  verifyBase(ctx, paths, base);
-  const renames = parseRenamePlan(paths, planText);
-  if (renames.length === 0) throw new DldError("no rename plan on stdin.");
-  const onto = mergeBase(ctx, paths, base);
-  const head = git("rev-parse", "HEAD").trim();
-  if (onto === head) throw new DldError("HEAD is already at the merge-base \u2014 nothing to squash.");
-  const indexRel = posix2.join(decisionsPathspec(paths), "INDEX.md");
-  const branchFiles = nulSeparated(
-    git("diff", "-z", "--no-renames", "--name-only", "--diff-filter=AMRD", `${onto}..HEAD`)
-  );
-  const stage = /* @__PURE__ */ new Set();
-  for (const { path, newId } of renames) {
-    stage.add(path);
-    stage.add(posix2.join(posix2.dirname(path), `${newId}.md`));
+function parseConfig(text, warn = () => {
+}) {
+  const doc = (0, import_yaml2.parseDocument)(text, { logLevel: "silent" });
+  const problem = doc.errors[0] ?? doc.warnings[0];
+  if (problem !== void 0) throw invalid(`not valid YAML: ${problem.message}`);
+  const raw = doc.toJS();
+  if (!isRecord2(raw)) throw invalid("expected a mapping of keys to values");
+  for (const key of Object.keys(raw)) {
+    if (!CONFIG_KEYS.some((known) => known === key)) warn(unknownKeyMessage(key));
   }
-  for (const file of branchFiles) if (file !== indexRel) stage.add(file);
-  const subjects = git("log", "--reverse", "--format=- %s", `${onto}..HEAD`).replace(/\n+$/, "");
-  const message = reindexMessage(renames, subjects);
-  const indexFull = join7(paths.root, indexRel);
-  if (ctx.fs.lexists(indexFull) && !ctx.fs.isRegularFile(indexFull)) {
-    throw new DldError(`${indexRel} is not a regular file.`);
+  const mode = raw.mode;
+  if (mode !== "flat" && mode !== "namespaced") {
+    throw invalid("'mode' must be 'flat' or 'namespaced'");
   }
-  const saved = {
-    head,
-    tree: git("write-tree").trim(),
-    index: ctx.fs.isRegularFile(indexFull) ? { bytes: ctx.fs.readBytes(indexFull), mode: ctx.fs.fileMode(indexFull) } : void 0
-  };
-  let stepName = "resetting to the merge-base";
-  const step = (name, run2) => {
-    stepName = name;
-    return run2();
-  };
-  try {
-    step("resetting to the merge-base", () => git("reset", "--quiet", onto));
-    step(`restoring ${indexRel}`, () => {
-      if (existsAtHead(git, indexRel)) {
-        git("--literal-pathspecs", "checkout", "HEAD", "--", indexRel);
-      } else {
-        ctx.fs.remove(indexFull);
-      }
-    });
-    for (const path of [...stage].sort()) {
-      step(`staging ${path}`, () => stagePath(ctx, git, join7(paths.root, path), path));
-    }
-    step("checking the staged changes", () => {
-      if (!hasStagedChanges(git)) {
-        throw new DldError(
-          "nothing to commit after squash. The reindex may have already been applied, or the plan didn't match the branch state."
-        );
-      }
-    });
-    step("committing", () => {
-      try {
-        git("commit", "--quiet", "-m", message);
-      } catch (error) {
-        if (error instanceof GitCommandError)
-          throw new DldError(`git commit failed: ${error.stderr}`);
-        throw error;
-      }
-    });
-  } catch (error) {
-    throw rollback(ctx, git, indexFull, saved, stepName, error);
+  const namespaces = optionalStringList(raw.namespaces, "namespaces");
+  const unsafe = namespaces.find((name) => !/^[A-Za-z0-9._-]+$/.test(name) || /^\.\.?$/.test(name));
+  if (unsafe !== void 0) {
+    throw invalid(`'namespaces' entries must be plain directory names, got '${unsafe}'`);
+  }
+  if (mode === "namespaced" && namespaces.length === 0) {
+    throw invalid("'namespaces' must list at least one namespace when 'mode' is 'namespaced'");
   }
   return {
-    commit: git("rev-parse", "--short", "HEAD").trim(),
-    onto: git("rev-parse", "--short", onto).trim()
+    decisionsDir: requiredString(raw.decisions_dir, "decisions_dir"),
+    mode,
+    namespaces,
+    annotationPrefix: optionalString(raw.annotation_prefix, "annotation_prefix") ?? "@decision",
+    // @decision(DL-023)
+    annotationExclude: repoRelativePatterns(raw.annotation_exclude, "annotation_exclude"),
+    implementReview: optionalBoolean(raw.implement_review, "implement_review") ?? true,
+    decisionEdits: decisionEdits(raw.decision_edits),
+    snapshotArtifacts: snapshotArtifacts(raw.snapshot_artifacts),
+    ...optionalBaseBranch(raw.base_branch)
   };
 }
-function existsAtHead(git, path) {
-  return git("--literal-pathspecs", "ls-tree", "-z", "HEAD", "--", path) !== "";
+function unknownKeyMessage(key) {
+  let closest;
+  let best = 3;
+  for (const known of CONFIG_KEYS) {
+    const distance = editDistance(key, known);
+    if (distance < best) [closest, best] = [known, distance];
+  }
+  const hint = closest === void 0 ? "" : `; did you mean '${closest}'?`;
+  return `${CONFIG_FILE}: unknown key '${key}'${hint}`;
+}
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      current[j] = Math.min(
+        (previous[j] ?? 0) + 1,
+        (current[j - 1] ?? 0) + 1,
+        (previous[j - 1] ?? 0) + cost
+      );
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
 }
-function stagePath(ctx, git, full, path) {
-  const known = ctx.fs.lexists(full) || git("--literal-pathspecs", "ls-files", "-z", "--", path) !== "";
-  if (known) git("--literal-pathspecs", "add", "-A", "--", path);
+function optionalBaseBranch(value) {
+  const branch = optionalString(value, "base_branch");
+  if (branch === void 0) return {};
+  if (branch.startsWith("-") || branch === "@" || /[\s~^:?*[\\]|\.\.|@\{|^\/|\/$|\.lock$|\.$|^origin\//.test(branch)) {
+    throw invalid(
+      `'base_branch' must be a branch name such as main or develop, without origin/, got '${branch}'`
+    );
+  }
+  return { baseBranch: branch };
 }
-function hasStagedChanges(git) {
+function invalid(message) {
+  return new DldError(`${CONFIG_FILE}: ${message}`);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredString(value, key) {
+  const result = optionalString(value, key);
+  if (result === void 0) throw invalid(`'${key}' is required`);
+  return result;
+}
+function optionalString(value, key) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw invalid(`'${key}' must be a non-empty string`);
+  }
+  return value;
+}
+function optionalBoolean(value, key) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "boolean") throw invalid(`'${key}' must be true or false`);
+  return value;
+}
+function optionalStringList(value, key) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) throw invalid(`'${key}' must be a list of strings`);
+  return value.map((item) => {
+    if (typeof item !== "string" || item.trim() === "") {
+      throw invalid(`'${key}' must be a list of non-empty strings`);
+    }
+    return item;
+  });
+}
+function repoRelativePatterns(value, key) {
+  const patterns = optionalStringList(value, key);
+  const outside = patterns.find((pattern) => /^([/\\]|[A-Za-z]:|\.\.([/\\]|$))/.test(pattern));
+  if (outside !== void 0) {
+    throw invalid(`'${key}' patterns must be relative to the repository root, got '${outside}'`);
+  }
+  return patterns;
+}
+function decisionEdits(value) {
+  if (value === void 0 || value === null) return "block";
+  const allowed = DECISION_EDITS;
+  if (!allowed.includes(value)) {
+    throw invalid(`'decision_edits' must be one of ${DECISION_EDITS.join(", ")}`);
+  }
+  return value;
+}
+function snapshotArtifacts(value) {
+  const key = "snapshot_artifacts";
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) throw invalid(`'${key}' must be a list of {title, prompt} entries`);
+  return value.map((item) => {
+    if (!isRecord2(item)) throw invalid(`'${key}' entries must have 'title' and 'prompt'`);
+    return {
+      title: requiredString(item.title, `${key}[].title`),
+      prompt: requiredString(item.prompt, `${key}[].prompt`)
+    };
+  });
+}
+
+// src/core/project.ts
+function findProjectRoot(ctx) {
   try {
-    git("diff", "--cached", "--quiet");
-    return false;
+    return ctx.git(["rev-parse", "--show-toplevel"]).trim();
   } catch (error) {
-    if (error instanceof GitCommandError && error.status === 1) return true;
+    if (error instanceof GitCommandError) throw new DldError("not a git repository");
     throw error;
   }
 }
-function rollback(ctx, git, indexFull, saved, stepName, cause) {
-  try {
-    git("reset", "--quiet", "--soft", saved.head);
-    git("read-tree", saved.tree);
-    if (saved.index === void 0) ctx.fs.remove(indexFull);
-    else writeFileAtomic(ctx, indexFull, saved.index.bytes, saved.index.mode);
-  } catch (rollbackError) {
-    return new DldError(
-      `commit-reindex failed while ${stepName}: ${describe(cause)}
-Rolling back also failed: ${describe(rollbackError)}
-To restore by hand: git reset --soft ${saved.head} && git read-tree ${saved.tree}`
-    );
-  }
-  if (!(cause instanceof DldError)) return cause;
-  return new DldError(
-    `commit-reindex failed while ${stepName}: ${cause.message}
-The branch was restored to ${saved.head}.`,
-    cause.exitCode
-  );
+function resolvePaths(root, config) {
+  const decisionsDir = join5(root, config.decisionsDir);
+  return { root, decisionsDir, recordsDir: join5(decisionsDir, "records") };
 }
-function describe(error) {
-  return error instanceof Error ? error.message : String(error);
+function loadProject(ctx) {
+  const root = findProjectRoot(ctx);
+  const config = loadConfig(ctx, root);
+  return { config, paths: resolvePaths(root, config) };
 }
 
 // src/cli/commands/base-option.ts
-function baseOption(value, fallback = DEFAULT_BASE) {
-  const base = value ?? fallback;
-  if (base.startsWith("-")) throw new UsageError(`--base must be a git ref, got '${base}'`);
-  return base;
+function baseOption(value, defaults) {
+  if (value === void 0 && defaults !== void 0) {
+    return resolveBase(defaults.ctx, defaults.project.config.baseBranch);
+  }
+  if (value === void 0 || value === "") throw new UsageError("--base is required.");
+  if (value.startsWith("-")) throw new UsageError(`--base must be a git ref, got '${value}'`);
+  return value;
 }
+var DEFAULT_BASE_HELP = "default: the base resolve-base picks";
 function skippedNotice(reason) {
   return `[dld-reindex] open PRs not scanned: ${reason}
 `;
 }
 
-// src/cli/commands/commit-reindex.ts
-var commitReindexCommand = {
-  name: "commit-reindex",
-  summary: "Squash the branch into one reindex commit",
-  internal: true,
-  usage: `Usage: dld commit-reindex --base <ref> < plan
+// src/cli/commands/check-decision-edits.ts
+var EXIT_BLOCKED = 3;
+var checkDecisionEditsCommand = {
+  name: "check-decision-edits",
+  summary: "List edits to the prose of decisions already on the base branch (CI gate)",
+  usage: `Usage: dld check-decision-edits [--base <ref>] [--uncommitted] [DL-NNN ...]
+
+A decision is integrated when it exists at the merge-base of the base branch and HEAD;
+otherwise it is a draft (so is one still proposed there). Without IDs, print
+<path>\\t<DL-NNN>\\t<state> for each integrated decision whose body (the text after the
+frontmatter), id or timestamp changed (edited), or that is gone (deleted). With IDs, print
+one line per ID with its state: draft, integrated, edited, deleted or allowed.
+
+A commit on the branch with a "Decision-Edit: DL-NNN[, DL-NNN ...]" trailer allows edits to
+the decisions it names: they are printed as allowed. The trailer must be in the message's last
+paragraph, which holds only trailers. Trailers do not apply with --uncommitted.
 
-Read a rename plan on standard input and squash the branch's commits since the merge-base
-with <ref> into one reindex commit. INDEX.md is left at its merge-base state. On failure the
-branch, index and INDEX.md are restored.
+Without IDs, exits 3 when decision_edits is block (the default) and an edited or deleted
+decision was printed. With IDs, and otherwise, exits 0. Errors exit 1, usage errors 2.
 
 Options:
-  --base <ref>  Base ref (required)
+  --base <ref>     Base ref (${DEFAULT_BASE_HELP})
+  --uncommitted    Compare with HEAD instead of the merge-base: only uncommitted changes
 `,
   run(args, io, ctx) {
-    const { values } = parseCommandArgs({ args: [...args], options: { base: { type: "string" } } });
-    if (!values.base) throw new DldError("--base is required.");
-    const base = baseOption(values.base);
+    const { values, positionals: ids } = parseCommandArgs({
+      args: [...args],
+      options: { base: { type: "string" }, uncommitted: { type: "boolean" } },
+      allowPositionals: true
+    });
+    const bad = ids.find((id) => !DECISION_ID.test(id));
+    if (bad !== void 0) throw new UsageError(`expected decision IDs like DL-001, got '${bad}'`);
     const project = loadProject(ctx);
-    const { commit, onto } = commitReindex(ctx, project, ctx.readStdin(), base);
-    io.stdout(`Created reindex commit ${commit} on top of ${onto}
+    const base = editBase(
+      ctx,
+      project,
+      values.base === void 0 ? void 0 : baseOption(values.base)
+    );
+    const edits = checkDecisionEdits(ctx, project, base, ids, {
+      uncommitted: values.uncommitted === true
+    });
+    for (const edit of edits) io.stdout(`${formatRecordEdit(edit)}
 `);
-    return EXIT_OK;
+    const changed = edits.some(({ state }) => state === "edited" || state === "deleted");
+    const blocked = ids.length === 0 && changed && project.config.decisionEdits === "block";
+    return blocked ? EXIT_BLOCKED : EXIT_OK;
   }
 };
 
-// src/core/init.ts
-import { join as join8 } from "node:path";
-function parseMode(value) {
-  if (value !== "flat" && value !== "namespaced") {
-    throw new DldError(`mode must be 'flat' or 'namespaced', got '${value}'.`);
+// src/core/snapshot.ts
+import { basename as basename5, join as join7, relative as relative5 } from "node:path";
+
+// src/core/state.ts
+var import_yaml3 = __toESM(require_dist(), 1);
+import { join as join6, relative as relative4 } from "node:path";
+var STATE_FILE = ".dld-state.yaml";
+function statePath(paths) {
+  return join6(paths.decisionsDir, STATE_FILE);
+}
+function loadStateDocument(ctx, paths) {
+  const path = statePath(paths);
+  if (!ctx.fs.exists(path)) return new import_yaml3.Document(void 0, { schema: "failsafe" });
+  const source = relative4(paths.root, path);
+  const doc = (0, import_yaml3.parseDocument)(ctx.fs.readFile(path), { schema: "failsafe", logLevel: "error" });
+  const problem = doc.errors[0] ?? doc.warnings[0];
+  if (problem !== void 0) throw new DldError(`${source}: not valid YAML: ${problem.message}`);
+  if (doc.contents !== null && !(0, import_yaml3.isMap)(doc.contents)) {
+    throw new DldError(`${source}: expected a mapping of sections`);
   }
-  return value;
+  return doc;
 }
-function renderConfig(mode, namespaces) {
-  const lines = ["decisions_dir: decisions", `mode: ${mode}`];
-  if (mode === "namespaced") lines.push("namespaces:", ...namespaces.map((ns) => `  - ${ns}`));
-  lines.push("annotation_prefix: '@decision'");
-  return `${lines.join("\n")}
-`;
+function readStateSection(ctx, paths, section) {
+  const value = loadStateDocument(ctx, paths).toJS()?.[section];
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : void 0;
 }
-function createConfig(ctx, root, mode, namespaces) {
-  if (mode === "namespaced" && namespaces.length === 0) {
-    throw new DldError("namespaced mode requires at least one namespace.");
-  }
-  const path = join8(root, CONFIG_FILE);
-  createFileExclusive(ctx, path, renderConfig(mode, namespaces), `${CONFIG_FILE} already exists.`);
-  return path;
+function writeStateSection(ctx, paths, section, value) {
+  const doc = loadStateDocument(ctx, paths);
+  doc.set(section, value);
+  writeFileAtomic(ctx, statePath(paths), String(doc));
 }
-function createDirectories(ctx, { config, paths }) {
-  ctx.fs.mkdir(paths.decisionsDir);
-  ctx.fs.mkdir(paths.recordsDir);
-  if (config.mode !== "namespaced") return;
-  for (const namespace of config.namespaces) {
-    const dir = join8(paths.recordsDir, namespace);
-    ctx.fs.mkdir(dir);
-    const keep = join8(dir, ".gitkeep");
-    if (!ctx.fs.exists(keep)) createFileExclusive(ctx, keep, "", `${keep} already exists.`);
-  }
+function stateString(section, key) {
+  const value = section?.[key];
+  return typeof value === "string" && value !== "" ? value : void 0;
 }
-
-// src/cli/commands/create-config.ts
-var createConfigCommand = {
-  name: "create-config",
-  summary: "Create dld.config.yaml at the project root",
-  internal: true,
-  usage: "Usage: dld create-config <flat|namespaced> [namespace ...]\n\nCreate dld.config.yaml. Namespaced mode needs at least one namespace.\n",
-  run(args, io, ctx) {
-    const { positionals } = parseCommandArgs({
-      args: [...args],
-      options: {},
-      allowPositionals: true
-    });
-    const [mode, ...namespaces] = positionals;
-    if (mode === void 0) throw new UsageError("missing <flat|namespaced>");
-    const path = createConfig(ctx, findProjectRoot(ctx), parseMode(mode), namespaces);
-    io.stdout(`Created ${path}
-`);
-    return EXIT_OK;
+function shortHead(ctx, root) {
+  try {
+    return ctx.git(["-C", root, "rev-parse", "--short", "HEAD"]).trim();
+  } catch (error) {
+    if (error instanceof GitCommandError) return "unknown";
+    throw error;
   }
-};
+}
 
-// src/core/decisions.ts
-import { join as join9, relative as relative4 } from "node:path";
-function updateStatus(ctx, project, id, status) {
-  const path = findRecordFile(ctx, project.paths.recordsDir, id);
-  if (path === void 0) throw new DldError(`decision ${id} not found.`);
-  const text = ctx.fs.readFile(path);
-  writeFileAtomic(ctx, path, setStatus(text, status, relative4(project.paths.root, path)));
-  return path;
+// src/core/snapshot.ts
+var DECISION_BOUNDARY = "===DLD_DECISION_BOUNDARY===";
+var BUILT_IN_ARTIFACTS = ["SNAPSHOT.md", "OVERVIEW.md"];
+var isSnapshotted = (status) => status === "accepted" || status === "proposed";
+function readRecords(ctx, { paths }) {
+  return listRecordFiles(ctx, paths.recordsDir).map((path) => {
+    const text = ctx.fs.readFile(path);
+    const record = parseRecord(text, relative5(paths.root, path));
+    return { path, number: recordNumber(path), text, status: record.status };
+  }).sort((a, b) => a.number - b.number);
 }
-function createDecision(ctx, project, input) {
-  if (!DECISION_ID.test(input.id)) {
-    throw new DldError(`invalid decision ID '${input.id}'; expected DL-<digits>, e.g. DL-001.`);
+function collectActiveDecisions(ctx, project, { includeProposed = false } = {}) {
+  if (!ctx.fs.isDirectory(project.paths.recordsDir)) {
+    throw new DldError(`records directory not found at ${project.paths.recordsDir}`);
   }
-  const namespaced = project.config.mode === "namespaced" && input.namespace !== void 0;
-  if (namespaced && !isSafeDirName(input.namespace ?? "")) {
-    throw new DldError(`invalid namespace '${input.namespace}'.`);
+  const wanted = includeProposed ? isSnapshotted : (status) => status === "accepted";
+  return readRecords(ctx, project).filter((record) => wanted(record.status)).map((record) => record.text).join(`${DECISION_BOUNDARY}
+`);
+}
+function detectSnapshotChanges(ctx, project) {
+  const { paths } = project;
+  const state = readStateSection(ctx, paths, "snapshot");
+  if (state === void 0) return { mode: "full" };
+  if (BUILT_IN_ARTIFACTS.some((name) => !ctx.fs.exists(join7(paths.decisionsDir, name)))) {
+    return { mode: "full" };
   }
-  const dir = namespaced ? join9(project.paths.recordsDir, input.namespace ?? "") : project.paths.recordsDir;
-  ctx.fs.mkdir(dir);
-  const path = join9(dir, `${input.id}.md`);
-  const content = renderNewRecord({
-    id: input.id,
-    title: input.title,
-    timestamp: formatTimestamp(ctx.now()),
-    ...namespaced && input.namespace !== void 0 ? { namespace: input.namespace } : {},
-    tags: input.tags,
-    supersedes: input.supersedes,
-    amends: input.amends,
-    body: input.body
-  });
-  createFileExclusive(ctx, path, content, `${path} already exists.`);
-  return path;
+  const included = stateString(state, "decisions_included");
+  if (included === void 0 || !/^\d+$/.test(included)) return { mode: "full" };
+  const includedNumber = Number.parseInt(included, 10);
+  const proposedIncluded = stateString(state, "includes_proposed") === "true";
+  const newDecisions = readRecords(ctx, project).filter(
+    (record) => record.number > includedNumber && isSnapshotted(record.status) || !proposedIncluded && record.status === "proposed"
+  ).map((record) => formatId(record.number));
+  const git = gitAt(ctx, paths.root);
+  let stored = stateString(state, "commit_hash");
+  const lastRun = stateString(state, "last_run");
+  if ((stored === void 0 || stored === "unknown") && lastRun !== void 0) {
+    stored = gitOrEmpty(git, "log", `--until=${lastRun}`, "--format=%h", "-1").trim() || void 0;
+  }
+  const commit2 = resolveStateCommit(git, stored);
+  let modifiedDecisions = [];
+  let commitRange = "";
+  if (commit2 !== void 0 && commit2 !== shortHead(ctx, paths.root)) {
+    commitRange = `${commit2}..HEAD`;
+    const numbers = nulSeparated(
+      gitOrEmpty(git, "diff", "-z", "--name-only", commitRange, "--", recordsPathspec(paths))
+    ).map((path) => basename5(path)).filter((name) => RECORD_FILE.test(name)).map((name) => recordNumber(name)).filter((number) => number <= includedNumber);
+    modifiedDecisions = [...new Set(numbers)].sort((a, b) => a - b).map(formatId);
+  }
+  return { mode: "incremental", newDecisions, modifiedDecisions, commitRange };
+}
+function formatSnapshotChanges(changes) {
+  if (changes.mode === "full") return "mode: full\n";
+  return [
+    "mode: incremental",
+    `new_decisions: ${changes.newDecisions.join(", ")}`,
+    `modified_decisions: ${changes.modifiedDecisions.join(", ")}`,
+    `commit_range: ${changes.commitRange}`,
+    ""
+  ].join("\n");
 }
-function isSafeDirName(name) {
-  return name !== "." && name !== ".." && /^[A-Za-z0-9._-]+$/.test(name);
+function updateSnapshotState(ctx, project, customArtifacts) {
+  const { paths } = project;
+  const timestamp = formatTimestamp(ctx.now());
+  const commit2 = shortHead(ctx, paths.root);
+  const highest = readRecords(ctx, project).filter((record) => isSnapshotted(record.status)).reduce((max, record) => Math.max(max, record.number), 0);
+  const artifacts = /* @__PURE__ */ Object.create(null);
+  for (const name of [...BUILT_IN_ARTIFACTS, ...customArtifacts]) artifacts[name] = timestamp;
+  writeStateSection(ctx, paths, "snapshot", {
+    last_run: timestamp,
+    commit_hash: commit2,
+    decisions_included: String(highest),
+    includes_proposed: "true",
+    artifacts
+  });
+  return { timestamp, commit: commit2, highest };
 }
 
-// src/cli/commands/create-decision.ts
-var createDecisionCommand = {
-  name: "create-decision",
-  summary: "Create a proposed decision record",
+// src/cli/commands/collect-active-decisions.ts
+var collectActiveDecisionsCommand = {
+  name: "collect-active-decisions",
+  summary: "Print every accepted decision record",
   internal: true,
-  usage: `Usage: dld create-decision --id <DL-NNN> --title <title> [options]
+  usage: `Usage: dld collect-active-decisions [--include-proposed]
 
-Create a decision record with status proposed and print its path.
+Print each accepted record in ID order, separated by ===DLD_DECISION_BOUNDARY=== lines.
 
 Options:
-  --id <DL-NNN>            Decision ID (required)
-  --title <title>          Title (required)
-  --namespace <name>       Namespace directory (namespaced projects only)
-  --tags <a,b>             Comma-separated tags
-  --supersedes <DL-X,...>  Decisions this one supersedes
-  --amends <DL-X,...>      Decisions this one amends
-  --body-stdin             Read the markdown body from standard input
+  --include-proposed  Print proposed records too, in the same ID order
 `,
   run(args, io, ctx) {
     const { values } = parseCommandArgs({
       args: [...args],
-      options: {
-        id: { type: "string" },
-        title: { type: "string" },
-        namespace: { type: "string" },
-        tags: { type: "string" },
-        supersedes: { type: "string" },
-        amends: { type: "string" },
-        "body-stdin": { type: "boolean" }
-      }
-    });
-    const body = values["body-stdin"] === true ? ctx.readStdin() : "";
-    const { id, title } = values;
-    if (id === void 0 || id === "" || title === void 0 || title === "") {
-      throw new DldError("--id and --title are required.");
-    }
-    const namespace = values.namespace === "" ? void 0 : values.namespace;
-    const path = createDecision(ctx, loadProject(ctx), {
-      id,
-      title,
-      ...namespace === void 0 ? {} : { namespace },
-      tags: values.tags ?? "",
-      supersedes: values.supersedes ?? "",
-      amends: values.amends ?? "",
-      body
+      options: { "include-proposed": { type: "boolean" } }
     });
-    io.stdout(`${path}
-`);
+    io.stdout(
+      collectActiveDecisions(ctx, loadProject(ctx), {
+        includeProposed: values["include-proposed"] === true
+      })
+    );
     return EXIT_OK;
   }
 };
 
-// src/cli/commands/create-directories.ts
-var createDirectoriesCommand = {
-  name: "create-directories",
-  summary: "Create the decisions directory structure from the config",
-  internal: true,
-  usage: "Usage: dld create-directories\n\nCreate the decisions and records directories, and one per namespace.\n",
-  run(args, io, ctx) {
-    parseCommandArgs({ args: [...args], options: {} });
-    createDirectories(ctx, loadProject(ctx));
-    io.stdout("Created decisions directory structure.\n");
-    return EXIT_OK;
-  }
-};
+// src/core/commit-reindex.ts
+import { join as join8, posix as posix2 } from "node:path";
 
-// src/core/index-file.ts
-import { basename as basename5, join as join10, relative as relative5, sep as sep2 } from "node:path";
-var INDEX_FILE = "INDEX.md";
-function renderIndex(rows, mode) {
-  const namespaced = mode === "namespaced";
-  const lines = [
-    "# Decision Log",
-    "",
-    namespaced ? "| ID | Title | Status | Namespace | Tags |" : "| ID | Title | Status | Tags |",
-    namespaced ? "|----|-------|--------|-----------|------|" : "|----|-------|--------|------|"
-  ];
-  const sorted = [...rows].sort((a, b) => b.number - a.number);
-  for (const { record } of sorted) {
-    const cells = [record.id, record.title, record.status];
-    if (namespaced) cells.push(record.namespace ?? "");
-    cells.push(record.tags.join(", "));
-    lines.push(`| ${cells.join(" | ")} |`);
+// src/core/rename-plan.ts
+import { posix } from "node:path";
+function renameProblem(paths, rename) {
+  const { path, oldId, newId } = rename;
+  if (!DECISION_ID.test(oldId) || !DECISION_ID.test(newId)) return "IDs must match DL-[0-9]+.";
+  if (!isCanonicalId(newId)) {
+    const canonical = canonicalSpelling(newId);
+    return `new ID '${newId}' is not canonical${canonical === void 0 ? "" : `; use ${canonical}`}.`;
   }
-  return `${lines.join("\n")}
-`;
-}
-function indexPath(paths) {
-  return join10(paths.decisionsDir, INDEX_FILE);
-}
-function collectIndexRows(ctx, paths, includeBase) {
-  const localFiles = listRecordFiles(ctx, paths.recordsDir);
-  const rows = localFiles.map((path) => ({
-    number: recordNumber(path),
-    record: parseRecord(ctx.fs.readFile(path), relative5(paths.root, path))
-  }));
-  if (includeBase === void 0) return rows;
-  const git = (...args) => ctx.git(["-C", paths.root, ...args]);
-  try {
-    git("rev-parse", "--verify", "--quiet", `${includeBase}^{commit}`);
-  } catch (error) {
-    if (error instanceof GitCommandError) {
-      throw new DldError(`--include-base ref '${includeBase}' not found.`);
-    }
-    throw error;
+  if (oldId === newId) return "old and new IDs are the same.";
+  const segments = path.split("/");
+  if (path.startsWith("/") || segments.some((s) => s === "" || s === "." || s === "..")) {
+    return `path '${path}' must be relative to the project root, without '.' or '..' segments.`;
   }
-  const localNames = new Set(localFiles.map((path) => basename5(path)));
-  const recordsRel = relative5(paths.root, paths.recordsDir).split(sep2).join("/");
-  const basePaths = git("ls-tree", "-r", "--name-only", includeBase, "--", recordsRel).split("\n").filter((path) => RECORD_FILE.test(basename5(path)) && !localNames.has(basename5(path)));
-  for (const path of basePaths) {
-    rows.push({
-      number: recordNumber(path),
-      record: parseRecord(git("show", `${includeBase}:${path}`), `${includeBase}:${path}`)
-    });
+  const records = recordsPathspec(paths);
+  if (!path.startsWith(`${records}/`)) {
+    return `path '${path}' is not under ${records}/.`;
   }
-  return rows;
+  if (posix.basename(path) !== `${oldId}.md`) {
+    return `path '${path}' is not named ${oldId}.md.`;
+  }
+  return void 0;
 }
-function writeIndex(ctx, paths, content) {
-  writeFileAtomic(ctx, indexPath(paths), content);
+function parseRenamePlan(paths, text) {
+  const renames = [];
+  const lineNumbers = [];
+  const seen = { path: /* @__PURE__ */ new Set(), old: /* @__PURE__ */ new Set(), new: /* @__PURE__ */ new Set() };
+  text.split("\n").forEach((raw, index) => {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+    if (line.trim() === "") return;
+    const fail = (message) => new DldError(`rename plan line ${index + 1}: ${message}`, EXIT_USAGE);
+    const fields = line.split("	");
+    const [path, oldId, newId] = fields;
+    if (fields.length !== 3 || path === void 0 || oldId === void 0 || newId === void 0) {
+      throw fail("expected <path>\\t<DL-OLD>\\t<DL-NEW>.");
+    }
+    const rename = { path, oldId, newId };
+    const problem = renameProblem(paths, rename);
+    if (problem !== void 0) throw fail(problem);
+    if (seen.path.has(path)) throw fail(`path '${path}' appears more than once.`);
+    if (seen.old.has(oldId)) throw fail(`${oldId} is renamed more than once.`);
+    if (seen.new.has(newId)) throw fail(`${newId} is the target of more than one rename.`);
+    seen.path.add(path);
+    seen.old.add(oldId);
+    seen.new.add(newId);
+    renames.push(rename);
+    lineNumbers.push(index + 1);
+  });
+  renames.forEach(({ newId }, index) => {
+    if (seen.old.has(newId)) {
+      throw new DldError(
+        `rename plan line ${lineNumbers[index]}: ${newId} is both renamed and a rename target.`
+      );
+    }
+  });
+  return renames;
 }
 
-// src/cli/commands/create-empty-index.ts
-var createEmptyIndexCommand = {
-  name: "create-empty-index",
-  summary: "Write an INDEX.md with no decisions",
-  internal: true,
-  usage: "Usage: dld create-empty-index\n\nWrite INDEX.md in the decisions directory with only the table header.\n",
-  run(args, io, ctx) {
-    parseCommandArgs({ args: [...args], options: {} });
-    const { config, paths } = loadProject(ctx);
-    writeIndex(ctx, paths, renderIndex([], config.mode));
-    io.stdout(`Created ${indexPath(paths)}
-`);
-    return EXIT_OK;
-  }
-};
+// src/core/commit-reindex.ts
+var SUBJECT_LIST_LIMIT = 3;
+function reindexMessage(renames, originalSubjects = "") {
+  const pairs = renames.map(({ oldId, newId }) => `${oldId} -> ${newId}`);
+  const subject = renames.length > SUBJECT_LIST_LIMIT ? `reindex ${renames.length} local decisions to avoid base-branch collisions` : `reindex local decisions: ${pairs.join(", ")}`;
+  const message = `${subject}
 
-// src/cli/commands/detect-snapshot-changes.ts
-var detectSnapshotChangesCommand = {
-  name: "detect-snapshot-changes",
-  summary: "Report what changed since the last snapshot",
-  internal: true,
-  usage: "Usage: dld detect-snapshot-changes\n\nPrint mode (full or incremental), new_decisions, modified_decisions and commit_range.\n",
-  run(args, io, ctx) {
-    parseCommandArgs({ args: [...args], options: {} });
-    io.stdout(formatSnapshotChanges(detectSnapshotChanges(ctx, loadProject(ctx))));
-    return EXIT_OK;
-  }
-};
+Renames:
+${pairs.map((pair) => `- ${pair}`).join("\n")}`;
+  return originalSubjects === "" ? message : `${message}
 
-// src/core/annotations.ts
-import { join as join11, relative as relative6, sep as sep3 } from "node:path";
-var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
-  ".git",
-  // Agent configuration directories, which hold installed skills.
-  ".claude",
-  ".agents",
-  ".agent",
-  ".codex",
-  ".cursor",
-  ".opencode",
-  ".pi",
-  ".tessl",
-  "node_modules",
-  "vendor",
-  ".venv",
-  "__pycache__",
-  "target",
-  "dist",
-  "build",
-  "out",
-  ".next",
-  ".gradle",
-  "coverage"
-]);
-var EXCLUDED_FILE = /(\.lock|\.min\.js|\.min\.css|\.map)$/;
-var BINARY_SNIFF_BYTES = 8192;
-function scanOptionsFor({ config, paths }) {
+Squashed from original branch commits:
+${originalSubjects}`;
+}
+function commitReindex(ctx, { paths }, planText, base, { squash = false } = {}) {
+  verifyBase(ctx, paths, base);
+  const renames = parseRenamePlan(paths, planText);
+  if (renames.length === 0) throw new DldError("no rename plan on stdin.");
+  for (const { oldId, newId, path } of renames) {
+    const renamed = posix2.join(posix2.dirname(path), `${newId}.md`);
+    if (!ctx.fs.isRegularFile(join8(paths.root, renamed))) {
+      throw new DldError(`${renamed} not found. Run rename-decision for ${oldId} first.`);
+    }
+  }
+  const git = gitAt(ctx, paths.root);
+  return squash ? squashReindex(ctx, git, paths, renames, base) : commitOnTop(ctx, git, paths, renames);
+}
+function commitOnTop(ctx, git, paths, renames) {
+  const stage = /* @__PURE__ */ new Set();
+  for (const { path, newId } of renames) {
+    stage.add(path);
+    stage.add(posix2.join(posix2.dirname(path), `${newId}.md`));
+  }
+  for (const file of nulSeparated(git("diff", "-z", "--no-renames", "--name-only", "HEAD"))) {
+    stage.add(file);
+  }
+  const head = git("rev-parse", "HEAD").trim();
+  const tree = git("write-tree").trim();
+  let stepName = "staging";
+  try {
+    for (const path of [...stage].sort()) {
+      stepName = `staging ${path}`;
+      stagePath(ctx, git, join8(paths.root, path), path);
+    }
+    stepName = "checking the staged changes";
+    if (!hasStagedChanges(git)) {
+      throw new DldError(
+        "nothing to commit. The reindex may have already been committed, or the plan didn't match the working tree."
+      );
+    }
+    stepName = "committing";
+    commit(git, reindexMessage(renames));
+  } catch (error) {
+    try {
+      git("read-tree", tree);
+    } catch (restoreError) {
+      throw new DldError(
+        `commit-reindex failed while ${stepName}: ${describe(error)}
+Restoring the index also failed: ${describe(restoreError)}
+To restore by hand: git read-tree ${tree}`
+      );
+    }
+    if (!(error instanceof DldError)) throw error;
+    throw new DldError(
+      `commit-reindex failed while ${stepName}: ${error.message}
+The index was restored.`,
+      error.exitCode
+    );
+  }
   return {
-    root: paths.root,
-    decisionsDir: paths.decisionsDir,
-    prefix: config.annotationPrefix,
-    exclude: config.annotationExclude
+    commit: git("rev-parse", "--short", "HEAD").trim(),
+    onto: git("rev-parse", "--short", head).trim()
   };
 }
-function listScannableFiles(ctx, options) {
-  const output = ctx.git([
-    "-C",
-    options.root,
-    "ls-files",
-    "-z",
-    "--cached",
-    "--others",
-    "--exclude-standard",
-    // @decision(DL-023)
-    "--",
-    ...(options.exclude ?? []).map((pattern) => `:(exclude,glob)${pattern}`)
-  ]);
-  const decisionsRel = relative6(options.root, options.decisionsDir).split(sep3).join("/");
-  const files = /* @__PURE__ */ new Set();
-  for (const file of output.split("\0")) {
-    if (file === "" || EXCLUDED_FILE.test(file)) continue;
-    if (file === decisionsRel || file.startsWith(`${decisionsRel}/`)) continue;
-    const dirs = file.split("/").slice(0, -1);
-    if (dirs.some((dir) => EXCLUDED_DIRS.has(dir))) continue;
-    files.add(file);
+function commit(git, message) {
+  try {
+    git("commit", "--quiet", "-m", message);
+  } catch (error) {
+    if (error instanceof GitCommandError) throw new DldError(`git commit failed: ${error.stderr}`);
+    throw error;
   }
-  return [...files].sort();
 }
-function escapeRegExp(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function scanAnnotations(ctx, options) {
-  const pattern = new RegExp(`${escapeRegExp(options.prefix)}\\((DL-\\d+)\\)`, "g");
-  const found = [];
-  for (const file of listScannableFiles(ctx, options)) {
-    const path = join11(options.root, file);
-    if (!ctx.fs.isRegularFile(path)) continue;
-    const text = ctx.fs.readFile(path);
-    if (text.slice(0, BINARY_SNIFF_BYTES).includes("\0")) continue;
-    text.split("\n").forEach((content, index) => {
-      for (const match of content.matchAll(pattern)) {
-        if (match[1] !== void 0) found.push({ file, line: index + 1, id: match[1] });
+function squashReindex(ctx, git, paths, renames, base) {
+  const onto = mergeBase(ctx, paths, base);
+  const head = git("rev-parse", "HEAD").trim();
+  if (onto === head) throw new DldError("HEAD is already at the merge-base \u2014 nothing to squash.");
+  const indexRel = posix2.join(decisionsPathspec(paths), "INDEX.md");
+  const branchFiles = nulSeparated(
+    git("diff", "-z", "--no-renames", "--name-only", "--diff-filter=AMRD", `${onto}..HEAD`)
+  );
+  const stage = /* @__PURE__ */ new Set();
+  for (const { path, newId } of renames) {
+    stage.add(path);
+    stage.add(posix2.join(posix2.dirname(path), `${newId}.md`));
+  }
+  for (const file of branchFiles) if (file !== indexRel) stage.add(file);
+  const subjects = git("log", "--reverse", "--format=- %s", `${onto}..HEAD`).replace(/\n+$/, "");
+  const message = reindexMessage(renames, subjects);
+  const indexFull = join8(paths.root, indexRel);
+  if (ctx.fs.lexists(indexFull) && !ctx.fs.isRegularFile(indexFull)) {
+    throw new DldError(`${indexRel} is not a regular file.`);
+  }
+  const saved = {
+    head,
+    tree: git("write-tree").trim(),
+    index: ctx.fs.isRegularFile(indexFull) ? { bytes: ctx.fs.readBytes(indexFull), mode: ctx.fs.fileMode(indexFull) } : void 0
+  };
+  let stepName = "resetting to the merge-base";
+  const step = (name, run2) => {
+    stepName = name;
+    return run2();
+  };
+  try {
+    step("resetting to the merge-base", () => git("reset", "--quiet", onto));
+    step(`restoring ${indexRel}`, () => {
+      if (existsAtHead(git, indexRel)) {
+        git("--literal-pathspecs", "checkout", "HEAD", "--", indexRel);
+      } else {
+        ctx.fs.remove(indexFull);
+      }
+    });
+    for (const path of [...stage].sort()) {
+      step(`staging ${path}`, () => stagePath(ctx, git, join8(paths.root, path), path));
+    }
+    step("checking the staged changes", () => {
+      if (!hasStagedChanges(git)) {
+        throw new DldError(
+          "nothing to commit after squash. The reindex may have already been applied, or the plan didn't match the branch state."
+        );
       }
     });
+    step("committing", () => commit(git, message));
+  } catch (error) {
+    throw rollback(ctx, git, indexFull, saved, stepName, error);
   }
-  return found;
+  return {
+    commit: git("rev-parse", "--short", "HEAD").trim(),
+    onto: git("rev-parse", "--short", onto).trim()
+  };
 }
-function missingAnnotations(ctx, options, ids) {
-  const annotated = new Set(scanAnnotations(ctx, options).map((annotation) => annotation.id));
-  return ids.filter((id) => !annotated.has(id));
+function existsAtHead(git, path) {
+  return git("--literal-pathspecs", "ls-tree", "-z", "HEAD", "--", path) !== "";
 }
-function formatAnnotation({ file, line, id }) {
-  return `${file}:${line}:${id}`;
+function stagePath(ctx, git, full, path) {
+  const known = ctx.fs.lexists(full) || git("--literal-pathspecs", "ls-files", "-z", "--", path) !== "";
+  if (known) git("--literal-pathspecs", "add", "-A", "--", path);
 }
-
-// src/cli/commands/find-annotations.ts
-var findAnnotationsCommand = {
-  name: "find-annotations",
-  summary: "List every annotation in the codebase",
-  internal: true,
-  usage: "Usage: dld find-annotations\n\nPrint <file>:<line>:<DL-NNN> for every annotation, one per line.\n",
-  run(args, io, ctx) {
-    parseCommandArgs({ args: [...args], options: {} });
-    for (const annotation of scanAnnotations(ctx, scanOptionsFor(loadProject(ctx)))) {
-      io.stdout(`${formatAnnotation(annotation)}
-`);
-    }
-    return EXIT_OK;
+function hasStagedChanges(git) {
+  try {
+    git("diff", "--cached", "--quiet");
+    return false;
+  } catch (error) {
+    if (error instanceof GitCommandError && error.status === 1) return true;
+    throw error;
   }
-};
+}
+function rollback(ctx, git, indexFull, saved, stepName, cause) {
+  try {
+    git("reset", "--quiet", "--soft", saved.head);
+    git("read-tree", saved.tree);
+    if (saved.index === void 0) ctx.fs.remove(indexFull);
+    else writeFileAtomic(ctx, indexFull, saved.index.bytes, saved.index.mode);
+  } catch (rollbackError) {
+    return new DldError(
+      `commit-reindex failed while ${stepName}: ${describe(cause)}
+Rolling back also failed: ${describe(rollbackError)}
+To restore by hand: git reset --soft ${saved.head} && git read-tree ${saved.tree}`
+    );
+  }
+  if (!(cause instanceof DldError)) return cause;
+  return new DldError(
+    `commit-reindex failed while ${stepName}: ${cause.message}
+The branch was restored to ${saved.head}.`,
+    cause.exitCode
+  );
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
-// src/cli/commands/find-collisions.ts
-var findCollisionsCommand = {
-  name: "find-collisions",
-  summary: "List locally added decisions whose IDs are taken",
+// src/cli/commands/commit-reindex.ts
+var commitReindexCommand = {
+  name: "commit-reindex",
+  summary: "Commit the renamed decisions",
   internal: true,
-  usage: `Usage: dld find-collisions [--base <ref>]
+  usage: `Usage: dld commit-reindex --base <ref> [--squash] < plan
 
-Print <path>\\t<DL-NNN> for each decision added on this branch whose ID is taken on the base
-branch or in an open pull request.
+Read a rename plan on standard input and commit the renames, which rename-decision has
+already applied. By default this adds one commit on top of HEAD with the plan's paths and
+every tracked file changed since HEAD; untracked files are left out. On failure the index is
+restored.
+
+With --squash, the branch's commits since the merge-base with <ref> are squashed into one
+reindex commit instead, and INDEX.md is left at its merge-base state. On failure the branch,
+index and INDEX.md are restored.
 
 Options:
-  --base <ref>  Base ref (default: origin/main)
+  --base <ref>  Base ref (required)
+  --squash      Squash the branch instead of adding a commit
 `,
   run(args, io, ctx) {
-    const { values } = parseCommandArgs({ args: [...args], options: { base: { type: "string" } } });
+    const { values } = parseCommandArgs({
+      args: [...args],
+      options: { base: { type: "string" }, squash: { type: "boolean" } }
+    });
     const base = baseOption(values.base);
-    const { collisions, skipped } = findCollisions(ctx, loadProject(ctx), base);
-    for (const { path, id } of collisions) io.stdout(`${path}	${id}
+    const project = loadProject(ctx);
+    const { commit: commit2, onto } = commitReindex(ctx, project, ctx.readStdin(), base, {
+      squash: values.squash === true
+    });
+    io.stdout(`Created reindex commit ${commit2} on top of ${onto}
 `);
-    if (skipped !== void 0) io.stderr(skippedNotice(skipped));
     return EXIT_OK;
   }
 };
 
-// src/core/audit.ts
-import { basename as basename6, relative as relative7, sep as sep4 } from "node:path";
-var MENTION = /DL-\d+/g;
-var toPosix = (path) => path.split(sep4).join("/");
-var idNumber2 = (id) => Number.parseInt(id.slice(3), 10);
-function recordsChangedSinceAudit(ctx, { paths }) {
-  const git = gitAt(ctx, paths.root);
-  const stored = stateString(readStateSection(ctx, paths, "audit"), "commit_hash");
-  const commit = resolveStateCommit(git, stored);
-  if (commit === void 0) return void 0;
-  const records = recordsPathspec(paths);
-  return /* @__PURE__ */ new Set([
-    ...nulSeparated(git("diff", "-z", "--name-only", commit, "--", records)),
-    ...nulSeparated(git("ls-files", "-z", "--others", "--exclude-standard", "--", records))
-  ]);
-}
-function findMissingAmends(ctx, project, { all }) {
-  const { paths } = project;
-  const changed = all ? void 0 : recordsChangedSinceAudit(ctx, project);
-  const found = [];
-  const files = listRecordFiles(ctx, paths.recordsDir).sort(
-    (a, b) => recordNumber(a) - recordNumber(b)
-  );
-  for (const file of files) {
-    const rel = toPosix(relative7(paths.root, file));
-    if (changed !== void 0 && !changed.has(rel)) continue;
-    const text = ctx.fs.readFile(file);
-    const record = parseRecord(text, rel);
-    const source = basename6(file, ".md");
-    const declared = /* @__PURE__ */ new Set([...record.supersedes, ...record.amends]);
-    const mentioned = new Set(recordBody(text).match(MENTION) ?? []);
-    const refs = [...mentioned].filter((id) => id !== source && !declared.has(id)).sort((a, b) => idNumber2(a) - idNumber2(b));
-    for (const referenced of refs) found.push({ source, referenced });
+// src/core/init.ts
+import { join as join9 } from "node:path";
+function parseMode(value) {
+  if (value !== "flat" && value !== "namespaced") {
+    throw new DldError(`mode must be 'flat' or 'namespaced', got '${value}'.`);
   }
-  return found;
+  return value;
 }
-function updateAuditState(ctx, { paths }) {
-  const timestamp = formatTimestamp(ctx.now());
-  const commit = shortHead(ctx, paths.root);
-  writeStateSection(ctx, paths, "audit", { last_run: timestamp, commit_hash: commit });
-  return { timestamp, commit };
+function renderConfig(mode, namespaces) {
+  const lines = ["decisions_dir: decisions", `mode: ${mode}`];
+  if (mode === "namespaced") lines.push("namespaces:", ...namespaces.map((ns) => `  - ${ns}`));
+  lines.push("annotation_prefix: '@decision'");
+  return `${lines.join("\n")}
+`;
+}
+function createConfig(ctx, root, mode, namespaces) {
+  if (mode === "namespaced" && namespaces.length === 0) {
+    throw new DldError("namespaced mode requires at least one namespace.");
+  }
+  const path = join9(root, CONFIG_FILE);
+  createFileExclusive(ctx, path, renderConfig(mode, namespaces), `${CONFIG_FILE} already exists.`);
+  return path;
+}
+function createDirectories(ctx, { config, paths }) {
+  ctx.fs.mkdir(paths.decisionsDir);
+  ctx.fs.mkdir(paths.recordsDir);
+  if (config.mode !== "namespaced") return;
+  for (const namespace of config.namespaces) {
+    const dir = join9(paths.recordsDir, namespace);
+    ctx.fs.mkdir(dir);
+    const keep = join9(dir, ".gitkeep");
+    if (!ctx.fs.exists(keep)) createFileExclusive(ctx, keep, "", `${keep} already exists.`);
+  }
 }
 
-// src/cli/commands/find-missing-amends.ts
-var findMissingAmendsCommand = {
-  name: "find-missing-amends",
-  summary: "List decision IDs mentioned in a body but not declared",
+// src/cli/commands/create-config.ts
+var createConfigCommand = {
+  name: "create-config",
+  summary: "Create dld.config.yaml at the project root",
   internal: true,
-  usage: `Usage: dld find-missing-amends [--all]
-
-Print <source-id>:<referenced-id> for each decision ID a record's body mentions without
-listing it in supersedes or amends. Only records changed since the last audit are checked.
-
-Options:
-  --all  Check every record
-`,
+  usage: "Usage: dld create-config <flat|namespaced> [namespace ...]\n\nCreate dld.config.yaml. Namespaced mode needs at least one namespace.\n",
   run(args, io, ctx) {
-    const { values } = parseCommandArgs({ args: [...args], options: { all: { type: "boolean" } } });
-    const found = findMissingAmends(ctx, loadProject(ctx), { all: values.all === true });
-    for (const { source, referenced } of found) io.stdout(`${source}:${referenced}
+    const { positionals } = parseCommandArgs({
+      args: [...args],
+      options: {},
+      allowPositionals: true
+    });
+    const [mode, ...namespaces] = positionals;
+    if (mode === void 0) throw new UsageError("missing <flat|namespaced>");
+    const path = createConfig(ctx, findProjectRoot(ctx), parseMode(mode), namespaces);
+    io.stdout(`Created ${path}
 `);
     return EXIT_OK;
   }
 };
 
-// src/core/rename.ts
-import { Buffer as Buffer2 } from "node:buffer";
-import { join as join12, posix as posix3 } from "node:path";
-var idPattern = (id, flags = "") => new RegExp(`${id}(?![0-9])`, flags);
-function changedFiles(ctx, paths, commit) {
-  return nulSeparated(
-    gitAt(ctx, paths.root)(
-      "diff",
-      "-z",
-      "--find-renames",
-      "--name-only",
-      "--diff-filter=AMR",
-      commit
-    )
-  );
-}
-function rewriteFile(ctx, path, edit) {
-  if (!ctx.fs.isRegularFile(path)) return;
-  const bytes = ctx.fs.readBytes(path);
-  if (bytes.subarray(0, BINARY_SNIFF_BYTES).includes(0)) return;
-  const text = Buffer2.from(bytes).toString("latin1");
-  const edited = edit(text);
-  if (edited === text) return;
-  writeFileAtomic(ctx, path, Buffer2.from(edited, "latin1"), ctx.fs.fileMode(path));
+// src/core/decisions.ts
+import { join as join10, relative as relative6 } from "node:path";
+function updateStatus(ctx, project, id, status) {
+  const path = findRecordFile(ctx, project.paths.recordsDir, id, project.paths.root);
+  if (path === void 0) throw new DldError(`decision ${id} not found.`);
+  const text = ctx.fs.readFile(path);
+  writeFileAtomic(ctx, path, setStatus(text, status, relative6(project.paths.root, path)));
+  return path;
 }
-function renameDecision(ctx, project, rename, base) {
-  const { paths, config } = project;
-  const { path, oldId, newId } = rename;
-  const problem = renameProblem(paths, rename);
-  if (problem !== void 0) throw new DldError(problem);
-  const full = join12(paths.root, path);
-  if (!ctx.fs.isRegularFile(full)) throw new DldError(`${path} not found.`);
-  const record = parseRecord(ctx.fs.readFile(full), path);
-  if (record.id !== oldId) throw new DldError(`${path} has id ${record.id}, not ${oldId}.`);
-  const newPath = posix3.join(posix3.dirname(path), `${newId}.md`);
-  const newFull = join12(paths.root, newPath);
-  if (ctx.fs.lexists(newFull)) throw new DldError(`${newPath} already exists.`);
-  verifyBase(ctx, paths, base);
-  const since = mergeBase(ctx, paths, base);
-  const scannable = new Set(listScannableFiles(ctx, scanOptionsFor(project)));
-  gitAt(ctx, paths.root)("mv", "--", path, newPath);
-  const substitute = (text) => text.replace(idPattern(oldId, "g"), newId);
-  rewriteFile(ctx, newFull, (text) => substitute(setId(text, oldId, newId)));
-  const decisions = `${decisionsPathspec(paths)}/`;
-  const prefix = Buffer2.from(config.annotationPrefix, "utf8").toString("latin1");
-  const oldAnnotation = `${prefix}(${oldId})`;
-  const newAnnotation = `${prefix}(${newId})`;
-  for (const file of changedFiles(ctx, paths, since)) {
-    if (file === newPath) continue;
-    if (file.startsWith(decisions)) {
-      rewriteFile(ctx, join12(paths.root, file), substitute);
-    } else if (scannable.has(file)) {
-      rewriteFile(
-        ctx,
-        join12(paths.root, file),
-        (text) => text.split(oldAnnotation).join(newAnnotation)
+function createDecision(ctx, project, input) {
+  if (!isCanonicalId(input.id)) {
+    const canonical = canonicalSpelling(input.id);
+    throw new DldError(
+      canonical === void 0 ? `invalid decision ID '${input.id}'; expected DL-<digits>, e.g. DL-001.` : `decision ID '${input.id}' is not canonical; use ${canonical}.`,
+      EXIT_USAGE
+    );
+  }
+  const number = Number.parseInt(input.id.slice(3), 10);
+  const { config } = project;
+  if (input.namespace !== void 0) {
+    if (config.mode !== "namespaced") {
+      throw new DldError("--namespace is only valid in a namespaced project.", EXIT_USAGE);
+    }
+    if (!config.namespaces.includes(input.namespace)) {
+      throw new DldError(
+        `unknown namespace '${input.namespace}'; configured namespaces: ${config.namespaces.join(", ")}.`,
+        EXIT_USAGE
       );
     }
   }
-  return newPath;
-}
-function findStaleMentions(ctx, { paths }, planText, base) {
-  const renames = parseRenamePlan(paths, planText);
-  if (renames.length === 0) return [];
-  verifyBase(ctx, paths, base);
-  const decisions = `${decisionsPathspec(paths)}/`;
-  const files = changedFiles(ctx, paths, mergeBase(ctx, paths, base)).flatMap((file) => {
-    if (file.startsWith(decisions)) return [];
-    const full = join12(paths.root, file);
-    if (!ctx.fs.isRegularFile(full)) return [];
-    const text = ctx.fs.readFile(full);
-    if (text.slice(0, BINARY_SNIFF_BYTES).includes("\0")) return [];
-    return [{ file, lines: text.split("\n").map((line) => line.replace(/\r$/, "")) }];
-  });
-  const found = [];
-  for (const { oldId, newId } of renames) {
-    const pattern = idPattern(oldId);
-    for (const { file, lines } of files) {
-      lines.forEach((text, index) => {
-        if (pattern.test(text)) found.push({ file, line: index + 1, oldId, newId, text });
-      });
-    }
+  const existing = listRecordFiles(ctx, project.paths.recordsDir).find(
+    (path2) => recordNumber(path2) === number
+  );
+  if (existing !== void 0) {
+    throw new DldError(
+      `decision ${input.id} already exists: ${relative6(project.paths.root, existing)}`
+    );
   }
-  return found;
-}
-function formatStaleMention({ file, line, oldId, newId, text }) {
-  return `${file}	${line}	${oldId}	${newId}	${text}`;
+  const namespaced = input.namespace !== void 0;
+  const dir = namespaced ? join10(project.paths.recordsDir, input.namespace ?? "") : project.paths.recordsDir;
+  ctx.fs.mkdir(dir);
+  const path = join10(dir, `${input.id}.md`);
+  const content = renderNewRecord({
+    id: input.id,
+    title: input.title,
+    timestamp: formatTimestamp(ctx.now()),
+    ...namespaced && input.namespace !== void 0 ? { namespace: input.namespace } : {},
+    tags: input.tags,
+    supersedes: input.supersedes,
+    amends: input.amends,
+    body: input.body
+  });
+  createFileExclusive(ctx, path, content, `${path} already exists.`);
+  return path;
 }
 
-// src/cli/commands/find-stale-mentions.ts
-var findStaleMentionsCommand = {
-  name: "find-stale-mentions",
-  summary: "List remaining mentions of renamed decision IDs",
+// src/cli/commands/create-decision.ts
+var createDecisionCommand = {
+  name: "create-decision",
+  summary: "Create a proposed decision record",
   internal: true,
-  usage: `Usage: dld find-stale-mentions --base <ref> < plan
+  usage: `Usage: dld create-decision --id <DL-NNN> --title <title> [options]
 
-Read a rename plan (<path>\\t<DL-OLD>\\t<DL-NEW> per line) on standard input and print
-<path>\\t<line>\\t<DL-OLD>\\t<DL-NEW>\\t<text> for each remaining DL-OLD mention in changed
-files outside the decisions directory.
+Create a decision record with status proposed and print its path.
 
 Options:
-  --base <ref>  Base ref for the local change set (required)
+  --id <DL-NNN>            Decision ID (required)
+  --title <title>          Title (required)
+  --namespace <name>       Namespace directory (namespaced projects only)
+  --tags <a,b>             Comma-separated tags
+  --supersedes <DL-X,...>  Decisions this one supersedes
+  --amends <DL-X,...>      Decisions this one amends
+  --body-stdin             Read the markdown body from standard input
 `,
   run(args, io, ctx) {
-    const { values } = parseCommandArgs({ args: [...args], options: { base: { type: "string" } } });
-    if (!values.base) throw new DldError("--base is required.");
-    const base = baseOption(values.base);
-    const project = loadProject(ctx);
-    for (const mention of findStaleMentions(ctx, project, ctx.readStdin(), base)) {
-      io.stdout(`${formatStaleMention(mention)}
-`);
+    const { values } = parseCommandArgs({
+      args: [...args],
+      options: {
+        id: { type: "string" },
+        title: { type: "string" },
+        namespace: { type: "string" },
+        tags: { type: "string" },
+        supersedes: { type: "string" },
+        amends: { type: "string" },
+        "body-stdin": { type: "boolean" }
+      }
+    });
+    const body = values["body-stdin"] === true ? ctx.readStdin() : "";
+    const { id, title } = values;
+    if (id === void 0 || id === "" || title === void 0 || title === "") {
+      throw new UsageError("--id and --title are required.");
     }
+    const namespace = values.namespace === "" ? void 0 : values.namespace;
+    const path = createDecision(ctx, loadProject(ctx), {
+      id,
+      title,
+      ...namespace === void 0 ? {} : { namespace },
+      tags: values.tags ?? "",
+      supersedes: values.supersedes ?? "",
+      amends: values.amends ?? "",
+      body
+    });
+    io.stdout(`${path}
+`);
     return EXIT_OK;
   }
 };
 
-// src/cli/commands/init.ts
-import { join as join17, relative as relative8 } from "node:path";
-
-// src/generate/harnesses.ts
-import { join as join13 } from "node:path";
+// src/cli/commands/create-directories.ts
+var createDirectoriesCommand = {
+  name: "create-directories",
+  summary: "Create the decisions directory structure from the config",
+  internal: true,
+  usage: "Usage: dld create-directories\n\nCreate the decisions and records directories, and one per namespace.\n",
+  run(args, io, ctx) {
+    parseCommandArgs({ args: [...args], options: {} });
+    createDirectories(ctx, loadProject(ctx));
+    io.stdout("Created decisions directory structure.\n");
+    return EXIT_OK;
+  }
+};
 
-// src/generate/template.ts
-var import_yaml4 = __toESM(require_dist(), 1);
-var TEMPLATE_FIELDS = ["name", "description", "compatibility", "internal"];
-function parseTemplate(text, skill, source) {
-  const fail = (line, message) => new DldError(`${source}:${line}: ${message}`);
-  if (text.includes("\r")) throw fail(1, "must use LF line endings, not CRLF");
-  const lines = text.split("\n");
-  if (lines[0] !== "---") throw fail(1, "must start with a --- frontmatter line");
-  const end = lines.indexOf("---", 1);
-  if (end === -1) throw fail(1, "frontmatter has no closing --- line");
-  const doc = (0, import_yaml4.parseDocument)(lines.slice(1, end).join("\n"), { logLevel: "silent" });
-  const problem = doc.errors[0];
-  if (problem !== void 0) {
+// src/core/index-file.ts
+import { basename as basename6, join as join11, relative as relative7, sep as sep3 } from "node:path";
+var INDEX_FILE = "INDEX.md";
+function renderIndex(rows, mode) {
+  const namespaced = mode === "namespaced";
+  const lines = [
+    "# Decision Log",
+    "",
+    namespaced ? "| ID | Title | Status | Namespace | Tags |" : "| ID | Title | Status | Tags |",
+    namespaced ? "|----|-------|--------|-----------|------|" : "|----|-------|--------|------|"
+  ];
+  const sorted = [...rows].sort((a, b) => b.number - a.number);
+  for (const { record } of sorted) {
+    const cells = [record.id, record.title, record.status];
+    if (namespaced) cells.push(record.namespace ?? "");
+    cells.push(record.tags.join(", "));
+    lines.push(`| ${cells.join(" | ")} |`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function indexPath(paths) {
+  return join11(paths.decisionsDir, INDEX_FILE);
+}
+function collectIndexRows(ctx, paths, includeBase) {
+  const localFiles = listRecordFiles(ctx, paths.recordsDir);
+  const rows = localFiles.map((path) => ({
+    number: recordNumber(path),
+    record: parseRecord(ctx.fs.readFile(path), relative7(paths.root, path))
+  }));
+  if (includeBase === void 0) return rows;
+  const git = (...args) => ctx.git(["-C", paths.root, ...args]);
+  try {
+    git("rev-parse", "--verify", "--quiet", `${includeBase}^{commit}`);
+  } catch (error) {
+    if (error instanceof GitCommandError) {
+      throw new DldError(`--include-base ref '${includeBase}' not found.`);
+    }
+    throw error;
+  }
+  const localNames = new Set(localFiles.map((path) => basename6(path)));
+  const recordsRel = relative7(paths.root, paths.recordsDir).split(sep3).join("/");
+  const basePaths = git("ls-tree", "-r", "--name-only", includeBase, "--", recordsRel).split("\n").filter((path) => RECORD_FILE.test(basename6(path)) && !localNames.has(basename6(path)));
+  for (const path of basePaths) {
+    rows.push({
+      number: recordNumber(path),
+      record: parseRecord(git("show", `${includeBase}:${path}`), `${includeBase}:${path}`)
+    });
+  }
+  return rows;
+}
+function writeIndex(ctx, paths, content) {
+  writeFileAtomic(ctx, indexPath(paths), content);
+}
+
+// src/cli/install.ts
+import { relative as relative8, sep as sep4 } from "node:path";
+
+// src/generate/gitattributes.ts
+import { join as join12 } from "node:path";
+var GITATTRIBUTES = ".gitattributes";
+var INDEX_MERGE_COMMENT = "# dld-kit: keep both sides' rows when merging the decision index";
+var MERGE_ATTRIBUTE = /^([-!]?merge(=|$)|binary$)/;
+var SPECIAL = /[\s"\\*?[\]]|^[!#]|(^|\/)\.\.(\/|$)/;
+function unquote(pattern) {
+  return pattern.length > 1 && pattern.startsWith('"') && pattern.endsWith('"') ? pattern.slice(1, -1).replace(/\\(.)/g, "$1") : pattern;
+}
+function planIndexMergeAttribute(ctx, root, index) {
+  const path = join12(root, GITATTRIBUTES);
+  const wanted = `/${index} merge=union`;
+  if (SPECIAL.test(index)) {
+    return {
+      warnings: [
+        `the decision index ${index} cannot be named in ${GITATTRIBUTES} as a plain pattern, so dld-kit does not add its merge=union line. Add a line that matches it yourself, or two branches that add decisions will conflict on it.`
+      ]
+    };
+  }
+  if (ctx.fs.lexists(path) && !ctx.fs.isRegularFile(path)) {
+    return {
+      warnings: [
+        `${GITATTRIBUTES} is not a regular file, so dld-kit does not edit it. Add this line to it yourself: ${wanted}`
+      ]
+    };
+  }
+  const text = ctx.fs.lexists(path) ? ctx.fs.readFile(path) : "";
+  const lines = text.split(/\r?\n/);
+  const warnings = [];
+  let set = false;
+  lines.forEach((line, index_) => {
+    const [raw, ...attributes] = line.trim().split(/\s+/);
+    if (raw === void 0 || raw === "" || raw.startsWith("#")) return;
+    const pattern = unquote(raw);
+    const forIndex = pattern === `/${index}` || pattern === index;
+    if (forIndex && attributes.some((attribute) => MERGE_ATTRIBUTE.test(attribute))) set = true;
+    if (!forIndex && lines[index_ - 1] === INDEX_MERGE_COMMENT) {
+      warnings.push(
+        `${GITATTRIBUTES} still sets a merge driver for ${pattern}, an earlier decisions directory. Remove that line if the index is no longer there.`
+      );
+    }
+  });
+  if (set) return { warnings };
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const separator = text === "" ? "" : text.endsWith("\n") ? eol : eol + eol;
+  return {
+    content: `${text}${separator}${INDEX_MERGE_COMMENT}${eol}${wanted}${eol}`,
+    creates: !ctx.fs.lexists(path),
+    warnings
+  };
+}
+function applyIndexMergeAttribute(ctx, root, plan) {
+  if (plan.content === void 0) return false;
+  writeFileAtomic(ctx, join12(root, GITATTRIBUTES), plan.content);
+  return true;
+}
+
+// src/generate/harnesses.ts
+import { join as join13 } from "node:path";
+
+// src/generate/template.ts
+var import_yaml4 = __toESM(require_dist(), 1);
+var TEMPLATE_FIELDS = ["name", "description", "compatibility", "internal"];
+function parseTemplate(text, skill, source) {
+  const fail = (line, message) => new DldError(`${source}:${line}: ${message}`);
+  if (text.includes("\r")) throw fail(1, "must use LF line endings, not CRLF");
+  const lines = text.split("\n");
+  if (lines[0] !== "---") throw fail(1, "must start with a --- frontmatter line");
+  const end = lines.indexOf("---", 1);
+  if (end === -1) throw fail(1, "frontmatter has no closing --- line");
+  const doc = (0, import_yaml4.parseDocument)(lines.slice(1, end).join("\n"), { logLevel: "silent" });
+  const problem = doc.errors[0];
+  if (problem !== void 0) {
     const line = 1 + (problem.linePos?.[0].line ?? 1);
     throw fail(line, `frontmatter is not valid YAML: ${problem.message.split("\n", 1)[0]}`);
   }
@@ -9140,150 +9347,28 @@ function targetsFor(harnesses) {
   };
 }
 
-// src/generate/install.ts
-import { dirname as dirname4, join as join16 } from "node:path";
-
-// src/generate/generate.ts
-import { dirname as dirname2, join as join14 } from "node:path";
-var MANIFEST = "SKILL.md";
-var normalMode = (mode) => mode & 73 ? 493 : 420;
-function listFiles(ctx, dir, other = () => {
-}, prefix = "") {
-  if (!ctx.fs.isDirectory(dir)) return [];
-  const found = [];
-  for (const entry of ctx.fs.readDir(dir).sort((a, b) => a.name < b.name ? -1 : 1)) {
-    if (entry.name.startsWith(".")) continue;
-    const rel = `${prefix}${entry.name}`;
-    if (entry.isDirectory) {
-      found.push(...listFiles(ctx, join14(dir, entry.name), other, `${rel}/`));
-    } else {
-      if (!entry.isFile) other(rel);
-      found.push(rel);
-    }
-  }
-  return found;
-}
-var utf8 = new TextDecoder("utf-8", { fatal: true });
-function readSupportingFile(ctx, path, source) {
-  try {
-    return utf8.decode(ctx.fs.readBytes(path));
-  } catch (error) {
-    if (error instanceof TypeError) throw new DldError(`${source}: not UTF-8 text`);
-    throw error;
-  }
-}
-function manifest(template, adapter, { body, usesDld }, version2) {
-  const fields = adapter.fields.flatMap((field) => template.lines[field] ?? []);
-  return [
-    "---",
-    ...fields,
-    ...adapter.extraFrontmatter,
-    ...usesDld ? adapter.dldFrontmatter : [],
-    "metadata:",
-    `  dld-kit-version: "${version2}"`,
-    "---",
-    `<!-- Generated by dld-kit from ${template.source}. Do not edit: updating the skills overwrites this file. -->`,
-    body
-  ].join("\n");
-}
-function generateSkills(ctx, templatesDir, adapter, version2, { sourceDir = "templates/skills", extraFiles = /* @__PURE__ */ new Map() } = {}) {
-  const skills = ctx.fs.readDir(templatesDir).filter((entry) => entry.isDirectory && !entry.name.startsWith(".")).map((entry) => entry.name).sort();
-  const provided = /* @__PURE__ */ new Set();
-  const support = /* @__PURE__ */ new Map();
-  for (const skill of skills) {
-    const files = listFiles(ctx, join14(templatesDir, skill), (rel) => {
-      throw new DldError(`${sourceDir}/${skill}/${rel}: templates must be regular files`);
-    }).filter((file) => file !== MANIFEST);
-    support.set(skill, files);
-    for (const file of files) provided.add(`${skill}/${file}`);
-  }
-  for (const path of extraFiles.keys()) {
-    if (provided.has(path)) throw new DldError(`${sourceDir}/${path}: also generated; remove it`);
-    provided.add(path);
-  }
-  const output = /* @__PURE__ */ new Map();
-  for (const skill of skills) {
-    const path = join14(templatesDir, skill, MANIFEST);
-    const source = `${sourceDir}/${skill}/${MANIFEST}`;
-    const template = parseTemplate(ctx.fs.readFile(path), skill, source);
-    const rendered = renderBody(template, {
-      exists: (ref) => provided.has(`${ref.skill}/${ref.path}`),
-      script: (ref) => adapter.scriptRef(skill, ref),
-      dld: () => adapter.dld(skill),
-      dldSetup: () => adapter.dldSetup(skill)
-    });
-    if (!template.internal || adapter.internalManifest) {
-      output.set(`${skill}/${MANIFEST}`, {
-        content: manifest(template, adapter, rendered, version2),
-        mode: 420
-      });
-    }
-    for (const file of support.get(skill) ?? []) {
-      const full = join14(templatesDir, skill, file);
-      output.set(`${skill}/${file}`, {
-        content: readSupportingFile(ctx, full, `${sourceDir}/${skill}/${file}`),
-        mode: normalMode(ctx.fs.fileMode(full))
-      });
-    }
-  }
-  for (const [path, file] of extraFiles) output.set(path, { ...file, mode: normalMode(file.mode) });
-  return new Map([...output].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
-}
-function ownedSkill(path, files, generated) {
-  const skill = path.split("/", 1)[0] ?? "";
-  return generated.has(skill) || skill.startsWith("dld-") || files.has(path);
-}
-function diffOutput(ctx, dir, files) {
-  const generated = new Set([...files.keys()].map((path) => path.split("/", 1)[0] ?? ""));
-  const existing = new Set(
-    listFiles(ctx, dir).filter((path) => ownedSkill(path, files, generated))
-  );
-  const diff = { changed: [], missing: [], extra: [] };
-  for (const [path, file] of files) {
-    const full = join14(dir, path);
-    if (!existing.has(path) || !ctx.fs.isRegularFile(full)) diff.missing.push(path);
-    else if (ctx.fs.readFile(full) !== file.content || normalMode(ctx.fs.fileMode(full)) !== file.mode) {
-      diff.changed.push(path);
-    }
-  }
-  diff.extra = [...existing].filter((path) => !files.has(path)).sort();
-  return diff;
-}
-function writeOutput(ctx, dir, files) {
-  const diff = diffOutput(ctx, dir, files);
-  for (const path of diff.extra) ctx.fs.remove(join14(dir, path));
-  for (const path of [...diff.missing, ...diff.changed]) {
-    const file = files.get(path);
-    if (file === void 0) continue;
-    const full = join14(dir, path);
-    ctx.fs.mkdir(join14(full, ".."));
-    if (ctx.fs.lexists(full) && !ctx.fs.isRegularFile(full)) ctx.fs.remove(full);
-    writeFileAtomic(ctx, full, file.content, file.mode);
-  }
-  removeEmptyParents(ctx, dir, diff.extra);
-  return diff;
-}
-function removeEmptyParents(ctx, dir, paths) {
-  const parents = /* @__PURE__ */ new Set();
-  for (const path of paths) {
-    for (let parent = dirname2(path); parent !== "."; parent = dirname2(parent)) parents.add(parent);
-  }
-  const deepestFirst = [...parents].sort((a, b) => b.split("/").length - a.split("/").length);
-  for (const parent of deepestFirst) {
-    const full = join14(dir, parent);
-    if (ctx.fs.isDirectory(full) && ctx.fs.readDir(full).length === 0) ctx.fs.removeDir(full);
-  }
-}
-
 // src/generate/rule.ts
-import { dirname as dirname3, join as join15, posix as posix4 } from "node:path";
+import { dirname as dirname2, join as join14, posix as posix3 } from "node:path";
 
 // templates/rules/dld-workflow.md
-var dld_workflow_default = "# DLD (Decision-Linked Development)\n\nThis project uses Decision-Linked Development. Decision records (DL-*.md) live in the `records/` subdirectory of the decisions directory set in `dld.config.yaml` (`decisions/` by default). High-level docs (INDEX.md, OVERVIEW.md, SNAPSHOT.md) live in the decisions directory.\n\n## Rules\n\n- When you encounter `@decision(DL-XXX)` annotations in code, read the referenced decision with the dld-lookup skill BEFORE modifying the annotated code.\n- ALWAYS look up and verify related decisions before modifying annotated code. Do not skip this step.\n- NEVER modify code in a way that contradicts an existing decision without first confirming with the user. If the change requires breaking a previous decision, a new decision must be recorded (with the dld-decide skill) that explicitly supersedes the old one. If it only partially modifies a previous decision, record it as an amendment instead.\n\n## Skills\n\n- dld-decide: record a new decision\n- dld-plan: break down a feature into multiple grouped decisions\n- dld-implement: implement proposed decisions\n- dld-lookup: query decisions by ID, tag, or code path\n- dld-adjust: adjust or update existing decisions\n- dld-audit: scan for drift between decisions and code\n- dld-snapshot: regenerate SNAPSHOT.md and OVERVIEW.md from the decision log\n- dld-status: a quick overview of the decision log state\n- dld-retrofit: generate decisions from an existing codebase\n- dld-reindex: resolve decision-ID collisions with the base branch (and open PRs) before rebasing\n";
+var dld_workflow_default = "# DLD (Decision-Linked Development)\n\nThis project uses Decision-Linked Development. Decision records (DL-*.md) live in the `records/` subdirectory of the decisions directory set in `dld.config.yaml` (`decisions/` by default). High-level docs (INDEX.md, OVERVIEW.md, SNAPSHOT.md) live in the decisions directory.\n\n## Rules\n\n- When you encounter `@decision(DL-XXX)` annotations in code, read the referenced decision with the dld-lookup skill BEFORE modifying the annotated code.\n- ALWAYS look up and verify related decisions before modifying annotated code. Do not skip this step.\n- NEVER modify code in a way that contradicts an existing decision without first confirming with the user. If the change requires breaking a previous decision, a new decision must be recorded (with the dld-decide skill) that explicitly supersedes the old one. If it only partially modifies a previous decision, record it as an amendment instead.\n- Decision records that are not on the base branch yet (e.g. `main`), or still `proposed` there, are drafts: edit them freely, whatever their status. On records already on the base branch, the frontmatter can always be updated (except `id` and `timestamp`), but change the prose below it only through the dld-adjust skill, which follows `decision_edits` in `dld.config.yaml`: `block` (the default) never edits it and records an amendment or superseding decision instead, `ask` edits after the user confirms, `allow` edits.\n\n## Skills\n\n- dld-decide: record a new decision\n- dld-plan: break down a feature into multiple grouped decisions\n- dld-implement: implement proposed decisions\n- dld-lookup: query decisions by ID, tag, or code path\n- dld-adjust: adjust or update existing decisions\n- dld-audit: scan for drift between decisions and code\n- dld-snapshot: regenerate SNAPSHOT.md and OVERVIEW.md from the decision log\n- dld-status: a quick overview of the decision log state\n- dld-retrofit: generate decisions from an existing codebase\n- dld-reindex: resolve decision-ID collisions with the base branch and open PRs\n";
 
 // src/generate/rule.ts
 var RULE_TEXT = dld_workflow_default;
 var RULE_SOURCE = "templates/rules/dld-workflow.md";
+var DEFAULT_PREFIX = "@decision";
+function ruleTextFor(prefix) {
+  return RULE_TEXT.replaceAll(`\`${DEFAULT_PREFIX}(`, () => `\`${prefix}(`);
+}
+function projectRuleText(ctx, root) {
+  if (!ctx.fs.exists(join14(root, CONFIG_FILE))) return RULE_TEXT;
+  try {
+    return ruleTextFor(loadConfig({ ...ctx, warn: () => {
+    } }, root).annotationPrefix);
+  } catch {
+    return RULE_TEXT;
+  }
+}
 var CLAUDE_RULE_FILE = ".claude/rules/dld-workflow.md";
 var AGENTS_RULE_FILE = ".agents/rules/dld-workflow.md";
 var CLAUDE_IMPORT_FILE = ".claude/CLAUDE.md";
@@ -9318,7 +9403,18 @@ function renderImportFile(version2) {
 }
 var IMPORT_STAMP = /^<!-- Generated by dld-kit (\S+) for Claude Code:/;
 function importFileVersion(content) {
-  return IMPORT_STAMP.exec(content)?.[1];
+  const version2 = IMPORT_STAMP.exec(content)?.[1];
+  if (version2 === void 0) return void 0;
+  const afterNotice = (text) => text.replace(/\r\n/g, "\n").replace(/^[^\n]*\n/, "");
+  return afterNotice(content) === afterNotice(renderImportFile(version2)) ? version2 : void 0;
+}
+function editedImportWarnings(content) {
+  if (!IMPORT_STAMP.test(content) || importFileVersion(content) !== void 0) return [];
+  const warning = `${CLAUDE_IMPORT_FILE} holds content dld-kit did not write, so dld-kit leaves it as it is and no longer updates it. Remove its "Generated by dld-kit" line to keep it as your own file.`;
+  if (importsAgentsMd(content, CLAUDE_IMPORT_FILE)) return [warning];
+  return [
+    `${warning} It no longer imports AGENTS.md, so Claude Code may not load the DLD rule from it: add the line @../AGENTS.md back.`
+  ];
 }
 function renderBlock(text, version2) {
   const body = text.endsWith("\n") ? text.slice(0, -1) : text;
@@ -9359,10 +9455,10 @@ function upsertBlock(content, block, file) {
 }
 function planRule(ctx, root, channels, version2, { harnesses = [] } = {}, text = RULE_TEXT) {
   const plan = { writes: [], removals: [], warnings: [] };
-  const regular = (file) => ctx.fs.isRegularFile(join15(root, file));
-  const read = (file) => regular(file) ? ctx.fs.readFile(join15(root, file)) : "";
+  const regular = (file) => ctx.fs.isRegularFile(join14(root, file));
+  const read = (file) => regular(file) ? ctx.fs.readFile(join14(root, file)) : "";
   const resolved = (file) => {
-    const full = join15(root, file);
+    const full = join14(root, file);
     return ctx.fs.exists(full) ? ctx.fs.realPath(full) : full;
   };
   let blockFiles = [AGENTS_MD, CLAUDE_MD].filter(
@@ -9381,9 +9477,9 @@ function planRule(ctx, root, channels, version2, { harnesses = [] } = {}, text =
     pending.set(file, updated);
     if (updated !== content) plan.writes.push({ path: file, content: updated });
   }
-  const linkedDir = symlinkedPart(ctx, root, dirname3(CLAUDE_IMPORT_FILE));
+  const linkedDir = symlinkedPart(ctx, root, dirname2(CLAUDE_IMPORT_FILE));
   const ownsImport = linkedDir === void 0 && importFileVersion(read(CLAUDE_IMPORT_FILE)) !== void 0;
-  const wantsImport = channels.has("claude-file") && blockFiles.includes(AGENTS_MD) && !SHARED_CLAUDE_FILES.some((file) => ctx.fs.lexists(join15(root, file)));
+  const wantsImport = channels.has("claude-file") && blockFiles.includes(AGENTS_MD) && !SHARED_CLAUDE_FILES.some((file) => ctx.fs.lexists(join14(root, file)));
   if (ownsImport || wantsImport && linkedDir === void 0) {
     const content = renderImportFile(version2);
     pending.set(CLAUDE_IMPORT_FILE, content);
@@ -9420,22 +9516,24 @@ function planRule(ctx, root, channels, version2, { harnesses = [] } = {}, text =
   for (const channel of ["claude-file", "agents-file"]) {
     const path = RULE_FILES[channel];
     if (loadsBlock(channel)) {
-      if (ctx.fs.lexists(join15(root, path))) plan.removals.push(path);
+      if (ctx.fs.lexists(join14(root, path))) plan.removals.push(path);
     } else if (channels.has(channel)) {
-      refuseSymlinkedDir(ctx, root, dirname3(path));
+      refuseSymlinkedDir(ctx, root, dirname2(path));
       const content = renderRuleFile(channel, text, version2);
       if (read(path) !== content) plan.writes.push({ path, content });
     }
   }
   const ruleInstalled = blockFiles.length > 0 || channels.size > 0;
   plan.warnings.push(...legacyBlockWarnings(read(CLAUDE_MD), ruleInstalled));
+  if (linkedDir === void 0)
+    plan.warnings.push(...editedImportWarnings(read(CLAUDE_IMPORT_FILE)));
   return plan;
 }
 function projectView(ctx, root) {
-  const exists = (file) => ctx.fs.exists(join15(root, file));
+  const exists = (file) => ctx.fs.exists(join14(root, file));
   return {
     exists,
-    read: (file) => exists(file) && !ctx.fs.isDirectory(join15(root, file)) ? ctx.fs.readFile(join15(root, file)) : ""
+    read: (file) => exists(file) && !ctx.fs.isDirectory(join14(root, file)) ? ctx.fs.readFile(join14(root, file)) : ""
   };
 }
 function instructionFiles(harness, view) {
@@ -9451,7 +9549,7 @@ function instructionFiles(harness, view) {
 }
 var FENCE = /^ {0,3}(`{3,}|~{3,})/;
 function importsAgentsMd(content, file) {
-  const dir = posix4.dirname(file);
+  const dir = posix3.dirname(file);
   let fence;
   for (const line of content.split(/\r?\n/)) {
     const marker = FENCE.exec(line)?.[1];
@@ -9464,7 +9562,7 @@ function importsAgentsMd(content, file) {
     const prose = line.replace(/`[^`]*`/g, "");
     for (const match of prose.matchAll(/(?:^|\s)@(\S+)/g)) {
       const target = match[1];
-      if (target !== void 0 && posix4.normalize(posix4.join(dir, target)) === AGENTS_MD) {
+      if (target !== void 0 && posix3.normalize(posix3.join(dir, target)) === AGENTS_MD) {
         return true;
       }
     }
@@ -9484,9 +9582,9 @@ function blindWarnings(blockFiles, blind, reads) {
   });
 }
 function blockPlacement(ctx, root, targets) {
-  if (ctx.fs.isRegularFile(join15(root, AGENTS_MD))) return AGENTS_MD;
-  const agentsLinked = ctx.fs.lexists(join15(root, AGENTS_MD));
-  if (ctx.fs.isRegularFile(join15(root, CLAUDE_MD)) && (agentsLinked || targets.every((h) => h.instructions.includes(CLAUDE_MD)))) {
+  if (ctx.fs.isRegularFile(join14(root, AGENTS_MD))) return AGENTS_MD;
+  const agentsLinked = ctx.fs.lexists(join14(root, AGENTS_MD));
+  if (ctx.fs.isRegularFile(join14(root, CLAUDE_MD)) && (agentsLinked || targets.every((h) => h.instructions.includes(CLAUDE_MD)))) {
     return CLAUDE_MD;
   }
   if (agentsLinked) {
@@ -9497,8 +9595,8 @@ function blockPlacement(ctx, root, targets) {
   return AGENTS_MD;
 }
 function switchWarnings(ctx, root, file, targets) {
-  if (file !== AGENTS_MD || ctx.fs.lexists(join15(root, AGENTS_MD))) return [];
-  const claudeMd = join15(root, CLAUDE_MD);
+  if (file !== AGENTS_MD || ctx.fs.lexists(join14(root, AGENTS_MD))) return [];
+  const claudeMd = join14(root, CLAUDE_MD);
   if (!ctx.fs.exists(claudeMd) || ctx.fs.isDirectory(claudeMd)) return [];
   const switching = targets.filter((h) => !h.readsAll && h.instructions.includes(CLAUDE_MD));
   if (switching.length === 0) return [];
@@ -9518,7 +9616,7 @@ function legacyBlockWarnings(claudeMd, ruleInstalled) {
   ];
 }
 function loadsRule(ctx, root, harness) {
-  if (harness.rule !== "block" && ctx.fs.exists(join15(root, RULE_FILES[harness.rule]))) {
+  if (harness.rule !== "block" && ctx.fs.exists(join14(root, RULE_FILES[harness.rule]))) {
     return true;
   }
   const view = projectView(ctx, root);
@@ -9526,17 +9624,17 @@ function loadsRule(ctx, root, harness) {
     (file) => view.read(file).split(/\r?\n/).some((line) => line === BLOCK_START || LEGACY_HEADING.test(line))
   );
 }
-function sessionContext(ctx, root, harness, text = RULE_TEXT) {
-  if (!ctx.fs.exists(join15(root, CONFIG_FILE))) return void 0;
-  return loadsRule(ctx, root, harness) ? void 0 : text;
+function sessionContext(ctx, root, harness, text) {
+  if (!ctx.fs.exists(join14(root, CONFIG_FILE))) return void 0;
+  return loadsRule(ctx, root, harness) ? void 0 : text ?? projectRuleText(ctx, root);
 }
 function symlinkedPart(ctx, root, dir) {
   let current = "";
   for (const part of dir.split("/")) {
     current = current === "" ? part : `${current}/${part}`;
-    const full = join15(root, current);
+    const full = join14(root, current);
     if (!ctx.fs.lexists(full)) return void 0;
-    if (!ctx.fs.exists(full) || ctx.fs.realPath(full) !== join15(ctx.fs.realPath(root), current)) {
+    if (!ctx.fs.exists(full) || ctx.fs.realPath(full) !== join14(ctx.fs.realPath(root), current)) {
       return current;
     }
   }
@@ -9550,58 +9648,671 @@ function refuseSymlinkedDir(ctx, root, dir) {
     );
   }
 }
-function installedRuleChannels(ctx, root) {
-  const channels = /* @__PURE__ */ new Set();
-  for (const channel of ["claude-file", "agents-file"]) {
-    if (ctx.fs.lexists(join15(root, RULE_FILES[channel]))) channels.add(channel);
+function installedRuleChannels(ctx, root) {
+  const channels = /* @__PURE__ */ new Set();
+  for (const channel of ["claude-file", "agents-file"]) {
+    if (ctx.fs.lexists(join14(root, RULE_FILES[channel]))) channels.add(channel);
+  }
+  if (importFileVersion(projectView(ctx, root).read(CLAUDE_IMPORT_FILE)) !== void 0) {
+    channels.add("claude-file");
+  }
+  for (const file of [AGENTS_MD, CLAUDE_MD]) {
+    const path = join14(root, file);
+    if (ctx.fs.isRegularFile(path) && findBlock(ctx.fs.readFile(path), file) !== void 0) {
+      channels.add("block");
+    }
+  }
+  return channels;
+}
+function installedRuleStamps(ctx, root) {
+  const stamps = [];
+  const regular = (file) => ctx.fs.isRegularFile(join14(root, file));
+  for (const file of [CLAUDE_RULE_FILE, AGENTS_RULE_FILE].filter(regular)) {
+    stamps.push({ path: file, version: ruleVersion(ctx.fs.readFile(join14(root, file))) });
+  }
+  const imported = importFileVersion(projectView(ctx, root).read(CLAUDE_IMPORT_FILE));
+  if (imported !== void 0) stamps.push({ path: CLAUDE_IMPORT_FILE, version: imported });
+  for (const file of [AGENTS_MD, CLAUDE_MD].filter(regular)) {
+    const content = ctx.fs.readFile(join14(root, file));
+    const span = findBlock(content, file);
+    if (span !== void 0) {
+      stamps.push({ path: file, version: ruleVersion(content.slice(span.from, span.to)) });
+    }
+  }
+  return stamps;
+}
+function applyRulePlan(ctx, root, plan) {
+  for (const { path, content } of plan.writes) {
+    const full = join14(root, path);
+    ctx.fs.mkdir(dirname2(full));
+    if (ctx.fs.lexists(full) && !ctx.fs.isRegularFile(full)) ctx.fs.remove(full);
+    writeFileAtomic(ctx, full, content);
+  }
+  for (const path of plan.removals) {
+    const full = join14(root, path);
+    ctx.fs.remove(full);
+    if (ctx.fs.isDirectory(dirname2(full)) && ctx.fs.readDir(dirname2(full)).length === 0) {
+      ctx.fs.removeDir(dirname2(full));
+    }
+  }
+}
+
+// src/cli/install.ts
+var AGENT_HELP = `Agents: ${HARNESS_NAMES.join(", ")}. --agent takes a comma-separated list and can be repeated.`;
+function parseAgents(values) {
+  const names = (values ?? []).flatMap((value) => value.split(",")).map((name) => name.trim());
+  const harnesses = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (name === "") continue;
+    const harness = findHarness(name);
+    if (harness === void 0) {
+      throw new UsageError(`unknown agent '${name}'; expected one of: ${HARNESS_NAMES.join(", ")}`);
+    }
+    harnesses.add(harness);
+  }
+  return HARNESSES.filter((harness) => harnesses.has(harness));
+}
+async function selectHarnesses(io, detected, requested, yes) {
+  const selected = /* @__PURE__ */ new Set([...detected.map((d) => d.harness), ...requested]);
+  const ordered = () => HARNESSES.filter((harness) => selected.has(harness));
+  if (io.prompt === void 0 || yes) {
+    if (selected.size === 0) {
+      throw new UsageError(
+        `no agent detected in this project; name them with --agent (${HARNESS_NAMES.join(", ")})`
+      );
+    }
+    return ordered();
+  }
+  const found = new Map(detected.map((d) => [d.harness, d.marker]));
+  const width = Math.max(...HARNESS_NAMES.map((name) => name.length));
+  for (; ; ) {
+    const lines = HARNESSES.map((harness, i) => {
+      const box = selected.has(harness) ? "[x]" : "[ ]";
+      const marker = found.get(harness);
+      const note = marker === void 0 ? "" : ` (found ${marker})`;
+      return `  ${i + 1}. ${box} ${harness.name.padEnd(width)}  ${harness.title}${note}
+`;
+    });
+    io.stdout(`Install DLD for these agents:
+${lines.join("")}`);
+    const answer = (await io.prompt("Numbers to toggle, or Enter to continue: ")).trim();
+    if (answer === "") {
+      if (selected.size > 0) return ordered();
+      io.stdout("Select at least one agent.\n");
+      continue;
+    }
+    const picks = answer.split(/[\s,]+/).map((pick) => HARNESSES[Number(pick) - 1]);
+    if (picks.some((harness) => harness === void 0)) {
+      io.stdout(`Enter numbers from 1 to ${HARNESSES.length}.
+`);
+      continue;
+    }
+    for (const harness of picks) {
+      if (harness === void 0) continue;
+      if (selected.has(harness)) selected.delete(harness);
+      else selected.add(harness);
+    }
+  }
+}
+function cliPath(io) {
+  if (io.cliPath === void 0) throw new DldError("cannot locate the running dld file");
+  return io.cliPath;
+}
+function printReport(io, report2) {
+  for (const { dir, written, removed, unchanged, removedPaths } of report2.skills) {
+    io.stdout(`${dir}: ${written} written, ${removed} removed, ${unchanged} unchanged
+`);
+    for (const path of removedPaths) io.stdout(`Removed ${path}
+`);
+  }
+  for (const path of report2.ruleWritten) {
+    io.stdout(
+      path === CLAUDE_IMPORT_FILE ? `Wrote ${path} (imports AGENTS.md for Claude Code)
+` : `Wrote the DLD rule to ${path}
+`
+    );
+  }
+  for (const path of report2.ruleRemoved) io.stdout(`Removed ${path} (the rule is in the block)
+`);
+  for (const warning of report2.warnings) io.stderr(`Warning: ${warning}
+`);
+}
+function ensureIndexMergeAttribute(io, ctx, project) {
+  const { root } = project.paths;
+  const index = relative8(root, indexPath(project.paths)).split(sep4).join("/");
+  const plan = planIndexMergeAttribute(ctx, root, index);
+  if (applyIndexMergeAttribute(ctx, root, plan)) {
+    const verb = plan.creates === true ? "Created" : "Updated";
+    io.stdout(`${verb} ${GITATTRIBUTES}: ${index} merges keep the rows from both sides
+`);
+  }
+  for (const warning of plan.warnings) io.stderr(`Warning: ${warning}
+`);
+}
+
+// src/cli/commands/create-empty-index.ts
+var createEmptyIndexCommand = {
+  name: "create-empty-index",
+  summary: "Write an INDEX.md with no decisions",
+  internal: true,
+  usage: "Usage: dld create-empty-index\n\nWrite INDEX.md in the decisions directory with only the table header, and add its\nunion-merge line to .gitattributes.\n",
+  run(args, io, ctx) {
+    parseCommandArgs({ args: [...args], options: {} });
+    const project = loadProject(ctx);
+    const { config, paths } = project;
+    writeIndex(ctx, paths, renderIndex([], config.mode));
+    io.stdout(`Created ${indexPath(paths)}
+`);
+    ensureIndexMergeAttribute(io, ctx, project);
+    return EXIT_OK;
+  }
+};
+
+// src/cli/commands/detect-snapshot-changes.ts
+var detectSnapshotChangesCommand = {
+  name: "detect-snapshot-changes",
+  summary: "Report what changed since the last snapshot",
+  internal: true,
+  usage: "Usage: dld detect-snapshot-changes\n\nPrint mode (full or incremental), new_decisions, modified_decisions and commit_range.\n",
+  run(args, io, ctx) {
+    parseCommandArgs({ args: [...args], options: {} });
+    io.stdout(formatSnapshotChanges(detectSnapshotChanges(ctx, loadProject(ctx))));
+    return EXIT_OK;
+  }
+};
+
+// src/core/annotations.ts
+import { join as join15, relative as relative9, sep as sep5 } from "node:path";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  // Agent configuration directories, which hold installed skills.
+  ".claude",
+  ".agents",
+  ".agent",
+  ".codex",
+  ".cursor",
+  ".opencode",
+  ".pi",
+  ".tessl",
+  "node_modules",
+  "vendor",
+  ".venv",
+  "__pycache__",
+  "target",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".gradle",
+  "coverage"
+]);
+var EXCLUDED_FILE = /(\.lock|\.min\.js|\.min\.css|\.map)$/;
+var BINARY_SNIFF_BYTES = 8192;
+var MAX_SCAN_BYTES = 16 * 1024 * 1024;
+function scanOptionsFor({ config, paths }) {
+  return {
+    root: paths.root,
+    decisionsDir: paths.decisionsDir,
+    prefix: config.annotationPrefix,
+    exclude: config.annotationExclude
+  };
+}
+function listScannableFiles(ctx, options) {
+  const output = ctx.git([
+    "-C",
+    options.root,
+    "ls-files",
+    "-z",
+    "--cached",
+    "--others",
+    "--exclude-standard",
+    // @decision(DL-023)
+    "--",
+    ...(options.exclude ?? []).map((pattern) => `:(exclude,glob)${pattern}`)
+  ]);
+  const decisionsRel = relative9(options.root, options.decisionsDir).split(sep5).join("/");
+  const files = /* @__PURE__ */ new Set();
+  for (const file of output.split("\0")) {
+    if (file === "" || EXCLUDED_FILE.test(file)) continue;
+    if (file === decisionsRel || file.startsWith(`${decisionsRel}/`)) continue;
+    const dirs = file.split("/").slice(0, -1);
+    if (dirs.some((dir) => EXCLUDED_DIRS.has(dir))) continue;
+    files.add(file);
+  }
+  return [...files].sort();
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function readScannable(ctx, root, file, onSkip) {
+  const path = join15(root, file);
+  let text;
+  try {
+    if (!ctx.fs.isRegularFile(path)) return void 0;
+    if (ctx.fs.fileSize(path) > MAX_SCAN_BYTES) {
+      onSkip({ file, reason: `larger than ${MAX_SCAN_BYTES / 1024 / 1024} MB` });
+      return void 0;
+    }
+    text = ctx.fs.readFile(path);
+  } catch (error) {
+    if (!(error instanceof FsError)) throw error;
+    onSkip({ file, reason: error.message });
+    return void 0;
+  }
+  return text.slice(0, BINARY_SNIFF_BYTES).includes("\0") ? void 0 : text;
+}
+function scanAnnotations(ctx, options, onSkip = () => {
+}, onNearMiss = () => {
+}) {
+  const prefix = escapeRegExp(options.prefix);
+  const pattern = new RegExp(`${prefix}\\((DL-\\d+)\\)`, "g");
+  const exact = new RegExp(`^${prefix}\\(DL-\\d+\\)$`);
+  const loose = new RegExp(`${prefix}\\([^()\\n]*\\)`, "gi");
+  const found = [];
+  for (const file of listScannableFiles(ctx, options)) {
+    const text = readScannable(ctx, options.root, file, onSkip);
+    if (text === void 0) continue;
+    text.split("\n").forEach((content, index) => {
+      const line = index + 1;
+      for (const match of content.matchAll(pattern)) {
+        if (match[1] !== void 0) found.push({ file, line, id: match[1] });
+      }
+      for (const [candidate] of content.matchAll(loose)) {
+        if (!exact.test(candidate) && /dl-\d/i.test(candidate)) {
+          onNearMiss({ file, line, text: candidate });
+        }
+      }
+    });
+  }
+  return found;
+}
+function formatNearMiss({ file, line, text }) {
+  return `${file}:${line}: not an annotation: ${text}`;
+}
+function missingAnnotations(ctx, options, ids, onSkip, onNearMiss) {
+  const annotated = new Set(
+    scanAnnotations(ctx, options, onSkip, onNearMiss).map((annotation) => annotation.id)
+  );
+  return ids.filter((id) => !annotated.has(id));
+}
+function formatSkipped({ file, reason }) {
+  return `Warning: skipped ${file} (${reason}); annotations in it are not counted`;
+}
+function formatAnnotation({ file, line, id }) {
+  return `${file}:${line}:${id}`;
+}
+
+// src/cli/commands/find-annotations.ts
+var findAnnotationsCommand = {
+  name: "find-annotations",
+  summary: "List every annotation in the codebase",
+  internal: true,
+  usage: "Usage: dld find-annotations\n\nPrint <file>:<line>:<DL-NNN> for every annotation, one per line.\n",
+  run(args, io, ctx) {
+    parseCommandArgs({ args: [...args], options: {} });
+    const annotations = scanAnnotations(
+      ctx,
+      scanOptionsFor(loadProject(ctx)),
+      (skipped) => io.stderr(`${formatSkipped(skipped)}
+`),
+      // @decision(DL-074)
+      (nearMiss) => ctx.warn(formatNearMiss(nearMiss))
+    );
+    for (const annotation of annotations) {
+      io.stdout(`${formatAnnotation(annotation)}
+`);
+    }
+    return EXIT_OK;
+  }
+};
+
+// src/cli/commands/find-collisions.ts
+var findCollisionsCommand = {
+  name: "find-collisions",
+  summary: "List locally added decisions whose IDs are taken",
+  internal: true,
+  usage: `Usage: dld find-collisions [--base <ref>]
+
+Print <path>\\t<DL-NNN> for each decision added on this branch whose ID is taken on the base
+branch or in an open pull request.
+
+Options:
+  --base <ref>  Base ref (${DEFAULT_BASE_HELP})
+`,
+  run(args, io, ctx) {
+    const { values } = parseCommandArgs({ args: [...args], options: { base: { type: "string" } } });
+    const project = loadProject(ctx);
+    const base = baseOption(values.base, { ctx, project });
+    const { collisions, skipped } = findCollisions(ctx, project, base);
+    for (const { path, id } of collisions) io.stdout(`${path}	${id}
+`);
+    if (skipped !== void 0) io.stderr(skippedNotice(skipped));
+    return EXIT_OK;
+  }
+};
+
+// src/core/audit.ts
+import { basename as basename7, relative as relative10, sep as sep6 } from "node:path";
+var MENTION = /DL-\d+/g;
+var toPosix2 = (path) => path.split(sep6).join("/");
+var idNumber2 = (id) => Number.parseInt(id.slice(3), 10);
+function recordsChangedSinceAudit(ctx, { paths }) {
+  const git = gitAt(ctx, paths.root);
+  const stored = stateString(readStateSection(ctx, paths, "audit"), "commit_hash");
+  const commit2 = resolveStateCommit(git, stored);
+  if (commit2 === void 0) return void 0;
+  const records = recordsPathspec(paths);
+  return /* @__PURE__ */ new Set([
+    ...nulSeparated(git("diff", "-z", "--name-only", commit2, "--", records)),
+    ...nulSeparated(git("ls-files", "-z", "--others", "--exclude-standard", "--", records))
+  ]);
+}
+function findMissingAmends(ctx, project, { all }) {
+  const { paths } = project;
+  const changed = all ? void 0 : recordsChangedSinceAudit(ctx, project);
+  const found = [];
+  const files = listRecordFiles(ctx, paths.recordsDir).sort(
+    (a, b) => recordNumber(a) - recordNumber(b)
+  );
+  for (const file of files) {
+    const rel = toPosix2(relative10(paths.root, file));
+    if (changed !== void 0 && !changed.has(rel)) continue;
+    const text = ctx.fs.readFile(file);
+    const record = parseRecord(text, rel);
+    const source = basename7(file, ".md");
+    const declared = /* @__PURE__ */ new Set([...record.supersedes, ...record.amends]);
+    const mentioned = new Set(recordBody(text).match(MENTION) ?? []);
+    const refs = [...mentioned].filter((id) => id !== source && !declared.has(id)).sort((a, b) => idNumber2(a) - idNumber2(b));
+    for (const referenced of refs) found.push({ source, referenced });
+  }
+  return found;
+}
+function updateAuditState(ctx, { paths }) {
+  const timestamp = formatTimestamp(ctx.now());
+  const commit2 = shortHead(ctx, paths.root);
+  writeStateSection(ctx, paths, "audit", { last_run: timestamp, commit_hash: commit2 });
+  return { timestamp, commit: commit2 };
+}
+
+// src/cli/commands/find-missing-amends.ts
+var findMissingAmendsCommand = {
+  name: "find-missing-amends",
+  summary: "List decision IDs mentioned in a body but not declared",
+  internal: true,
+  usage: `Usage: dld find-missing-amends [--all]
+
+Print <source-id>:<referenced-id> for each decision ID a record's body mentions without
+listing it in supersedes or amends. Only records changed since the last audit are checked.
+
+Options:
+  --all  Check every record
+`,
+  run(args, io, ctx) {
+    const { values } = parseCommandArgs({ args: [...args], options: { all: { type: "boolean" } } });
+    const found = findMissingAmends(ctx, loadProject(ctx), { all: values.all === true });
+    for (const { source, referenced } of found) io.stdout(`${source}:${referenced}
+`);
+    return EXIT_OK;
+  }
+};
+
+// src/core/rename.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { join as join16, posix as posix4 } from "node:path";
+var idPattern = (id, flags = "") => new RegExp(`${id}(?![0-9])`, flags);
+function changedFiles(ctx, paths, commit2) {
+  return nulSeparated(
+    gitAt(ctx, paths.root)(
+      "diff",
+      "-z",
+      "--find-renames",
+      "--name-only",
+      "--diff-filter=AMR",
+      commit2
+    )
+  );
+}
+function rewriteFile(ctx, path, edit) {
+  if (!ctx.fs.isRegularFile(path)) return;
+  const bytes = ctx.fs.readBytes(path);
+  if (bytes.subarray(0, BINARY_SNIFF_BYTES).includes(0)) return;
+  const text = Buffer2.from(bytes).toString("latin1");
+  const edited = edit(text);
+  if (edited === text) return;
+  writeFileAtomic(ctx, path, Buffer2.from(edited, "latin1"), ctx.fs.fileMode(path));
+}
+function renameDecision(ctx, project, rename, base) {
+  const { paths, config } = project;
+  const { path, oldId, newId } = rename;
+  const problem = renameProblem(paths, rename);
+  if (problem !== void 0) throw new DldError(problem, EXIT_USAGE);
+  const full = join16(paths.root, path);
+  if (!ctx.fs.isRegularFile(full)) throw new DldError(`${path} not found.`);
+  const record = parseRecord(ctx.fs.readFile(full), path);
+  if (record.id !== oldId) throw new DldError(`${path} has id ${record.id}, not ${oldId}.`);
+  const newPath = posix4.join(posix4.dirname(path), `${newId}.md`);
+  const newFull = join16(paths.root, newPath);
+  if (ctx.fs.lexists(newFull)) throw new DldError(`${newPath} already exists.`);
+  verifyBase(ctx, paths, base);
+  const since = mergeBase(ctx, paths, base);
+  const scannable = new Set(listScannableFiles(ctx, scanOptionsFor(project)));
+  gitAt(ctx, paths.root)("mv", "--", path, newPath);
+  const substitute = (text) => text.replace(idPattern(oldId, "g"), newId);
+  rewriteFile(ctx, newFull, (text) => substitute(setId(text, oldId, newId)));
+  const decisions = `${decisionsPathspec(paths)}/`;
+  const prefix = Buffer2.from(config.annotationPrefix, "utf8").toString("latin1");
+  const oldAnnotation = `${prefix}(${oldId})`;
+  const newAnnotation = `${prefix}(${newId})`;
+  for (const file of changedFiles(ctx, paths, since)) {
+    if (file === newPath) continue;
+    if (file.startsWith(decisions)) {
+      rewriteFile(ctx, join16(paths.root, file), substitute);
+    } else if (scannable.has(file)) {
+      rewriteFile(
+        ctx,
+        join16(paths.root, file),
+        (text) => text.split(oldAnnotation).join(newAnnotation)
+      );
+    }
+  }
+  return newPath;
+}
+function findStaleMentions(ctx, { paths }, planText, base) {
+  const renames = parseRenamePlan(paths, planText);
+  if (renames.length === 0) throw new DldError("no rename plan on stdin.");
+  verifyBase(ctx, paths, base);
+  const decisions = `${decisionsPathspec(paths)}/`;
+  const files = changedFiles(ctx, paths, mergeBase(ctx, paths, base)).flatMap((file) => {
+    if (file.startsWith(decisions)) return [];
+    const full = join16(paths.root, file);
+    if (!ctx.fs.isRegularFile(full)) return [];
+    const text = ctx.fs.readFile(full);
+    if (text.slice(0, BINARY_SNIFF_BYTES).includes("\0")) return [];
+    return [{ file, lines: text.split("\n").map((line) => line.replace(/\r$/, "")) }];
+  });
+  const found = [];
+  for (const { oldId, newId } of renames) {
+    const pattern = idPattern(oldId);
+    for (const { file, lines } of files) {
+      lines.forEach((text, index) => {
+        if (pattern.test(text)) found.push({ file, line: index + 1, oldId, newId, text });
+      });
+    }
+  }
+  return found;
+}
+function formatStaleMention({ file, line, oldId, newId, text }) {
+  return `${file}	${line}	${oldId}	${newId}	${text}`;
+}
+
+// src/cli/commands/find-stale-mentions.ts
+var findStaleMentionsCommand = {
+  name: "find-stale-mentions",
+  summary: "List remaining mentions of renamed decision IDs",
+  internal: true,
+  usage: `Usage: dld find-stale-mentions --base <ref> < plan
+
+Read a rename plan (<path>\\t<DL-OLD>\\t<DL-NEW> per line) on standard input and print
+<path>\\t<line>\\t<DL-OLD>\\t<DL-NEW>\\t<text> for each remaining DL-OLD mention in changed
+files outside the decisions directory.
+
+Options:
+  --base <ref>  Base ref for the local change set (required)
+`,
+  run(args, io, ctx) {
+    const { values } = parseCommandArgs({ args: [...args], options: { base: { type: "string" } } });
+    const base = baseOption(values.base);
+    const project = loadProject(ctx);
+    for (const mention of findStaleMentions(ctx, project, ctx.readStdin(), base)) {
+      io.stdout(`${formatStaleMention(mention)}
+`);
+    }
+    return EXIT_OK;
+  }
+};
+
+// src/cli/commands/init.ts
+import { join as join19, relative as relative11 } from "node:path";
+
+// src/generate/install.ts
+import { dirname as dirname4, join as join18 } from "node:path";
+
+// src/generate/generate.ts
+import { dirname as dirname3, join as join17 } from "node:path";
+var MANIFEST = "SKILL.md";
+var normalMode = (mode) => mode & 73 ? 493 : 420;
+function listFiles(ctx, dir, other = () => {
+}, prefix = "") {
+  if (!ctx.fs.isDirectory(dir)) return [];
+  const found = [];
+  for (const entry of ctx.fs.readDir(dir).sort((a, b) => a.name < b.name ? -1 : 1)) {
+    if (entry.name.startsWith(".")) continue;
+    const rel = `${prefix}${entry.name}`;
+    if (entry.isDirectory) {
+      found.push(...listFiles(ctx, join17(dir, entry.name), other, `${rel}/`));
+    } else {
+      if (!entry.isFile) other(rel);
+      found.push(rel);
+    }
+  }
+  return found;
+}
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function readSupportingFile(ctx, path, source) {
+  try {
+    return utf8.decode(ctx.fs.readBytes(path));
+  } catch (error) {
+    if (error instanceof TypeError) throw new DldError(`${source}: not UTF-8 text`);
+    throw error;
+  }
+}
+function manifest(template, adapter, { body, usesDld }, version2) {
+  const fields = adapter.fields.flatMap((field) => template.lines[field] ?? []);
+  return [
+    "---",
+    ...fields,
+    ...adapter.extraFrontmatter,
+    ...usesDld ? adapter.dldFrontmatter : [],
+    "metadata:",
+    `  dld-kit-version: "${version2}"`,
+    "---",
+    `<!-- Generated by dld-kit from ${template.source}. Do not edit: updating the skills overwrites this file. -->`,
+    body
+  ].join("\n");
+}
+function generateSkills(ctx, templatesDir, adapter, version2, { sourceDir = "templates/skills", extraFiles = /* @__PURE__ */ new Map() } = {}) {
+  const skills = ctx.fs.readDir(templatesDir).filter((entry) => entry.isDirectory && !entry.name.startsWith(".")).map((entry) => entry.name).sort();
+  const provided = /* @__PURE__ */ new Set();
+  const support = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const files = listFiles(ctx, join17(templatesDir, skill), (rel) => {
+      throw new DldError(`${sourceDir}/${skill}/${rel}: templates must be regular files`);
+    }).filter((file) => file !== MANIFEST);
+    support.set(skill, files);
+    for (const file of files) provided.add(`${skill}/${file}`);
   }
-  if (importFileVersion(projectView(ctx, root).read(CLAUDE_IMPORT_FILE)) !== void 0) {
-    channels.add("claude-file");
+  for (const path of extraFiles.keys()) {
+    if (provided.has(path)) throw new DldError(`${sourceDir}/${path}: also generated; remove it`);
+    provided.add(path);
   }
-  for (const file of [AGENTS_MD, CLAUDE_MD]) {
-    const path = join15(root, file);
-    if (ctx.fs.isRegularFile(path) && findBlock(ctx.fs.readFile(path), file) !== void 0) {
-      channels.add("block");
+  const output = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const path = join17(templatesDir, skill, MANIFEST);
+    const source = `${sourceDir}/${skill}/${MANIFEST}`;
+    const template = parseTemplate(ctx.fs.readFile(path), skill, source);
+    const rendered = renderBody(template, {
+      exists: (ref) => provided.has(`${ref.skill}/${ref.path}`),
+      script: (ref) => adapter.scriptRef(skill, ref),
+      dld: () => adapter.dld(skill),
+      dldSetup: () => adapter.dldSetup(skill)
+    });
+    if (!template.internal || adapter.internalManifest) {
+      output.set(`${skill}/${MANIFEST}`, {
+        content: manifest(template, adapter, rendered, version2),
+        mode: 420
+      });
+    }
+    for (const file of support.get(skill) ?? []) {
+      const full = join17(templatesDir, skill, file);
+      output.set(`${skill}/${file}`, {
+        content: readSupportingFile(ctx, full, `${sourceDir}/${skill}/${file}`),
+        mode: normalMode(ctx.fs.fileMode(full))
+      });
     }
   }
-  return channels;
+  for (const [path, file] of extraFiles) output.set(path, { ...file, mode: normalMode(file.mode) });
+  return new Map([...output].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
 }
-function installedRuleStamps(ctx, root) {
-  const stamps = [];
-  const regular = (file) => ctx.fs.isRegularFile(join15(root, file));
-  for (const file of [CLAUDE_RULE_FILE, AGENTS_RULE_FILE].filter(regular)) {
-    stamps.push({ path: file, version: ruleVersion(ctx.fs.readFile(join15(root, file))) });
-  }
-  const imported = importFileVersion(projectView(ctx, root).read(CLAUDE_IMPORT_FILE));
-  if (imported !== void 0) stamps.push({ path: CLAUDE_IMPORT_FILE, version: imported });
-  for (const file of [AGENTS_MD, CLAUDE_MD].filter(regular)) {
-    const content = ctx.fs.readFile(join15(root, file));
-    const span = findBlock(content, file);
-    if (span !== void 0) {
-      stamps.push({ path: file, version: ruleVersion(content.slice(span.from, span.to)) });
+var anyDldSkill = (skill) => skill.startsWith("dld-");
+function ownedSkill(path, files, generated, owns) {
+  const skill = path.split("/", 1)[0] ?? "";
+  return generated.has(skill) || owns(skill) || files.has(path);
+}
+function diffOutput(ctx, dir, files, owns = anyDldSkill) {
+  const generated = new Set([...files.keys()].map((path) => path.split("/", 1)[0] ?? ""));
+  const existing = new Set(
+    listFiles(ctx, dir).filter((path) => ownedSkill(path, files, generated, owns))
+  );
+  const diff = { changed: [], missing: [], extra: [] };
+  for (const [path, file] of files) {
+    const full = join17(dir, path);
+    if (!existing.has(path) || !ctx.fs.isRegularFile(full)) diff.missing.push(path);
+    else if (ctx.fs.readFile(full) !== file.content || normalMode(ctx.fs.fileMode(full)) !== file.mode) {
+      diff.changed.push(path);
     }
   }
-  return stamps;
+  diff.extra = [...existing].filter((path) => !files.has(path)).sort();
+  return diff;
 }
-function applyRulePlan(ctx, root, plan) {
-  for (const { path, content } of plan.writes) {
-    const full = join15(root, path);
-    ctx.fs.mkdir(dirname3(full));
+function writeOutput(ctx, dir, files, owns = anyDldSkill) {
+  const diff = diffOutput(ctx, dir, files, owns);
+  for (const path of diff.extra) ctx.fs.remove(join17(dir, path));
+  for (const path of [...diff.missing, ...diff.changed]) {
+    const file = files.get(path);
+    if (file === void 0) continue;
+    const full = join17(dir, path);
+    ctx.fs.mkdir(join17(full, ".."));
     if (ctx.fs.lexists(full) && !ctx.fs.isRegularFile(full)) ctx.fs.remove(full);
-    writeFileAtomic(ctx, full, content);
+    writeFileAtomic(ctx, full, file.content, file.mode);
   }
-  for (const path of plan.removals) {
-    const full = join15(root, path);
-    ctx.fs.remove(full);
-    if (ctx.fs.isDirectory(dirname3(full)) && ctx.fs.readDir(dirname3(full)).length === 0) {
-      ctx.fs.removeDir(dirname3(full));
-    }
+  removeEmptyParents(ctx, dir, diff.extra);
+  return diff;
+}
+function removeEmptyParents(ctx, dir, paths) {
+  const parents = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    for (let parent = dirname3(path); parent !== "."; parent = dirname3(parent)) parents.add(parent);
+  }
+  const deepestFirst = [...parents].sort((a, b) => b.split("/").length - a.split("/").length);
+  for (const parent of deepestFirst) {
+    const full = join17(dir, parent);
+    if (ctx.fs.isDirectory(full) && ctx.fs.readDir(full).length === 0) ctx.fs.removeDir(full);
   }
 }
 
 // src/generate/install.ts
 function packageSource(ctx, cliPath2, command) {
-  const templatesDir = join16(dirname4(cliPath2), "..", "templates", "skills");
+  const templatesDir = join18(dirname4(cliPath2), "..", "templates", "skills");
   if (!ctx.fs.isDirectory(templatesDir)) {
     throw new DldError(
       `dld ${command} installs skills from the dld-kit npm package, but this copy of dld (${cliPath2}) has no templates beside it. Run it from the package instead: npx dld-kit@latest ${command}`
@@ -9609,16 +10320,51 @@ function packageSource(ctx, cliPath2, command) {
   }
   return { templatesDir, cli: ctx.fs.readFile(cliPath2) };
 }
-var isOwned = (name) => name.startsWith("dld-");
-function ownedSkills(ctx, root, layout) {
-  const dir = join16(root, layout.dir);
+var SHIPPED_SKILLS = /* @__PURE__ */ new Set([
+  "dld-adjust",
+  "dld-audit",
+  "dld-audit-auto",
+  "dld-common",
+  "dld-decide",
+  "dld-implement",
+  "dld-init",
+  "dld-lookup",
+  "dld-plan",
+  "dld-reindex",
+  "dld-retrofit",
+  "dld-snapshot",
+  "dld-status"
+]);
+var isShipped = (name) => SHIPPED_SKILLS.has(name);
+function dldEntries(ctx, root, layout) {
+  const dir = join18(root, layout.dir);
   if (!ctx.fs.isDirectory(dir)) return [];
-  return ctx.fs.readDir(dir).filter((entry) => !entry.isFile && isOwned(entry.name)).map((entry) => entry.name).sort();
+  return ctx.fs.readDir(dir).filter((entry) => !entry.isFile && entry.name.startsWith("dld-")).sort((a, b) => a.name < b.name ? -1 : 1);
+}
+function dldKitSkills(ctx, root, layout) {
+  const dir = join18(root, layout.dir);
+  const owned = /* @__PURE__ */ new Set();
+  for (const entry of dldEntries(ctx, root, layout)) {
+    if (isShipped(entry.name)) {
+      owned.add(entry.name);
+      continue;
+    }
+    if (!entry.isDirectory) continue;
+    const skillMd = join18(dir, entry.name, "SKILL.md");
+    if (!ctx.fs.isRegularFile(skillMd)) continue;
+    const content = ctx.fs.readFile(skillMd);
+    const notice2 = `Generated by dld-kit from templates/skills/${entry.name}/SKILL.md.`;
+    if (SKILL_STAMP.test(content) && content.includes(notice2)) owned.add(entry.name);
+  }
+  return owned;
+}
+function ownedSkills(ctx, root, layout) {
+  return [...dldKitSkills(ctx, root, layout)].sort();
 }
 function refuseSymlinkedSkills(ctx, root, layout) {
-  const dir = join16(root, layout.dir);
+  const dir = join18(root, layout.dir);
   if (!ctx.fs.isDirectory(dir)) return;
-  const linked = ctx.fs.readDir(dir).filter((entry) => isOwned(entry.name) && !entry.isDirectory && !entry.isFile).map((entry) => `${layout.dir}/${entry.name}`).sort();
+  const linked = ctx.fs.readDir(dir).filter((entry) => isShipped(entry.name) && !entry.isDirectory && !entry.isFile).map((entry) => `${layout.dir}/${entry.name}`).sort();
   if (linked.length === 0) return;
   throw new DldError(
     `${linked.join(", ")} ${linked.length === 1 ? "is a symlink" : "are symlinks"}, so another installer, such as npx skills, manages these skills. Update them with npx skills update, or remove them and run this command again. To set up DLD without touching them, run the dld-init skill or dld install-rule.`
@@ -9626,7 +10372,7 @@ function refuseSymlinkedSkills(ctx, root, layout) {
 }
 var SKILLS_LOCK = "skills-lock.json";
 function skillsLockWarning(ctx, root) {
-  const path = join16(root, SKILLS_LOCK);
+  const path = join18(root, SKILLS_LOCK);
   if (!ctx.fs.isRegularFile(path)) return [];
   let skills;
   try {
@@ -9635,7 +10381,7 @@ function skillsLockWarning(ctx, root) {
     return [];
   }
   if (typeof skills !== "object" || skills === null) return [];
-  const listed = Object.keys(skills).filter(isOwned).sort();
+  const listed = Object.keys(skills).filter(isShipped).sort();
   if (listed.length === 0) return [];
   return [
     `${SKILLS_LOCK} lists ${listed.join(", ")}: npx skills manages those skills, so dld update and npx skills update overwrite each other's copies. Update them with one of the two.`
@@ -9662,8 +10408,8 @@ function installedStamps(ctx, root) {
   for (const layout of LAYOUTS) {
     for (const skill of ownedSkills(ctx, root, layout)) {
       const path = `${layout.dir}/${skill}/SKILL.md`;
-      if (!ctx.fs.isRegularFile(join16(root, path))) continue;
-      stamps.push({ path, version: SKILL_STAMP.exec(ctx.fs.readFile(join16(root, path)))?.[1] });
+      if (!ctx.fs.isRegularFile(join18(root, path))) continue;
+      stamps.push({ path, version: SKILL_STAMP.exec(ctx.fs.readFile(join18(root, path)))?.[1] });
     }
   }
   return [...stamps, ...installedRuleStamps(ctx, root)];
@@ -9722,23 +10468,40 @@ function planInstall(ctx, root, request) {
     const files = generateSkills(ctx, source.templatesDir, layout.adapter, request.version, {
       extraFiles: cli
     });
-    return { layout, files };
-  });
-  const rule = planRule(ctx, root, request.rules, request.version, {
-    harnesses: request.harnesses
+    const owned = dldKitSkills(ctx, root, layout);
+    const owns = (skill) => owned.has(skill);
+    return { layout, files, owns };
   });
+  const rule = planRule(
+    ctx,
+    root,
+    request.rules,
+    request.version,
+    { harnesses: request.harnesses },
+    request.ruleText
+  );
   const warnings = layouts.length > 0 ? skillsLockWarning(ctx, root) : [];
+  for (const { layout, files, owns } of skills) {
+    const generated = new Set([...files.keys()].map((path) => path.split("/", 1)[0] ?? ""));
+    for (const { name } of dldEntries(ctx, root, layout)) {
+      if (generated.has(name) || owns(name)) continue;
+      warnings.push(
+        `${layout.dir}/${name} is not a dld-kit skill (no dld-kit stamp), so it is left in place.`
+      );
+    }
+  }
   return { skills, rule, warnings };
 }
 function applyInstall(ctx, root, plan) {
-  const skills = plan.skills.map(({ layout, files }) => {
-    const diff = writeOutput(ctx, join16(root, layout.dir), files);
+  const skills = plan.skills.map(({ layout, files, owns }) => {
+    const diff = writeOutput(ctx, join18(root, layout.dir), files, owns);
     const written = diff.changed.length + diff.missing.length;
     return {
       dir: layout.dir,
       written,
       removed: diff.extra.length,
-      unchanged: files.size - written
+      unchanged: files.size - written,
+      removedPaths: diff.extra.map((path) => `${layout.dir}/${path}`)
     };
   });
   applyRulePlan(ctx, root, plan.rule);
@@ -9750,85 +10513,6 @@ function applyInstall(ctx, root, plan) {
   };
 }
 
-// src/cli/install.ts
-var AGENT_HELP = `Agents: ${HARNESS_NAMES.join(", ")}. --agent takes a comma-separated list and can be repeated.`;
-function parseAgents(values) {
-  const names = (values ?? []).flatMap((value) => value.split(",")).map((name) => name.trim());
-  const harnesses = /* @__PURE__ */ new Set();
-  for (const name of names) {
-    if (name === "") continue;
-    const harness = findHarness(name);
-    if (harness === void 0) {
-      throw new UsageError(`unknown agent '${name}'; expected one of: ${HARNESS_NAMES.join(", ")}`);
-    }
-    harnesses.add(harness);
-  }
-  return HARNESSES.filter((harness) => harnesses.has(harness));
-}
-async function selectHarnesses(io, detected, requested, yes) {
-  const selected = /* @__PURE__ */ new Set([...detected.map((d) => d.harness), ...requested]);
-  const ordered = () => HARNESSES.filter((harness) => selected.has(harness));
-  if (io.prompt === void 0 || yes) {
-    if (selected.size === 0) {
-      throw new UsageError(
-        `no agent detected in this project; name them with --agent (${HARNESS_NAMES.join(", ")})`
-      );
-    }
-    return ordered();
-  }
-  const found = new Map(detected.map((d) => [d.harness, d.marker]));
-  const width = Math.max(...HARNESS_NAMES.map((name) => name.length));
-  for (; ; ) {
-    const lines = HARNESSES.map((harness, i) => {
-      const box = selected.has(harness) ? "[x]" : "[ ]";
-      const marker = found.get(harness);
-      const note = marker === void 0 ? "" : ` (found ${marker})`;
-      return `  ${i + 1}. ${box} ${harness.name.padEnd(width)}  ${harness.title}${note}
-`;
-    });
-    io.stdout(`Install DLD for these agents:
-${lines.join("")}`);
-    const answer = (await io.prompt("Numbers to toggle, or Enter to continue: ")).trim();
-    if (answer === "") {
-      if (selected.size > 0) return ordered();
-      io.stdout("Select at least one agent.\n");
-      continue;
-    }
-    const picks = answer.split(/[\s,]+/).map((pick) => HARNESSES[Number(pick) - 1]);
-    if (picks.some((harness) => harness === void 0)) {
-      io.stdout(`Enter numbers from 1 to ${HARNESSES.length}.
-`);
-      continue;
-    }
-    for (const harness of picks) {
-      if (harness === void 0) continue;
-      if (selected.has(harness)) selected.delete(harness);
-      else selected.add(harness);
-    }
-  }
-}
-function cliPath(io) {
-  if (io.cliPath === void 0) throw new DldError("cannot locate the running dld file");
-  return io.cliPath;
-}
-function printReport(io, report2) {
-  for (const { dir, written, removed, unchanged } of report2.skills) {
-    io.stdout(`${dir}: ${written} written, ${removed} removed, ${unchanged} unchanged
-`);
-  }
-  for (const path of report2.ruleWritten) {
-    io.stdout(
-      path === CLAUDE_IMPORT_FILE ? `Wrote ${path} (imports AGENTS.md for Claude Code)
-` : `Wrote the DLD rule to ${path}
-`
-    );
-  }
-  for (const path of report2.ruleRemoved) io.stdout(`Removed ${path} (the rule is in the block)
-`);
-  for (const warning of report2.warnings) io.stderr(`Warning: ${warning}
-`);
-}
-
 // src/cli/commands/init.ts
 var initCommand = {
   name: "init",
@@ -9865,7 +10549,7 @@ ${AGENT_HELP}
       throw new UsageError("--namespaces needs at least one namespace");
     }
     const root = findProjectRoot(ctx);
-    if (ctx.fs.lexists(join17(root, CONFIG_FILE))) {
+    if (ctx.fs.lexists(join19(root, CONFIG_FILE))) {
       throw new DldError(
         `DLD is already set up here (${CONFIG_FILE} exists). Run dld update to refresh the skills and rule, or dld update --agent <name> to add an agent.`
       );
@@ -9891,10 +10575,11 @@ ${AGENT_HELP}
     createDirectories(ctx, project);
     writeIndex(ctx, project.paths, renderIndex([], project.config.mode));
     const report2 = applyInstall(ctx, root, plan);
-    const index = relative8(root, indexPath(project.paths));
+    const index = relative11(root, indexPath(project.paths));
     io.stdout(`Created ${CONFIG_FILE} and ${index}
 `);
     printReport(io, report2);
+    ensureIndexMergeAttribute(io, ctx, project);
     io.stdout(
       `
 DLD is set up for: ${harnesses.map((harness) => harness.name).join(", ")}. Commit these files so everyone gets the same skills and rule.
@@ -9936,7 +10621,9 @@ ${AGENT_HELP}
       rules,
       version,
       force: values.force === true,
-      harnesses: requested
+      harnesses: requested,
+      // @decision(DL-074)
+      ruleText: projectRuleText(ctx, root)
     });
     const report2 = applyInstall(ctx, root, plan);
     printReport(io, report2);
@@ -9947,6 +10634,50 @@ ${AGENT_HELP}
   }
 };
 
+// src/core/proposed.ts
+import { basename as basename8, relative as relative12, sep as sep7 } from "node:path";
+function listProposed(ctx, project, base) {
+  const { paths } = project;
+  verifyBase(ctx, paths, base, " Fetch first or pass --base.");
+  const atBase = integratedRecords(ctx, paths, base).byId;
+  return listRecordFiles(ctx, paths.recordsDir).map((file) => {
+    const path = relative12(paths.root, file).split(sep7).join("/");
+    return { file, path, record: parseRecord(ctx.fs.readFile(file), path) };
+  }).filter(({ record }) => record.status === "proposed").sort((a, b) => recordNumber(a.file) - recordNumber(b.file)).map(({ file, path, record }) => {
+    const id = basename8(file, ".md");
+    return { id, title: record.title, path, addedOnBranch: !atBase.has(id) };
+  });
+}
+function formatProposed({ id, title, addedOnBranch }) {
+  return `${id}	${addedOnBranch ? "branch" : "base"}	${title}`;
+}
+
+// src/cli/commands/list-proposed.ts
+var listProposedCommand = {
+  name: "list-proposed",
+  summary: "List proposed decisions, marking those added on this branch",
+  internal: true,
+  usage: `Usage: dld list-proposed [--base <ref>]
+
+Print <DL-NNN>\\t<branch|base>\\t<title> for each proposed decision, ascending by ID: branch
+when its file does not exist at the merge-base with the base branch (added on this branch,
+committed or not), base otherwise.
+
+Options:
+  --base <ref>  Base ref (${DEFAULT_BASE_HELP})
+`,
+  run(args, io, ctx) {
+    const { values } = parseCommandArgs({ args: [...args], options: { base: { type: "string" } } });
+    const project = loadProject(ctx);
+    const base = baseOption(values.base, { ctx, project });
+    for (const proposed of listProposed(ctx, project, base)) {
+      io.stdout(`${formatProposed(proposed)}
+`);
+    }
+    return EXIT_OK;
+  }
+};
+
 // src/cli/commands/list-taken-ids.ts
 var listTakenIdsCommand = {
   name: "list-taken-ids",
@@ -9958,12 +10689,13 @@ Print the decision IDs on the base branch and in records touched by open pull re
 (via gh, when available), one per line, sorted.
 
 Options:
-  --base <ref>  Base ref (default: origin/main)
+  --base <ref>  Base ref (${DEFAULT_BASE_HELP})
 `,
   run(args, io, ctx) {
     const { values } = parseCommandArgs({ args: [...args], options: { base: { type: "string" } } });
-    const base = baseOption(values.base);
-    const { ids, skipped } = listTakenIds(ctx, loadProject(ctx), base);
+    const project = loadProject(ctx);
+    const base = baseOption(values.base, { ctx, project });
+    const { ids, skipped } = listTakenIds(ctx, project, base);
     for (const id of ids) io.stdout(`${id}
 `);
     if (skipped !== void 0) io.stderr(skippedNotice(skipped));
@@ -9997,12 +10729,13 @@ Print <path>\\t<DL-OLD>\\t<DL-NEW> for each colliding local decision, assigning
 IDs. Prints nothing when there are no collisions.
 
 Options:
-  --base <ref>  Base ref (default: origin/main)
+  --base <ref>  Base ref (${DEFAULT_BASE_HELP})
 `,
   run(args, io, ctx) {
     const { values } = parseCommandArgs({ args: [...args], options: { base: { type: "string" } } });
-    const base = baseOption(values.base);
-    const { renames, skipped } = planRenames(ctx, loadProject(ctx), base);
+    const project = loadProject(ctx);
+    const base = baseOption(values.base, { ctx, project });
+    const { renames, skipped } = planRenames(ctx, project, base);
     for (const rename of renames) io.stdout(`${formatRename(rename)}
 `);
     if (skipped !== void 0) io.stderr(skippedNotice(skipped));
@@ -10011,6 +10744,7 @@ Options:
 };
 
 // src/cli/commands/regenerate-index.ts
+import { basename as basename9, relative as relative13 } from "node:path";
 var regenerateIndexCommand = {
   name: "regenerate-index",
   summary: "Rebuild INDEX.md from the decision records",
@@ -10031,6 +10765,11 @@ Options:
     if (!ctx.fs.isDirectory(paths.recordsDir)) {
       throw new DldError(`records directory not found at ${paths.recordsDir}`);
     }
+    for (const files of duplicateRecordFiles(ctx, paths.recordsDir)) {
+      const ids = [...new Set(files.map((path) => basename9(path, ".md")))].join(" / ");
+      const shown = files.map((path) => relative13(paths.root, path)).join(", ");
+      ctx.warn(`${ids} is in more than one file: ${shown}`);
+    }
     const rows = collectIndexRows(ctx, paths, values["include-base"]);
     writeIndex(ctx, paths, renderIndex(rows, config.mode));
     io.stdout(rows.length === 0 ? "INDEX.md regenerated (empty).\n" : "INDEX.md regenerated.\n");
@@ -10038,6 +10777,76 @@ Options:
   }
 };
 
+// src/core/related.ts
+import { basename as basename10, relative as relative14, sep as sep8 } from "node:path";
+var RELATIONS = ["amends", "supersedes", "amended-by", "superseded-by"];
+var idNumber3 = (id) => DECISION_ID.test(id) ? Number.parseInt(id.slice(3), 10) : Number.POSITIVE_INFINITY;
+function relatedDecisions(ctx, project, id) {
+  const { paths } = project;
+  const targetFile = findRecordFile(ctx, paths.recordsDir, id, paths.root);
+  if (targetFile === void 0) throw new DldError(`decision ${id} not found.`);
+  const records = listRecordFiles(ctx, paths.recordsDir).map((file) => {
+    const path = relative14(paths.root, file).split(sep8).join("/");
+    return { file, id: basename10(file, ".md"), record: parseRecord(ctx.fs.readFile(file), path) };
+  });
+  const byId = new Map(records.map((entry) => [entry.id, entry.record]));
+  const target = records.find((entry) => entry.file === targetFile)?.record;
+  if (target === void 0) throw new DldError(`decision ${id} not found.`);
+  const related = [];
+  const add = (relation, other) => {
+    const record = byId.get(other);
+    related.push({
+      relation,
+      id: other,
+      status: record?.status ?? "missing",
+      title: record?.title ?? ""
+    });
+  };
+  for (const other of target.amends) add("amends", other);
+  for (const other of target.supersedes) add("supersedes", other);
+  for (const entry of records) {
+    if (entry.file === targetFile) continue;
+    if (entry.record.amends.includes(id)) add("amended-by", entry.id);
+    if (entry.record.supersedes.includes(id)) add("superseded-by", entry.id);
+  }
+  return related.sort(
+    (a, b) => idNumber3(a.id) - idNumber3(b.id) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0) || RELATIONS.indexOf(a.relation) - RELATIONS.indexOf(b.relation)
+  );
+}
+function formatRelated({ relation, id, status, title }) {
+  return `${relation}	${id}	${status}	${title}`;
+}
+
+// src/cli/commands/related-decisions.ts
+var relatedDecisionsCommand = {
+  name: "related-decisions",
+  summary: "List the decisions a decision amends or supersedes, and those that amend or supersede it",
+  internal: true,
+  usage: `Usage: dld related-decisions <DL-NNN>
+
+Print <relation>\\t<DL-NNN>\\t<status>\\t<title> for each related decision, ascending by ID.
+Relations: amends and supersedes (from the decision's own frontmatter), amended-by and
+superseded-by (records whose amends or supersedes list it). A listed ID with no record has
+status missing. Exits 1 if the decision does not exist.
+`,
+  run(args, io, ctx) {
+    const { positionals } = parseCommandArgs({
+      args: [...args],
+      options: {},
+      allowPositionals: true
+    });
+    const [id, ...extra] = positionals;
+    if (id === void 0 || !DECISION_ID.test(id))
+      throw new UsageError("expected one decision ID like DL-001");
+    if (extra.length > 0) throw new UsageError(`unexpected argument '${extra[0]}'`);
+    for (const related of relatedDecisions(ctx, loadProject(ctx), id)) {
+      io.stdout(`${formatRelated(related)}
+`);
+    }
+    return EXIT_OK;
+  }
+};
+
 // src/cli/commands/rename-decision.ts
 var renameDecisionCommand = {
   name: "rename-decision",
@@ -10052,7 +10861,7 @@ Options:
   --old <DL-OLD>  Current ID (required)
   --new <DL-NEW>  New ID (required)
   --path <path>   Record path relative to the project root (required)
-  --base <ref>    Base ref for the local change set (default: origin/main)
+  --base <ref>    Base ref for the local change set (${DEFAULT_BASE_HELP})
 `,
   run(args, io, ctx) {
     const { values } = parseCommandArgs({
@@ -10066,8 +10875,9 @@ Options:
     });
     const { old: oldId, new: newId, path } = values;
     if (!oldId || !newId || !path) throw new DldError("--old, --new, and --path are required.");
-    const base = baseOption(values.base);
-    const newPath = renameDecision(ctx, loadProject(ctx), { path, oldId, newId }, base);
+    const project = loadProject(ctx);
+    const base = baseOption(values.base, { ctx, project });
+    const newPath = renameDecision(ctx, project, { path, oldId, newId }, base);
     io.stdout(`${path} -> ${newPath}
 `);
     return EXIT_OK;
@@ -10075,19 +10885,63 @@ Options:
 };
 
 // src/cli/commands/resolve-base.ts
+import { join as join20 } from "node:path";
 var resolveBaseCommand = {
   name: "resolve-base",
   summary: "Print the base ref to check decision IDs against",
   internal: true,
   usage: `Usage: dld resolve-base
 
-Print the current branch's upstream when it tracks a differently named branch, otherwise
-origin/main.
+Print the base ref: base_branch from dld.config.yaml (origin/<name>, else <name>); else the
+current branch's upstream when it tracks a differently named branch; else origin/HEAD; else
+origin/main, then main. Only a ref that exists is printed; when none does, exit 1.
 `,
   run(args, io, ctx) {
     parseCommandArgs({ args: [...args], options: {} });
-    io.stdout(`${resolveBase(ctx)}
+    const root = findProjectRoot(ctx);
+    const config = ctx.fs.exists(join20(root, CONFIG_FILE)) ? loadConfig(ctx, root) : void 0;
+    io.stdout(`${resolveBase(ctx, config?.baseBranch)}
+`);
+    return EXIT_OK;
+  }
+};
+
+// src/cli/commands/restore-decision-prose.ts
+var restoreDecisionProseCommand = {
+  name: "restore-decision-prose",
+  summary: "Restore the body of decisions already on the base branch",
+  internal: true,
+  usage: `Usage: dld restore-decision-prose [--base <ref>] [--uncommitted] <DL-NNN> [DL-NNN ...]
+
+Put back the body (the text after the frontmatter), id and timestamp of each decision as
+they are at the merge-base of the base branch and HEAD, keeping the rest of the current
+frontmatter. A deleted decision
+is restored whole and staged. Fails for a draft.
+
+Options:
+  --base <ref>     Base ref (${DEFAULT_BASE_HELP})
+  --uncommitted    Restore from HEAD instead of the merge-base: undo only uncommitted edits
+`,
+  run(args, io, ctx) {
+    const { values, positionals: ids } = parseCommandArgs({
+      args: [...args],
+      options: { base: { type: "string" }, uncommitted: { type: "boolean" } },
+      allowPositionals: true
+    });
+    if (ids.length === 0) throw new UsageError("expected at least one decision ID");
+    const bad = ids.find((id) => !DECISION_ID.test(id));
+    if (bad !== void 0) throw new UsageError(`expected decision IDs like DL-001, got '${bad}'`);
+    const project = loadProject(ctx);
+    const base = editBase(
+      ctx,
+      project,
+      values.base === void 0 ? void 0 : baseOption(values.base)
+    );
+    const uncommitted = values.uncommitted === true;
+    for (const path of restoreDecisionProse(ctx, project, base, ids, { uncommitted })) {
+      io.stdout(`Restored ${path}
 `);
+    }
     return EXIT_OK;
   }
 };
@@ -10136,7 +10990,7 @@ Agents: ${HARNESS_NAMES.join(", ")}.
 };
 
 // src/cli/commands/update.ts
-import { join as join18 } from "node:path";
+import { join as join21 } from "node:path";
 var updateCommand = {
   name: "update",
   summary: "Refresh the installed DLD skills and rule to this version",
@@ -10159,9 +11013,10 @@ ${AGENT_HELP}
     });
     const requested = parseAgents(values.agent);
     const root = findProjectRoot(ctx);
-    if (!ctx.fs.lexists(join18(root, CONFIG_FILE))) {
+    if (!ctx.fs.lexists(join21(root, CONFIG_FILE))) {
       throw new DldError(`DLD is not set up here (${CONFIG_FILE} not found). Run dld init first.`);
     }
+    const project = loadProject(ctx);
     const installed = installedTargets(ctx, root);
     const added = targetsFor(requested);
     const layouts = /* @__PURE__ */ new Set([...installed.layouts, ...added.layouts]);
@@ -10177,11 +11032,14 @@ ${AGENT_HELP}
       rules,
       version,
       force: values.force === true,
-      harnesses: requested
+      harnesses: requested,
+      // @decision(DL-074)
+      ruleText: ruleTextFor(project.config.annotationPrefix)
     });
     const report2 = applyInstall(ctx, root, plan);
     report2.warnings.push(...missingAgentsRuleWarning({ layouts, rules }));
     printReport(io, report2);
+    ensureIndexMergeAttribute(io, ctx, project);
     return EXIT_OK;
   }
 };
@@ -10194,8 +11052,8 @@ var updateAuditStateCommand = {
   usage: "Usage: dld update-audit-state\n\nRecord the current time and HEAD commit as the last audit.\n",
   run(args, io, ctx) {
     parseCommandArgs({ args: [...args], options: {} });
-    const { timestamp, commit } = updateAuditState(ctx, loadProject(ctx));
-    io.stdout(`Audit state updated: ${timestamp} at ${commit}
+    const { timestamp, commit: commit2 } = updateAuditState(ctx, loadProject(ctx));
+    io.stdout(`Audit state updated: ${timestamp} at ${commit2}
 `);
     return EXIT_OK;
   }
@@ -10217,8 +11075,8 @@ SNAPSHOT.md, OVERVIEW.md and any custom artifacts named.
       options: {},
       allowPositionals: true
     });
-    const { timestamp, commit, highest } = updateSnapshotState(ctx, loadProject(ctx), positionals);
-    io.stdout(`Snapshot state updated: ${timestamp} at ${commit} (through ${formatId(highest)})
+    const { timestamp, commit: commit2, highest } = updateSnapshotState(ctx, loadProject(ctx), positionals);
+    io.stdout(`Snapshot state updated: ${timestamp} at ${commit2} (through ${formatId(highest)})
 `);
     return EXIT_OK;
   }
@@ -10271,7 +11129,15 @@ var verifyAnnotationsCommand = {
     if (ids.length === 0) throw new UsageError("expected at least one decision ID");
     const options = scanOptionsFor(loadProject(ctx));
     const prefix = options.prefix;
-    const missing = missingAnnotations(ctx, options, ids);
+    const missing = missingAnnotations(
+      ctx,
+      options,
+      ids,
+      (skipped) => io.stderr(`${formatSkipped(skipped)}
+`),
+      // @decision(DL-074)
+      (nearMiss) => ctx.warn(formatNearMiss(nearMiss))
+    );
     if (missing.length > 0) {
       io.stdout(`MISSING annotations in source code for: ${missing.join(" ")}
 `);
@@ -10292,14 +11158,18 @@ var COMMANDS = [
   updateCommand,
   installRuleCommand,
   sessionContextCommand,
+  checkDecisionEditsCommand,
   createConfigCommand,
   createDirectoriesCommand,
   createEmptyIndexCommand,
   nextIdCommand,
   createDecisionCommand,
   updateStatusCommand,
+  listProposedCommand,
+  relatedDecisionsCommand,
   regenerateIndexCommand,
   verifyAnnotationsCommand,
+  restoreDecisionProseCommand,
   findAnnotationsCommand,
   findMissingAmendsCommand,
   updateAuditStateCommand,
@@ -10320,7 +11190,7 @@ function usage(commands) {
   const list = (group) => group.map((c) => `  ${c.name.padEnd(25)} ${c.summary}`).join("\n");
   const setup = commands.filter((c) => !c.internal);
   const internal = commands.filter((c) => c.internal);
-  const sections = [`Setup commands:
+  const sections = [`Setup and CI commands:
 ${list(setup)}`];
   if (internal.length > 0) sections.push(`${INTERNAL_HEADING}:
 ${list(internal)}`);
@@ -10355,8 +11225,18 @@ function run(argv, io, ctx, commands = COMMANDS) {
 ${usage(commands)}`);
     return EXIT_USAGE;
   }
+  const printed = /* @__PURE__ */ new Set();
+  const runCtx = {
+    ...ctx,
+    warn: (message) => {
+      if (printed.has(message)) return;
+      printed.add(message);
+      io.stderr(`Warning: ${message}
+`);
+    }
+  };
   try {
-    const result = command.run(rest, io, ctx);
+    const result = command.run(rest, io, runCtx);
     if (typeof result === "number") return result;
     return result.catch((error) => report(error, command, io));
   } catch (error) {
@@ -10412,6 +11292,7 @@ var nodeFileSystem = {
   lexists: (path) => fsCall("read", path, () => lstatSync(path, { throwIfNoEntry: false }) !== void 0),
   isRegularFile: (path) => fsCall("read", path, () => lstatSync(path, { throwIfNoEntry: false })?.isFile() ?? false),
   readFile: (path) => fsCall("read", path, () => readFileSync(path, "utf8")),
+  fileSize: (path) => fsCall("read", path, () => lstatSync(path).size),
   readBytes: (path) => fsCall("read", path, () => readFileSync(path)),
   readDir: (path) => fsCall(
     "read",
@@ -10495,7 +11376,12 @@ function createNodeContext(cwd, env) {
     gh: nodeGh(cwd, env),
     env,
     readStdin: () => fsCall("read", "standard input", () => readFileSync(0, "utf8")),
-    now: () => /* @__PURE__ */ new Date()
+    now: () => /* @__PURE__ */ new Date(),
+    // @decision(DL-079)
+    warn: (message) => {
+      process.stderr.write(`Warning: ${message}
+`);
+    }
   };
 }
 function hasCode(error, code) {