@gonrocca/zero-pi 0.1.17 → 0.1.19

package/extensions/zero-models.ts

@@ -21,7 +21,6 @@ import { join } from "node:path";
 
 import { readAutotuneMode, type AutotuneMode } from "./autotune.ts";
 import type { AutotunePending } from "./autotune-extension.ts";
-import { discoverModels } from "./opencode-models.ts";
 
 /** The SDD phases, in pipeline order. */
 export const PHASES = ["explore", "plan", "build", "veredicto"] as const;
@@ -214,45 +213,30 @@ const CUSTOM_PROVIDER = "— otro provider (escribir) —";
 /**
  * Group models by provider for the picker.
  *
- * The primary source is OpenCode's model catalog — the same one the `zero`
- * installer's picker uses — so every provider the user authenticated there
- * (opencode-go, openai/codex, anthropic, …) is offered, with only tool-call-
- * capable models (the SDD phases need tool calls). When OpenCode is not
- * present it falls back to pi's own model registry, then to an empty map.
+ * The source is pi's own model registry — `getAll()` returns every model from
+ * every provider the user is authenticated for (`anthropic`, `openai-codex`,
+ * `opencode-go`, …), each with the exact provider id and model id pi resolves
+ * at runtime. Using pi's registry — rather than a foreign catalog like
+ * OpenCode's — guarantees the names written to `~/.pi/zero.json` are names pi
+ * actually understands, so a configured phase model never fails to resolve.
  */
 function providerGroups(registry: PiModelRegistry | undefined): Map<string, string[]> {
-  try {
-    const discovered = discoverModels().filter((m) => m.toolCall);
-    if (discovered.length > 0) return groupByProvider(discovered);
-  } catch {
-    /* fall through to pi's registry */
-  }
   if (registry && typeof registry.getAll === "function") {
     try {
       const all = registry.getAll();
       if (all && all.length > 0) return groupByProvider(all);
     } catch {
-      /* fall through */
+      /* fall through to an empty map */
     }
   }
   return new Map();
 }
 
-/**
- * Find the provider that owns a model id — checked against OpenCode's catalog
- * first, then pi's own registry.
- */
+/** Find the provider that owns a model id, per pi's own model registry. */
 function resolveProvider(
   registry: PiModelRegistry | undefined,
   modelId: string,
 ): string | undefined {
-  try {
-    for (const m of discoverModels()) {
-      if (m.id === modelId) return m.provider;
-    }
-  } catch {
-    /* ignore */
-  }
   if (registry && typeof registry.getAll === "function") {
     try {
       for (const m of registry.getAll()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/zero-pi",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "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": [
@@ -44,7 +44,6 @@
     "extensions/sdd-agents.ts",
     "extensions/conversation-resume.ts",
     "extensions/zero-models.ts",
-    "extensions/opencode-models.ts",
     "extensions/autotune.ts",
     "extensions/autotune-extension.ts",
     "extensions/spec-merge.ts",

package/prompts/forge.md

@@ -1,34 +1,17 @@
 ---
-description: Run an automatic spec-driven development pipeline for a feature request
+description: Run the zero spec-driven development pipeline for a feature request
 ---
 
-Run the zero SDD pipeline for the feature request in the arguments.
-
-**Parse the arguments first.** If the arguments start with `--continue`, this is
-a **resume** run, not a fresh one:
-
-- `--continue` with no slug → resume mode: hand control to the orchestrator's
-  `## Resuming a run` section, which scans `.sdd/*/` for an unfinished run.
-- `--continue <slug>` → resume mode targeting `.sdd/<slug>/` directly. If that
-  directory does not exist, report "no such run: <slug>" and stop — do **not**
-  start a fresh run under that slug.
-- Anything else (a feature request, or no arguments) → a fresh run, exactly
-  today's behaviour: the arguments are the feature request.
-
-Follow the zero SDD orchestrator instructions: drive the run through the
-explore → plan → build → veredicto phases, honour the build/veredicto iteration
-cap, and use the execution mode (interactive or automatic) the user chose.
-
-Delegate each phase to its dedicated sub-agent so the phase runs on the model
-it is configured for: `zero-explore`, `zero-plan`, `zero-build`, and
-`zero-veredicto`. You stay the orchestrator — you decide phase order and count
-the rounds; the sub-agents only execute their phase.
-
-In interactive mode, pause after each phase with a summary and ask before
-continuing. Never report success unless the veredicto phase returned a `pasa`
-verdict; if the cap is reached first, report that the result is not verified.
-
-To change the per-phase models, the user runs the `/zero-models` command — do
-not handle model configuration here.
+Run the zero SDD pipeline for the feature request below — you are the
+orchestrator. Drive it through four phases in order: **explore → plan → build →
+veredicto**, delegating each to its sub-agent (`zero-explore`, `zero-plan`,
+`zero-build`, `zero-veredicto`). A `corregir` verdict re-runs `build`; a
+`replantear` verdict re-runs `plan`; after a few rounds with no `pasa`, stop and
+report the result as not verified. Ask the user for interactive or automatic
+mode up front; in interactive mode pause after each phase for approval. Never
+claim success unless veredicto returned `pasa`.
+
+If the request begins with `--continue [slug]`, resume that unfinished run from
+its `.sdd/<slug>/` artifacts instead of starting fresh.
 
 Feature request: $ARGUMENTS

package/extensions/opencode-models.ts

@@ -1,111 +0,0 @@
-// zero-pi — OpenCode model-catalog discovery.
-//
-// Surfaces the model providers a user can run by cross-referencing OpenCode's
-// model catalog cache with the user's OpenCode auth file. This is the same
-// approach the `zero` installer's model picker uses, so `/zero-models` offers
-// the same providers — opencode-go, openai (codex/gpt), anthropic, … — as the
-// installer, instead of a hardcoded Claude list.
-//
-// Sources, under the user's home (ZERO_HOME-overridable for tests):
-//   ~/.cache/opencode/models.json       — the full provider/model catalog
-//   ~/.local/share/opencode/auth.json   — the providers the user authenticated
-//
-// Discovery is total: a missing or corrupt file yields an empty list, so a
-// user without OpenCode simply falls back to pi's own model registry.
-
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-/** A model discovered from OpenCode's catalog. */
-export interface DiscoveredModel {
-  /** The provider id, e.g. `opencode-go`, `openai`, `anthropic`. */
-  provider: string;
-  /** The model id, e.g. `gpt-5-codex`. */
-  id: string;
-  /** The human-readable model name. */
-  name: string;
-  /** Whether the model supports tool calls — required for the SDD phases. */
-  toolCall: boolean;
-  /** Whether the model exposes a reasoning-effort setting. */
-  reasoning: boolean;
-}
-
-/** The home directory discovery resolves OpenCode paths against. */
-function discoveryHome(): string {
-  const override = process.env.ZERO_HOME;
-  return typeof override === "string" && override.trim() !== "" ? override : homedir();
-}
-
-/** True for a plain (non-array) object. */
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** Read and parse a JSON file; returns null on any failure. */
-function readJson(path: string): unknown {
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as unknown;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Extract a provider's models from its OpenCode catalog entry.
- *
- * Exported for tests.
- */
-export function extractModels(
-  providerId: string,
-  entry: Record<string, unknown>,
-): DiscoveredModel[] {
-  const raw = entry.models;
-  if (!isObject(raw)) return [];
-
-  const models: DiscoveredModel[] = [];
-  for (const [id, model] of Object.entries(raw)) {
-    if (!isObject(model)) continue;
-    models.push({
-      provider: providerId,
-      id,
-      name: typeof model.name === "string" ? model.name : id,
-      toolCall: model.tool_call === true,
-      reasoning: model.reasoning === true,
-    });
-  }
-  return models;
-}
-
-/**
- * Discover every model the user can run, flattened across all OpenCode-
- * authenticated providers.
- *
- * `catalogJson` and `authJson` are injectable for tests; in normal use they
- * are read from OpenCode's cache and auth files on disk. The result is empty
- * when either source is absent or malformed.
- */
-export function discoverModels(
-  catalogJson?: unknown,
-  authJson?: unknown,
-): DiscoveredModel[] {
-  // Only touch disk when an argument is genuinely absent — an explicit value
-  // (including `null`) is used as given, so tests never read real files.
-  const auth =
-    authJson === undefined
-      ? readJson(join(discoveryHome(), ".local", "share", "opencode", "auth.json"))
-      : authJson;
-  const catalog =
-    catalogJson === undefined
-      ? readJson(join(discoveryHome(), ".cache", "opencode", "models.json"))
-      : catalogJson;
-  if (!isObject(auth) || !isObject(catalog)) return [];
-
-  const models: DiscoveredModel[] = [];
-  for (const providerId of Object.keys(auth)) {
-    const entry = catalog[providerId];
-    if (!isObject(entry)) continue;
-    models.push(...extractModels(providerId, entry));
-  }
-  return models;
-}