@gonrocca/zero-pi 0.1.11 → 0.1.13

package/README.md

@@ -65,19 +65,24 @@ orchestrator's plan-phase summary reports the run total and any exceptions.
 ### Per-phase models (`/zero-models`)
 
 `/zero-models` is a real pi command — a code handler, not an LLM prompt — for
-the SDD models. Run it with no argument to pick a phase and a model
-interactively, or set one directly:
+the SDD models. Run it with no argument for the interactive picker, or set one
+directly:
 
 ```
-/zero-models                        # interactive picker
-/zero-models build=claude-opus-4-7  # set one phase
+/zero-models                          # interactive picker
+/zero-models build=claude-opus-4-7     # set one phase
+/zero-models build=codex/gpt-5-codex   # set one phase with an explicit provider
 ```
 
-It reads and writes `~/.pi/zero.json`; the orchestrator picks the change up on
-the next `/forge` run.
+The interactive picker is **provider-aware**: it reads pi's model registry, so
+the flow is **phase → provider → model** and every provider you have configured
+(anthropic, codex, opencode, …) and its models are offered — not a hardcoded
+list. An `— otro provider —` / `— otro modelo —` entry still lets you type
+anything by hand.
 
-Per-phase model assignments are read from `~/.pi/zero.json`, which the `zero`
-CLI writes when it installs this layer.
+It reads and writes `~/.pi/zero.json` — `models` (the per-phase model id) plus a
+parallel `providers` map. The orchestrator picks the change up on the next
+`/forge` run. The `zero` CLI also writes this file when it installs the layer.
 
 **Run memory** — every SDD run reads from and writes to Cortex (the memory MCP
 server). Before exploring, the orchestrator recalls prior `zero-run/*` traces

package/extensions/autotune.ts

@@ -172,12 +172,50 @@ export function parseRunLine(line: string): RunRecord | null {
   };
 }
 
+/**
+ * Drop duplicate run records by their `(feature, ts)` identity, keeping the
+ * FIRST occurrence in input order.
+ *
+ * The `~/.pi/zero-runs.jsonl` log is a local cache of a shared run log: a
+ * careless Cortex PULL can re-append a record already present (even a machine
+ * re-pulling its own push), so the same `(feature, ts)` may appear more than
+ * once. This pass collapses each identity to a single sample so `aggregate`
+ * never counts a run twice.
+ *
+ * The identity key is `` `${feature}\0${ts}` `` — a NUL separator, which can
+ * appear neither in a feature slug nor an ISO 8601 timestamp, so the two
+ * fields can never collide ambiguously (`feature:"a-b", ts:"c"` vs
+ * `feature:"a", ts:"b-c"` stay distinct). Identity is `(feature, ts)` alone,
+ * independent of `v`/`verdicts` — v1 and v2 records dedupe identically.
+ *
+ * Keeping the FIRST occurrence is deterministic and stable under append: the
+ * local PUSH writes a run's line before any later PULL can re-fetch it, so the
+ * first copy is the one closest to the origin; and appending more duplicates
+ * never changes which record survives. The kept set depends only on the
+ * identities present, not on the count or order of duplicates. Pure and never
+ * throws.
+ */
+export function dedupeRunRecords(records: RunRecord[]): RunRecord[] {
+  const seen = new Set<string>();
+  const out: RunRecord[] = [];
+  for (const record of records) {
+    const key = `${record.feature}\0${record.ts}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(record);
+  }
+  return out;
+}
+
 /**
  * Read `~/.pi/zero-runs.jsonl` (or any path) into a list of valid `RunRecord`s.
  *
  * A missing or unreadable file yields `[]`. The file is split on `\n`; empty
  * lines are skipped, and any line `parseRunLine` rejects (a malformed or
- * half-written record) is dropped. Never throws.
+ * half-written record) is dropped. The parsed records are then passed through
+ * `dedupeRunRecords`, so the returned array is already de-duplicated by
+ * `(feature, ts)` — the aggregation call site never sees a duplicate sample.
+ * Never throws.
  */
 export function readRunRecords(path: string): RunRecord[] {
   let contents: string;
@@ -193,7 +231,7 @@ export function readRunRecords(path: string): RunRecord[] {
     const record = parseRunLine(line);
     if (record !== null) records.push(record);
   }
-  return records;
+  return dedupeRunRecords(records);
 }
 
 // ---------------------------------------------------------------------------

package/extensions/conversation-resume.ts

@@ -91,9 +91,10 @@ interface PiAPI {
   ): void;
 }
 
-/** Convert a shell argument into a single-quoted literal for PowerShell/sh. */
+/** Convert a shell argument into a single-quoted literal for the host shell. */
 export function quoteShellArg(value: string): string {
-  return `'${value.replace(/'/g, "''")}'`;
+  if (process.platform === "win32") return `'${value.replace(/'/g, "''")}'`;
+  return `'${value.replace(/'/g, "'\\''")}'`;
 }
 
 /** The project-local resume path. */

package/extensions/zero-models.ts

@@ -4,8 +4,13 @@
 // changing the per-phase SDD models in `~/.pi/zero.json`. It is deterministic:
 // no model is involved, so it does exactly what you pick, every time.
 //
-//   /zero-models                        interactive — pick a phase, pick a model
-//   /zero-models build=claude-opus-4-7   set one phase directly
+//   /zero-models                              interactive — phase, provider, model
+//   /zero-models build=claude-opus-4-7         set one phase directly
+//   /zero-models build=codex/gpt-5-codex       set phase with an explicit provider
+//
+// The interactive picker reads pi's model registry, so every provider you have
+// configured — anthropic, codex, opencode, … — and its models are offered, not
+// just a hardcoded Claude list.
 //
 // The SDD orchestrator reads `~/.pi/zero.json` at the start of every `/forge`
 // run, so a change takes effect on the next run.
@@ -23,6 +28,8 @@ export type Phase = (typeof PHASES)[number];
 
 /** The per-phase model map. */
 export type PhaseModels = Record<Phase, string>;
+/** The per-phase provider map — parallel to {@link PhaseModels}. */
+export type PhaseProviders = Record<Phase, string>;
 
 /** Fallback models when `~/.pi/zero.json` has none — cheap to explore, strong
  *  to plan and review. */
@@ -33,9 +40,8 @@ const DEFAULT_MODELS: PhaseModels = {
   veredicto: "claude-opus-4-7",
 };
 
-/** Models offered in the interactive picker — the Claude lineup pi-claude-cli
- *  exposes. Any other model can still be typed via the custom option. */
-const MODEL_CHOICES = [
+/** Model list used only when pi's model registry is unavailable. */
+const FALLBACK_MODELS = [
   "claude-opus-4-7",
   "claude-opus-4-6",
   "claude-sonnet-4-6",
@@ -74,19 +80,52 @@ export function readModels(data: Record<string, unknown>): PhaseModels {
   return models;
 }
 
-/** Parse a `<phase>=<model>` (or `<phase> <model>`) assignment. */
-export function parseAssignment(arg: string): { phase: Phase; model: string } | null {
+/**
+ * Extract the per-phase providers from a zero.json object. A missing provider
+ * is an empty string — the consumer resolves or ignores it.
+ */
+export function readProviders(data: Record<string, unknown>): PhaseProviders {
+  const raw = (data.providers ?? {}) as Record<string, unknown>;
+  const providers: PhaseProviders = { explore: "", plan: "", build: "", veredicto: "" };
+  for (const phase of PHASES) {
+    if (typeof raw[phase] === "string") providers[phase] = raw[phase] as string;
+  }
+  return providers;
+}
+
+/** A provider-qualified model assignment from the direct command form. */
+export interface Assignment {
+  phase: Phase;
+  model: string;
+  provider?: string;
+}
+
+/**
+ * Parse a direct `<phase>=<model>` assignment. The value may carry an explicit
+ * provider as `<provider>/<model>` — the first `/` splits them.
+ */
+export function parseAssignment(arg: string): Assignment | null {
   const match = arg.trim().match(/^(\w+)\s*[=\s]\s*(.+)$/);
   if (!match) return null;
   const phase = match[1].toLowerCase();
-  const model = match[2].trim();
-  if (!isPhase(phase) || model === "") return null;
-  return { phase, model };
+  if (!isPhase(phase)) return null;
+  let value = match[2].trim();
+  if (value === "") return null;
+
+  const slash = value.indexOf("/");
+  if (slash > 0 && slash < value.length - 1) {
+    return { phase, provider: value.slice(0, slash).trim(), model: value.slice(slash + 1).trim() };
+  }
+  return { phase, model: value };
 }
 
-/** Render the per-phase model map as an aligned block. */
-export function formatModels(models: PhaseModels): string {
-  return PHASES.map((phase) => `  ${phase.padEnd(10)} ${models[phase]}`).join("\n");
+/** Render the per-phase model map as an aligned `provider/model` block. */
+export function formatPhases(models: PhaseModels, providers: PhaseProviders): string {
+  return PHASES.map((phase) => {
+    const provider = providers[phase];
+    const label = provider ? `${provider}/${models[phase]}` : models[phase];
+    return `  ${phase.padEnd(10)} ${label}`;
+  }).join("\n");
 }
 
 /** The valid `autotune` modes a user can set. */
@@ -118,50 +157,28 @@ export function formatAutotune(mode: AutotuneMode): string {
   }
 }
 
-/** Write the models back into `~/.pi/zero.json`, preserving every other key. */
-function writeModels(data: Record<string, unknown>, models: PhaseModels): void {
-  writeFileSync(zeroJsonPath(), `${JSON.stringify({ ...data, models }, null, 2)}\n`, "utf8");
+/** A pi model entry — only the fields the picker needs. */
+export interface PiModel {
+  provider: string;
+  id: string;
+  name?: string;
 }
 
 /**
- * Write an updated `~/.pi/zero.json` object, preserving every other key via the
- * same `{ ...data }` spread, 2-space indent and trailing newline `writeModels`
- * uses. The caller passes the keys it wants to add/override.
+ * Group model ids by provider, each list sorted and de-duplicated. Malformed
+ * entries are skipped so a registry quirk never crashes the picker.
  */
-function writeZeroJson(data: Record<string, unknown>, patch: Record<string, unknown>): void {
-  writeFileSync(zeroJsonPath(), `${JSON.stringify({ ...data, ...patch }, null, 2)}\n`, "utf8");
-}
-
-/** Whether a value is a non-null, non-array object. */
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/**
- * Extract the `autotunePending` adjustments from a zero.json object.
- *
- * Returns only well-formed records — an array entry with string `phase`/`from`/
- * `to`/`reason` and a recognized phase — so a malformed key never crashes the
- * picker. A missing or off-shape key yields `[]`.
- */
-function readAutotunePending(data: Record<string, unknown>): AutotunePending[] {
-  const raw = data.autotunePending;
-  if (!Array.isArray(raw)) return [];
-  const pending: AutotunePending[] = [];
-  for (const entry of raw) {
-    if (!isObject(entry)) continue;
-    const { phase, from, to, reason } = entry;
-    if (
-      typeof phase === "string" &&
-      isPhase(phase) &&
-      typeof from === "string" &&
-      typeof to === "string" &&
-      typeof reason === "string"
-    ) {
-      pending.push({ phase, from, to, reason });
-    }
+export function groupByProvider(models: readonly PiModel[]): Map<string, string[]> {
+  const map = new Map<string, string[]>();
+  for (const m of models) {
+    if (!m || typeof m.provider !== "string" || typeof m.id !== "string") continue;
+    if (m.provider === "" || m.id === "") continue;
+    const list = map.get(m.provider) ?? [];
+    if (!list.includes(m.id)) list.push(m.id);
+    map.set(m.provider, list);
   }
-  return pending;
+  for (const list of map.values()) list.sort();
+  return map;
 }
 
 /** The slice of pi's extension API this command uses. */
@@ -170,8 +187,14 @@ interface PiUI {
   input(prompt: string, placeholder?: string): Promise<string | undefined>;
   notify(message: string, type?: "info" | "warning" | "error"): void;
 }
+/** pi's model registry — the source of every provider's model list. */
+interface PiModelRegistry {
+  getAll(): PiModel[];
+  getAvailable?(): PiModel[];
+}
 interface PiCommandContext {
   ui: PiUI;
+  modelRegistry?: PiModelRegistry;
 }
 interface PiExtensionAPI {
   registerCommand(
@@ -185,6 +208,39 @@ interface PiExtensionAPI {
 
 const SAVE_AND_EXIT = "— guardar y salir —";
 const CUSTOM_MODEL = "— otro modelo (escribir) —";
+const CUSTOM_PROVIDER = "— otro provider (escribir) —";
+
+/**
+ * Group the registry's models by provider. Prefers `getAvailable()` (providers
+ * with configured auth — what the user actually has) and falls back to the
+ * full `getAll()` set, then to an empty map when no registry is present.
+ */
+function providerGroups(registry: PiModelRegistry | undefined): Map<string, string[]> {
+  if (!registry || typeof registry.getAll !== "function") return new Map();
+  try {
+    const available = typeof registry.getAvailable === "function" ? registry.getAvailable() : [];
+    const source = available && available.length > 0 ? available : registry.getAll();
+    return groupByProvider(source ?? []);
+  } catch {
+    return new Map();
+  }
+}
+
+/** Find the provider that owns a model id, if the registry knows it. */
+function resolveProvider(
+  registry: PiModelRegistry | undefined,
+  modelId: string,
+): string | undefined {
+  if (!registry || typeof registry.getAll !== "function") return undefined;
+  try {
+    for (const m of registry.getAll()) {
+      if (m && m.id === modelId && typeof m.provider === "string") return m.provider;
+    }
+  } catch {
+    /* ignore */
+  }
+  return undefined;
+}
 
 /**
  * The pi extension entry point — registers the `/zero-models` command.
@@ -193,11 +249,14 @@ export default function register(pi?: PiExtensionAPI): void {
   if (!pi || typeof pi.registerCommand !== "function") return;
 
   pi.registerCommand("zero-models", {
-    description: "Show or set the per-phase SDD models — /zero-models [<phase>=<model>]",
+    description:
+      "Show or set the per-phase SDD models — /zero-models [<phase>=[<provider>/]<model>]",
     handler: async (args: string, ctx: PiCommandContext): Promise<void> => {
       try {
         const data = readZeroJson();
         const models = readModels(data);
+        const providers = readProviders(data);
+        const groups = providerGroups(ctx.modelRegistry);
 
         // Direct form: /zero-models build=claude-opus-4-7
         const arg = args.trim();
@@ -213,7 +272,11 @@ export default function register(pi?: PiExtensionAPI): void {
               );
               return;
             }
-            writeZeroJson(data, { autotune: mode });
+            writeFileSync(
+              zeroJsonPath(),
+              `${JSON.stringify({ ...data, autotune: mode }, null, 2)}\n`,
+              "utf8",
+            );
             ctx.ui.notify(`zero autotune: ${formatAutotune(mode)}`, "info");
             return;
           }
@@ -221,7 +284,7 @@ export default function register(pi?: PiExtensionAPI): void {
           const assignment = parseAssignment(arg);
           if (!assignment) {
             ctx.ui.notify(
-              "uso: /zero-models  —o—  /zero-models <fase>=<modelo> " +
+              "uso: /zero-models  —o—  /zero-models <fase>=[<provider>/]<modelo> " +
                 "(fase: explore | plan | build | veredicto)  —o—  " +
                 "/zero-models autotune=<modo>",
               "warning",
@@ -229,12 +292,23 @@ export default function register(pi?: PiExtensionAPI): void {
             return;
           }
           models[assignment.phase] = assignment.model;
-          writeModels(data, models);
-          ctx.ui.notify(`zero models: ${assignment.phase} → ${assignment.model}`, "info");
+          providers[assignment.phase] =
+            assignment.provider ??
+            resolveProvider(ctx.modelRegistry, assignment.model) ??
+            providers[assignment.phase];
+          writeFileSync(
+            zeroJsonPath(),
+            `${JSON.stringify({ ...data, models, providers }, null, 2)}\n`,
+            "utf8",
+          );
+          const shown = providers[assignment.phase]
+            ? `${providers[assignment.phase]}/${assignment.model}`
+            : assignment.model;
+          ctx.ui.notify(`zero models: ${assignment.phase} → ${shown}`, "info");
           return;
         }
 
-        // Interactive form: pick a phase, pick a model, repeat until saved.
+        // Interactive form: pick a phase, a provider, a model — until saved.
         let changed = false;
         let autotuneMode = readAutotuneMode(data);
         let autotuneChanged = false;
@@ -251,7 +325,9 @@ export default function register(pi?: PiExtensionAPI): void {
 
           const phasePick = await ctx.ui.select("zero · modelos SDD — elegí una fase", [
             ...(applyEntry ? [applyEntry] : []),
-            ...PHASES.map((p) => `${p}   →   ${models[p]}`),
+            ...PHASES.map(
+              (p) => `${p}   →   ${providers[p] ? `${providers[p]}/` : ""}${models[p]}`,
+            ),
             autotuneEntry,
             SAVE_AND_EXIT,
           ]);
@@ -284,40 +360,62 @@ export default function register(pi?: PiExtensionAPI): void {
           const phase = phasePick.split(/\s/)[0];
           if (!isPhase(phase)) break;
 
-          const modelPick = await ctx.ui.select(`Modelo para «${phase}»`, [
-            ...MODEL_CHOICES,
-            CUSTOM_MODEL,
-          ]);
+          // Pick a provider — from the registry, or typed when unknown.
+          let provider = providers[phase];
+          let modelChoices = FALLBACK_MODELS;
+          if (groups.size > 0) {
+            const providerPick = await ctx.ui.select(`Provider para «${phase}»`, [
+              ...[...groups.keys()].sort(),
+              CUSTOM_PROVIDER,
+            ]);
+            if (!providerPick) continue;
+            if (providerPick === CUSTOM_PROVIDER) {
+              const typed = await ctx.ui.input(
+                `Provider para «${phase}»`,
+                providers[phase] || "",
+              );
+              if (!typed || typed.trim() === "") continue;
+              provider = typed.trim();
+              modelChoices = groups.get(provider) ?? [];
+            } else {
+              provider = providerPick;
+              modelChoices = groups.get(providerPick) ?? [];
+            }
+          }
+
+          // Pick a model within that provider — or type one.
+          const label = provider ? `Modelo para «${phase}» (${provider})` : `Modelo para «${phase}»`;
+          const modelPick = await ctx.ui.select(label, [...modelChoices, CUSTOM_MODEL]);
           if (!modelPick) continue;
 
           let model = modelPick;
           if (modelPick === CUSTOM_MODEL) {
-            const typed = await ctx.ui.input(`Modelo para «${phase}»`, models[phase]);
+            const typed = await ctx.ui.input(label, models[phase]);
             if (!typed || typed.trim() === "") continue;
             model = typed.trim();
           }
           models[phase] = model;
+          providers[phase] = provider || resolveProvider(ctx.modelRegistry, model) || "";
           changed = true;
         }
 
         if (changed || autotuneChanged) {
           // Build the patch, preserving every other key via the spread. When
           // the pending suggestion was applied, clear the `autotunePending` key.
-          const patch: Record<string, unknown> = { models };
+          const patch: Record<string, unknown> = { models, providers };
           if (autotuneChanged) patch.autotune = autotuneMode;
-          if (pendingApplied) patch.autotunePending = undefined;
 
           const merged = { ...data, ...patch };
           if (pendingApplied) delete merged.autotunePending;
           writeFileSync(zeroJsonPath(), `${JSON.stringify(merged, null, 2)}\n`, "utf8");
 
-          const summary = [`zero · modelos SDD guardados:\n${formatModels(models)}`];
+          const summary = [`zero · modelos SDD guardados:\n${formatPhases(models, providers)}`];
           summary.push(`  autotune   ${autotuneMode}`);
           if (pendingApplied) summary.push("sugerencia aplicada");
           ctx.ui.notify(summary.join("\n"), "info");
         } else {
           ctx.ui.notify(
-            `zero · modelos SDD (sin cambios):\n${formatModels(models)}\n` +
+            `zero · modelos SDD (sin cambios):\n${formatPhases(models, providers)}\n` +
               `  autotune   ${autotuneMode}`,
             "info",
           );
@@ -331,3 +429,35 @@ export default function register(pi?: PiExtensionAPI): void {
     },
   });
 }
+
+/** Whether a value is a non-null, non-array object. */
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Extract the `autotunePending` adjustments from a zero.json object.
+ *
+ * Returns only well-formed records — an array entry with string `phase`/`from`/
+ * `to`/`reason` and a recognized phase — so a malformed key never crashes the
+ * picker. A missing or off-shape key yields `[]`.
+ */
+function readAutotunePending(data: Record<string, unknown>): AutotunePending[] {
+  const raw = data.autotunePending;
+  if (!Array.isArray(raw)) return [];
+  const pending: AutotunePending[] = [];
+  for (const entry of raw) {
+    if (!isObject(entry)) continue;
+    const { phase, from, to, reason } = entry;
+    if (
+      typeof phase === "string" &&
+      isPhase(phase) &&
+      typeof from === "string" &&
+      typeof to === "string" &&
+      typeof reason === "string"
+    ) {
+      pending.push({ phase, from, to, reason });
+    }
+  }
+  return pending;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/zero-pi",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "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": [

package/prompts/orchestrator.md

@@ -105,10 +105,12 @@ count — the sub-agents only carry out their own phase.
 
 ## Model configuration
 
-The per-phase model assignments live in `~/.pi/zero.json` under `models`
-(keys: `explore`, `plan`, `build`, `veredicto`). Read that file at the start of
-a run and delegate each phase's sub-agent to the model listed there. When the
-file is absent or a phase is missing, fall back to the session's default model.
+The per-phase model assignments live in `~/.pi/zero.json`: `models` maps each
+phase (`explore`, `plan`, `build`, `veredicto`) to a model id, and the parallel
+`providers` map gives the provider that model belongs to. Read that file at the
+start of a run and delegate each phase's sub-agent to its configured
+provider + model. When the file is absent, a phase is missing, or its provider
+entry is empty, fall back to the session's default model.
 
 ## Execution mode
 
@@ -160,8 +162,31 @@ the iteration cap reached — save one run-trace memory with `memoria_save`:
 
 Use the project name Cortex derives from the working directory.
 
+**Pull run metrics — at run start, alongside recall.** When `/forge` starts,
+together with the recall above, pull the shared run-metrics log from Cortex into
+the local `~/.pi/zero-runs.jsonl` so the autotune sees runs from other machines:
+
+- Query Cortex with `memoria_search` / `memoria_recent` over the **fixed**
+  `zero-metrics` project namespace, filtering `type:"metric"`. Bound the result
+  to the **200 most-recent records** — if Cortex cannot apply an exact limit,
+  fetch the newest batch and truncate to 200.
+- For each record, extract the `what` field — the verbatim `RunRecord` JSON
+  line. Do not re-serialize or reformat it; use the string as-is.
+- **Naive append:** append each extracted line, followed by a single `\n`, to
+  `~/.pi/zero-runs.jsonl`. Create the file if absent. Never rewrite, reorder, or
+  delete existing lines, and do not compare against what is already in the file
+  — de-duplication is handled deterministically by the reader (`dedupeRunRecords`
+  in `autotune.ts`), so appending an already-present record is safe.
+- If the pull finds no records, leave the file unchanged and continue.
+
+**One-session lag (intended).** This pull runs at `/forge` start; the autotune
+extension reads `~/.pi/zero-runs.jsonl` at the *next* `session_start`. So a
+record pulled now influences tuning one session later — consistent with the
+autotune's existing one-run lag.
+
 If Cortex is unavailable — installed with `--no-mcp`, or the server is down —
-skip recall and persist silently. The memory loop must never block a run.
+skip recall, the metrics pull, and persist silently. The memory loop must never
+block a run.
 
 ## Run metrics
 
@@ -207,6 +232,27 @@ Rules:
   ever produced a verdict, write nothing — only a `pasa` or `cap-reached` run
   is recorded.
 
+**Push to Cortex.** After appending the local line, also save the same
+`RunRecord` to Cortex so other machines' autotune can pull it. This is separate
+from — and additional to — the `session_summary` save in "## Run memory"; do
+both, and it does not rewrite the local line. Call `memoria_save` with:
+
+- `project`: `"zero-metrics"` — the fixed, dedicated namespace. NOT the
+  cwd-derived project.
+- `type`: `"metric"`.
+- `topic_key`: `zero-metric/<feature>/<ts>` — unique per run record, so two
+  distinct runs never upsert over each other.
+- `title`: `zero metric — <feature> @ <ts>`.
+- `what`: the `RunRecord` JSON line **verbatim** — the exact same one-line
+  string just written to `~/.pi/zero-runs.jsonl`, not reformatted or
+  pretty-printed.
+- `why`: `"zero run metrics — synced for cross-machine autotune"`.
+
+No verdict → no local line and no push (consistent with "No record without a
+verdict" above). If the push fails for any reason, or zero runs with `--no-mcp`
+or Cortex is down — emit a non-blocking warning and continue, never block the
+run. The local line already stands.
+
 ## Spec sync & archive
 
 The project keeps a **canonical spec store** at `.sdd/specs/requirements.md` —

package/skills/{sdd-routing.md → sdd-routing/SKILL.md}

@@ -1,4 +1,5 @@
 ---
+name: sdd-routing
 description: Route a natural-language request into the zero SDD pipeline when the user signals SDD intent
 ---
 

package/skills/{skill-loop.md → skill-loop/SKILL.md}

@@ -1,4 +1,5 @@
 ---
+name: skill-loop
 description: zero's skill auto-learning loop — distill, store, surface, and refine reusable skills
 ---