pi-system-one 1.2.4 → 1.3.1

package/README.md

@@ -6,6 +6,28 @@ System One decisions for Pi. Plug in TypeSafe Jev, Reflex, or your own provider.
 pi install npm:pi-system-one
 ```
 
+## Pi built-in classifier vs `pi-system-one` (as of Pi v1.0.3)
+
+Pi already supports Jev through `codemode`. It can classify one question or combine classification with other tool calls in a script. This extension exposes decisions as a dedicated `system_one` tool, with a `/judge` prompt and a skill that guides when to use it. Choose based on your workflow, not on a claim that either route is more accurate.
+
+| Need | Pi classifier through `codemode` | `pi-system-one` today |
+|---|---|---|
+| Setup | Enable `codemode`; sign in with `/login typesafe` or set `TYPESAFE_API_KEY`. | Install extension and sign in with `/login typesafe` or set `TYPESAFE_API_KEY`. Jev uses `jev-latest` by default. |
+| Agent interface | Script calls `models.classify()`; you choose model, state, and questions. | Model calls `system_one` directly. `/judge` and bundled skill provide usage guidance. |
+| One-off decisions | Write a `codemode` script even for a standalone classification. Useful if you already use scripts. | Call `system_one` without writing a script or enabling `codemode`. The same tool works mid-conversation when no other tool calls need orchestration. |
+| Multiple tool calls | A script can gather data, call a classifier, and filter results before they reach the model. | The tool batches decision questions over supplied state, but does not replace `codemode` for scripting other tools. |
+| Host availability | Requires a Pi host with `codemode` enabled and classifier models exposed to its scripts. | Loads as an extension without `codemode`; package also declares an OMP extension entry. Requires a host that supports this extension's APIs. |
+| Endpoints | Pi's registered classifier models, including Jev across supported providers. | Any backend compatible with `POST /v1/systemone`, including local Reflex and custom endpoints. |
+| Inputs | Pi classifier schema: object state, string question fields, `bool` for yes/no. | Accepts string or JSON state, `noul` for yes/no, and normalizes common argument aliases. |
+| Score output | Score and confidence. Choice answers still include probabilities. | Score, confidence, per-level probabilities, and legend when backend supplies them. |
+| Credentials | Pi resolves provider credentials, including saved `/login typesafe` key. | TypeSafe endpoint reuses Pi credentials per call. Explicit `SYSTEM_ONE_API_KEY` or session key takes precedence; custom endpoints never receive Pi's TypeSafe key. |
+
+Pi's [v1.0.3 Codemode guide](https://github.com/earendil-works/pi/blob/v1.0.3/packages/coding-agent/docs/codemode.md) documents scripts, model calls, and orchestration. Its [CLI guide](https://github.com/earendil-works/pi/blob/v1.0.3/packages/coding-agent/docs/cli.md#enable-codemode) explains how to enable `codemode`. Pi extensions can also [call classifiers without Codemode](https://github.com/earendil-works/pi/blob/v1.0.3/packages/coding-agent/docs/models.md#use-classifier-models); the table compares the agent-facing Codemode route with this extension's agent-facing tool, not every way to write a Pi extension.
+
+Pi v1.0.3 [defines its Score answer](https://github.com/earendil-works/pi/blob/v1.0.3/packages/ai/src/types.ts#L660-L678) with only `score` and `confidence`. Its [response parser](https://github.com/earendil-works/pi/blob/v1.0.3/packages/ai/src/api/system-one-shared.ts#L80-L119) copies only those two Score fields. [TypeSafe's HTTP API](https://docs.typesafe.ai/api#score-answer) returns `probabilities` and `legend` too. Pi's [classifier input types](https://github.com/earendil-works/pi/blob/v1.0.3/packages/ai/src/types.ts#L635-L658) and [codemode docs](https://github.com/earendil-works/pi/blob/v1.0.3/packages/coding-agent/docs/codemode.md#classify) document the narrower inputs shown above. These references describe Pi v1.0.3, not future releases.
+
+If you already use `codemode` to combine tools and only need Pi's classifier response, use Pi's built-in route. For standalone decisions, choose this extension when you want a direct tool without a script or Codemode setup. It also provides prompt guidance, compatible custom endpoints, and the full Score distribution when the backend supplies it. The extension can run on a host without `codemode` if that host supports its extension APIs. Its OMP package entry makes it installable in OMP, but it does not guarantee support for every Pi or OMP version. `/so config` can save non-secret settings or select Pi's native classifier. Native mode rejects Score questions because Pi v1.0.3 does not expose their probability distribution. See [Pi classifier docs for v1.0.3](https://github.com/earendil-works/pi/blob/v1.0.3/packages/coding-agent/docs/models.md#use-classifier-models).
+
 For Oh My Pi (OMP), install the published package with:
 
 ```bash
@@ -20,7 +42,7 @@ omp install /path/to/pi-system-one
 omp --extension /path/to/pi-system-one
 ```
 
-Set `SYSTEM_ONE_BASE_URL` before launch, or run `/so config`; the `system_one` tool is registered after the endpoint is configured.
+The `system_one` tool registers at startup. Without settings, it uses TypeSafe Jev through this extension's HTTP provider and asks Pi for your TypeSafe credential at call time. Run `/login typesafe` first, or set `TYPESAFE_API_KEY`.
 
 <!-- <img src="./demo.gif" alt="Description" width="640" >    -->
 
@@ -29,41 +51,39 @@ Set `SYSTEM_ONE_BASE_URL` before launch, or run `/so config`; the `system_one` t
 <img width="1836" height="1092" alt="demo" src="https://github.com/user-attachments/assets/341c0e4a-d0e5-4df0-85d2-74ca2f316db5" />
 
 
-Setup Provider:
-##### locally hosted model e.g Reflex, von, laya etc, any model that supports `POST /v1/systemone`
+### Custom endpoint
+
+For Reflex or another backend that supports `POST /v1/systemone`, run `/so config` and choose `custom`, or retain your existing environment setup:
+
 ```bash
 export SYSTEM_ONE_BASE_URL=http://localhost:8008
+export SYSTEM_ONE_MODEL=reflex
+# Set SYSTEM_ONE_API_KEY only when your endpoint requires a key.
 ```
-or
 
-##### typesafe/JEV
-```bash
-export SYSTEM_ONE_BASE_URL=https://api.typesafe.ai
-export SYSTEM_ONE_MODEL=jev-latest
-# Option 1: paste the key directly
-export SYSTEM_ONE_API_KEY="..."
-# Option 2: reuse an existing variable
-export SYSTEM_ONE_API_KEY="$TYPESAFE_API_KEY"
-```
+Existing `SYSTEM_ONE_BASE_URL` takes precedence over saved settings. For TypeSafe, `jev-latest` is supplied automatically when no model is set. Other endpoints may require `SYSTEM_ONE_MODEL`.
 
 
 ---
 
-**Configuration**
+## Configuration
 
-The extension provides a `/so` command for configuring the System One client:
+Run `/so config` to choose `typesafe` (default HTTP path), `custom` (any System One endpoint), or `native` (Pi classifier). `/so config native` and `/so config typesafe` switch directly. Non-secret settings are saved to `<agent-dir>/pi-system-one.json`, where `<agent-dir>` is Pi's agent directory (`~/.pi/agent` by default or `PI_CODING_AGENT_DIR`). Terminal Pi and Paseo must use the same agent directory to share that file and Pi's saved login. Restart or reload an already-running client after the other client changes settings. Use `/so status` to inspect current mode and credential availability.
 
-- `SYSTEM_ONE_BASE_URL` – required endpoint URL.
-- `SYSTEM_ONE_MODEL` – optional default model name.
-- `SYSTEM_ONE_API_KEY` – optional API key.
+For example, a saved custom endpoint looks like this:
 
-When you run `/so config`, you can:
+```json
+{
+  "mode": "custom",
+  "baseUrl": "http://localhost:8008",
+  "model": "reflex",
+  "timeoutMs": 10000
+}
+```
 
-- **Enter a new API key** – it is stored in memory only and will be lost when the session ends.
-- **Enter `-`** – forget the memory‑only key. If a `SYSTEM_ONE_API_KEY` environment variable is present, the client will fall back to it; otherwise the key becomes absent.
-- **Leave the input empty** – keep the existing value.
+Never store a key in JSON. A key entered into `/so config` stays in this session only. Leave key input blank to keep it; enter `-` to forget it. For custom endpoints, set `SYSTEM_ONE_BASE_URL` with `SYSTEM_ONE_API_KEY` if using environment credentials. An environment key without an environment endpoint never follows a saved custom URL. Custom URLs saved by `/so config` must be HTTP(S), without URL credentials, query, or fragment; put authentication in the key input or environment instead. Native mode supports Choice and Noul but rejects Score questions rather than hide missing probabilities. For full Score results, select `typesafe` or `custom`.
 
-The current configuration can be inspected with `/so status`.
+Environment endpoint and model values override saved settings at startup. A saved model is not reused when an environment endpoint points elsewhere. When `/so config` changes a custom URL, blank model input clears the previous endpoint's model; enter a model to keep using one. An explicit `/so config` choice takes effect immediately in this session. If both are set, the environment endpoint wins again on next startup.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-system-one",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "description": "System One decisions for Pi. Plug in TypeSafe Jev, Reflex, or your own provider.",
   "type": "module",
   "license": "MIT",
@@ -42,5 +42,8 @@
     "extensions": [
       "./src/extension.ts"
     ]
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "1.0.1"
   }
 }

package/src/commands.ts

@@ -1,19 +1,20 @@
-// pi-system-one/src/commands.ts
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
-import { HttpSystemOneProvider } from "system-one-core";
 import {
   applyConfigAnswers,
-  blankSession,
-  type ConfigAnswers,
+  type ConfigMode,
+  createSessionConfig,
   describeConfig,
   type SessionConfig,
+  TYPESAFE_BASE_URL,
+  TYPESAFE_MODEL,
 } from "./config.ts";
+import { saveStoredConfig } from "./persistence.ts";
+import { isTypeSafeEndpoint, resolveSessionProvider } from "./provider.ts";
 import { buildSystemOneTool } from "./tool.ts";
 
-/** Mutable holder: empty until env or `/so config` provides a base URL. */
 export interface SessionStore {
   session?: SessionConfig;
 }
@@ -21,106 +22,193 @@ export interface SessionStore {
 export function registerSystemOneCommands(
   pi: ExtensionAPI,
   store: SessionStore,
+  configPath?: string,
 ) {
+  let registered = false;
   function applyProvider() {
-    if (!store.session?.current.baseUrl) return;
-    const ext = store.session.current;
-    const provider = new HttpSystemOneProvider({
-      id: "configured",
-      baseUrl: ext.baseUrl,
-      apiKey: ext.apiKey,
-      defaultModel: ext.model,
-      timeoutMs: ext.timeoutMs,
-    });
-    pi.registerTool(buildSystemOneTool({ provider }));
+    if (registered) return;
+    registered = true;
+    pi.registerTool(
+      buildSystemOneTool({
+        resolveProvider: (ctx) =>
+          resolveSessionProvider(store.session ?? createSessionConfig(), ctx),
+      }),
+    );
   }
 
-  async function cmdConfig(ctx: ExtensionCommandContext): Promise<void> {
-    const cur = store.session?.current;
-    const baseUrlRaw = await ctx.ui.input(
-      `SYSTEM_ONE_BASE_URL (current: ${cur?.baseUrl || "unset"}):`,
-      cur?.baseUrl ?? "",
-    );
-    if (baseUrlRaw === undefined) {
-      ctx.ui.notify("Cancelled.", "info");
-      return;
-    }
-    const baseUrl = baseUrlRaw.trim();
-    if (!baseUrl && !cur?.baseUrl) {
-      ctx.ui.notify("Cancelled (base URL is required).", "info");
-      return;
-    }
-    const modelRaw = await ctx.ui.input(
-      `SYSTEM_ONE_MODEL (current: ${cur?.model ?? "server default"}):`,
-      cur?.model ?? "",
+  async function cmdConfig(
+    ctx: ExtensionCommandContext,
+    requestedMode?: string,
+  ): Promise<void> {
+    const current = store.session ?? createSessionConfig();
+    const modes: ConfigMode[] = [
+      current.mode,
+      ...(["typesafe", "custom", "native"] as ConfigMode[]).filter(
+        (mode) => mode !== current.mode,
+      ),
+    ];
+    const descriptions: Record<ConfigMode, string> = {
+      typesafe: "TypeSafe Jev (HTTP, full Score)",
+      custom: "Custom System One endpoint",
+      native: "Pi classifier (Choice and Noul only)",
+    };
+    const options = modes.map(
+      (mode) =>
+        `${mode} — ${descriptions[mode]}${mode === current.mode ? " (current)" : ""}`,
     );
-    if (modelRaw === undefined) {
+    const modeRaw =
+      requestedMode ??
+      (await ctx.ui.select("System One provider mode", options));
+    if (modeRaw === undefined) {
       ctx.ui.notify("Cancelled.", "info");
       return;
     }
-    const apiKeyRaw = await ctx.ui.input(
-      "SYSTEM_ONE_API_KEY (empty = keep, - = forget memory key (reverts to environment variable if set, otherwise becomes absent), memory-only, gone when the session closes):",
-      "",
-    );
-    if (apiKeyRaw === undefined) {
-      ctx.ui.notify("Cancelled.", "info");
+    const mode =
+      requestedMode === undefined
+        ? modes[options.indexOf(modeRaw)]
+        : (modeRaw.trim().toLowerCase() as ConfigMode);
+    if (!mode || !modes.includes(mode)) {
+      ctx.ui.notify("Choose typesafe, custom, or native.", "error");
       return;
     }
-    const answers: ConfigAnswers = {
-      baseUrl,
-      model: modelRaw.trim(),
-      apiKey: apiKeyRaw.trim(),
-      timeoutMs: "",
+    const next: SessionConfig = {
+      current: { ...current.current },
+      mode,
+      keyInMemory: current.keyInMemory,
     };
-    if (!store.session) {
-      store.session = blankSession();
+    if (mode === "typesafe") {
+      next.current.baseUrl = TYPESAFE_BASE_URL;
+      next.current.model = TYPESAFE_MODEL;
+      // A key exported for a custom endpoint must not follow a mode switch.
+      next.current.apiKey =
+        !process.env.SYSTEM_ONE_BASE_URL ||
+        isTypeSafeEndpoint(process.env.SYSTEM_ONE_BASE_URL)
+          ? process.env.SYSTEM_ONE_API_KEY || undefined
+          : undefined;
+      next.keyInMemory = false;
+    } else if (mode === "native") {
+      next.current.baseUrl = "";
+      next.current.model = TYPESAFE_MODEL;
+      next.current.apiKey = undefined;
+      next.keyInMemory = false;
+    } else {
+      const baseUrlRaw = await ctx.ui.input(
+        `SYSTEM_ONE_BASE_URL (current: ${current.mode === "custom" ? current.current.baseUrl : "unset"}):`,
+        current.mode === "custom" ? current.current.baseUrl : "",
+      );
+      if (baseUrlRaw === undefined) {
+        ctx.ui.notify("Cancelled.", "info");
+        return;
+      }
+      const baseUrl =
+        baseUrlRaw.trim() ||
+        (current.mode === "custom" ? current.current.baseUrl : "");
+      if (!baseUrl) {
+        ctx.ui.notify("Cancelled (base URL is required).", "info");
+        return;
+      }
+      const sameEndpoint =
+        current.mode === "custom" && baseUrl === current.current.baseUrl;
+      const modelRaw = await ctx.ui.input(
+        `SYSTEM_ONE_MODEL (current: ${sameEndpoint ? (current.current.model ?? "server default") : "server default"}):`,
+        sameEndpoint ? (current.current.model ?? "") : "",
+      );
+      if (modelRaw === undefined) {
+        ctx.ui.notify("Cancelled.", "info");
+        return;
+      }
+      const apiKeyRaw = await ctx.ui.input(
+        "SYSTEM_ONE_API_KEY (empty = keep, - = forget session key; never saved to JSON):",
+        "",
+      );
+      if (apiKeyRaw === undefined) {
+        ctx.ui.notify("Cancelled.", "info");
+        return;
+      }
+      next.current.baseUrl = baseUrl;
+      next.current.model =
+        modelRaw.trim() || (sameEndpoint ? current.current.model : undefined);
+      if (!sameEndpoint) {
+        // Never carry a key entered for one endpoint to another endpoint.
+        next.current.apiKey = undefined;
+        next.keyInMemory = false;
+      }
+      if (apiKeyRaw.trim() === "-") {
+        next.current.apiKey =
+          sameEndpoint && process.env.SYSTEM_ONE_BASE_URL === baseUrl
+            ? process.env.SYSTEM_ONE_API_KEY || undefined
+            : undefined;
+        next.keyInMemory = false;
+      } else if (apiKeyRaw.trim()) {
+        applyConfigAnswers(next, {
+          baseUrl: "",
+          model: "",
+          apiKey: apiKeyRaw.trim(),
+          timeoutMs: "",
+        });
+      }
     }
-    const memoryKey = applyConfigAnswers(store.session, answers);
-    applyProvider();
+    if (configPath) {
+      try {
+        saveStoredConfig(configPath, {
+          mode,
+          ...(mode === "custom"
+            ? {
+                baseUrl: next.current.baseUrl,
+                ...(next.current.model ? { model: next.current.model } : {}),
+              }
+            : {}),
+          timeoutMs: next.current.timeoutMs,
+        });
+      } catch (error) {
+        ctx.ui.notify(
+          `Could not save settings: ${error instanceof Error ? error.message : String(error)}`,
+          "error",
+        );
+        return;
+      }
+    }
+    store.session = next;
     ctx.ui.notify(
-      memoryKey
-        ? "Updated for this session. API key is in memory only and will be gone when the session closes; export SYSTEM_ONE_API_KEY to persist it."
-        : "Updated for this session.",
+      next.keyInMemory
+        ? "Updated. API key stays in memory only; other settings were saved."
+        : configPath
+          ? "Settings saved."
+          : "Updated for this session.",
       "info",
     );
   }
 
   async function cmdStatus(ctx: ExtensionCommandContext): Promise<void> {
-    if (!store.session) {
-      ctx.ui.notify(
-        "System One is not configured. Export SYSTEM_ONE_BASE_URL or run /so config.",
-        "info",
+    const session = store.session ?? createSessionConfig();
+    let summary = describeConfig(session);
+    if (
+      session.mode !== "native" &&
+      !session.current.apiKey &&
+      isTypeSafeEndpoint(session.current.baseUrl)
+    ) {
+      const key = await ctx.modelRegistry?.getApiKeyForProvider?.("typesafe");
+      summary = summary.replace(
+        "api key: absent",
+        key
+          ? "api key: Pi TypeSafe credentials available"
+          : "api key: absent (run /login typesafe)",
       );
-      return;
     }
-    ctx.ui.notify(describeConfig(store.session), "info");
+    ctx.ui.notify(summary, "info");
   }
 
-  const completions = [
-    {
-      value: "config",
-      label: "config - change endpoint, model, or key",
-      description: "Reconfigure System One for this session",
-    },
-    {
-      value: "status",
-      label: "status - show current config",
-      description: "Show current endpoint, model, and key source",
-    },
-  ];
-
   pi.registerCommand("so", {
     description: "System One config (/so status for current)",
-    getArgumentCompletions: (prefix: string) => {
-      const p = prefix.trim().toLowerCase();
-      return completions.filter((c) => c.value.startsWith(p));
-    },
+    getArgumentCompletions: (prefix: string) =>
+      ["config", "status"]
+        .filter((c) => c.startsWith(prefix.trim().toLowerCase()))
+        .map((c) => ({ value: c, label: c })),
     handler: async (args, ctx) => {
-      const [cmd] = args.trim().toLowerCase().split(/\s+/);
+      const [cmd, mode] = args.trim().toLowerCase().split(/\s+/);
       if (cmd === "status") await cmdStatus(ctx);
-      else await cmdConfig(ctx);
+      else await cmdConfig(ctx, cmd === "config" ? mode : undefined);
     },
   });
-
   return { applyProvider, store };
 }

package/src/config.ts

@@ -1,10 +1,9 @@
 // pi-system-one/src/config.ts
 //
-// Configuration is environment variables. `/so config` applies overrides
-// in memory for the current session only. API keys are never written to
-// disk by this extension: a key typed into `/so config` lives in memory
-// and is gone when the session closes. To persist, export it
-// (e.g. SYSTEM_ONE_API_KEY) in the shell.
+// Non-secret settings can persist in the user agent directory. Environment
+// variables retain precedence at startup. API keys are never written by this
+// extension: /so config keys live only in memory; Pi login or explicit
+// environment credentials provide persistent authentication.
 
 export interface SystemOneEnv {
   SYSTEM_ONE_BASE_URL?: string;
@@ -21,6 +20,17 @@ export interface SystemOneExtConfig {
 }
 
 export const DEFAULT_TIMEOUT_MS = 10_000;
+export const TYPESAFE_BASE_URL = "https://api.typesafe.ai";
+export const TYPESAFE_MODEL = "jev-latest";
+export type ConfigMode = "typesafe" | "custom" | "native";
+
+/** Public settings only. Credentials never belong in this file. */
+export interface StoredConfig {
+  mode?: ConfigMode;
+  baseUrl?: string;
+  model?: string;
+  timeoutMs?: number;
+}
 
 export function loadSystemOneConfig(
   env: SystemOneEnv = process.env,
@@ -48,12 +58,49 @@ export interface SessionConfig {
   current: SystemOneExtConfig;
   /** True when the key came from `/so config` (memory-only). */
   keyInMemory: boolean;
+  mode: ConfigMode;
 }
 
 export function createSessionConfig(
   env: SystemOneEnv = process.env,
+  stored: StoredConfig = {},
 ): SessionConfig {
-  return { current: loadSystemOneConfig(env), keyInMemory: false };
+  const mode: ConfigMode = env.SYSTEM_ONE_BASE_URL
+    ? "custom"
+    : (stored.mode ?? "typesafe");
+  const baseUrl =
+    mode === "native"
+      ? ""
+      : (env.SYSTEM_ONE_BASE_URL ??
+        (mode === "typesafe" ? TYPESAFE_BASE_URL : (stored.baseUrl ?? "")));
+  const rawTimeout = env.SYSTEM_ONE_TIMEOUT_MS
+    ? Number(env.SYSTEM_ONE_TIMEOUT_MS)
+    : (stored.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  if (!Number.isFinite(rawTimeout) || rawTimeout <= 0)
+    throw new Error("SYSTEM_ONE_TIMEOUT_MS must be a positive number");
+  return {
+    mode,
+    current: {
+      baseUrl,
+      // An env key without an env endpoint must not follow a saved custom URL.
+      apiKey:
+        mode === "native" ||
+        (stored.mode === "custom" && !env.SYSTEM_ONE_BASE_URL)
+          ? undefined
+          : env.SYSTEM_ONE_API_KEY || undefined,
+      model:
+        mode === "native"
+          ? TYPESAFE_MODEL
+          : env.SYSTEM_ONE_MODEL ||
+            (env.SYSTEM_ONE_BASE_URL &&
+            env.SYSTEM_ONE_BASE_URL !== stored.baseUrl
+              ? undefined
+              : stored.model) ||
+            (mode === "typesafe" ? TYPESAFE_MODEL : undefined),
+      timeoutMs: rawTimeout,
+    },
+    keyInMemory: false,
+  };
 }
 
 /** Empty session for `/so config` when no env is present. */
@@ -66,6 +113,7 @@ export function blankSession(): SessionConfig {
       timeoutMs: DEFAULT_TIMEOUT_MS,
     },
     keyInMemory: false,
+    mode: "custom",
   };
 }
 
@@ -106,14 +154,18 @@ export function applyConfigAnswers(
 /** Human-readable summary. Shows whether a key exists, never the key. */
 export function describeConfig(session: SessionConfig): string {
   const c = session.current;
-  const keyLine = !c.apiKey
-    ? "  api key: absent"
-    : session.keyInMemory
-      ? "  api key: in memory only (gone when the session closes; export SYSTEM_ONE_API_KEY to persist)"
-      : "  api key: from environment";
+  const keyLine =
+    session.mode === "native"
+      ? "  api key: managed by Pi (native classifier)"
+      : !c.apiKey
+        ? "  api key: absent"
+        : session.keyInMemory
+          ? "  api key: in memory only (gone when the session closes; export SYSTEM_ONE_API_KEY to persist)"
+          : "  api key: from environment";
   return [
     "System One:",
-    `  endpoint: ${c.baseUrl}`,
+    `  mode: ${session.mode}`,
+    `  endpoint: ${c.baseUrl || "none"}`,
     keyLine,
     `  model: ${c.model ?? "server default"}`,
     `  timeout: ${c.timeoutMs}ms`,

package/src/extension.ts

@@ -2,9 +2,13 @@
 
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  type ExtensionAPI,
+  getAgentDir,
+} from "@earendil-works/pi-coding-agent";
 import { registerSystemOneCommands, type SessionStore } from "./commands.ts";
 import { createSessionConfig } from "./config.ts";
+import { loadStoredConfig } from "./persistence.ts";
 
 /**
  * Directory holding the bundled `system-one` skill (use-case catalog).
@@ -22,23 +26,29 @@ export function systemOnePromptsDir(): string {
 }
 
 export default function piSystemOneExtension(pi: ExtensionAPI) {
-  // The /so command is always registered so config stays reachable with
-  // no env set. The tool appears once a base URL exists (env or /so config).
+  const configPath = join(getAgentDir(), "pi-system-one.json");
   const store: SessionStore = {};
   try {
-    store.session = createSessionConfig();
-  } catch {
-    pi.on("session_start", (event, ctx) => {
-      if (event.reason === "startup" || event.reason === "new") {
-        ctx.ui.notify(
-          "System One: SYSTEM_ONE_BASE_URL is not set. Export it or run /so config.",
-          "warning",
-        );
-      }
+    store.session = createSessionConfig(
+      process.env,
+      loadStoredConfig(configPath),
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+      store.session = createSessionConfig(process.env);
+    } catch {
+      store.session = createSessionConfig({});
+    }
+    pi.on("session_start", (_event, ctx) => {
+      ctx.ui.notify(
+        `System One: ${message}. Ignoring saved settings; fix them or run /so config.`,
+        "warning",
+      );
     });
   }
 
-  const { applyProvider } = registerSystemOneCommands(pi, store);
+  const { applyProvider } = registerSystemOneCommands(pi, store, configPath);
   applyProvider();
 
   // Contribute the bundled `system-one` skill (use-case catalog) and the