@gonrocca/zero-pi 0.1.48 → 0.1.49

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,43 @@ 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 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 +117,109 @@ 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
-// ---------------------------------------------------------------------------
-
-/**
- * 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 +229,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);
-
   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-diff-extension.ts

@@ -0,0 +1,59 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { isEmptyDelta, mergeDelta, parseDelta, type MergeSummary } from "./spec-merge.ts";
+
+const SDD_DIR = ".sdd";
+const STORE_FILE = join(".sdd", "specs", "requirements.md");
+
+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 readFileOrNull(path: string): string | null { try { return readFileSync(path, "utf8"); } catch { return null; } }
+function resolveSlug(arg: string): string | null {
+  const explicit = arg.trim();
+  if (explicit) return explicit;
+  try {
+    const candidates = readdirSync(SDD_DIR, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "specs" && e.name !== "archive" && existsSync(join(SDD_DIR, e.name, "spec.md"))).map((e) => e.name);
+    return candidates.length === 1 ? candidates[0] : null;
+  } catch { return null; }
+}
+
+export function formatDiffReport(summary: MergeSummary): string {
+  const lines = ["zero-diff: delta aplicaría estos cambios:"];
+  if (summary.added.length) lines.push(`  agregados:    ${summary.added.join(", ")}`);
+  if (summary.modified.length) lines.push(`  modificados:  ${summary.modified.join(", ")}`);
+  if (summary.renamed.length) lines.push(`  renombrados:  ${summary.renamed.map((r) => `${r.from} → ${r.to}`).join(", ")}`);
+  if (summary.removed.length) lines.push(`  eliminados:   ${summary.removed.join(", ")}`);
+  return lines.join("\n");
+}
+
+function runDiff(args: string, ctx: PiCommandContext): void {
+  const notify = (m: string, t?: NotifyType) => { try { ctx.ui.notify(m, t); } catch {} };
+  const slug = resolveSlug(args);
+  if (slug === null) { notify("zero-diff: no hay un único run — corré /zero-diff <slug>", "warning"); return; }
+  const deltaPath = join(SDD_DIR, slug, "spec.md");
+  const deltaText = readFileOrNull(deltaPath);
+  if (deltaText === null) { notify(`zero-diff: ${deltaPath} no existe — no hay delta para comparar`, "warning"); return; }
+  const storeText = readFileOrNull(STORE_FILE) ?? "";
+  const result = mergeDelta(storeText, deltaText);
+  if (!result.ok) {
+    const detail = result.errors.map((e) => `  - [${e.kind}] ${e.message}`).join("\n");
+    notify(`zero-diff: store NO se podría actualizar — el delta tiene errores de guardrail:\n${detail}`, "error");
+    return;
+  }
+  if (isEmptyDelta(parseDelta(deltaText))) notify(`zero-diff: delta vacío en ${deltaPath} — nada cambiaría`, "info");
+  else notify(formatDiffReport(result.summary), "info");
+}
+
+export default function register(pi?: PiExtensionAPI): void {
+  if (!pi || typeof pi.registerCommand !== "function") return;
+  pi.registerCommand("zero-diff", {
+    description: "Muestra el diff lógico de un spec.md delta sin escribir archivos",
+    handler: (args: string, ctx: PiCommandContext): void => {
+      try { if (ctx?.ui?.notify) runDiff(args, ctx); }
+      catch (err) { try { ctx.ui.notify(`zero-diff: ${err instanceof Error ? err.message : String(err)}`, "error"); } catch {} }
+    },
+  });
+}

package/extensions/zero-issue-extension.ts

@@ -0,0 +1,51 @@
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { buildIssueBody } from "./pr-body.ts";
+import { createGhRunner, type SpawnLike } from "./gh-runner.ts";
+import { writeLinks } from "./sdd-links.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 readFileOrEmpty(path: string): string { try { return readFileSync(path, "utf8"); } catch { return ""; } }
+function resolveSlug(arg: string): string | null { if (arg.trim()) return arg.trim(); try { const c = readdirSync(SDD_DIR, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "specs" && e.name !== "archive").map((e) => e.name); return c.length === 1 ? c[0] : null; } catch { return null; } }
+function parseArgs(args: string): { slugArg: string; labels: string[] } { const parts = args.trim().split(/\s+/).filter(Boolean); let slugArg = ""; let type: string | undefined; for (const p of parts) p.startsWith("--type=") ? type = p.slice(7) : slugArg ||= p; return { slugArg, labels: type ? [type] : ["type:feature"] }; }
+function normalizeTitle(s: string): string { return s.toLowerCase().replace(/\s+/g, " ").trim(); }
+async function labelIfExists(gh: ReturnType<typeof createGhRunner>, candidates: string[]): Promise<{ applied: string[]; skipped: string[] }> { const labels = await gh.listLabels(); const existing = new Set(labels.ok ? (labels.data ?? []) : []); return { applied: candidates.filter((l) => existing.has(l)), skipped: candidates.filter((l) => !existing.has(l)) }; }
+function writeTempBody(body: string): string { const file = join(tmpdir(), `zero-issue-body-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.md`); writeFileSync(file, body, "utf8"); return file; }
+function skippedNote(skipped: string[]): string { return skipped.length ? `; skipié labels que no existen en este repo: ${skipped.join(", ")}` : ""; }
+
+export async function runZeroIssue(args: string, ctx: PiCommandContext, spawnImpl: SpawnLike = spawn as unknown as SpawnLike): Promise<void> {
+  const notify = (m: string, t?: NotifyType) => { try { ctx.ui.notify(m, t); } catch {} };
+  const { slugArg, labels } = parseArgs(args);
+  const slug = resolveSlug(slugArg);
+  if (slug === null) { notify("zero-issue: no hay un único run — corré /zero-issue <slug>", "warning"); return; }
+  const dir = join(SDD_DIR, slug);
+  const built = buildIssueBody({ proposalMd: readFileOrEmpty(join(dir, "proposal.md")), specMd: readFileOrEmpty(join(dir, "spec.md")) });
+  const gh = createGhRunner({ spawn: spawnImpl });
+  const detected = await gh.detect();
+  if (!detected.data?.available) { notify(`zero-issue: ${detected.data?.hint ?? "gh CLI no disponible"}`, "error"); return; }
+  const dup = await gh.searchIssues(built.title);
+  if (!dup.ok) { notify(`zero-issue: gh issue list falló${dup.stderr ? ` — ${dup.stderr}` : ""}`, "error"); return; }
+  const existing = dup.data?.find((i) => normalizeTitle(i.title) === normalizeTitle(built.title));
+  if (existing) { writeLinks(SDD_DIR, slug, { issueNumber: existing.number, issueUrl: existing.url, createdAt: new Date().toISOString() }); notify(`zero-issue: ya existe el issue #${existing.number}`, "info"); return; }
+  const { applied, skipped } = await labelIfExists(gh, labels);
+  const tmp = writeTempBody(built.body);
+  try {
+    const created = await gh.createIssue({ title: built.title, bodyFile: tmp, labels: applied });
+    if (!created.ok) { notify(`zero-issue: gh issue create falló${created.stderr ? ` — ${created.stderr}` : ""}`, "error"); return; }
+    writeLinks(SDD_DIR, slug, { issueNumber: created.data?.number, issueUrl: created.data?.url, createdAt: new Date().toISOString() });
+    notify(`zero-issue: issue creado${created.data?.number ? ` #${created.data.number}` : ""}${created.data?.url ? ` ${created.data.url}` : ""}${skippedNote(skipped)}`, "info");
+  } finally {
+    if (existsSync(tmp)) rmSync(tmp, { force: true });
+  }
+}
+
+export default function register(pi?: PiExtensionAPI): void {
+  if (!pi || typeof pi.registerCommand !== "function") return;
+  pi.registerCommand("zero-issue", { description: "Crea o enlaza un issue de GitHub desde .sdd/<slug>", handler: (args, ctx) => runZeroIssue(args, ctx).catch((err) => { try { ctx.ui.notify(`zero-issue: ${err instanceof Error ? err.message : String(err)}`, "error"); } catch {} }) });
+}

package/extensions/zero-pr-extension.ts

@@ -0,0 +1,78 @@
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { readRunRecords } from "./autotune.ts";
+import { buildPrBody } from "./pr-body.ts";
+import { createGhRunner, type SpawnLike } from "./gh-runner.ts";
+import { readLinks, writeLinks } from "./sdd-links.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 readFileOrEmpty(path: string): string { try { return readFileSync(path, "utf8"); } catch { return ""; } }
+function parseArgs(args: string): { slugArg: string; labels: string[] } {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  let slugArg = "";
+  let type: string | undefined;
+  for (const p of parts) p.startsWith("--type=") ? type = p.slice(7) : slugArg ||= p;
+  return { slugArg, labels: type ? [type] : ["type:feature", "status:approved"] };
+}
+function resolveSlug(arg: string): string | null {
+  if (arg.trim()) return arg.trim();
+  try {
+    const candidates = readdirSync(SDD_DIR, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "specs" && e.name !== "archive").map((e) => e.name);
+    return candidates.length === 1 ? candidates[0] : null;
+  } catch { return null; }
+}
+function latestVerdict(slug: string): { verdict: string; reasoning?: string } | null {
+  const path = process.env.ZERO_RUNS_PATH || join(homedir(), ".pi", "zero-runs.jsonl");
+  let latest: { ts: string; verdict: string; reasoning?: 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, reasoning: (r as any).reasoning ?? (r as any).verdictReasoning };
+  return latest;
+}
+async function labelIfExists(gh: ReturnType<typeof createGhRunner>, candidates: string[]): Promise<{ applied: string[]; skipped: string[] }> {
+  const labels = await gh.listLabels();
+  const existing = new Set(labels.ok ? (labels.data ?? []) : []);
+  return { applied: candidates.filter((l) => existing.has(l)), skipped: candidates.filter((l) => !existing.has(l)) };
+}
+function writeTempBody(body: string): string {
+  const file = join(tmpdir(), `zero-pr-body-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.md`);
+  writeFileSync(file, body, "utf8");
+  return file;
+}
+function skippedNote(skipped: string[]): string { return skipped.length ? `; skipié labels que no existen en este repo: ${skipped.join(", ")}` : ""; }
+
+export async function runZeroPr(args: string, ctx: PiCommandContext, spawnImpl: SpawnLike = spawn as unknown as SpawnLike): Promise<void> {
+  const notify = (m: string, t?: NotifyType) => { try { ctx.ui.notify(m, t); } catch {} };
+  const { slugArg, labels } = parseArgs(args);
+  const slug = resolveSlug(slugArg);
+  if (slug === null) { notify("zero-pr: no hay un único run — corré /zero-pr <slug>", "warning"); return; }
+  const verdict = latestVerdict(slug);
+  if (verdict?.verdict !== "pasa") { notify(`zero-pr: ${slug} no tiene veredicto pasa (último: ${verdict?.verdict ?? "—"})`, "warning"); return; }
+  const dir = join(SDD_DIR, slug);
+  const artifacts = { proposalMd: readFileOrEmpty(join(dir, "proposal.md")), specMd: readFileOrEmpty(join(dir, "spec.md")), tasksMd: readFileOrEmpty(join(dir, "tasks.md")), verdictReasoning: verdict.reasoning };
+  const links = readLinks(SDD_DIR, slug);
+  const gh = createGhRunner({ spawn: spawnImpl });
+  const detected = await gh.detect();
+  if (!detected.data?.available) { notify(`zero-pr: ${detected.data?.hint ?? "gh CLI no disponible"}`, "error"); return; }
+  const { applied, skipped } = await labelIfExists(gh, labels);
+  const built = buildPrBody({ ...artifacts, linkedIssueNumber: typeof links.issueNumber === "number" ? links.issueNumber : undefined });
+  const tmp = writeTempBody(built.body);
+  try {
+    const result = await gh.createPr({ title: built.title, bodyFile: tmp, labels: applied });
+    if (!result.ok) { notify(`zero-pr: gh pr create falló${result.stderr ? ` — ${result.stderr}` : ""}`, "error"); return; }
+    writeLinks(SDD_DIR, slug, { prNumber: result.data?.number, prUrl: result.data?.url, createdAt: new Date().toISOString() });
+    notify(`zero-pr: PR creado${result.data?.number ? ` #${result.data.number}` : ""}${result.data?.url ? ` ${result.data.url}` : ""}${skippedNote(skipped)}`, "info");
+  } finally {
+    if (existsSync(tmp)) rmSync(tmp, { force: true });
+  }
+}
+
+export default function register(pi?: PiExtensionAPI): void {
+  if (!pi || typeof pi.registerCommand !== "function") return;
+  pi.registerCommand("zero-pr", { description: "Crea un PR de GitHub desde .sdd/<slug>", handler: (args, ctx) => runZeroPr(args, ctx).catch((err) => { try { ctx.ui.notify(`zero-pr: ${err instanceof Error ? err.message : String(err)}`, "error"); } catch {} }) });
+}