@sangyaahub/pi-marg 1.0.5 → 1.0.7

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "PiMarg — a governed development path for Pi Agent and Oh My Pi.",
-    "version": "1.0.5"
+    "version": "1.0.7"
   },
   "plugins": [
     {
       "name": "pi-marg",
       "description": "Intent-led development workflow with live A/B/C/D routing, capability detection, verification, and approval gates.",
       "source": "./",
-      "version": "1.0.5",
+      "version": "1.0.7",
       "author": {
         "name": "Sangyaa",
         "email": "contact@sangyaa.co"

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 1.0.7 — 2026-10-03
+
+- Stages 1–3 of Auto Mode intake now use the host selection tool (`ask` on OMP) instead of asking the user to type numbers in chat.
+- The `auto-intake` agent can call `ask`, so the selection window is available when intake runs as a subagent.
+
+## 1.0.6 — 2026-10-03
+
+- Reopening `/pi-marg` highlights the saved boundary, work type, skill, and A/B/C/D selectors. Enter keeps that row, and intake activates the first required stage model before the work message is sent.
+- A saved route now survives a new OMP or Pi process. A selector that disappeared from the live catalog is reported missing and is not remapped or activated.
+- An empty OMP catalog can sign in, add a custom OpenAI-compatible provider, or cancel. Provider files store the env var name, and the secret is written only to the runtime `.env`.
+
 ## 1.0.5 — 2026-09-26
 
 - Documented how to register CheaperInference in Oh My Pi so Kimi and GLM models can be chosen at every A/B/C/D stage.

package/MODEL-SETUP.md

@@ -16,7 +16,7 @@ LIVE AUTHENTICATED CATALOG
    high backup ──► low backup
 ```
 
-If the live catalog is empty, PiMarg stops and promotes provider/subscription setup instead of guessing models.
+If the live catalog is empty, `/pi-marg` offers three actions: sign in with `/login`, add a custom OpenAI-compatible provider, or cancel. The custom path writes `apiKey: ENV_VAR_NAME` into `~/.omp/agent/models.yml` and the secret only into `~/.omp/agent/.env`. Cancelling writes neither file.
 
 ## Roles
 
@@ -37,7 +37,7 @@ Use Pi's normal provider configuration or environment variables, then verify ava
 pi --list-models
 ```
 
-The Pi adapter reads `ctx.scopedModels` when the session has a model allowlist; otherwise it reads `ctx.modelRegistry.getAvailable()`. This respects both authentication and an intentional session scope.
+The Pi adapter reads `ctx.scopedModels` when the session has a model allowlist; otherwise it reads `ctx.modelRegistry.getAvailable()`. A model can be authenticated and still hidden because that session allowlist is active. This is a scope limit, not a missing login.
 
 ## Oh My Pi
 
@@ -72,8 +72,8 @@ Any of those four models can be chosen for any stage. Calls spend CheaperInferen
 
 ## Selection workflow
 
-1. Run `/pi-marg` for the full native intake, or `/auto-models choose` to change saved models.
-2. Confirm the work type so PiMarg knows which stages are required.
+1. Run `/pi-marg` for the full native intake, or `/auto-models choose` to change saved models. Reopening either one highlights the saved boundary, work type, skill, and each saved A/B/C/D and backup selector. Pressing Enter keeps that highlighted row.
+2. Confirm the work type so PiMarg knows which stages are required. A saved choice that is no longer in the live catalog is reported as missing and is not activated or remapped.
 3. Required stage prompts and catalog sections are always shown in ascending order: **A, then B, then C, then D** (skipping stages that do not apply).
 4. For each required stage, choose a **provider** first (numbered `1. …`), then a **model** from that provider (numbered `1. …`). Exact `provider/id` selectors are the selection keys—not display numbers alone.
 5. Select A and C when discovery/review is required; recommended frontier choices appear first within their lists when recognizable, but every live model remains selectable.

package/README.md

@@ -3,7 +3,7 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/sangyaahub/pi-marg/releases"><img alt="Version 1.0.5" src="https://img.shields.io/badge/version-1.0.5-0451F7"></a>
+  <a href="https://github.com/sangyaahub/pi-marg/releases"><img alt="Version 1.0.7" src="https://img.shields.io/badge/version-1.0.7-0451F7"></a>
   <a href="LICENSE"><img alt="MIT License" src="https://img.shields.io/badge/license-MIT-C27B1A"></a>
   <a href="https://pi.dev/packages?name=pi-marg"><img alt="Pi package" src="https://img.shields.io/badge/Pi-package-0338A8"></a>
   <a href="https://omp.sh"><img alt="Oh My Pi plugin" src="https://img.shields.io/badge/OMP-plugin-021E5C"></a>
@@ -11,7 +11,7 @@
 
 # PiMarg
 
-**Version 1.0.5 · MIT licensed · Pi Agent + Oh My Pi · by [Sangyaa](https://sangyaa.co)**
+**Version 1.0.7 · MIT licensed · Pi Agent + Oh My Pi · by [Sangyaa](https://sangyaa.co)**
 
 PiMarg turns an ordinary prompt into a governed development path. It identifies the work boundary, selects one engineering method, discovers the models and tools the active runtime really provides, separates thinking from execution, records evidence, and stops before protected actions.
 
@@ -122,7 +122,13 @@ Authenticate providers using the active runtime's normal login flow, then run:
 /auto-models choose
 ```
 
-The router shows every model in the live authenticated and enabled registry. Stage-appropriate choices appear first and all other enabled choices remain selectable. It does not promise that a subscription route is free or unlimited. See [MODEL-SETUP.md](MODEL-SETUP.md).
+The router shows every model in the live authenticated and enabled registry. Stage-appropriate choices appear first and all other enabled choices remain selectable. Reopening `/pi-marg` highlights the saved selector; Enter keeps it and activates the first required stage model. It does not promise that a subscription route is free or unlimited. See [MODEL-SETUP.md](MODEL-SETUP.md).
+
+### Custom OpenAI-compatible provider
+
+When OMP has no models yet, `/pi-marg` can register a custom provider without leaving the intake. It asks for a provider id, display name, base URL, env var name, and model ids. `models.yml` stores `apiKey: YOUR_ENV_VAR`. The secret goes only in `~/.omp/agent/.env`. After the runtime reloads, every model from that provider is offered at A, B, C, and D. A and C must still be different models, and B and D must still be different models. With only one model, PiMarg says so before stage A and lets you add another model or stop before the paired stage.
+
+CheaperInference below is one worked example of that same shape, not the only custom provider PiMarg accepts.
 
 ### CheaperInference (Kimi and GLM)
 

package/adapters/omp/extensions/model-router.ts

@@ -5,7 +5,7 @@ import {
   buildFallbackCatalog,
   buildModelCatalog,
   candidatesForProvider,
-  emptyCatalogSetupMessage,
+  commitIntakeRoute,
   emptyModelRouteState,
   executeAutomaticFailover,
   executeModelRoute,
@@ -13,12 +13,12 @@ import {
   findTerminalUsageLimitFailure,
   formatFailoverRecoveryMessage,
   hasConfiguredFallback,
-  matchNumberedOption,
   modelFailureKey,
   modelToolUsageLimitFailure,
   numberedOptionLabel,
   requiredStagesForWorkType,
-  restoreModelRouteState,
+  resolveSelectAnswer,
+  revalidateSavedRoute,
   uniqueProviders,
   type AutoStage,
   type FallbackLevel,
@@ -26,8 +26,12 @@ import {
   type ModelLike,
   type ModelRouteParams,
   type ModelRouteState,
+  type SelectAnswerResolution,
+  type WorkBoundary,
 } from "../../../core/model-routing";
 import { normalizeCapabilityNames } from "../../../core/runtime-capabilities";
+import { loadRuntimeRoute, rememberRuntimeRoute } from "../../../core/user-route";
+import { configureEmptyCatalog, resolveSingleModel } from "./provider-setup";
 
 const WORK_BOUNDARIES = ["1. Job/client", "2. Personal"] as const;
 
@@ -71,10 +75,68 @@ function commandPrompt(args: string): string {
   return trimmed;
 }
 
+const WORK_BOUNDARY_ITEMS = ["Job/client", "Personal"] as const;
+const WORK_TYPE_ITEMS = [
+  "New idea or development from scratch",
+  "New feature for an existing repository",
+  "Improve an existing feature",
+  "Pro-active bug fix",
+  "Security review or fixes",
+  "Thoughts about an existing repository or features",
+  "Business, sales, or other non-technical analysis",
+] as const;
+const SKILL_MODE_ITEMS = [
+  "Compound Engineering",
+  "Superpowers",
+  "GSD Core",
+  "PiMarg chooses the best available skill",
+] as const;
+
 function optionLabel(candidate: ModelCandidate): string {
   return `${candidate.label} — ${candidate.selector}`;
 }
 
+function savedIndex<T>(items: readonly T[], matches: (item: T) => boolean): number | undefined {
+  const index = items.findIndex(matches);
+  return index >= 0 ? index : undefined;
+}
+
+function takeAnswer<T>(ctx: any, resolution: SelectAnswerResolution<T>): T | undefined {
+  switch (resolution.status) {
+    case "matched":
+      return resolution.item;
+    case "cancelled":
+      ctx.ui.notify("Selection cancelled; no model was saved.", "warning");
+      return undefined;
+    case "conflict":
+      ctx.ui.notify("That answer matches more than one option; no model was saved.", "error");
+      return undefined;
+    case "unrecognized":
+      ctx.ui.notify(`Unrecognized selection ${JSON.stringify(resolution.received)}; no model was saved.`, "error");
+      return undefined;
+    default: {
+      const unreachable: never = resolution;
+      return unreachable;
+    }
+  }
+}
+
+async function askChoice<T>(
+  ctx: any,
+  title: string,
+  items: readonly T[],
+  labelOf: (item: T) => string,
+  options: ReadonlyArray<string | { label: string; description?: string }>,
+  settings: { initialIndex?: number; helpText?: string } = {},
+): Promise<T | undefined> {
+  const answer = await ctx.ui.select(title, [...options], {
+    selectionMarker: "radio",
+    ...(settings.helpText ? { helpText: settings.helpText } : {}),
+    ...(typeof settings.initialIndex === "number" ? { initialIndex: settings.initialIndex } : {}),
+  });
+  return takeAnswer(ctx, resolveSelectAnswer(answer, items, labelOf));
+}
+
 function optionDescription(stage: AutoStage, candidate: ModelCandidate): string {
   const preferredTier = stage === "A" || stage === "C" ? "frontier" : "execution";
   const fit = candidate.tier === preferredTier ? "Recommended fit" : "Available";
@@ -86,6 +148,7 @@ async function chooseModel(
   stage: AutoStage,
   candidates: ModelCandidate[],
   selected: Partial<Record<AutoStage, ModelCandidate>>,
+  saved?: ModelCandidate,
 ): Promise<ModelCandidate | undefined> {
   const opposite: Record<AutoStage, AutoStage> = { A: "C", C: "A", B: "D", D: "B" };
   const other = selected[opposite[stage]];
@@ -98,13 +161,14 @@ async function chooseModel(
     return undefined;
   }
 
+  const highlighted = saved && eligible.some((candidate) => candidate.selector === saved.selector) ? saved : undefined;
   return chooseCandidateByProvider(ctx, eligible, {
     providerTitle: `Stage ${stage} provider`,
     modelTitle: `Stage ${stage} model`,
     purpose: STAGE_PURPOSE[stage],
     providerDescription: (name) => `All authenticated ${name} models for ${STAGE_PURPOSE[stage]}`,
     modelDescription: (candidate) => optionDescription(stage, candidate),
-  });
+  }, highlighted);
 }
 
 async function chooseFallbackModel(
@@ -112,6 +176,7 @@ async function chooseFallbackModel(
   level: FallbackLevel,
   candidates: ModelCandidate[],
   other?: ModelCandidate,
+  saved?: ModelCandidate,
 ): Promise<ModelCandidate | undefined> {
   const eligible = candidates.filter((candidate) => (
     candidate.access === "runtime-model" && (!other || candidate.identity !== other.identity)
@@ -125,6 +190,7 @@ async function chooseFallbackModel(
     return undefined;
   }
 
+  const highlighted = saved && eligible.some((candidate) => candidate.selector === saved.selector) ? saved : undefined;
   return chooseCandidateByProvider(ctx, eligible, {
     providerTitle: `${title} backup provider`,
     modelTitle: `${title} backup model`,
@@ -133,7 +199,7 @@ async function chooseFallbackModel(
     modelDescription: (candidate) => (
       `${FALLBACK_PURPOSE[level]}${candidate.billingNote ? ` · ${candidate.billingNote}` : ""}`
     ),
-  });
+  }, highlighted);
 }
 
 async function chooseCandidateByProvider(
@@ -146,20 +212,23 @@ async function chooseCandidateByProvider(
     providerDescription(provider: string): string;
     modelDescription(candidate: ModelCandidate): string;
   },
+  saved?: ModelCandidate,
 ): Promise<ModelCandidate | undefined> {
   const providers = uniqueProviders(candidates);
   const providerOptions = providers.map((name, index) => ({
     label: numberedOptionLabel(index, `${name} (${candidatesForProvider(candidates, name).length})`),
     description: copy.providerDescription(name),
   }));
-  const providerAnswer = await ctx.ui.select(copy.providerTitle, providerOptions, {
-    selectionMarker: "radio",
-    helpText: `${providers.length} providers · ${candidates.length} models · ${copy.purpose}`,
-  });
-  const provider = matchNumberedOption(
-    providerAnswer,
+  const provider = await askChoice(
+    ctx,
+    copy.providerTitle,
     providers,
     (name) => `${name} (${candidatesForProvider(candidates, name).length})`,
+    providerOptions,
+    {
+      initialIndex: saved ? savedIndex(providers, (name) => name === saved.provider) : undefined,
+      helpText: `${providers.length} providers · ${candidates.length} models · ${copy.purpose}`,
+    },
   );
   if (!provider) return undefined;
 
@@ -168,29 +237,11 @@ async function chooseCandidateByProvider(
     label: numberedOptionLabel(index, optionLabel(candidate)),
     description: copy.modelDescription(candidate),
   }));
-  const answer = await ctx.ui.select(copy.modelTitle, modelOptions, {
-    selectionMarker: "radio",
-    helpText: `${providerModels.length} ${provider} choices · ${copy.purpose}`,
+  const savedHere = saved?.provider === provider ? saved.selector : undefined;
+  return askChoice(ctx, copy.modelTitle, providerModels, optionLabel, modelOptions, {
+    initialIndex: savedHere ? savedIndex(providerModels, (candidate) => candidate.selector === savedHere) : undefined,
+    helpText: `${providerModels.length} ${provider} choices · ${copy.purpose}${savedHere ? ` · saved ${savedHere}` : ""}`,
   });
-  return matchNumberedOption(answer, providerModels, optionLabel);
-}
-
-function selectedState(
-  workType: number,
-  selected: Partial<Record<AutoStage, ModelCandidate>>,
-  fallbacks: Record<FallbackLevel, ModelCandidate>,
-): ModelRouteState {
-  const selectedAt = new Date().toISOString();
-  return {
-    version: 2,
-    workType,
-    selections: Object.fromEntries(
-      Object.entries(selected).map(([stage, candidate]) => [stage, { ...candidate, selectedAt }]),
-    ) as ModelRouteState["selections"],
-    fallbacks: Object.fromEntries(
-      Object.entries(fallbacks).map(([level, candidate]) => [level, { ...candidate, selectedAt }]),
-    ) as ModelRouteState["fallbacks"],
-  };
 }
 
 function intakeMessage(
@@ -227,11 +278,20 @@ export default function modelRouter(pi: any) {
   let recoveryToken: symbol | undefined;
   let sessionGeneration = 0;
   let pendingToolFailure: { selector: string; key: string } | undefined;
+  const routeHome = (ctx: any) => typeof ctx?.agentHome === "string" ? ctx.agentHome : undefined;
+  const persistRoute = (nextState: ModelRouteState, ctx?: any) => {
+    pi.appendEntry(MODEL_STATE_TYPE, nextState);
+    try {
+      rememberRuntimeRoute("OMP", nextState, routeHome(ctx));
+    } catch {
+      ctx?.ui?.notify?.("PiMarg saved the route in this session, but could not update the user route file.", "warning");
+    }
+  };
   const restore = (_event: unknown, ctx: any) => {
     sessionGeneration += 1;
     recoveryToken = undefined;
     pendingToolFailure = undefined;
-    state = restoreModelRouteState(ctx.sessionManager.getBranch());
+    state = loadRuntimeRoute("OMP", ctx.sessionManager.getBranch(), routeHome(ctx));
   };
 
   pi.on("session_start", restore);
@@ -253,7 +313,7 @@ export default function modelRouter(pi: any) {
         activate: (model) => pi.setModel(model),
         persist: (nextState) => {
           if (sessionGeneration !== generation) throw new Error("session changed during automatic recovery");
-          pi.appendEntry(MODEL_STATE_TYPE, nextState);
+          persistRoute(nextState, ctx);
         },
       }, failure.key);
       if (sessionGeneration !== generation) {
@@ -348,43 +408,167 @@ export default function modelRouter(pi: any) {
       }
       if (!request) return;
 
-      const boundaryLabel = await ctx.ui.select("Work boundary", [...WORK_BOUNDARIES], {
-        selectionMarker: "radio",
-      });
-      const boundary = matchNumberedOption(boundaryLabel, ["Job/client", "Personal"], (item) => item);
+      const boundary = await askChoice(
+        ctx,
+        "Work boundary",
+        WORK_BOUNDARY_ITEMS,
+        (item) => item,
+        WORK_BOUNDARIES,
+        { initialIndex: savedIndex(WORK_BOUNDARY_ITEMS, (item) => item === state.boundary) },
+      );
       if (!boundary) return;
 
-      const workTypeLabel = await ctx.ui.select("Work type", [...WORK_TYPES], { selectionMarker: "radio" });
-      const workType = Number.parseInt(workTypeLabel?.match(/^([1-7])\./)?.[1] ?? "", 10);
-      if (!Number.isInteger(workType)) return;
-
-      const skillMode = await ctx.ui.select("Workflow skill", [...SKILL_MODES], { selectionMarker: "radio" });
-      if (!skillMode) return;
-
-      const liveModels = ctx.models.list() as ModelLike[];
+      const workTypeItem = await askChoice(
+        ctx,
+        "Work type",
+        WORK_TYPE_ITEMS,
+        (item) => item,
+        WORK_TYPES,
+        {
+          initialIndex: typeof state.workType === "number" && state.workType >= 1 && state.workType <= WORK_TYPE_ITEMS.length
+            ? state.workType - 1
+            : undefined,
+        },
+      );
+      if (!workTypeItem) return;
+      const workType = WORK_TYPE_ITEMS.indexOf(workTypeItem) + 1;
+      const workTypeLabel = WORK_TYPES[workType - 1]!;
+
+      const skillItem = await askChoice(
+        ctx,
+        "Workflow skill",
+        SKILL_MODE_ITEMS,
+        (item) => item,
+        SKILL_MODES,
+        { initialIndex: savedIndex(SKILL_MODES, (item) => item === state.skillMode) },
+      );
+      if (!skillItem) return;
+      const skillMode = SKILL_MODES[SKILL_MODE_ITEMS.indexOf(skillItem)]!;
+
+      const home = routeHome(ctx);
+      const pauseForRestart = () => {
+        rememberRuntimeRoute("OMP", {
+          version: 2,
+          workType,
+          boundary,
+          skillMode,
+          selections: {},
+          fallbacks: {},
+        }, home);
+        ctx.ui.notify(
+          "Restart OMP so it reloads models.yml, then run /pi-marg again. Work type and skill answers are saved and model selection will resume.",
+          "warning",
+        );
+      };
+      let liveModels = ctx.models.list() as ModelLike[];
       if (liveModels.length === 0) {
-        ctx.ui.notify(emptyCatalogSetupMessage("OMP"), "error");
-        return;
+        const setup = await configureEmptyCatalog(ctx, home);
+        if (setup.status === "restart") {
+          pauseForRestart();
+          return;
+        }
+        if (setup.status !== "ready") return;
+        liveModels = setup.models;
       }
+
+      let stopBeforePair = false;
+      if (liveModels.length === 1) {
+        const decision = await resolveSingleModel(ctx, home);
+        if (decision === "defer") {
+          stopBeforePair = true;
+        } else if (decision.status === "restart") {
+          pauseForRestart();
+          return;
+        } else if (decision.status !== "ready") {
+          return;
+        } else {
+          liveModels = decision.models;
+        }
+      }
+
       const catalog = buildModelCatalog(liveModels, hasExternalDevin(pi));
       const fallbackCatalog = buildFallbackCatalog(catalog);
+      const availability = revalidateSavedRoute(state, liveModels, hasExternalDevin(pi));
       const selected: Partial<Record<AutoStage, ModelCandidate>> = {};
-      for (const stage of requiredStagesForWorkType(workType)) {
-        const choice = await chooseModel(ctx, stage, catalog[stage], selected);
+      const stages = requiredStagesForWorkType(workType);
+      const oppositeStage: Record<AutoStage, AutoStage> = { A: "C", C: "A", B: "D", D: "B" };
+      for (const stage of stages) {
+        if (stopBeforePair && selected[oppositeStage[stage]]) {
+          ctx.ui.notify(
+            `Stage ${stage} needs a different model from Stage ${oppositeStage[stage]}. Stopping before that paired stage; nothing was saved as a complete route.`,
+            "warning",
+          );
+          return;
+        }
+        const savedChoice = availability.selections[stage];
+        if (savedChoice?.status === "missing") {
+          ctx.ui.notify(
+            `Saved Stage ${stage} selector ${savedChoice.selection.selector} is missing from the live catalog. Choose a replacement.`,
+            "warning",
+          );
+        }
+        const choice = await chooseModel(
+          ctx,
+          stage,
+          catalog[stage],
+          selected,
+          savedChoice?.status === "present" ? savedChoice.selection : undefined,
+        );
         if (!choice) return;
         selected[stage] = choice;
       }
 
-      const high = await chooseFallbackModel(ctx, "high", fallbackCatalog.high);
+      const savedHigh = availability.fallbacks.high;
+      if (savedHigh?.status === "missing") {
+        ctx.ui.notify(
+          `Saved high backup ${savedHigh.selection.selector} is missing from the live catalog. Choose a replacement.`,
+          "warning",
+        );
+      }
+      const high = await chooseFallbackModel(
+        ctx,
+        "high",
+        fallbackCatalog.high,
+        undefined,
+        savedHigh?.status === "present" ? savedHigh.selection : undefined,
+      );
       if (!high) return;
-      const low = await chooseFallbackModel(ctx, "low", fallbackCatalog.low, high);
+      const savedLow = availability.fallbacks.low;
+      if (savedLow?.status === "missing") {
+        ctx.ui.notify(
+          `Saved low backup ${savedLow.selection.selector} is missing from the live catalog. Choose a replacement.`,
+          "warning",
+        );
+      }
+      const low = await chooseFallbackModel(
+        ctx,
+        "low",
+        fallbackCatalog.low,
+        high,
+        savedLow?.status === "present" ? savedLow.selection : undefined,
+      );
       if (!low) return;
-      const fallbacks = { high, low };
 
-      const nextState = selectedState(workType, selected, fallbacks);
-      state = nextState;
-      pi.appendEntry(MODEL_STATE_TYPE, nextState);
-      pi.sendUserMessage(intakeMessage(request, boundary, workTypeLabel!, skillMode, selected, fallbacks));
+      const committed = await commitIntakeRoute(state, {
+        workType,
+        boundary: boundary as WorkBoundary,
+        skillMode,
+        selections: selected,
+        fallbacks: { high, low },
+        activateStage: stages[0]!,
+      }, {
+        runtimeName: "OMP",
+        models: liveModels,
+        hasExternalDevin: hasExternalDevin(pi),
+        activate: (model) => pi.setModel(model),
+        persist: (nextState) => persistRoute(nextState, ctx),
+      });
+      if (committed.error) {
+        ctx.ui.notify(committed.error, "error");
+        return;
+      }
+      state = committed.state;
+      pi.sendUserMessage(intakeMessage(request, boundary, workTypeLabel, skillMode, selected, { high, low }));
     },
   });
 
@@ -407,7 +591,7 @@ export default function modelRouter(pi: any) {
         models,
         hasExternalDevin: hasExternalDevin(pi),
         activate: (model) => pi.setModel(model),
-        persist: (nextState) => pi.appendEntry(MODEL_STATE_TYPE, nextState),
+        persist: (nextState) => persistRoute(nextState, ctx),
       });
       state = execution.state;
       return execution.response;