@sangyaahub/pi-marg 1.0.5 → 1.0.6

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.6"
   },
   "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.6",
       "author": {
         "name": "Sangyaa",
         "email": "contact@sangyaa.co"

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 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.6" src="https://img.shields.io/badge/version-1.0.6-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.6 · 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;

package/adapters/omp/extensions/provider-setup.ts

@@ -0,0 +1,177 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  probeModelIds,
+  validateCustomProvider,
+  writeCustomProvider,
+  type CustomProviderInput,
+} from "../../../core/provider-config";
+import {
+  numberedOptionLabel,
+  resolveSelectAnswer,
+  type ModelLike,
+} from "../../../core/model-routing";
+import { agentDirectory } from "../../../core/user-route";
+
+const SETUP_ITEMS = [
+  "Sign in to a provider",
+  "Add a custom OpenAI-compatible provider",
+  "Cancel",
+] as const;
+
+const DISTINCT_ITEMS = [
+  "Add another model",
+  "Continue and stop before the paired stage",
+] as const;
+
+export type CatalogSetup =
+  | { status: "ready"; models: ModelLike[] }
+  | { status: "cancelled" }
+  | { status: "restart" };
+
+async function askText(ctx: any, title: string, placeholder: string, masked = false): Promise<string | undefined> {
+  const value = await ctx.ui.input(title, placeholder, masked ? { masked: true } : undefined);
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (!trimmed) {
+    ctx.ui.notify("Selection cancelled; no model was saved.", "warning");
+    return undefined;
+  }
+  return trimmed;
+}
+
+async function askItems<T extends string>(
+  ctx: any,
+  title: string,
+  items: readonly T[],
+): Promise<T | undefined> {
+  const answer = await ctx.ui.select(
+    title,
+    items.map((item, index) => numberedOptionLabel(index, item)),
+    { selectionMarker: "radio" },
+  );
+  const resolved = resolveSelectAnswer(answer, items, (item) => item);
+  switch (resolved.status) {
+    case "matched":
+      return resolved.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(resolved.received)}; no model was saved.`, "error");
+      return undefined;
+    default: {
+      const unreachable: never = resolved;
+      return unreachable;
+    }
+  }
+}
+
+function envAlreadySet(home: string | undefined, name: string): boolean {
+  if (process.env[name]) return true;
+  const envPath = join(agentDirectory("OMP", home), ".env");
+  if (!existsSync(envPath)) return false;
+  return new RegExp(`^${name}=`, "m").test(readFileSync(envPath, "utf8"));
+}
+
+async function chooseProbedIds(ctx: any, typed: string[], probed: string[]): Promise<string[] | undefined> {
+  const items = ["Keep the model ids I typed", "Use every returned id", ...probed];
+  const choice = await askItems(ctx, "Models to register", items);
+  if (!choice) return undefined;
+  if (choice === "Keep the model ids I typed") return typed;
+  if (choice === "Use every returned id") return probed;
+  return [choice];
+}
+
+export async function addCustomProvider(ctx: any, home: string | undefined): Promise<CatalogSetup> {
+  const providerId = await askText(ctx, "Custom provider", "Provider id (lowercase)");
+  if (!providerId) return { status: "cancelled" };
+  const displayName = await askText(ctx, "Custom provider", "Display name");
+  if (!displayName) return { status: "cancelled" };
+  const baseUrl = await askText(ctx, "Custom provider", "Base URL");
+  if (!baseUrl) return { status: "cancelled" };
+  let allowLocalHttp = false;
+  try {
+    const url = new URL(baseUrl);
+    if (url.protocol === "http:" && url.hostname === "127.0.0.1") {
+      const confirm = await askItems(ctx, "Local endpoint", ["Use this local http endpoint", "Cancel"]);
+      if (confirm !== "Use this local http endpoint") return { status: "cancelled" };
+      allowLocalHttp = true;
+    }
+  } catch {
+    ctx.ui.notify("Base URL must be an https URL.", "error");
+    return { status: "cancelled" };
+  }
+  const envVar = await askText(ctx, "Custom provider", "Env var name");
+  if (!envVar) return { status: "cancelled" };
+  const modelText = await askText(ctx, "Custom provider", "Model ids, comma-separated");
+  if (!modelText) return { status: "cancelled" };
+  let modelIds = modelText.split(",").map((id) => id.trim()).filter(Boolean);
+  const secret = envAlreadySet(home, envVar) ? undefined : await askText(ctx, "Custom provider", `${envVar} value`, true);
+  if (!envAlreadySet(home, envVar) && !secret) return { status: "cancelled" };
+
+  const draft: CustomProviderInput = {
+    providerId,
+    displayName,
+    baseUrl,
+    envVar,
+    modelIds,
+    allowLocalHttp,
+  };
+  const problem = validateCustomProvider(draft);
+  if (problem) {
+    ctx.ui.notify(problem, "error");
+    return { status: "cancelled" };
+  }
+
+  const probeKey = secret ?? process.env[envVar];
+  if (probeKey) {
+    const probed = await probeModelIds(baseUrl, probeKey);
+    if (probed) {
+      const chosen = await chooseProbedIds(ctx, modelIds, probed);
+      if (!chosen) return { status: "cancelled" };
+      modelIds = chosen;
+      draft.modelIds = chosen;
+    }
+  }
+
+  try {
+    const directory = agentDirectory("OMP", home);
+    writeCustomProvider({
+      modelsPath: join(directory, "models.yml"),
+      envPath: join(directory, ".env"),
+    }, draft, secret);
+  } catch (error) {
+    ctx.ui.notify(error instanceof Error ? error.message : "Could not write the provider.", "error");
+    return { status: "cancelled" };
+  }
+
+  if (typeof ctx.models?.reload === "function") {
+    await ctx.models.reload();
+  }
+  const models = (ctx.models.list() ?? []) as ModelLike[];
+  if (models.length === 0) return { status: "restart" };
+  return { status: "ready", models };
+}
+
+export async function configureEmptyCatalog(ctx: any, home: string | undefined): Promise<CatalogSetup> {
+  const choice = await askItems(ctx, "Model setup", SETUP_ITEMS);
+  if (!choice || choice === "Cancel") return { status: "cancelled" };
+  if (choice === "Sign in to a provider") {
+    if (typeof ctx.openLogin === "function") await ctx.openLogin();
+    else ctx.ui.notify("Sign in with /login, verify with `omp models`, then run /pi-marg again.", "warning");
+    const models = (ctx.models.list() ?? []) as ModelLike[];
+    return models.length > 0 ? { status: "ready", models } : { status: "cancelled" };
+  }
+  return addCustomProvider(ctx, home);
+}
+
+export async function resolveSingleModel(ctx: any, home: string | undefined): Promise<CatalogSetup | "defer"> {
+  const choice = await askItems(ctx, "Distinct models", DISTINCT_ITEMS);
+  if (!choice) return { status: "cancelled" };
+  if (choice === "Continue and stop before the paired stage") return "defer";
+  return addCustomProvider(ctx, home);
+}

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

@@ -12,10 +12,10 @@ import {
   hasConfiguredFallback,
   modelFailureKey,
   modelToolUsageLimitFailure,
-  restoreModelRouteState,
   type ModelLike,
   type ModelRouteParams,
 } from "../../../core/model-routing";
+import { loadRuntimeRoute, rememberRuntimeRoute } from "../../../core/user-route";
 
 function toolNames(pi: any): string[] {
   return (pi.getAllTools?.() ?? [])
@@ -38,12 +38,21 @@ export default function modelRouter(pi: any) {
   let sessionGeneration = 0;
   let pendingModelFailure: { selector: string; key: string } | undefined;
   let pendingToolFailure: { selector: string; key: string } | undefined;
+  const routeHome = (ctx: any) => typeof ctx?.agentHome === "string" ? ctx.agentHome : undefined;
+  const persistRoute = (nextState: Parameters<typeof rememberRuntimeRoute>[1], ctx?: any) => {
+    pi.appendEntry(MODEL_STATE_TYPE, nextState);
+    try {
+      rememberRuntimeRoute("Pi", 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;
     pendingModelFailure = undefined;
     pendingToolFailure = undefined;
-    state = restoreModelRouteState(ctx.sessionManager.getBranch());
+    state = loadRuntimeRoute("Pi", ctx.sessionManager.getBranch(), routeHome(ctx));
   };
 
   pi.on("session_start", restore);
@@ -63,7 +72,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) {
@@ -162,7 +171,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;

package/adapters/pi/prompts/auto-models.md

@@ -5,8 +5,8 @@ argument-hint: [status | choose]
 
 Load `auto-mode-router` and read its model-routing reference.
 
-- With no argument or `status`, call `auto_model_route` with `action: status`, then show the saved A/B/C/D selectors, separation checks, high/low backups, active fallback, and last failover.
-- With `choose`, call `auto_model_route` with `action: catalog` and the active work type. Present required stages and exact available selectors. Save each stage with `action: select`, then save two distinct runtime models with `action: select_fallback`, first `fallback: high`, then `fallback: low`.
+- With no argument or `status`, call `auto_model_route` with `action: status`, then show the saved A/B/C/D selectors, separation checks, high/low backups, active fallback, and last failover. Show a saved selector as `missing` when status says it is no longer in the live catalog. Do not remap it to a similarly named model.
+- With `choose`, call `auto_model_route` with `action: catalog` and the active work type. Show the saved selectors first and pass each one as the initially selected choice before asking for a replacement. Present required stages and exact available selectors. Save each stage with `action: select`, then save two distinct runtime models with `action: select_fallback`, first `fallback: high`, then `fallback: low`.
 - Do not type or persist a model ID that the live catalog did not return.
 - Treat any model returned by Pi's registry as a normal in-session route. Treat Devin or another external coding-agent session as a capability-gated external route; creating one requires `post-web` approval.
 - C/D are the authoritative independent review selectors. Any detected advisor or watcher is supplemental and must not weaken the A≠C or B≠D checks.

package/commands/auto-models.md

@@ -5,8 +5,8 @@ argument-hint: [status | choose]
 
 Load `auto-mode-router` and read its model-routing reference.
 
-- With no argument or `status`, call `auto_model_route` with `action: status`, then show the saved A/B/C/D selectors, separation checks, high/low backups, active fallback, and last failover.
-- With `choose`, call `auto_model_route` with `action: catalog` and the active work type. Present required stages and exact available selectors. Save each stage with `action: select`, then save two distinct runtime models with `action: select_fallback`, first `fallback: high`, then `fallback: low`.
+- With no argument or `status`, call `auto_model_route` with `action: status`, then show the saved A/B/C/D selectors, separation checks, high/low backups, active fallback, and last failover. Show a saved selector as `missing` when status says it is no longer in the live catalog. Do not remap it to a similarly named model.
+- With `choose`, call `auto_model_route` with `action: catalog` and the active work type. Show the saved selectors first and pass each one as the initially selected choice before asking for a replacement. Present required stages and exact available selectors. Save each stage with `action: select`, then save two distinct runtime models with `action: select_fallback`, first `fallback: high`, then `fallback: low`.
 - Do not type or persist a model ID that the live catalog did not return.
 - Distinguish native `devin/swe-*` OMP models from the optional external `devin/mcp-session` route. Only creating the external session requires `post-web` approval.
 - C/D are the authoritative independent review selectors. A configured OMP advisor is supplemental and must not weaken the A≠C or B≠D checks.

package/core/model-routing.ts

@@ -36,9 +36,13 @@ export interface ModelSelection extends ModelCandidate {
   selectedAt: string;
 }
 
+export type WorkBoundary = "Job/client" | "Personal";
+
 export interface ModelRouteState {
   version: 2;
   workType?: number;
+  boundary?: WorkBoundary;
+  skillMode?: string;
   selections: Partial<Record<AutoStage, ModelSelection>>;
   fallbacks: Partial<Record<FallbackLevel, ModelSelection>>;
   activeStage?: AutoStage;
@@ -370,6 +374,38 @@ export function buildFallbackCatalog(catalog: Record<AutoStage, ModelCandidate[]
   } satisfies Record<FallbackLevel, ModelCandidate[]>;
 }
 
+export interface SavedChoiceAvailability {
+  status: "present" | "missing";
+  selection: ModelSelection;
+}
+
+export function revalidateSavedRoute(
+  state: ModelRouteState,
+  models: readonly ModelLike[],
+  hasExternalDevin: boolean,
+): {
+  selections: Partial<Record<AutoStage, SavedChoiceAvailability>>;
+  fallbacks: Partial<Record<FallbackLevel, SavedChoiceAvailability>>;
+} {
+  const catalog = buildModelCatalog([...models], hasExternalDevin);
+  const fallbackCatalog = buildFallbackCatalog(catalog);
+  const selections: Partial<Record<AutoStage, SavedChoiceAvailability>> = {};
+  for (const stage of STAGES) {
+    const selection = state.selections[stage];
+    if (!selection) continue;
+    const live = catalog[stage].some((item) => item.selector === selection.selector);
+    selections[stage] = { status: live ? "present" : "missing", selection };
+  }
+  const fallbacks: Partial<Record<FallbackLevel, SavedChoiceAvailability>> = {};
+  for (const level of FALLBACK_LEVELS) {
+    const selection = state.fallbacks[level];
+    if (!selection) continue;
+    const live = fallbackCatalog[level].some((item) => item.selector === selection.selector);
+    fallbacks[level] = { status: live ? "present" : "missing", selection };
+  }
+  return { selections, fallbacks };
+}
+
 export function numberedOptionLabel(index: number, text: string): string {
   return `${index + 1}. ${text}`;
 }
@@ -383,6 +419,42 @@ export function matchNumberedOption<T>(
   return items.find((item, index) => numberedOptionLabel(index, labelOf(item)) === answer);
 }
 
+export type SelectAnswerResolution<T> =
+  | { status: "cancelled" }
+  | { status: "matched"; item: T }
+  | { status: "conflict" }
+  | { status: "unrecognized"; received: string };
+
+const DISAMBIGUATION_SUFFIX = /^(?: \(\d+\)| · .+)$/;
+
+export function resolveSelectAnswer<T>(
+  answer: string | undefined,
+  items: readonly T[],
+  labelOf: (item: T) => string,
+): SelectAnswerResolution<T> {
+  if (answer === undefined) return { status: "cancelled" };
+  const received = answer.trim();
+  if (!received) return { status: "cancelled" };
+
+  const numbered = items.filter((item, index) => numberedOptionLabel(index, labelOf(item)) === received);
+  if (numbered.length > 1) return { status: "conflict" };
+  if (numbered.length === 1) return { status: "matched", item: numbered[0]! };
+
+  const exact = items.filter((item) => labelOf(item) === received);
+  if (exact.length > 1) return { status: "conflict" };
+  if (exact.length === 1) return { status: "matched", item: exact[0]! };
+
+  const suffixed = items.filter((item) => {
+    const label = labelOf(item);
+    if (!received.startsWith(label) || received.length === label.length) return false;
+    return DISAMBIGUATION_SUFFIX.test(received.slice(label.length));
+  });
+  if (suffixed.length > 1) return { status: "conflict" };
+  if (suffixed.length === 1) return { status: "matched", item: suffixed[0]! };
+
+  return { status: "unrecognized", received };
+}
+
 export function uniqueProviders(candidates: readonly ModelCandidate[]): string[] {
   return [...new Set(candidates.map((candidate) => candidate.provider))].sort((left, right) => left.localeCompare(right));
 }
@@ -621,6 +693,59 @@ export async function executeAutomaticFailover(
   };
 }
 
+export interface IntakeRouteDraft {
+  workType: number;
+  boundary?: WorkBoundary;
+  skillMode?: string;
+  selections: Partial<Record<AutoStage, ModelCandidate>>;
+  fallbacks: Record<FallbackLevel, ModelCandidate>;
+  activateStage: AutoStage;
+}
+
+export async function commitIntakeRoute(
+  currentState: ModelRouteState,
+  intake: IntakeRouteDraft,
+  port: ModelRoutePort,
+): Promise<{ state: ModelRouteState; error?: string }> {
+  const selected = intake.selections[intake.activateStage];
+  if (!selected) {
+    return { state: currentState, error: `Stage ${intake.activateStage} has no model to activate.` };
+  }
+  if (selected.access === "runtime-model") {
+    const model = port.models.find((item) => `${item.provider}/${item.id}` === selected.selector);
+    const failure = `Could not activate ${selected.selector}; verify ${selected.provider} authentication.`;
+    if (!model) return { state: currentState, error: failure };
+    try {
+      const activated = await port.activate(model);
+      if (activated === false) return { state: currentState, error: failure };
+    } catch {
+      return { state: currentState, error: failure };
+    }
+  }
+
+  const selectedAt = port.now?.() ?? new Date().toISOString();
+  const selections = Object.fromEntries(
+    Object.entries(intake.selections).map(([stage, candidate]) => [stage, { ...candidate, selectedAt }]),
+  ) as ModelRouteState["selections"];
+  const fallbacks = Object.fromEntries(
+    Object.entries(intake.fallbacks).map(([level, candidate]) => [level, { ...candidate, selectedAt }]),
+  ) as ModelRouteState["fallbacks"];
+  const nextState: ModelRouteState = {
+    version: 2,
+    workType: intake.workType,
+    boundary: intake.boundary,
+    skillMode: intake.skillMode,
+    selections,
+    fallbacks,
+    activeStage: intake.activateStage,
+    activeFallback: undefined,
+    exhaustedSelectors: [],
+    handledFailureKeys: [],
+  };
+  port.persist(nextState);
+  return { state: nextState };
+}
+
 export async function executeModelRoute(
   currentState: ModelRouteState,
   params: ModelRouteParams,
@@ -670,7 +795,14 @@ export async function executeModelRoute(
   }
 
   if (params.action === "status") {
-    return { state: currentState, response: toolResult(JSON.stringify(currentState, null, 2), { state: currentState }) };
+    const availability = revalidateSavedRoute(currentState, port.models, port.hasExternalDevin);
+    return {
+      state: currentState,
+      response: toolResult(
+        JSON.stringify({ ...currentState, availability }, null, 2),
+        { state: currentState, availability },
+      ),
+    };
   }
 
   if (params.action === "select_fallback") {

package/core/provider-config.ts

@@ -0,0 +1,142 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export interface CustomProviderInput {
+  providerId: string;
+  displayName: string;
+  baseUrl: string;
+  envVar: string;
+  modelIds: string[];
+  allowLocalHttp: boolean;
+}
+
+export interface ProviderFiles {
+  modelsPath: string;
+  envPath: string;
+}
+
+const PROVIDER_ID = /^[a-z0-9_-]+$/;
+const ENV_VAR = /^[A-Z][A-Z0-9_]*$/;
+const MODEL_ID = /^[A-Za-z0-9._:-]+$/;
+
+export function validateCustomProvider(input: CustomProviderInput): string | undefined {
+  if (!PROVIDER_ID.test(input.providerId)) {
+    return "Provider id must be lowercase letters, numbers, underscores, or hyphens.";
+  }
+  if (!input.displayName.trim()) return "Display name is required.";
+  let url: URL;
+  try {
+    url = new URL(input.baseUrl);
+  } catch {
+    return "Base URL must be an https URL.";
+  }
+  const local = url.protocol === "http:" && url.hostname === "127.0.0.1";
+  if (url.protocol !== "https:" && !(local && input.allowLocalHttp)) {
+    return "Base URL must use https unless you confirm a local http://127.0.0.1 endpoint.";
+  }
+  if (!ENV_VAR.test(input.envVar)) {
+    return "Env var name must match the runtime convention, such as EXAMPLE_GATEWAY_API_KEY.";
+  }
+  if (input.modelIds.length === 0) return "At least one model id is required.";
+  const unique = new Set(input.modelIds);
+  if (unique.size !== input.modelIds.length) return "Model ids must be unique.";
+  if (input.modelIds.some((id) => !MODEL_ID.test(id))) return "Model ids must be non-empty and contain no spaces.";
+  return undefined;
+}
+
+function yamlString(value: string): string {
+  if (/^[A-Za-z0-9_./:-]+$/.test(value)) return value;
+  return JSON.stringify(value);
+}
+
+export function renderProviderBlock(input: CustomProviderInput): string {
+  const models = input.modelIds.map((id, index) => {
+    const name = index === 0 && input.displayName.trim() ? input.displayName.trim() : id;
+    return `      - id: ${yamlString(id)}\n        name: ${yamlString(name)}`;
+  }).join("\n");
+  return [
+    `  ${input.providerId}:`,
+    `    baseUrl: ${yamlString(input.baseUrl)}`,
+    "    api: openai-completions",
+    `    apiKey: ${input.envVar}`,
+    "    authHeader: true",
+    "    models:",
+    models,
+  ].join("\n");
+}
+
+export function insertProvider(existing: string, providerId: string, block: string): string {
+  if (new RegExp(`^  ${providerId}:\\s*$`, "m").test(existing)) {
+    throw new Error(`Provider ${providerId} already exists in models.yml.`);
+  }
+  const trimmedBlock = block.replace(/\s+$/, "");
+  if (!existing.trim()) return `providers:\n${trimmedBlock}\n`;
+  const lines = existing.split("\n");
+  const providersIndex = lines.findIndex((line) => /^providers:\s*$/.test(line));
+  if (providersIndex === -1) {
+    const suffix = existing.endsWith("\n") ? "" : "\n";
+    return `${existing}${suffix}providers:\n${trimmedBlock}\n`;
+  }
+  lines.splice(providersIndex + 1, 0, ...trimmedBlock.split("\n"));
+  return `${lines.join("\n").replace(/\n*$/, "")}\n`;
+}
+
+export function upsertEnvAssignment(existing: string, name: string, value: string): string {
+  if (new RegExp(`^${name}=`, "m").test(existing)) return existing;
+  const suffix = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+  return `${existing}${suffix}${name}=${value}\n`;
+}
+
+function atomicWrite(path: string, contents: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const backup = `${path}.bak`;
+  const temporary = `${path}.${process.pid}.tmp`;
+  const hadOriginal = existsSync(path);
+  if (hadOriginal) copyFileSync(path, backup);
+  try {
+    writeFileSync(temporary, contents, { mode: 0o600 });
+    renameSync(temporary, path);
+  } catch (error) {
+    if (hadOriginal && existsSync(backup)) copyFileSync(backup, path);
+    throw error;
+  }
+}
+
+export function writeCustomProvider(files: ProviderFiles, input: CustomProviderInput, secret?: string): void {
+  const problem = validateCustomProvider(input);
+  if (problem) throw new Error(problem);
+  if (secret && (secret.includes("\n") || secret.includes("\r"))) {
+    throw new Error("The API key must be a single line.");
+  }
+  const existing = existsSync(files.modelsPath) ? readFileSync(files.modelsPath, "utf8") : "";
+  const next = insertProvider(existing, input.providerId, renderProviderBlock(input));
+  if (secret && next.includes(secret)) {
+    throw new Error("Refusing to write the API key into models.yml.");
+  }
+  atomicWrite(files.modelsPath, next);
+  if (!secret) return;
+  const currentEnv = existsSync(files.envPath) ? readFileSync(files.envPath, "utf8") : "";
+  atomicWrite(files.envPath, upsertEnvAssignment(currentEnv, input.envVar, secret));
+}
+
+export async function probeModelIds(
+  baseUrl: string,
+  apiKey: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<string[] | undefined> {
+  const url = `${baseUrl.replace(/\/$/, "")}/models`;
+  try {
+    const response = await fetchImpl(url, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!response.ok) return undefined;
+    const body = await response.json() as { data?: Array<{ id?: unknown }> };
+    const ids = (body.data ?? [])
+      .map((item) => item.id)
+      .filter((id): id is string => typeof id === "string" && id.length > 0);
+    return ids.length > 0 ? ids : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/core/user-route.ts

@@ -0,0 +1,100 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+import {
+  emptyModelRouteState,
+  isFallbackLevel,
+  isStage,
+  restoreModelRouteState,
+  type ModelRouteState,
+  type RuntimeName,
+  type WorkBoundary,
+} from "./model-routing";
+
+const ROUTE_FILE = "pi-marg-route.json";
+
+export function agentDirectory(runtime: RuntimeName, home = process.env.PI_MARG_AGENT_HOME || homedir()): string {
+  return join(home, runtime === "OMP" ? ".omp" : ".pi", "agent");
+}
+
+export function userRoutePath(runtime: RuntimeName, home?: string): string {
+  return join(home ? agentDirectory(runtime, home) : agentDirectory(runtime), ROUTE_FILE);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isBoundary(value: unknown): value is WorkBoundary {
+  return value === "Job/client" || value === "Personal";
+}
+
+function stringList(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  return value.filter((item): item is string => typeof item === "string");
+}
+
+export function parseUserRoute(raw: string): ModelRouteState | undefined {
+  try {
+    const data = JSON.parse(raw) as unknown;
+    if (!isRecord(data) || data.version !== 2) return undefined;
+    const activeStage = isStage(data.activeStage) ? data.activeStage : undefined;
+    const activeFallback = isFallbackLevel(data.activeFallback) ? data.activeFallback : undefined;
+    return {
+      version: 2,
+      workType: typeof data.workType === "number" ? data.workType : undefined,
+      boundary: isBoundary(data.boundary) ? data.boundary : undefined,
+      skillMode: typeof data.skillMode === "string" ? data.skillMode : undefined,
+      selections: isRecord(data.selections) ? data.selections as ModelRouteState["selections"] : {},
+      fallbacks: isRecord(data.fallbacks) ? data.fallbacks as ModelRouteState["fallbacks"] : {},
+      ...(activeStage ? { activeStage } : {}),
+      ...(activeFallback ? { activeFallback } : {}),
+      ...(stringList(data.exhaustedSelectors) ? { exhaustedSelectors: stringList(data.exhaustedSelectors) } : {}),
+      ...(stringList(data.handledFailureKeys) ? { handledFailureKeys: stringList(data.handledFailureKeys) } : {}),
+      ...(isRecord(data.lastFailover) ? { lastFailover: data.lastFailover as ModelRouteState["lastFailover"] } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+export function readUserRoute(path: string): ModelRouteState | undefined {
+  try {
+    return parseUserRoute(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+export function writeUserRoute(path: string, state: ModelRouteState): void {
+  const payload = parseUserRoute(JSON.stringify({ ...state, version: 2 })) ?? emptyModelRouteState();
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
+  renameSync(temporary, path);
+}
+
+export function routeHasChoices(state: ModelRouteState): boolean {
+  return Boolean(
+    state.workType
+    || state.boundary
+    || state.skillMode
+    || Object.keys(state.selections).length > 0
+    || Object.keys(state.fallbacks).length > 0,
+  );
+}
+
+export function loadSavedRoute(entries: readonly unknown[], file: ModelRouteState | undefined): ModelRouteState {
+  const branch = restoreModelRouteState(entries);
+  if (routeHasChoices(branch)) return branch;
+  return file ?? branch;
+}
+
+export function loadRuntimeRoute(runtime: RuntimeName, entries: readonly unknown[], home?: string): ModelRouteState {
+  return loadSavedRoute(entries, readUserRoute(userRoutePath(runtime, home)));
+}
+
+export function rememberRuntimeRoute(runtime: RuntimeName, state: ModelRouteState, home?: string): void {
+  writeUserRoute(userRoutePath(runtime, home), state);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sangyaahub/pi-marg",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "A governed, model-routed development path for Pi Agent and Oh My Pi.",
   "type": "module",
   "license": "MIT",

package/scripts/install.sh

@@ -71,4 +71,4 @@ if [[ "${runtime}" == "omp" || "${runtime}" == "both" ]]; then
   omp plugin install --scope user pi-marg@pi-marg-marketplace
 fi
 
-echo "PiMarg v1.0.5 installed for ${runtime}. Start a fresh runtime session, then run /pi-marg."
+echo "PiMarg v1.0.6 installed for ${runtime}. Start a fresh runtime session, then run /pi-marg."

package/scripts/validate.sh

@@ -45,7 +45,7 @@ bun -e '
   const packageJson = await Bun.file("package.json").json();
   const marketplace = await Bun.file(".omp-plugin/marketplace.json").json();
   if (packageJson.name !== "@sangyaahub/pi-marg") throw new Error("Unexpected package name");
-  if (packageJson.version !== "1.0.5") throw new Error("package.json must be v1.0.5");
+  if (packageJson.version !== "1.0.6") throw new Error("package.json must be v1.0.6");
   if (packageJson.license !== "MIT") throw new Error("package.json must declare MIT");
   if (packageJson.author !== "Sangyaa") throw new Error("Unexpected package author");
   if (!packageJson.keywords?.includes("pi-package")) throw new Error("Pi catalog keyword is missing");

package/skills/auto-mode-router/references/intake-and-state.md

@@ -125,6 +125,8 @@ ledger: <path>
 
 Reuse this state for normal follow-ups. Start over only when the user explicitly resets it or introduces a materially different outcome.
 
+The v2 model route persists `boundary` (`Job/client` or `Personal`) and `skillMode` with the A/B/C/D selectors and backups. Reopening `/pi-marg` highlights those saved values. The conversational `context:` and `mode:` lines above are the same facts in the ledger's shorthand; they are not a second configuration store.
+
 ## Availability check
 
 Before declaring the task ready: