@gonrocca/zero-pi 0.1.48 → 0.1.49

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,65 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { validateArtifactSet, validateSpecDelta, 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 presence = Object.fromEntries(ARTIFACTS.map((a) => [a, texts[a] !== null])) as Record<(typeof ARTIFACTS)[number], boolean>;
+  const defects = validateArtifactSet(presence);
+  if (texts.spec !== null) defects.push(...validateSpecDelta(texts.spec));
+  if (texts.tasks !== null) defects.push(...validateTasksFile(texts.tasks));
+
+  const structural = defects.filter((d) => !d.kind.startsWith("missing-proposal"));
+  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 {} }
+    },
+  });
+}

package/extensions/zero-validate.ts

@@ -0,0 +1,133 @@
+import { checkGuardrails, parseDelta, type MergeError, type RenameBlock, type RequirementBlock } from "./spec-merge.ts";
+
+export interface ValidationDefect {
+  kind: string;
+  message: string;
+  task?: string;
+  path?: string;
+  name?: string;
+  declaredTotal?: number;
+  computedTotal?: number;
+}
+
+export interface TaskRecord {
+  id: string;
+  title: string;
+  files: { path: string; isNew: boolean }[];
+  review: number | null;
+  reviewRaw: string | null;
+}
+
+export interface WorkloadSection {
+  estimates: Map<string, number>;
+  declaredTotal: number | null;
+}
+
+export function parseTasks(text: string): { tasks: TaskRecord[]; workload: WorkloadSection | null; defects: ValidationDefect[] } {
+  const tasks: TaskRecord[] = [];
+  const defects: ValidationDefect[] = [];
+  const lines = typeof text === "string" ? text.split(/\r?\n/) : [];
+  let current: TaskRecord | null = null;
+  let collectingFiles = false;
+
+  const pushFile = (line: string): void => {
+    if (!current) return;
+    const matches = [...line.matchAll(/`([^`]+)`\s*(\(new\))?/g)];
+    for (const m of matches) current.files.push({ path: m[1], isNew: Boolean(m[2]) });
+  };
+
+  for (const line of lines) {
+    const task = line.match(/^\s*- \[[ xX]\]\s+\*\*(T\d+)\.\s+([^*]+)\*\*/);
+    if (task) {
+      current = { id: task[1], title: task[2].trim(), files: [], review: null, reviewRaw: null };
+      tasks.push(current);
+      collectingFiles = false;
+      continue;
+    }
+    if (!current) continue;
+    if (/^\s*-\s+files:/.test(line)) {
+      collectingFiles = true;
+      pushFile(line);
+      continue;
+    }
+    if (/^\s*-\s+review:/.test(line)) {
+      collectingFiles = false;
+      const raw = line.replace(/^\s*-\s+review:\s*/, "").trim();
+      current.reviewRaw = raw;
+      const m = raw.match(/~?(\d+)\s+changed lines/i);
+      current.review = m ? Number(m[1]) : null;
+      continue;
+    }
+    if (collectingFiles) {
+      if (/^\s*`[^`]+`/.test(line) || /^\s+`[^`]+`/.test(line)) pushFile(line);
+      else if (/^\s*-\s+/.test(line)) collectingFiles = false;
+    }
+  }
+
+  for (const task of tasks) {
+    if (task.files.length === 0) defects.push({ kind: "missing-files", task: task.id, message: `${task.id} is missing files list` });
+    if (task.reviewRaw === null) defects.push({ kind: "missing-review", task: task.id, message: `${task.id} is missing review estimate` });
+    else if (task.review === null) defects.push({ kind: "non-integer-review", task: task.id, message: `${task.id} review estimate is not an integer` });
+  }
+
+  const workload = parseWorkload(lines);
+  return { tasks, workload, defects };
+}
+
+function parseWorkload(lines: string[]): WorkloadSection | null {
+  const start = lines.findIndex((l) => /^##\s+Review Workload\s*$/.test(l));
+  if (start < 0) return null;
+  const estimates = new Map<string, number>();
+  let declaredTotal: number | null = null;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^##\s+/.test(line)) break;
+    let m = line.match(/^\|\s*(T\d+)\s*\|\s*~?(\d+)\s*\|/);
+    if (m) estimates.set(m[1], Number(m[2]));
+    m = line.match(/^\s*-\s*(T\d+)\s*[:|-]\s*~?(\d+)/);
+    if (m) estimates.set(m[1], Number(m[2]));
+    m = line.match(/\*\*Total:\s*~?(\d+)\s+changed lines\*\*/i);
+    if (m) declaredTotal = Number(m[1]);
+  }
+  return { estimates, declaredTotal };
+}
+
+export function validateTasksFile(text: string): ValidationDefect[] {
+  const parsed = parseTasks(text);
+  const defects = [...parsed.defects];
+  if (parsed.workload === null) {
+    defects.push({ kind: "missing-review-workload", message: "tasks.md is missing ## Review Workload" });
+  } else {
+    const computedTotal = parsed.tasks.reduce((sum, task) => sum + (task.review ?? 0), 0);
+    if (parsed.workload.declaredTotal === null) defects.push({ kind: "missing-workload-total", message: "Review Workload is missing total" });
+    else if (parsed.workload.declaredTotal !== computedTotal) defects.push({ kind: "total-mismatch", declaredTotal: parsed.workload.declaredTotal, computedTotal, message: `Review Workload total ${parsed.workload.declaredTotal} does not match computed ${computedTotal}` });
+    for (const task of parsed.tasks) {
+      const est = parsed.workload.estimates.get(task.id);
+      if (est !== undefined && task.review !== null && est !== task.review) defects.push({ kind: "workload-task-mismatch", task: task.id, declaredTotal: est, computedTotal: task.review, message: `${task.id} workload estimate does not match task review` });
+    }
+  }
+  return defects;
+}
+
+function allBlocks(delta: ReturnType<typeof parseDelta>): Array<RequirementBlock | RenameBlock> {
+  return [...delta.added, ...delta.modified, ...delta.removed, ...delta.renamed];
+}
+
+export function validateSpecDelta(text: string): ValidationDefect[] {
+  const delta = parseDelta(text);
+  const defects: ValidationDefect[] = checkGuardrails([], delta).map((e: MergeError) => ({ kind: e.kind, name: e.name, message: e.message }));
+  for (const block of allBlocks(delta)) {
+    const name = "name" in block ? block.name : block.to;
+    if (block.body.trim() === "") defects.push({ kind: "empty-body", name, message: `Requirement ${name} has an empty body` });
+    if (!block.body.includes("Acceptance criteria")) defects.push({ kind: "missing-acceptance-criteria", name, message: `Requirement ${name} is missing Acceptance criteria` });
+  }
+  return defects;
+}
+
+export function validateArtifactSet(present: { proposal: boolean; spec: boolean; design: boolean; tasks: boolean }): ValidationDefect[] {
+  const defects: ValidationDefect[] = [];
+  for (const key of ["proposal", "spec", "design", "tasks"] as const) {
+    if (!present[key]) defects.push({ kind: `missing-${key}`, path: `${key}.md`, message: `${key}.md is missing` });
+  }
+  return defects;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/zero-pi",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "description": "zero-pi — an installable layer for pi (pi.dev): the zero spec-driven development workflow (explore → plan → build → veredicto) with per-phase model autotune and token-efficient batched builds. Adds capability to pi without modifying pi.",
   "type": "module",
   "keywords": [
@@ -33,7 +33,13 @@
       "./extensions/zero-models.ts",
       "./extensions/autotune-extension.ts",
       "./extensions/spec-merge-extension.ts",
-      "./extensions/provider-guard-extension.ts"
+      "./extensions/zero-validate-extension.ts",
+      "./extensions/zero-status-extension.ts",
+      "./extensions/zero-pr-extension.ts",
+      "./extensions/zero-issue-extension.ts",
+      "./extensions/zero-diff-extension.ts",
+      "./extensions/provider-guard-extension.ts",
+      "./extensions/scan-guard-extension.ts"
     ]
   },
   "files": [
@@ -53,8 +59,20 @@
     "extensions/autotune-extension.ts",
     "extensions/spec-merge.ts",
     "extensions/spec-merge-extension.ts",
+    "extensions/zero-validate.ts",
+    "extensions/zero-validate-extension.ts",
+    "extensions/zero-status.ts",
+    "extensions/zero-status-extension.ts",
+    "extensions/pr-body.ts",
+    "extensions/sdd-links.ts",
+    "extensions/gh-runner.ts",
+    "extensions/zero-pr-extension.ts",
+    "extensions/zero-issue-extension.ts",
+    "extensions/zero-diff-extension.ts",
     "extensions/provider-guard.ts",
     "extensions/provider-guard-extension.ts",
+    "extensions/scan-guard.ts",
+    "extensions/scan-guard-extension.ts",
     "README.md",
     "LICENSE"
   ],

package/prompts/phases/explore.md

@@ -24,6 +24,12 @@ constraints — reading past that point burns tokens without improving the plan.
 As a rough gauge, a localized change rarely needs more than ~20 tool calls; if
 you blow past that on a small request, you are over-exploring.
 
+**Scope every search to the project, never the filesystem root.** Search inside
+the repo/code directory you are working in. A `find`, `grep -r`, or `rg` rooted
+at `/`, a bare drive (`/c`, `C:\`), or `~`/`$HOME` is forbidden — on Windows it
+hangs forever forcing OneDrive to hydrate every cloud placeholder it walks, and
+zero blocks such commands at the tool boundary anyway.
+
 Produce a concise findings report the **plan** phase can build on: what exists,
 what is relevant to the request, and what to watch out for.
 

package/prompts/phases/plan.md

@@ -85,6 +85,11 @@ means the same number on every run.
   per-task estimates, and the over-budget exceptions list — state "none" when
   there are no exceptions.
 
+When a run is likely to land as a chained PR series, make that explicit in the
+forecast: group tasks into reviewable PR-sized batches, name any ordering
+constraints between batches, and keep each batch small enough that `/zero-pr`
+can produce a focused pull request after `veredicto` returns `pasa`.
+
 **Return contract.** Return a concise result envelope to the orchestrator: your
 phase's outcome (findings, plan, build result, or verdict with its concrete
 reasoning) and the `.sdd/<slug>/` artifact path(s) you touched. No step-by-step

package/prompts/phases/veredicto.md

@@ -13,16 +13,27 @@ orchestrator's existing run-trace machinery — the Cortex `zero-run/<slug>` sav
 and the `~/.pi/zero-runs.jsonl` append. Do not write a separate verdict file;
 `.sdd/` artifacts stay plan state only.
 
-**Locating the code — read, do not search.** To check the build against the
-plan, read the `## Code roots` section in `design.md` (or the explore findings)
-for the absolute paths this feature touches, and read the build result for the
-files it changed — go straight to those paths to inspect the changes and run the
-tests. Do **not** run a filesystem-wide `find`/`grep` to rediscover where the
-code lives, and do **not** re-read a file you have already read this review
-unless it changed since; repeated re-reading is the main avoidable token cost on
-the review's model, which is often the most expensive in the pipeline. A single
-targeted search to fill a genuine gap is fine; a full-tree scan is not. This
-bounds cost only — it never lowers the bar for the verdict.
+**Locating the code — read, do not search.** Get the code root from the plan:
+the `## Code roots` section in `design.md`, or — for delta/forge runs that have
+no `design.md` — the `Code root:` line in `tasks.md` or the absolute path in
+your task input. Read the build result for the files it changed and go straight
+to those paths to inspect the changes and run the tests.
+
+**NEVER run a filesystem-wide scan to rediscover where the code lives.** A
+`find`, `grep -r`, or `rg` rooted at `/`, a bare drive (`/c`, `C:\`), or `~`/
+`$HOME` is forbidden — on Windows it does not merely run slow, it **hangs
+forever** forcing OneDrive to hydrate every cloud placeholder it walks (a real
+run wedged on `find / -maxdepth 12 …` for 6+ hours). zero blocks such commands
+at the tool boundary, so the call will fail anyway. Always scope a search to the
+code-root absolute path (`find <code-root> -name …`). If you cannot find the
+code root in the plan, say so in the verdict — do not go hunting for it.
+
+Also do **not** re-read a file you have already read this review unless it
+changed since; repeated re-reading is the main avoidable token cost on the
+review's model, which is often the most expensive in the pipeline. A single
+targeted search *inside the code root* to fill a genuine gap is fine; a
+full-tree scan is not. This bounds cost only — it never lowers the bar for the
+verdict.
 
 Review the build adversarially, with a fresh perspective. Check it against the
 plan's requirements, run the tests yourself, and look for gaps, regressions,
@@ -34,7 +45,9 @@ Record exactly one verdict:
 - `corregir` — fixable defects remain; the build phase must re-run.
 - `replantear` — the plan itself is wrong; the plan phase must re-run.
 
-Never return `pasa` unless the evidence supports it.
+Never return `pasa` unless the evidence supports it. `/zero-pr` is only allowed
+for runs whose latest recorded `veredicto` is `pasa`; if the verdict is
+`corregir` or `replantear`, the PR must wait for the next successful review.
 
 State the verdict's reasoning concretely — the specific defects for `corregir`,
 the specific plan flaw for `replantear`. The orchestrator persists that