@gonrocca/zero-pi 0.1.48 → 0.1.50

package/extensions/zero-branch-extension.ts

@@ -0,0 +1,64 @@
+import { spawn } from "node:child_process";
+
+import { createGitRunner, type GitRunner, type SpawnLike } from "./git-runner.ts";
+import { loadSddConfig } from "./sdd-config.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 }
+
+export interface BranchOptions { slug: string; dryRun: boolean; json: boolean; allowDirty: boolean; base?: string }
+
+export function sanitizeSlug(slug: string): string {
+  return slug.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-") || "feature";
+}
+
+export function parseBranchArgs(args: string): BranchOptions {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  const out: BranchOptions = { slug: "", dryRun: false, json: false, allowDirty: false };
+  for (const p of parts) {
+    if (p === "--dry-run") out.dryRun = true;
+    else if (p === "--json") out.json = true;
+    else if (p === "--allow-dirty") out.allowDirty = true;
+    else if (p.startsWith("--base=")) out.base = p.slice(7);
+    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 emit(ctx: PiCommandContext, opts: BranchOptions, payload: unknown, text: string, type: NotifyType = "info") { notify(ctx, opts.json ? JSON.stringify(payload) : text, type); }
+
+export async function runZeroBranch(args: string, ctx: PiCommandContext, runner?: GitRunner): Promise<void> {
+  const opts = parseBranchArgs(args);
+  if (!opts.slug) { notify(ctx, "zero-branch: usage /zero-branch <slug> [--dry-run] [--json] [--allow-dirty] [--base=<branch>]", "warning"); return; }
+  const config = loadSddConfig(process.cwd());
+  const branch = `${config.git.branchPrefix}${sanitizeSlug(opts.slug)}`;
+  const base = opts.base ?? config.git.baseBranch;
+  const git = runner ?? createGitRunner(spawn as unknown as SpawnLike);
+  if (!opts.allowDirty && await git.isDirty()) { emit(ctx, opts, { ok: false, branch, reason: "dirty-worktree" }, `zero-branch: worktree sucio; usá --allow-dirty si querés continuar`, "error"); return; }
+  if (opts.dryRun) { emit(ctx, opts, { ok: true, dryRun: true, branch, baseBranch: base }, `zero-branch: dry-run crearía/cambiaría a ${branch} desde ${base}`); return; }
+
+  let action = "create";
+  if (await git.branchExists(branch)) {
+    action = "reuse-local";
+    const switched = await git.switchBranch(branch);
+    if (!switched.ok) { emit(ctx, opts, { ok: false, branch, action, stderr: switched.stderr }, `zero-branch: no pude cambiar a ${branch}: ${switched.stderr}`, "error"); return; }
+  } else if (await git.branchExists(branch, true)) {
+    action = "track-remote";
+    const switched = await git.run(["switch", "--track", `origin/${branch}`]);
+    if (!switched.ok) { emit(ctx, opts, { ok: false, branch, action, stderr: switched.stderr }, `zero-branch: no pude trackear origin/${branch}: ${switched.stderr}`, "error"); return; }
+  } else {
+    const created = await git.createBranch(branch, base);
+    if (!created.ok) { emit(ctx, opts, { ok: false, branch, action, stderr: created.stderr }, `zero-branch: no pude crear ${branch}: ${created.stderr}`, "error"); return; }
+  }
+  writeLinks(SDD_DIR, opts.slug, { branch, baseBranch: base });
+  emit(ctx, opts, { ok: true, branch, baseBranch: base, action }, `zero-branch: ${action} ${branch} (base ${base})`);
+}
+
+export default function register(pi?: PiExtensionAPI): void {
+  if (!pi || typeof pi.registerCommand !== "function") return;
+  pi.registerCommand("zero-branch", { description: "Crea o cambia a la rama Git sdd/<slug> y la registra en links.json", handler: (args, ctx) => runZeroBranch(args, ctx).catch((err) => notify(ctx, `zero-branch: ${err instanceof Error ? err.message : String(err)}`, "error")) });
+}

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-git-validate-extension.ts

@@ -0,0 +1,56 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { readRunRecords } from "./autotune.ts";
+import { createGhRunner, type SpawnLike as GhSpawnLike } from "./gh-runner.ts";
+import { createGitRunner, type GitRunner, type SpawnLike } from "./git-runner.ts";
+import { readLinks } 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 }
+export interface GitCheck { name: string; ok: boolean; message: string }
+
+function parse(args: string): { slug: string; forMode: "pr" | "archive" | "any"; json: boolean } {
+  const out = { slug: "", forMode: "any" as "pr" | "archive" | "any", json: false };
+  for (const p of args.trim().split(/\s+/).filter(Boolean)) {
+    if (p === "--json") out.json = true;
+    else if (p.startsWith("--for=")) out.forMode = ["pr", "archive", "any"].includes(p.slice(6)) ? p.slice(6) as any : "any";
+    else if (!out.slug) out.slug = p;
+  }
+  return out;
+}
+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;
+}
+async function ghAvailable(spawnImpl: GhSpawnLike): Promise<boolean> { return Boolean((await createGhRunner({ spawn: spawnImpl }).detect()).data?.available); }
+export async function validateGitState(slug: string, forMode: "pr" | "archive" | "any", git: GitRunner, ghSpawn: GhSpawnLike = spawn as unknown as GhSpawnLike): Promise<{ ok: boolean; checks: GitCheck[] }> {
+  const links = readLinks(SDD_DIR, slug);
+  const expectedBranch = typeof links.branch === "string" ? links.branch : null;
+  const checks: GitCheck[] = [];
+  const dirty = await git.isDirty(); checks.push({ name: "worktree", ok: !dirty, message: dirty ? "worktree has uncommitted changes" : "worktree clean" });
+  const current = await git.currentBranch(); checks.push({ name: "branch", ok: !expectedBranch || current === expectedBranch, message: expectedBranch ? `current ${current || "(detached)"}, expected ${expectedBranch}` : `current ${current || "(detached)"}` });
+  checks.push({ name: "remote", ok: await git.hasRemote("origin"), message: "origin remote configured" });
+  if (forMode === "pr") checks.push({ name: "gh-auth", ok: await ghAvailable(ghSpawn), message: "gh CLI available/authenticated" });
+  if (forMode === "pr" || forMode === "archive") { const verdict = latestVerdict(slug); checks.push({ name: "verdict", ok: verdict === "pasa", message: `latest verdict ${verdict ?? "—"}` }); }
+  return { ok: checks.every((c) => c.ok), checks };
+}
+export async function runZeroGitValidate(args: string, ctx: PiCommandContext, git: GitRunner = createGitRunner(spawn as unknown as SpawnLike), ghSpawn: GhSpawnLike = spawn as unknown as GhSpawnLike): Promise<void> {
+  const opts = parse(args);
+  const notify = (m: string, t?: NotifyType) => { try { ctx.ui.notify(m, t); } catch {} };
+  if (!opts.slug) { notify("zero-git-validate: usage /zero-git-validate <slug> [--for=pr|archive|any] [--json]", "warning"); return; }
+  if (!existsSync(join(SDD_DIR, opts.slug))) { notify(`zero-git-validate: no existe .sdd/${opts.slug}`, "error"); return; }
+  const result = await validateGitState(opts.slug, opts.forMode, git, ghSpawn);
+  const text = result.checks.map((c) => `${c.ok ? "✅" : "❌"} ${c.name}: ${c.message}`).join("\n");
+  notify(opts.json ? JSON.stringify(result) : `zero-git-validate: ${result.ok ? "ok" : "falló"}\n${text}`, result.ok ? "info" : "error");
+}
+export default function register(pi?: PiExtensionAPI): void {
+  if (!pi || typeof pi.registerCommand !== "function") return;
+  pi.registerCommand("zero-git-validate", { description: "Valida worktree, rama, remote, gh auth y veredicto antes de PR/archive", handler: (args, ctx) => runZeroGitValidate(args, ctx).catch((err) => { try { ctx.ui.notify(`zero-git-validate: ${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,98 @@
+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";
+import { validateArtifactSet, 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 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(", ")}` : ""; }
+function readSpecArtifacts(dir: string): { specMd: string; specs?: Record<string, string> } {
+  const flat = readFileOrEmpty(join(dir, "spec.md"));
+  const specsDir = join(dir, "specs");
+  const specs: Record<string, string> = {};
+  try {
+    for (const e of readdirSync(specsDir, { withFileTypes: true })) if (e.isDirectory()) {
+      const text = readFileOrEmpty(join(specsDir, e.name, "spec.md"));
+      if (text) specs[e.name] = text;
+    }
+  } catch {}
+  return Object.keys(specs).length ? { specMd: flat, specs } : { specMd: flat };
+}
+
+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")), ...readSpecArtifacts(dir), tasksMd: readFileOrEmpty(join(dir, "tasks.md")), verdictReasoning: verdict.reasoning };
+  const defects = [
+    ...validateArtifactSet({ proposal: artifacts.proposalMd !== "", spec: artifacts.specMd !== "" || Boolean(artifacts.specs), design: existsSync(join(dir, "design.md")), tasks: artifacts.tasksMd !== "" }),
+    ...validateSpecInputs(dir),
+    ...validateTasksFile(artifacts.tasksMd),
+  ].filter((d) => !d.kind.startsWith("missing-proposal"));
+  if (defects.length > 0) { notify(`zero-pr: validateForPr falló:\n${defects.map((d) => `  - [${d.kind}] ${d.message}`).join("\n")}`, "error"); return; }
+  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({ slug, links, artifacts: { ...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, base: typeof links.baseBranch === "string" ? links.baseBranch : undefined, head: typeof links.branch === "string" ? links.branch : undefined } as any);
+    if (!result.ok) { notify(`zero-pr: gh pr create falló${result.stderr ? ` — ${result.stderr}` : ""}`, "error"); return; }
+    const parsedNumber = result.data?.number ?? (result.data?.url ? Number(/\/(?:pull|pulls)\/(\d+)(?:$|[?#])/.exec(result.data.url)?.[1]) : undefined);
+    writeLinks(SDD_DIR, slug, { prNumber: Number.isFinite(parsedNumber) ? parsedNumber : undefined, 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 {} }) });
+}

package/extensions/zero-status-extension.ts

@@ -0,0 +1,59 @@
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { readRunRecords } from "./autotune.ts";
+import { readLinks, type LinksRecord } from "./sdd-links.ts";
+import { buildStatus, type StatusRow } from "./zero-status.ts";
+
+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 listProjectSdd(): Record<string, string[]> {
+  const out: Record<string, string[]> = {};
+  for (const e of readdirSync(".sdd", { withFileTypes: true })) {
+    if (!e.isDirectory() || e.name === "specs" || e.name === "archive") continue;
+    out[e.name] = readdirSync(join(".sdd", e.name));
+  }
+  return out;
+}
+
+function render(rows: StatusRow[]): string {
+  if (rows.length === 0) return "zero-status: no encontré runs en .sdd/.";
+  const width = Math.max(4, ...rows.map((r) => r.slug.length));
+  const lines = [`zero-status: runs detectados`, `slug${" ".repeat(width - 4)}  artf  sync     verdict  github`];
+  for (const row of rows) {
+    const art = [row.artifacts.proposal, row.artifacts.spec, row.artifacts.design, row.artifacts.tasks].map((v) => (v ? "✓" : "·")).join("");
+    lines.push(`${row.slug.padEnd(width)}  ${art}  ${row.synced ? "synced " : "pending"}  ${row.lastVerdict ?? "—"}  ${row.github ?? "—"}`);
+  }
+  return lines.join("\n");
+}
+
+function readLinksBySlug(slugs: readonly string[]): Record<string, LinksRecord> {
+  const out: Record<string, LinksRecord> = {};
+  for (const slug of slugs) out[slug] = readLinks(".sdd", slug);
+  return out;
+}
+
+function runStatus(ctx: PiCommandContext): void {
+  const notify = (m: string, t?: NotifyType) => { try { ctx.ui.notify(m, t); } catch {} };
+  let sddDir: Record<string, string[]> = {};
+  let archiveEntries: string[] = [];
+  if (existsSync(".sdd")) sddDir = listProjectSdd();
+  if (existsSync(join(".sdd", "archive"))) archiveEntries = readdirSync(join(".sdd", "archive"));
+  const runRecords = readRunRecords(join(homedir(), ".pi", "zero-runs.jsonl"));
+  const linksBySlug = readLinksBySlug(Object.keys(sddDir));
+  notify(render(buildStatus({ sddDir, archiveEntries, runRecords, linksBySlug })), "info");
+}
+
+export default function register(pi?: PiExtensionAPI): void {
+  if (!pi || typeof pi.registerCommand !== "function") return;
+  pi.registerCommand("zero-status", {
+    description: "Muestra estado de artefactos, sync y último veredicto de runs .sdd/",
+    handler: (_args: string, ctx: PiCommandContext): void => {
+      try { if (ctx?.ui?.notify) runStatus(ctx); }
+      catch (err) { try { ctx.ui.notify(`zero-status: ${err instanceof Error ? err.message : String(err)}`, "error"); } catch {} }
+    },
+  });
+}

package/extensions/zero-status.ts

@@ -0,0 +1,65 @@
+import type { RunRecord } from "./autotune.ts";
+
+export interface StatusRow {
+  slug: string;
+  artifacts: { proposal: boolean; spec: boolean; design: boolean; tasks: boolean };
+  synced: boolean;
+  lastVerdict: string | null;
+  github?: string;
+}
+
+export interface GithubLinks { prNumber?: number; issueNumber?: number }
+
+export function formatGithubCell(links: GithubLinks | undefined): string {
+  if (!links) return "—";
+  const parts: string[] = [];
+  if (typeof links.prNumber === "number") parts.push(`#${links.prNumber}`);
+  if (typeof links.issueNumber === "number") parts.push(`issue #${links.issueNumber}`);
+  return parts.length ? parts.join(" / ") : "—";
+}
+
+export function matchesArchiveEntry(slug: string, name: string): boolean {
+  const esc = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\d{4}-\\d{2}-\\d{2}-${esc}(?:-\\d+)?$`).test(name);
+}
+
+export function latestVerdictBySlug(records: readonly Pick<RunRecord, "feature" | "ts" | "verdict">[]): Map<string, string> {
+  const latest = new Map<string, { ts: string; verdict: string }>();
+  for (const record of records) {
+    const prev = latest.get(record.feature);
+    if (!prev || record.ts > prev.ts) latest.set(record.feature, { ts: record.ts, verdict: record.verdict });
+  }
+  return new Map([...latest].map(([slug, v]) => [slug, v.verdict]));
+}
+
+export function buildStatus({
+  sddDir,
+  archiveEntries,
+  runRecords,
+  linksBySlug = {},
+}: {
+  sddDir: Record<string, readonly string[]>;
+  archiveEntries: readonly string[];
+  runRecords: readonly Pick<RunRecord, "feature" | "ts" | "verdict">[];
+  linksBySlug?: Record<string, GithubLinks | undefined>;
+}): StatusRow[] {
+  const verdicts = latestVerdictBySlug(runRecords);
+  return Object.keys(sddDir)
+    .filter((slug) => slug !== "specs" && slug !== "archive")
+    .sort((a, b) => a.localeCompare(b))
+    .map((slug) => {
+      const files = new Set(sddDir[slug]);
+      return {
+        slug,
+        artifacts: {
+          proposal: files.has("proposal.md"),
+          spec: files.has("spec.md"),
+          design: files.has("design.md"),
+          tasks: files.has("tasks.md"),
+        },
+        synced: archiveEntries.some((name) => matchesArchiveEntry(slug, name)),
+        lastVerdict: verdicts.get(slug) ?? null,
+        github: formatGithubCell(linksBySlug[slug]),
+      };
+    });
+}

package/extensions/zero-validate-extension.ts

@@ -0,0 +1,67 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { validateArtifactSet, validateSpecInputs, validateTasksFile, type ValidationDefect } from "./zero-validate.ts";
+
+const SDD_DIR = ".sdd";
+const ARTIFACTS = ["proposal", "spec", "design", "tasks"] as const;
+
+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; }
+}
+
+function formatDefects(defects: ValidationDefect[]): string {
+  return defects.map((d) => `  - [${d.kind}] ${d.task ? `${d.task}: ` : ""}${d.message}`).join("\n");
+}
+
+function runValidate(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-validate: no hay un único run para validar — corré /zero-validate <slug>", "warning");
+    return;
+  }
+  const dir = join(SDD_DIR, slug);
+  const texts = Object.fromEntries(ARTIFACTS.map((a) => [a, readFileOrNull(join(dir, `${a}.md`))])) as Record<(typeof ARTIFACTS)[number], string | null>;
+  const hasDomainSpec = existsSync(join(dir, "specs"));
+  const presence = Object.fromEntries(ARTIFACTS.map((a) => [a, a === "spec" ? texts.spec !== null || hasDomainSpec : texts[a] !== null])) as Record<(typeof ARTIFACTS)[number], boolean>;
+  const defects = validateArtifactSet(presence);
+  defects.push(...validateSpecInputs(dir));
+  if (texts.tasks !== null) defects.push(...validateTasksFile(texts.tasks));
+  for (const legacy of ["requirements.md"]) if (existsSync(join(dir, legacy))) defects.push({ kind: "legacy-artifact", path: legacy, message: `${legacy} is a legacy Kiro artifact; keep it only as historical context` });
+
+  const structural = defects.filter((d) => !d.kind.startsWith("missing-proposal") && d.kind !== "legacy-artifact");
+  if (structural.length > 0) {
+    notify(`zero-validate: encontré defectos estructurales en ${slug}; revisalos antes de sync:\n${formatDefects(defects)}`, "error");
+  } else if (defects.length > 0) {
+    notify(`zero-validate: ${slug} está usable, pero te falta un artefacto opcional:\n${formatDefects(defects)}`, "warning");
+  } else {
+    notify(`zero-validate: ${slug} está limpio — tenés propuesta, spec, diseño y tareas coherentes.`, "info");
+  }
+}
+
+export default function register(pi?: PiExtensionAPI): void {
+  if (!pi || typeof pi.registerCommand !== "function") return;
+  pi.registerCommand("zero-validate", {
+    description: "Valida artefactos .sdd/<slug>/ antes de sincronizar el spec store",
+    handler: (args: string, ctx: PiCommandContext): void => {
+      try { if (ctx?.ui?.notify) runValidate(args, ctx); }
+      catch (err) { try { ctx.ui.notify(`zero-validate: ${err instanceof Error ? err.message : String(err)}`, "error"); } catch {} }
+    },
+  });
+}