@gonrocca/zero-pi 0.1.15 → 0.1.17

package/extensions/sdd-agents.ts

@@ -0,0 +1,128 @@
+// zero-pi — SDD sub-agent provisioning.
+//
+// `/forge` delegates each phase to a dedicated sub-agent — `zero-explore`,
+// `zero-plan`, `zero-build`, `zero-veredicto`. pi-subagents discovers agents
+// from `~/.pi/agent/agents/**/*.md`, but a `pi install` of zero-pi ships only
+// the phase *prompts* (`prompts/phases/*.md`), never the agent definitions —
+// so `/forge` had nothing to delegate to and stalled.
+//
+// This extension closes that gap: at load it generates the four agent files
+// under `~/.pi/agent/agents/zero/` from the package's own phase prompts and
+// the per-phase models in `~/.pi/zero.json`. The files are regenerated every
+// load, so they stay in sync with the prompts and with `/zero-models`.
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The four SDD phases, each backed by a `prompts/phases/<phase>.md`. */
+export const PHASES = ["explore", "plan", "build", "veredicto"] as const;
+export type Phase = (typeof PHASES)[number];
+
+/**
+ * Split a phase prompt into its `description` (from `---` frontmatter) and its
+ * body. A prompt with no frontmatter yields an empty description and the whole
+ * text as the body. Exported for tests.
+ */
+export function splitPhasePrompt(raw: string): { description: string; body: string } {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) return { description: "", body: raw.trim() };
+  const descLine = match[1].match(/^description:\s*(.+)$/m);
+  return {
+    description: descLine ? descLine[1].trim() : "",
+    body: match[2].trim(),
+  };
+}
+
+/**
+ * Build the pi-subagents agent definition for one SDD phase: agent frontmatter
+ * (`name: zero-<phase>`, the phase model when known, a `replace` system
+ * prompt) followed by the phase prompt body. Exported for tests.
+ */
+export function buildAgentFile(
+  phase: Phase,
+  body: string,
+  description: string,
+  model: string | undefined,
+): string {
+  const front = [
+    "---",
+    `name: zero-${phase}`,
+    `description: ${description || `zero SDD ${phase} phase`}`,
+  ];
+  if (model) front.push(`model: ${model}`);
+  front.push(
+    "systemPromptMode: replace",
+    "inheritProjectContext: true",
+    "inheritSkills: false",
+    "---",
+  );
+  return `${front.join("\n")}\n\n${body}\n`;
+}
+
+/**
+ * Resolve the agent `model:` value for a phase from a parsed `zero.json`.
+ *
+ * zero.json stores a per-phase model as `"<model>"` or, in the installer's
+ * spec format, `"<model> <effort>"` — the agent `model:` field takes no effort
+ * suffix, so only the model token is kept. When `/zero-models` recorded the
+ * provider separately, it is folded back into a `provider/model` path. Returns
+ * `undefined` when no model is configured. Exported for tests.
+ */
+export function phaseModel(data: unknown, phase: Phase): string | undefined {
+  if (!data || typeof data !== "object") return undefined;
+  const d = data as {
+    models?: Record<string, unknown>;
+    providers?: Record<string, unknown>;
+  };
+  const raw = d.models?.[phase];
+  if (typeof raw !== "string" || raw.trim() === "") return undefined;
+
+  let model = raw.trim().split(/\s+/)[0];
+  const provider = d.providers?.[phase];
+  if (typeof provider === "string" && provider !== "" && !model.includes("/")) {
+    model = `${provider}/${model}`;
+  }
+  return model;
+}
+
+/** Read the per-phase model from `~/.pi/zero.json`; `undefined` when absent. */
+function readPhaseModel(phase: Phase): string | undefined {
+  try {
+    return phaseModel(
+      JSON.parse(readFileSync(join(homedir(), ".pi", "zero.json"), "utf8")),
+      phase,
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The pi extension entry point. Generates the four `zero-<phase>` agent files
+ * so `/forge` has real sub-agents to delegate to. Every failure is swallowed —
+ * provisioning must never break a pi session — and one phase failing does not
+ * block the others.
+ */
+export default function register(_pi?: unknown): void {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/extensions
+    const phasesDir = join(here, "..", "prompts", "phases");
+    const agentsDir = join(homedir(), ".pi", "agent", "agents", "zero");
+    mkdirSync(agentsDir, { recursive: true });
+
+    for (const phase of PHASES) {
+      try {
+        const raw = readFileSync(join(phasesDir, `${phase}.md`), "utf8");
+        const { description, body } = splitPhasePrompt(raw);
+        const file = buildAgentFile(phase, body, description, readPhaseModel(phase));
+        writeFileSync(join(agentsDir, `zero-${phase}.md`), file, "utf8");
+      } catch {
+        // A single phase failing must not block the other three.
+      }
+    }
+  } catch {
+    // Sub-agent provisioning must never break a pi session.
+  }
+}

package/extensions/win-tree-kill.ts

@@ -83,7 +83,7 @@ export default function register(): void {
     const require = createRequire(import.meta.url);
     const cp = require("node:child_process") as {
       spawn: (...args: unknown[]) => KillableChild;
-      execSync: (command: string, options?: unknown) => unknown;
+      exec: (command: string, callback: (error: unknown) => void) => unknown;
     };
 
     const originalSpawn = cp.spawn as typeof cp.spawn & { [WRAPPED]?: boolean };
@@ -92,8 +92,12 @@ export default function register(): void {
       return;
     }
 
+    // Fire-and-forget, ASYNC. A blocking execSync here would freeze pi's whole
+    // event loop on every subprocess kill — and pi kills a subprocess on most
+    // turns (pi-claude-cli's break-early). taskkill can take seconds or hang,
+    // so it must never run on the event loop.
     const exec = (command: string): void => {
-      cp.execSync(command, { stdio: "ignore" });
+      cp.exec(command, () => {});
     };
 
     const patchedSpawn = function (this: unknown, ...args: unknown[]): KillableChild {

package/extensions/working-phrases.ts

@@ -169,8 +169,13 @@ export function spinnerFrames(theme: Theme): string[] {
 
 // ── Extension entry point ──────────────────────────────────────────────────
 
+/** Module guard so a double-load never stacks handlers or a second timer. */
+let registered = false;
+
 export default function register(pi?: PiAPI): void {
   if (!pi || typeof pi.on !== "function") return;
+  if (registered) return;
+  registered = true;
 
   // The last UI handle seen on any event — the rotation timer uses it.
   let ui: PiUI | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/zero-pi",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "zero-pi — an installable layer for pi (pi.dev): the zero spec-driven development workflow, skill auto-learning, and an animated ZERO startup banner. Adds capability to pi without modifying pi.",
   "type": "module",
   "keywords": [
@@ -26,6 +26,7 @@
       "./extensions/startup-banner.ts",
       "./extensions/working-phrases.ts",
       "./extensions/win-tree-kill.ts",
+      "./extensions/sdd-agents.ts",
       "./extensions/conversation-resume.ts",
       "./extensions/zero-models.ts",
       "./extensions/autotune-extension.ts",
@@ -40,6 +41,7 @@
     "extensions/startup-banner.ts",
     "extensions/working-phrases.ts",
     "extensions/win-tree-kill.ts",
+    "extensions/sdd-agents.ts",
     "extensions/conversation-resume.ts",
     "extensions/zero-models.ts",
     "extensions/opencode-models.ts",