@gonrocca/zero-pi 0.1.48 → 0.1.50

package/extensions/sdd-config.ts

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface SddConfig {
+  git: {
+    branchPrefix: string;
+    numbering: boolean;
+    autoCommit: boolean;
+    commitStyle: "conventional" | "plain";
+    baseBranch: string;
+  };
+}
+
+export const DEFAULT_SDD_CONFIG: SddConfig = {
+  git: { branchPrefix: "sdd/", numbering: false, autoCommit: false, commitStyle: "conventional", baseBranch: "main" },
+};
+
+function asObject(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+export function loadSddConfig(root = process.cwd()): SddConfig {
+  const path = join(root, ".sdd", "config.json");
+  if (!existsSync(path)) return structuredClone(DEFAULT_SDD_CONFIG);
+  let parsed: Record<string, unknown>;
+  try { parsed = asObject(JSON.parse(readFileSync(path, "utf8"))); }
+  catch (err) { throw new Error(`invalid .sdd/config.json: ${err instanceof Error ? err.message : String(err)}`); }
+  const git = asObject(parsed.git);
+  return {
+    git: {
+      branchPrefix: typeof git.branchPrefix === "string" ? git.branchPrefix : DEFAULT_SDD_CONFIG.git.branchPrefix,
+      numbering: typeof git.numbering === "boolean" ? git.numbering : DEFAULT_SDD_CONFIG.git.numbering,
+      autoCommit: typeof git.autoCommit === "boolean" ? git.autoCommit : DEFAULT_SDD_CONFIG.git.autoCommit,
+      commitStyle: git.commitStyle === "plain" ? "plain" : DEFAULT_SDD_CONFIG.git.commitStyle,
+      baseBranch: typeof git.baseBranch === "string" ? git.baseBranch : DEFAULT_SDD_CONFIG.git.baseBranch,
+    },
+  };
+}

package/extensions/sdd-links.ts

@@ -0,0 +1,48 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface SddLinks {
+  prNumber?: number;
+  prUrl?: string;
+  issueNumber?: number;
+  issueUrl?: string;
+  branch?: string;
+  baseBranch?: string;
+  archivePath?: string;
+  createdAt?: string;
+  [key: string]: unknown;
+}
+
+export type LinksRecord = SddLinks;
+
+function linksPath(sddDir: string, slug: string): string {
+  return join(sddDir, slug, "links.json");
+}
+
+function validRecord(value: unknown): SddLinks {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value as SddLinks : {};
+}
+
+export function readLinks(sddDir: string, slug: string): SddLinks {
+  const path = linksPath(sddDir, slug);
+  if (!existsSync(path)) return {};
+  try {
+    return validRecord(JSON.parse(readFileSync(path, "utf8")));
+  } catch {
+    return {};
+  }
+}
+
+export function mergeLinks(current: SddLinks, partial: SddLinks): SddLinks {
+  return { ...validRecord(current), ...validRecord(partial) };
+}
+
+export function writeLinks(sddDir: string, slug: string, partial: SddLinks): SddLinks {
+  const path = linksPath(sddDir, slug);
+  const next = mergeLinks(readLinks(sddDir, slug), partial);
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  renameSync(tmp, path);
+  return next;
+}

package/extensions/spec-merge-extension.ts

@@ -114,6 +114,7 @@ function renderSyncReport(slug: string, date: string, summary: MergeSummary): st
     "",
     section("Added", summary.added),
     section("Modified", summary.modified),
+    section("Renamed", summary.renamed.map((r) => `${r.from} -> ${r.to}`)),
     section("Removed", summary.removed),
   ].join("\n");
 }
@@ -125,6 +126,9 @@ function describeSummary(summary: MergeSummary): string {
   if (summary.modified.length > 0) {
     lines.push(`  modificados:  ${summary.modified.join(", ")}  (reemplaza el texto de spec existente)`);
   }
+  if (summary.renamed.length > 0) {
+    lines.push(`  renombrados:  ${summary.renamed.map((r) => `${r.from} → ${r.to}`).join(", ")}  (mantiene la posición en el store)`);
+  }
   if (summary.removed.length > 0) {
     lines.push(`  eliminados:   ${summary.removed.join(", ")}  (borra del store)`);
   }

package/extensions/spec-merge.ts

@@ -1,95 +1,65 @@
 // zero-pi — canonical spec store delta-merge engine, pure-logic module.
-//
-// zero keeps a project-wide canonical spec store under `.sdd/specs/`. Every
-// `/forge` run produces a *delta* (`.sdd/<slug>/spec.md`) and, once the run
-// reaches a `pasa` verdict, the delta is folded into the store. The merge
-// *must* be deterministic and reproducible (the same delta against the same
-// store always yields the same result) — so every parsing, guardrail, and
-// merge decision lives here in plain, dependency-free TypeScript, exactly like
-// `autotune.ts`. The pi wiring lives in `spec-merge-extension.ts`.
-//
-// This file has no pi imports, no filesystem access, and no side-effecting
-// top-level code: parsing and merging are pure string work. It never throws on
-// malformed input — a bad emission degrades to a surfaced `MergeError`, never
-// a corrupted store.
 
 /** One named requirement: stable name + raw body text (criteria included). */
 export interface RequirementBlock {
   name: string;
-  /** Verbatim block body, trimmed; `""` allowed for a REMOVED entry. */
   body: string;
 }
 
-/** A parsed delta — three buckets, any may be empty. */
+export interface RenameBlock {
+  from: string;
+  to: string;
+  body: string;
+}
+
+/** A parsed delta — four buckets, any may be empty. */
 export interface SpecDelta {
   added: RequirementBlock[];
   modified: RequirementBlock[];
   removed: RequirementBlock[];
+  renamed: RenameBlock[];
 }
 
 /** A guardrail violation. `kind` drives the human message. */
 export interface MergeError {
   kind:
-    | "duplicate-in-delta" // same name twice across/within delta sections
-    | "added-name-collision" // ADDED name already in the store
-    | "modified-missing" // MODIFIED names a block absent from the store
-    | "removed-missing" // REMOVED names a block absent from the store
-    | "parse-error"; // malformed store or delta input
-  /** Offending requirement name (`""` for a `parse-error`). */
+    | "duplicate-in-delta"
+    | "added-name-collision"
+    | "modified-missing"
+    | "removed-missing"
+    | "renamed-missing"
+    | "renamed-to-collision"
+    | "renamed-duplicate"
+    | "renamed-parse-error"
+    | "parse-error";
   name: string;
-  /** Ready-to-surface explanation. */
   message: string;
 }
 
 /** What a successful merge changed — drives the sync report. */
 export interface MergeSummary {
-  added: string[]; // names appended
-  modified: string[]; // names replaced
-  removed: string[]; // names deleted
+  added: string[];
+  modified: string[];
+  removed: string[];
+  renamed: { from: string; to: string }[];
 }
 
-/** Result of a merge attempt: either the new store text, or the errors. */
 export type MergeResult =
   | { ok: true; store: string; summary: MergeSummary }
   | { ok: false; errors: MergeError[] };
 
-/** The pinned `# ` title line of `.sdd/specs/requirements.md`. A stable title
- *  keeps `renderStore` ↔ `parseStore` a clean round-trip. */
 export const STORE_TITLE = "Canonical specs";
 
-/** Matches a requirement-block header: `### REQ: <name>`. The name is
- *  everything after `REQ:`, captured for trimming by the caller. */
 const REQ_HEADER = /^###\s+REQ:\s*(.*)$/;
+const SECTION_HEADER = /^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s*$/i;
+const FROM_LINE = /^from:\s*(.+?)\s*$/i;
 
-/** Matches a delta section header: `## ADDED` / `## MODIFIED` / `## REMOVED`
- *  (case-insensitive on the keyword). */
-const SECTION_HEADER = /^##\s+(ADDED|MODIFIED|REMOVED)\s*$/i;
-
-// ---------------------------------------------------------------------------
-// Parsing
-// ---------------------------------------------------------------------------
-
-/**
- * Split a run of text lines into `### REQ:` blocks.
- *
- * Each block starts at a `### REQ:` header and runs up to (but not including)
- * the next `### REQ:` header or the end of the input. The name is everything
- * after `REQ:`, trimmed; the body is every following line up to the next
- * header, joined and trimmed. Lines before the first header are ignored — they
- * are a title or a section heading the caller already consumed. A header with
- * an empty name still produces a block (with `name === ""`); the caller's
- * guardrails decide whether that is acceptable.
- */
 function parseBlocks(lines: readonly string[]): RequirementBlock[] {
   const blocks: RequirementBlock[] = [];
   let current: { name: string; body: string[] } | null = null;
-
   const flush = (): void => {
-    if (current !== null) {
-      blocks.push({ name: current.name, body: current.body.join("\n").trim() });
-    }
+    if (current !== null) blocks.push({ name: current.name, body: current.body.join("\n").trim() });
   };
-
   for (const line of lines) {
     const header = line.match(REQ_HEADER);
     if (header !== null) {
@@ -100,47 +70,52 @@ function parseBlocks(lines: readonly string[]): RequirementBlock[] {
     }
   }
   flush();
-
   return blocks;
 }
 
-/**
- * Parse a canonical store file into ordered blocks.
- *
- * The store is a `# ` title line followed by a sequence of `### REQ:` blocks —
- * there are no `## ADDED` etc. headings in the *store*. Any line before the
- * first `### REQ:` header (the title, blank lines) is ignored. Never throws:
- * malformed input simply yields whatever blocks could be recognized — the
- * caller's `parse-error` guardrail decides whether the result is usable.
- * Empty or whitespace-only text yields `[]`.
- */
+function parseRenameBlocks(lines: readonly string[]): RenameBlock[] {
+  return parseBlocks(lines).map((block) => {
+    const bodyLines = block.body.split(/\r?\n/);
+    let from = "";
+    const kept: string[] = [];
+    let lifted = false;
+    for (const line of bodyLines) {
+      const match = line.match(FROM_LINE);
+      if (!lifted && match !== null) {
+        from = match[1].trim();
+        lifted = true;
+      } else {
+        kept.push(line);
+      }
+    }
+    return { from, to: block.name, body: kept.join("\n").trim() };
+  });
+}
+
 export function parseStore(text: string): RequirementBlock[] {
   if (typeof text !== "string") return [];
   return parseBlocks(text.split(/\r?\n/));
 }
 
-/**
- * Parse a delta `spec.md` into a `SpecDelta`.
- *
- * Walks the file line by line, switching the active bucket on each
- * `## ADDED` / `## MODIFIED` / `## REMOVED` header and collecting the
- * `### REQ:` blocks that follow into that bucket. Lines outside any section
- * (the `# ` title, blank lines) are ignored. An absent or empty section simply
- * yields an empty bucket. Never throws — missing/non-string text yields an
- * empty delta. A `### REQ:` block that appears before any section header is
- * dropped (it belongs to no bucket); the caller treats a delta with zero
- * blocks as "empty delta — nothing to sync", not an error.
- */
+export function loadCanonical(text: string | undefined | null): { blocks: RequirementBlock[]; errors: MergeError[] } {
+  const source = text ?? "";
+  const blocks = parseStore(source);
+  const errors = blocks.some((b) => b.name === "")
+    ? [{ kind: "parse-error" as const, name: "", message: "malformed canonical store: empty REQ name" }]
+    : [];
+  return { blocks, errors };
+}
+
 export function parseDelta(text: string): SpecDelta {
-  const delta: SpecDelta = { added: [], modified: [], removed: [] };
+  const delta: SpecDelta = { added: [], modified: [], removed: [], renamed: [] };
   if (typeof text !== "string") return delta;
 
   let section: keyof SpecDelta | null = null;
   let buffer: string[] = [];
-
   const flush = (): void => {
     if (section !== null && buffer.length > 0) {
-      delta[section].push(...parseBlocks(buffer));
+      if (section === "renamed") delta.renamed.push(...parseRenameBlocks(buffer));
+      else delta[section].push(...parseBlocks(buffer));
     }
     buffer = [];
   };
@@ -151,150 +126,113 @@ export function parseDelta(text: string): SpecDelta {
       flush();
       const keyword = sectionHeader[1].toUpperCase();
       section =
-        keyword === "ADDED" ? "added" : keyword === "MODIFIED" ? "modified" : "removed";
+        keyword === "ADDED"
+          ? "added"
+          : keyword === "MODIFIED"
+            ? "modified"
+            : keyword === "REMOVED"
+              ? "removed"
+              : "renamed";
       continue;
     }
     if (section !== null) buffer.push(line);
   }
   flush();
-
   return delta;
 }
 
-/** Total block count across the three delta buckets. */
 function deltaBlockCount(delta: SpecDelta): number {
-  return delta.added.length + delta.modified.length + delta.removed.length;
+  return delta.added.length + delta.modified.length + delta.removed.length + delta.renamed.length;
 }
 
-// ---------------------------------------------------------------------------
-// Guardrails
-// ---------------------------------------------------------------------------
-
-/**
- * Run every guardrail check against a parsed store + delta.
- *
- * Returns a `MergeError[]` — empty when the merge is safe to apply. Each error
- * carries the offending `name` and a ready-to-surface `message`. The checks,
- * in order:
- *
- *   - `parse-error`     — a block (store or delta) carries an empty name; the
- *                         input could not be structurally understood.
- *   - `duplicate-in-delta` — the same name appears more than once across (or
- *                         within) the ADDED/MODIFIED/REMOVED sections.
- *   - `added-name-collision` — an ADDED name already exists in the store (to
- *                         *change* a block the run must use MODIFIED).
- *   - `modified-missing` — a MODIFIED block names a requirement absent from
- *                         the store.
- *   - `removed-missing` — a REMOVED block names a requirement absent from the
- *                         store.
- *
- * Pure, never throws. `mergeDelta` runs this before applying *any* change, so
- * a non-empty result means the whole delta is rejected and the store is left
- * untouched.
- */
 export function checkGuardrails(
   store: readonly RequirementBlock[],
   delta: SpecDelta,
 ): MergeError[] {
   const errors: MergeError[] = [];
 
-  // parse-error — any block (store or delta) with an empty name is malformed.
   for (const block of store) {
     if (block.name === "") {
-      errors.push({
-        kind: "parse-error",
-        name: "",
-        message:
-          "malformed store: a `### REQ:` block has an empty name — the store could not be parsed",
-      });
+      errors.push({ kind: "parse-error", name: "", message: "malformed store: a `### REQ:` block has an empty name — the store could not be parsed" });
       break;
     }
   }
   for (const block of [...delta.added, ...delta.modified, ...delta.removed]) {
     if (block.name === "") {
-      errors.push({
-        kind: "parse-error",
-        name: "",
-        message:
-          "malformed delta: a `### REQ:` block has an empty name — the delta could not be parsed",
-      });
+      errors.push({ kind: "parse-error", name: "", message: "malformed delta: a `### REQ:` block has an empty name — the delta could not be parsed" });
+      break;
+    }
+  }
+  for (const block of delta.renamed) {
+    if (block.to === "" || block.from === "") {
+      errors.push({ kind: "renamed-parse-error", name: block.to || block.from, message: `RENAMED requirement "${block.to || block.from || "(empty)"}" must include both a target name and a \`from: <name>\` line` });
       break;
     }
   }
 
-  // duplicate-in-delta — the same name twice across all three delta sections.
   const seen = new Set<string>();
   const flagged = new Set<string>();
   for (const block of [...delta.added, ...delta.modified, ...delta.removed]) {
-    if (block.name === "") continue; // already reported as a parse-error
+    if (block.name === "") continue;
     if (seen.has(block.name)) {
       if (!flagged.has(block.name)) {
         flagged.add(block.name);
-        errors.push({
-          kind: "duplicate-in-delta",
-          name: block.name,
-          message: `duplicate requirement "${block.name}": it appears more than once in the delta — each requirement may appear at most once across ADDED/MODIFIED/REMOVED`,
-        });
+        errors.push({ kind: "duplicate-in-delta", name: block.name, message: `duplicate requirement "${block.name}": it appears more than once in the delta — each requirement may appear at most once across ADDED/MODIFIED/REMOVED` });
       }
-    } else {
-      seen.add(block.name);
+    } else seen.add(block.name);
+  }
+
+  const renameSeen = new Set<string>();
+  const modifiedNames = new Set(delta.modified.map((b) => b.name));
+  for (const block of delta.renamed) {
+    if (block.from === "" || block.to === "") continue;
+    for (const name of [block.from, block.to]) {
+      const allowedRenameThenModify = name === block.to && modifiedNames.has(name);
+      if (renameSeen.has(name) || (seen.has(name) && !allowedRenameThenModify)) {
+        if (!flagged.has(name)) {
+          flagged.add(name);
+          errors.push({ kind: "renamed-duplicate", name, message: `RENAMED requirement "${name}" conflicts with another delta entry — rename source and target names must be unique` });
+        }
+      } else renameSeen.add(name);
     }
   }
 
   const storeNames = new Set(store.map((b) => b.name));
+  const removedNames = new Set(delta.removed.map((b) => b.name));
+  const renameFrom = new Set(delta.renamed.map((b) => b.from).filter(Boolean));
 
-  // added-name-collision — an ADDED name already exists in the store.
   for (const block of delta.added) {
-    if (block.name === "") continue;
-    if (storeNames.has(block.name)) {
-      errors.push({
-        kind: "added-name-collision",
-        name: block.name,
-        message: `ADDED requirement "${block.name}" already exists in the store — use MODIFIED to change an existing requirement`,
-      });
+    if (block.name !== "" && storeNames.has(block.name) && !removedNames.has(block.name) && !renameFrom.has(block.name)) {
+      errors.push({ kind: "added-name-collision", name: block.name, message: `ADDED requirement "${block.name}" already exists in the store — use MODIFIED to change an existing requirement` });
     }
   }
-
-  // modified-missing — a MODIFIED name is absent from the store.
   for (const block of delta.modified) {
-    if (block.name === "") continue;
-    if (!storeNames.has(block.name)) {
-      errors.push({
-        kind: "modified-missing",
-        name: block.name,
-        message: `MODIFIED requirement "${block.name}" is not in the store — only an existing requirement can be modified`,
-      });
+    if (block.name !== "" && !storeNames.has(block.name) && !delta.renamed.some((r) => r.to === block.name)) {
+      errors.push({ kind: "modified-missing", name: block.name, message: `MODIFIED requirement "${block.name}" is not in the store — only an existing requirement can be modified` });
     }
   }
-
-  // removed-missing — a REMOVED name is absent from the store.
   for (const block of delta.removed) {
-    if (block.name === "") continue;
-    if (!storeNames.has(block.name)) {
-      errors.push({
-        kind: "removed-missing",
-        name: block.name,
-        message: `REMOVED requirement "${block.name}" is not in the store — only an existing requirement can be removed`,
-      });
+    if (block.name !== "" && !storeNames.has(block.name)) {
+      errors.push({ kind: "removed-missing", name: block.name, message: `REMOVED requirement "${block.name}" is not in the store — only an existing requirement can be removed` });
+    }
+  }
+  for (const block of delta.renamed) {
+    if (block.from === "" || block.to === "") continue;
+    if (!storeNames.has(block.from)) {
+      errors.push({ kind: "renamed-missing", name: block.from, message: `RENAMED requirement "${block.from}" is not in the store — only an existing requirement can be renamed` });
+    }
+    if (storeNames.has(block.to) && block.to !== block.from && !removedNames.has(block.to) && !renameFrom.has(block.to)) {
+      errors.push({ kind: "renamed-to-collision", name: block.to, message: `RENAMED target "${block.to}" already exists in the store — choose a new requirement name` });
     }
   }
 
   return errors;
 }
 
-// ---------------------------------------------------------------------------
-// Render
-// ---------------------------------------------------------------------------
+export function serializeCanonical(blocks: readonly RequirementBlock[], title: string = STORE_TITLE): string {
+  return renderStore([...blocks].sort((a, b) => a.name.localeCompare(b.name)), title);
+}
 
-/**
- * Render an ordered block list back to canonical store markdown.
- *
- * The output is a `# ` title line, a blank line, then every block as a
- * `### REQ: <name>` header followed by its body. Blocks are separated by a
- * blank line. Round-trips with `parseStore`: `parseStore(renderStore(blocks))`
- * yields the same names and (trimmed) bodies. `title` defaults to the pinned
- * `STORE_TITLE`. The result always ends with a single trailing newline.
- */
 export function renderStore(blocks: readonly RequirementBlock[], title: string = STORE_TITLE): string {
   const parts: string[] = [`# ${title}`];
   for (const block of blocks) {
@@ -304,70 +242,35 @@ export function renderStore(blocks: readonly RequirementBlock[], title: string =
   return `${parts.join("\n\n")}\n`;
 }
 
-// ---------------------------------------------------------------------------
-// Merge entry point
-// ---------------------------------------------------------------------------
-
-/**
- * The whole pipeline: parse both inputs, run every guardrail, and — only when
- * there are zero errors — apply the delta and render the new store.
- *
- * This is the single entry point the `/zero-sync` wiring calls. It is pure: no
- * filesystem, no pi, never throws.
- *
- * On any guardrail error it returns `{ ok: false, errors }` and **no store
- * text is produced** — a partially-applied store is structurally impossible,
- * because the merge runs after *all* guardrails pass. On success it returns
- * `{ ok: true, store, summary }` where the delta has been applied as:
- *
- *   - ADDED    → appended to the end of the store, in delta order;
- *   - MODIFIED → the matching store block's body is replaced in place;
- *   - REMOVED  → the matching store block is deleted.
- *
- * An empty delta (zero blocks in every section) is *not* an error: it returns
- * `ok: true` with the store unchanged and an empty `summary`, so the caller
- * can report "empty delta — nothing to sync".
- */
-export function mergeDelta(storeText: string, deltaText: string): MergeResult {
-  const store = parseStore(storeText);
-  const delta = parseDelta(deltaText);
-
+export function mergeDelta(storeTextOrBlocks: string | readonly RequirementBlock[], deltaTextOrDelta: string | SpecDelta): MergeResult {
+  const store = typeof storeTextOrBlocks === "string" ? parseStore(storeTextOrBlocks) : [...storeTextOrBlocks];
+  const delta = typeof deltaTextOrDelta === "string" ? parseDelta(deltaTextOrDelta) : deltaTextOrDelta;
   const errors = checkGuardrails(store, delta);
-  if (errors.length > 0) {
-    return { ok: false, errors };
-  }
+  if (errors.length > 0) return { ok: false, errors };
 
-  // Apply the delta. Guardrails have proven every name resolves, so the
-  // mutations below cannot fail or leave the store half-applied.
   const removedNames = new Set(delta.removed.map((b) => b.name));
+  const renamedByFrom = new Map(delta.renamed.map((b) => [b.from, b]));
   const modifiedByName = new Map(delta.modified.map((b) => [b.name, b]));
 
   const merged: RequirementBlock[] = [];
   for (const block of store) {
-    if (removedNames.has(block.name)) continue; // REMOVED — drop it
-    const replacement = modifiedByName.get(block.name);
-    merged.push(replacement ?? block); // MODIFIED — replace; else keep
-  }
-  for (const block of delta.added) {
-    merged.push(block); // ADDED — append in delta order
+    if (removedNames.has(block.name)) continue;
+    const rename = renamedByFrom.get(block.name);
+    const afterRename = rename ? { name: rename.to, body: rename.body === "" ? block.body : rename.body } : block;
+    const replacement = modifiedByName.get(afterRename.name);
+    merged.push(replacement ?? afterRename);
   }
+  for (const block of delta.added) merged.push(block);
 
   const summary: MergeSummary = {
     added: delta.added.map((b) => b.name),
     modified: delta.modified.map((b) => b.name),
     removed: delta.removed.map((b) => b.name),
+    renamed: delta.renamed.map((b) => ({ from: b.from, to: b.to })),
   };
-
   return { ok: true, store: renderStore(merged), summary };
 }
 
-/**
- * Whether a parsed delta carries no blocks at all.
- *
- * The `/zero-sync` command uses this to report "empty delta — nothing to sync"
- * before touching the store: a zero-block delta is valid (not a `MergeError`),
- * it simply has nothing to apply.
- */
 export function isEmptyDelta(delta: SpecDelta): boolean {
   return deltaBlockCount(delta) === 0;
 }

package/extensions/zero-archive-extension.ts

@@ -0,0 +1,44 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { readRunRecords } from "./autotune.ts";
+import { createGitRunner, type GitRunner, type SpawnLike } from "./git-runner.ts";
+import { mergeDelta } from "./spec-merge.ts";
+import { writeLinks } from "./sdd-links.ts";
+import { validateSpecInputs, validateTasksFile } from "./zero-validate.ts";
+
+const SDD_DIR = ".sdd";
+type NotifyType = "info" | "warning" | "error";
+interface PiCommandContext { ui: { notify(message: string, type?: NotifyType): void } }
+interface PiExtensionAPI { registerCommand(name: string, options: { description?: string; handler: (args: string, ctx: PiCommandContext) => void | Promise<void> }): void }
+
+function parse(args: string): { slug: string; dryRun: boolean; json: boolean; allowDirty: boolean } { const out = { slug: "", dryRun: false, json: false, allowDirty: false }; for (const p of args.trim().split(/\s+/).filter(Boolean)) { if (p === "--dry-run") out.dryRun = true; else if (p === "--json") out.json = true; else if (p === "--allow-dirty") out.allowDirty = true; else if (!out.slug) out.slug = p; } return out; }
+function notify(ctx: PiCommandContext, message: string, type?: NotifyType) { try { ctx.ui.notify(message, type); } catch {} }
+function latestVerdict(slug: string): string | null { const path = process.env.ZERO_RUNS_PATH || join(homedir(), ".pi", "zero-runs.jsonl"); let latest: { ts: string; verdict: string } | null = null; for (const r of readRunRecords(path)) if (r.feature === slug && (!latest || r.ts > latest.ts)) latest = { ts: r.ts, verdict: r.verdict }; return latest?.verdict ?? null; }
+function today(): string { return new Date().toISOString().slice(0, 10); }
+function read(path: string): string { try { return readFileSync(path, "utf8"); } catch { return ""; } }
+function atomicWrite(path: string, content: string): void { mkdirSync(dirname(path), { recursive: true }); const tmp = `${path}.${process.pid}.${Date.now()}.tmp`; writeFileSync(tmp, content, "utf8"); renameSync(tmp, path); }
+function specPairs(runDir: string): Array<{ domain: string; deltaPath: string; canonicalPath: string }> { const out: Array<{ domain: string; deltaPath: string; canonicalPath: string }> = []; if (existsSync(join(runDir, "spec.md"))) out.push({ domain: "default", deltaPath: join(runDir, "spec.md"), canonicalPath: join(SDD_DIR, "specs", "requirements.md") }); try { const base = join(runDir, "specs"); for (const e of readdirSync(base, { withFileTypes: true })) if (e.isDirectory() && existsSync(join(base, e.name, "spec.md"))) out.push({ domain: e.name, deltaPath: join(base, e.name, "spec.md"), canonicalPath: join(SDD_DIR, "specs", e.name, "requirements.md") }); } catch {} return out; }
+
+export async function runZeroArchive(args: string, ctx: PiCommandContext, git: GitRunner = createGitRunner(spawn as unknown as SpawnLike)): Promise<void> {
+  const opts = parse(args);
+  if (!opts.slug) { notify(ctx, "zero-archive: usage /zero-archive <slug> [--dry-run] [--json] [--allow-dirty]", "warning"); return; }
+  const runDir = join(SDD_DIR, opts.slug);
+  const emit = (payload: unknown, text: string, type: NotifyType = "info") => notify(ctx, opts.json ? JSON.stringify(payload) : text, type);
+  if (!existsSync(runDir)) { emit({ ok: false, reason: "missing-run" }, `zero-archive: no existe ${runDir}`, "error"); return; }
+  const verdict = latestVerdict(opts.slug); if (verdict !== "pasa") { emit({ ok: false, reason: "verdict", verdict }, `zero-archive: ${opts.slug} no tiene veredicto pasa (último: ${verdict ?? "—"})`, "error"); return; }
+  if (!opts.allowDirty && await git.isDirty()) { emit({ ok: false, reason: "dirty-worktree" }, "zero-archive: worktree sucio; usá --allow-dirty si corresponde", "error"); return; }
+  const defects = [...validateSpecInputs(runDir), ...validateTasksFile(read(join(runDir, "tasks.md")))]; if (defects.length) { emit({ ok: false, reason: "validate", defects }, `zero-archive: validación falló\n${defects.map((d) => `  - [${d.kind}] ${d.message}`).join("\n")}`, "error"); return; }
+  const pairs = specPairs(runDir); if (!pairs.length) { emit({ ok: false, reason: "missing-spec" }, "zero-archive: no hay spec.md para archivar", "error"); return; }
+  const writes: Array<{ path: string; next: string; before: string | null }> = [];
+  for (const pair of pairs) { const before = existsSync(pair.canonicalPath) ? read(pair.canonicalPath) : ""; const merged = mergeDelta(before, read(pair.deltaPath)); if (!merged.ok) { emit({ ok: false, reason: "merge", errors: merged.errors }, `zero-archive: merge falló en ${pair.domain}: ${merged.errors.map((e) => e.message).join("; ")}`, "error"); return; } writes.push({ path: pair.canonicalPath, next: merged.store, before: existsSync(pair.canonicalPath) ? before : null }); }
+  const archivePath = join(SDD_DIR, "archive", `${today()}-${opts.slug}`);
+  if (opts.dryRun) { emit({ ok: true, dryRun: true, archivePath, writes: writes.map((w) => w.path) }, `zero-archive: dry-run archivaría ${opts.slug} en ${archivePath}`); return; }
+  const written: typeof writes = [];
+  try { for (const w of writes) { atomicWrite(w.path, w.next); written.push(w); } writeLinks(SDD_DIR, opts.slug, { archivePath }); mkdirSync(dirname(archivePath), { recursive: true }); renameSync(runDir, archivePath); emit({ ok: true, archivePath, writes: writes.map((w) => w.path) }, `zero-archive: archivado en ${archivePath}`); }
+  catch (err) { for (const w of written.reverse()) { if (w.before === null) rmSync(w.path, { force: true }); else atomicWrite(w.path, w.before); } emit({ ok: false, reason: "rollback", error: err instanceof Error ? err.message : String(err) }, `zero-archive: falló y revertí cambios canónicos: ${err instanceof Error ? err.message : String(err)}`, "error"); }
+}
+
+export default function register(pi?: PiExtensionAPI): void { if (!pi || typeof pi.registerCommand !== "function") return; pi.registerCommand("zero-archive", { description: "Mergea el delta aprobado a .sdd/specs y mueve el run a .sdd/archive", handler: (args, ctx) => runZeroArchive(args, ctx).catch((err) => notify(ctx, `zero-archive: ${err instanceof Error ? err.message : String(err)}`, "error")) }); }