pi-system-one 1.1.2 → 1.1.4

package/README.md

@@ -7,4 +7,23 @@ pi install npm:pi-system-one
 export SYSTEM_ONE_BASE_URL=http://localhost:8008
 ```
 
-TypeSafe: `SYSTEM_ONE_BASE_URL=https://api.typesafe.ai SYSTEM_ONE_API_KEY=... SYSTEM_ONE_MODEL=jev-latest`.
+**Configuration**
+
+The extension provides a `/so` command for configuring the System One client:
+
+- `SYSTEM_ONE_BASE_URL` – required endpoint URL.
+- `SYSTEM_ONE_MODEL` – optional default model name.
+- `SYSTEM_ONE_API_KEY` – optional API key.
+
+When you run `/so config`, you can:
+
+- **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 an `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.
+
+The current configuration can be inspected with `/so status`.
+
+---
+
+For further details see the source code and comments in `src/commands.ts`.
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-system-one",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "System One decisions for Pi. Plug in TypeSafe Jev, Reflex, or your own provider.",
   "type": "module",
   "license": "MIT",

package/src/commands.ts

@@ -0,0 +1,126 @@
+// 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,
+  describeConfig,
+  type SessionConfig,
+} from "./config.ts";
+import { buildSystemOneTool } from "./tool.ts";
+
+/** Mutable holder: empty until env or `/so config` provides a base URL. */
+export interface SessionStore {
+  session?: SessionConfig;
+}
+
+export function registerSystemOneCommands(
+  pi: ExtensionAPI,
+  store: SessionStore,
+) {
+  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 }));
+  }
+
+  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 ?? "",
+    );
+    if (modelRaw === 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");
+      return;
+    }
+    const answers: ConfigAnswers = {
+      baseUrl,
+      model: modelRaw.trim(),
+      apiKey: apiKeyRaw.trim(),
+      timeoutMs: "",
+    };
+    if (!store.session) {
+      store.session = blankSession();
+    }
+    const memoryKey = applyConfigAnswers(store.session, answers);
+    applyProvider();
+    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.",
+      "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",
+      );
+      return;
+    }
+    ctx.ui.notify(describeConfig(store.session), "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));
+    },
+    handler: async (args, ctx) => {
+      const [cmd] = args.trim().toLowerCase().split(/\s+/);
+      if (cmd === "status") await cmdStatus(ctx);
+      else await cmdConfig(ctx);
+    },
+  });
+
+  return { applyProvider, store };
+}

package/src/config.ts

@@ -1,16 +1,27 @@
 // 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.
+
 export interface SystemOneEnv {
   SYSTEM_ONE_BASE_URL?: string;
   SYSTEM_ONE_API_KEY?: string;
   SYSTEM_ONE_MODEL?: string;
   SYSTEM_ONE_TIMEOUT_MS?: string;
 }
+
 export interface SystemOneExtConfig {
   baseUrl: string;
   apiKey?: string;
   model?: string;
   timeoutMs: number;
 }
+
+export const DEFAULT_TIMEOUT_MS = 10_000;
+
 export function loadSystemOneConfig(
   env: SystemOneEnv = process.env,
 ): SystemOneExtConfig {
@@ -21,7 +32,7 @@ export function loadSystemOneConfig(
     );
   const timeoutMs = env.SYSTEM_ONE_TIMEOUT_MS
     ? Number(env.SYSTEM_ONE_TIMEOUT_MS)
-    : 10_000;
+    : DEFAULT_TIMEOUT_MS;
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
     throw new Error("SYSTEM_ONE_TIMEOUT_MS must be a positive number");
   return {
@@ -31,11 +42,80 @@ export function loadSystemOneConfig(
     timeoutMs,
   };
 }
-export function describeConfig(cfg: SystemOneExtConfig): string {
+
+export interface SessionConfig {
+  /** Current effective config (env + in-memory overrides). */
+  current: SystemOneExtConfig;
+  /** True when the key came from `/so config` (memory-only). */
+  keyInMemory: boolean;
+}
+
+export function createSessionConfig(
+  env: SystemOneEnv = process.env,
+): SessionConfig {
+  return { current: loadSystemOneConfig(env), keyInMemory: false };
+}
+
+/** Empty session for `/so config` when no env is present. */
+export function blankSession(): SessionConfig {
+  return {
+    current: {
+      baseUrl: "",
+      apiKey: undefined,
+      model: undefined,
+      timeoutMs: DEFAULT_TIMEOUT_MS,
+    },
+    keyInMemory: false,
+  };
+}
+
+export interface ConfigAnswers {
+  /** Empty string keeps the existing value. */
+  baseUrl: string;
+  model: string;
+  /** Empty string keeps the existing key. Provided keys are memory-only. */
+  apiKey: string;
+  timeoutMs: string;
+}
+
+/** Apply `/so config` answers. Returns true when a memory-only key was set. */
+export function applyConfigAnswers(
+  session: SessionConfig,
+  answers: ConfigAnswers,
+  env: SystemOneEnv = process.env,
+): boolean {
+  if (answers.baseUrl) session.current.baseUrl = answers.baseUrl;
+  if (answers.model) session.current.model = answers.model;
+  const timeoutMs = Number(answers.timeoutMs);
+  if (answers.timeoutMs && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+    session.current.timeoutMs = timeoutMs;
+  }
+  if (answers.apiKey === "-") {
+    session.current.apiKey = env.SYSTEM_ONE_API_KEY || undefined;
+    session.keyInMemory = false;
+    return false;
+  }
+  if (answers.apiKey) {
+    session.current.apiKey = answers.apiKey;
+    session.keyInMemory = true;
+    return true;
+  }
+  return false;
+}
+
+/** 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";
   return [
-    `Provider endpoint: ${cfg.baseUrl}`,
-    `API key: ${cfg.apiKey ? "configured" : "absent"}`,
-    `Model: ${cfg.model ?? "server default"}`,
-    `Timeout: ${cfg.timeoutMs}ms`,
+    "System One:",
+    `  endpoint: ${c.baseUrl}`,
+    keyLine,
+    `  model: ${c.model ?? "server default"}`,
+    `  timeout: ${c.timeoutMs}ms`,
   ].join("\n");
 }

package/src/extension.ts

@@ -1,19 +1,25 @@
 // pi-system-one/src/extension.ts
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { HttpSystemOneProvider } from "system-one-core";
-import { loadSystemOneConfig } from "./config.ts";
-import { buildSystemOneTool } from "./tool.ts";
+import { registerSystemOneCommands, type SessionStore } from "./commands.ts";
+import { createSessionConfig } from "./config.ts";
 
 export default function piSystemOneExtension(pi: ExtensionAPI) {
-  const cfg = loadSystemOneConfig();
-  const tool = buildSystemOneTool({
-    provider: new HttpSystemOneProvider({
-      id: "configured",
-      baseUrl: cfg.baseUrl,
-      apiKey: cfg.apiKey,
-      defaultModel: cfg.model,
-      timeoutMs: cfg.timeoutMs,
-    }),
-  });
-  pi.registerTool(tool);
+  // 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 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",
+        );
+      }
+    });
+  }
+
+  const { applyProvider } = registerSystemOneCommands(pi, store);
+  applyProvider();
 }

package/src/render.ts

@@ -16,12 +16,19 @@ export function renderSystemOneResult(response: {
         lines.push(`    ${k}: ${v}`);
     } else if (a?.type === "noul") {
       lines.push(`${id}:`, `  noul: ${a.noul}`);
-    } else {
+    } else if (a?.type === "score") {
       lines.push(
         `${id}:`,
         `  score: ${a.score}`,
         `  confidence: ${a.confidence}`,
       );
+      if (a.probabilities && typeof a.probabilities === "object") {
+        lines.push(`  probabilities:`);
+        for (const [k, v] of Object.entries(a.probabilities))
+          lines.push(`    ${k}: ${v}`);
+      }
+    } else {
+      lines.push(`${id}:`, `  unknown answer type: ${a?.type ?? "missing"}`);
     }
     lines.push("");
   }

package/src/tool.ts

@@ -1,71 +1,215 @@
-// biome-ignore-all lint/suspicious/noExplicitAny: intentional dynamic boundary over JSON protocol values
-// pi-system-one/src/tool.ts
-
-import { SystemOne, type SystemOneProvider } from "system-one-core";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import {
+  type QuestionMap,
+  SystemOne,
+  type SystemOneProvider,
+  type SystemOneState,
+} from "system-one-core";
 import type { Static } from "typebox";
 import { Type } from "typebox";
 import { renderSystemOneResult } from "./render.ts";
 
-const ChoiceQ = Type.Object({
-  type: Type.Literal("choice"),
-  instructions: Type.Any(),
-  criteria: Type.Record(Type.String(), Type.Union([Type.Any(), Type.Null()])),
-});
-const NoulQ = Type.Object({
-  type: Type.Literal("noul"),
-  instructions: Type.Any(),
-  criteria: Type.Optional(
-    Type.Record(Type.String(), Type.Union([Type.Any(), Type.Null()])),
-  ),
-});
-const ScoreQ = Type.Object({
-  type: Type.Literal("score"),
-  instructions: Type.Any(),
-  criteria: Type.Array(Type.Any()),
-});
-export const systemOneParams = Type.Object({
-  state: Type.Union([
+/**
+ * JSON value accepted by System One.
+ *
+ * Arrays/objects use Type.Any() recursively because tool arguments already
+ * cross a JSON boundary. Keeping the schema non-recursive also tends to be
+ * easier for tool-calling models to consume.
+ */
+const JsonValue = Type.Union(
+  [
     Type.String(),
-    Type.Record(Type.String(), Type.Any()),
+    Type.Number(),
+    Type.Boolean(),
+    Type.Null(),
     Type.Array(Type.Any()),
-  ]),
-  questions: Type.Record(Type.String(), Type.Union([ChoiceQ, NoulQ, ScoreQ])),
-  model: Type.Optional(Type.String()),
-});
+    Type.Record(Type.String(), Type.Any()),
+  ],
+  {
+    description:
+      "A JSON value: string, number, boolean, null, object, or array.",
+  },
+);
+
+const ChoiceQ = Type.Object(
+  {
+    type: Type.Literal("choice", {
+      description: "Select exactly one outcome from a bounded set.",
+    }),
+
+    instructions: JsonValue,
+
+    criteria: Type.Record(Type.String(), JsonValue, {
+      minProperties: 1,
+      description:
+        "Available choices keyed by choice label. Each value describes that choice; use null when the label is self-explanatory. The keys are the choices; do not provide a separate options field.",
+    }),
+  },
+  {
+    additionalProperties: false,
+    description:
+      "A closed-set categorical decision. The keys of criteria are the available choices.",
+  },
+);
+
+const NoulCriteria = Type.Object(
+  {
+    true: Type.Optional(JsonValue),
+    false: Type.Optional(JsonValue),
+  },
+  {
+    additionalProperties: false,
+    minProperties: 1,
+    description: "Optional descriptions of the true/yes and false/no outcomes.",
+  },
+);
+
+const NoulQ = Type.Object(
+  {
+    type: Type.Literal("noul", {
+      description: "Estimate the likelihood of a yes/true outcome.",
+    }),
+
+    instructions: JsonValue,
+
+    criteria: Type.Optional(NoulCriteria),
+  },
+  {
+    additionalProperties: false,
+    description:
+      "A probabilistic yes/no judgment. Omit criteria unless the true or false outcomes need clarification.",
+  },
+);
+
+const ScoreQ = Type.Object(
+  {
+    type: Type.Literal("score", {
+      description: "Score the state against an ordered rubric.",
+    }),
+
+    instructions: JsonValue,
+
+    criteria: Type.Array(JsonValue, {
+      minItems: 2,
+      description:
+        "Ordered score levels from lowest to highest. Each array item defines one level of the rubric.",
+    }),
+  },
+  {
+    additionalProperties: false,
+    description:
+      "An ordered rubric decision. Criteria are ordered from lowest to highest.",
+  },
+);
+
+const Question = Type.Union([ChoiceQ, NoulQ, ScoreQ]);
+
+export const systemOneParams = Type.Object(
+  {
+    state: Type.Union(
+      [
+        Type.String(),
+        Type.Number(),
+        Type.Boolean(),
+        Type.Null(),
+        Type.Record(Type.String(), Type.Any()),
+        Type.Array(Type.Any()),
+      ],
+      {
+        description:
+          "Shared state or evidence that all questions should be evaluated against.",
+      },
+    ),
+
+    questions: Type.Record(Type.String(), Question, {
+      minProperties: 1,
+      description:
+        "One or more named decision questions. Questions sharing the same state should be sent together.",
+    }),
+  },
+  {
+    additionalProperties: false,
+    description: "Evaluate bounded decision questions against shared state.",
+  },
+);
+
 export type SystemOneParams = Static<typeof systemOneParams>;
 
-export function buildSystemOneTool(deps: { provider: SystemOneProvider }) {
-  const systemOne = new SystemOne({ provider: deps.provider });
+export interface SystemOneDetails {
+  answers: Record<string, unknown>;
+  model?: string;
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+  };
+  requestId?: string;
+  metadata: {
+    provider: string;
+    latencyMs?: number;
+  };
+}
+
+export function buildSystemOneTool(deps: {
+  provider: SystemOneProvider;
+}): ToolDefinition<typeof systemOneParams, SystemOneDetails> {
+  const systemOne = new SystemOne({
+    provider: deps.provider,
+  });
+
   return {
     name: "system_one",
     label: "System One",
+
     description:
-      "Evaluate one or more bounded decision questions against shared state using the configured System One provider. " +
-      "Use this when the answer space is known and a fast probabilistic decision is preferable to generating free-form text. " +
-      "Multiple independent choice, noul, and score questions should be batched into one call when they share the same state.",
+      "Evaluate bounded choice, yes/no likelihood, and ordered score questions against shared state. " +
+      "Use this when the possible outcomes or scoring rubric are known and structured probabilistic results are useful. " +
+      "Do not use it for open-ended text generation. " +
+      "Questions that share the same state can be evaluated together in one call.",
+
     parameters: systemOneParams,
-    async execute(
-      _toolCallId: string,
-      params: SystemOneParams,
-      signal: AbortSignal | undefined,
-    ) {
-      // Throw on failure per Pi contract — never encode errors in content.
-      // Safe to propagate unwrapped: core error messages/codes never contain secrets.
+
+    promptSnippet:
+      "Evaluate bounded choices, yes/no likelihoods, and ordered scores from shared state",
+
+    promptGuidelines: [
+      "Use system_one for closed-set classification, probabilistic yes/no judgments, or ordered rubric scoring.",
+      "Do not use system_one for open-ended text generation or when there is no bounded answer space or rubric.",
+      "Preserve user-specified choice labels, criteria, and score levels instead of inventing replacements.",
+      "For choice questions, the keys of criteria are the available choices; never add a separate options field.",
+      "For self-explanatory choice labels, prefer null criteria values instead of inventing definitions that could bias the decision.",
+      "For noul questions, omit criteria unless the true/yes or false/no outcomes need clarification.",
+      "For score questions, criteria must contain at least two ordered levels from lowest to highest.",
+      "Batch independent questions into one system_one call when they share the same state.",
+    ],
+
+    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
+      /*
+       * The LLM-facing TypeBox schema is intentionally separate from the
+       * provider protocol types. Cast only at this boundary instead of
+       * spreading `any` throughout the implementation.
+       */
       const response = await systemOne.evaluate(
         {
-          state: params.state as any,
-          questions: params.questions as any,
-          ...(params.model ? { model: params.model } : {}),
+          state: params.state as SystemOneState,
+          questions: params.questions as QuestionMap,
         },
         { signal },
       );
-      const text = renderSystemOneResult(response as any);
+
       return {
-        content: [{ type: "text" as const, text }],
+        content: [
+          {
+            type: "text" as const,
+            text: renderSystemOneResult(response),
+          },
+        ],
+
         details: {
           answers: response.answers,
           model: response.model,
           usage: response.usage,
+          requestId: response.requestId,
+          metadata: response.metadata,
         },
       };
     },

package/tests/commands.test.ts

@@ -0,0 +1,135 @@
+// pi-system-one/tests/commands.test.ts
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  registerSystemOneCommands,
+  type SessionStore,
+} from "../src/commands.ts";
+import { createSessionConfig } from "../src/config.ts";
+
+interface Captured {
+  tools: string[];
+  handler: ((args: string, ctx: never) => Promise<void>) | undefined;
+  completions: ((prefix: string) => { value: string }[]) | undefined;
+  notices: string[];
+}
+
+function harness() {
+  const cap: Captured = {
+    tools: [],
+    handler: undefined,
+    completions: undefined,
+    notices: [],
+  };
+  const pi = {
+    registerTool: (t: { name: string }) => {
+      cap.tools.push(t.name);
+    },
+    registerCommand: (
+      _n: string,
+      o: {
+        handler: (args: string, ctx: never) => Promise<void>;
+        getArgumentCompletions?: (prefix: string) => { value: string }[];
+      },
+    ) => {
+      cap.handler = o.handler;
+      cap.completions = o.getArgumentCompletions;
+    },
+    on: () => {},
+  };
+  return { pi: pi as never, cap };
+}
+
+function ctxFor(answers: (string | undefined)[], cap: Captured) {
+  return {
+    ui: {
+      input: async () => answers.shift(),
+      notify: (msg: string) => {
+        cap.notices.push(msg);
+      },
+    },
+  } as never;
+}
+
+describe("so command", () => {
+  it("completes config + status, case-insensitively", () => {
+    const { pi, cap } = harness();
+    registerSystemOneCommands(pi, {});
+    assert.deepEqual(
+      cap.completions?.("").map((c) => c.value),
+      ["config", "status"],
+    );
+    assert.deepEqual(
+      cap.completions?.("S").map((c) => c.value),
+      ["status"],
+    );
+    assert.deepEqual(cap.completions?.("x"), []);
+  });
+  it("bare /so configures from blank session and registers the tool", async () => {
+    const { pi, cap } = harness();
+    const store: SessionStore = {};
+    registerSystemOneCommands(pi, store);
+    await cap.handler?.("", ctxFor(["http://x/", "", ""], cap));
+    assert.deepEqual(cap.tools, ["system_one"]);
+    assert.equal(store.session?.current.baseUrl, "http://x/");
+  });
+  it("cancel (undefined) keeps everything and registers nothing", async () => {
+    const { pi, cap } = harness();
+    const store: SessionStore = {};
+    registerSystemOneCommands(pi, store);
+    await cap.handler?.("", ctxFor([undefined], cap));
+    assert.deepEqual(cap.tools, []);
+    assert.equal(store.session, undefined);
+    assert.match(cap.notices[0], /Cancelled/);
+  });
+  it("empty base URL keeps existing value", async () => {
+    const { pi, cap } = harness();
+    const store: SessionStore = {
+      session: createSessionConfig({ SYSTEM_ONE_BASE_URL: "http://keep/" }),
+    };
+    registerSystemOneCommands(pi, store);
+    await cap.handler?.("", ctxFor(["", "", ""], cap));
+    assert.equal(store.session?.current.baseUrl, "http://keep/");
+  });
+  it("whitespace-only base URL is rejected", async () => {
+    const { pi, cap } = harness();
+    const store: SessionStore = {};
+    registerSystemOneCommands(pi, store);
+    await cap.handler?.("", ctxFor(["   ", "", ""], cap));
+    assert.equal(store.session, undefined);
+    assert.match(cap.notices[0], /Cancelled/);
+  });
+  it("'-' forgets a memory key back to env", async () => {
+    const { pi, cap } = harness();
+    const store: SessionStore = {
+      session: createSessionConfig({ SYSTEM_ONE_BASE_URL: "http://x/" }),
+    };
+    registerSystemOneCommands(pi, store);
+    await cap.handler?.("", ctxFor(["", "", "sk-mem", ""], cap));
+    assert.equal(store.session?.keyInMemory, true);
+    await cap.handler?.("", ctxFor(["", "", "-", ""], cap));
+    // After forgetting the memory key, the API key should revert to the environment variable (if any).
+    // In the CI environment, SYSTEM_ONE_API_KEY may be set; otherwise it will be undefined.
+    assert.equal(store.session?.keyInMemory, false);
+    assert.equal(
+      store.session?.current.apiKey,
+      process.env.SYSTEM_ONE_API_KEY || undefined,
+    );
+  });
+  it("status shows current config; STATUS routes case-insensitively", async () => {
+    const { pi, cap } = harness();
+    const store: SessionStore = {
+      session: createSessionConfig({ SYSTEM_ONE_BASE_URL: "http://x/" }),
+    };
+    registerSystemOneCommands(pi, store);
+    await cap.handler?.("STATUS", ctxFor([], cap));
+    assert.match(cap.notices[0], /http:\/\/x\//);
+  });
+  it("status with no session explains how to configure", async () => {
+    const { pi, cap } = harness();
+    registerSystemOneCommands(pi, {});
+    await cap.handler?.("status", ctxFor([], cap));
+    assert.match(cap.notices[0], /not configured/);
+  });
+});

package/tests/config.test.ts

@@ -2,27 +2,135 @@
 
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { describeConfig, loadSystemOneConfig } from "../src/config.ts";
+import {
+  applyConfigAnswers,
+  blankSession,
+  createSessionConfig,
+  describeConfig,
+  loadSystemOneConfig,
+} from "../src/config.ts";
 
 describe("config", () => {
-  it("loads from env with localhost default", () => {
-    const cfg = loadSystemOneConfig({
+  it("loads from env", () => {
+    const s = createSessionConfig({
       SYSTEM_ONE_BASE_URL: "http://localhost:8008",
     });
-    assert.equal(cfg.baseUrl, "http://localhost:8008");
-    assert.equal(cfg.timeoutMs, 10_000);
+    assert.equal(s.current.baseUrl, "http://localhost:8008");
+    assert.equal(s.current.timeoutMs, 10_000);
+    assert.equal(s.keyInMemory, false);
   });
-  it("never exposes the key", () => {
-    const shown = describeConfig(
-      loadSystemOneConfig({
-        SYSTEM_ONE_BASE_URL: "https://api.typesafe.ai",
-        SYSTEM_ONE_API_KEY: "sk-live-123",
-      }),
+  it("overrides apply in memory, empty keeps", () => {
+    const s = createSessionConfig({
+      SYSTEM_ONE_BASE_URL: "http://a/",
+      SYSTEM_ONE_MODEL: "m1",
+    });
+    applyConfigAnswers(s, {
+      baseUrl: "http://b/",
+      model: "",
+      apiKey: "",
+      timeoutMs: "",
+    });
+    assert.equal(s.current.baseUrl, "http://b/");
+    assert.equal(s.current.model, "m1");
+    assert.equal(s.keyInMemory, false);
+  });
+  it("typed key is memory-only and reported, never shown", () => {
+    const s = createSessionConfig({ SYSTEM_ONE_BASE_URL: "http://a/" });
+    const memory = applyConfigAnswers(s, {
+      baseUrl: "",
+      model: "",
+      apiKey: "sk-typed",
+      timeoutMs: "",
+    });
+    assert.equal(memory, true);
+    assert.equal(s.keyInMemory, true);
+    const shown = describeConfig(s);
+    assert.doesNotMatch(shown, /sk-typed/);
+    assert.match(shown, /in memory only/);
+  });
+  it("env key is reported as from environment", () => {
+    const s = createSessionConfig({
+      SYSTEM_ONE_BASE_URL: "http://a/",
+      SYSTEM_ONE_API_KEY: "sk-env",
+    });
+    const shown = describeConfig(s);
+    assert.doesNotMatch(shown, /sk-env/);
+    assert.match(shown, /from environment/);
+  });
+  it("absent key is reported", () => {
+    const s = createSessionConfig({ SYSTEM_ONE_BASE_URL: "http://a/" });
+    assert.match(describeConfig(s), /absent/);
+  });
+  it("'-' forgets a memory key back to env", () => {
+    const s = createSessionConfig({
+      SYSTEM_ONE_BASE_URL: "http://a/",
+      SYSTEM_ONE_API_KEY: "sk-env",
+    });
+    applyConfigAnswers(s, {
+      baseUrl: "",
+      model: "",
+      apiKey: "sk-mem",
+      timeoutMs: "",
+    });
+    assert.equal(s.keyInMemory, true);
+    applyConfigAnswers(
+      s,
+      { baseUrl: "", model: "", apiKey: "-", timeoutMs: "" },
+      {},
     );
-    assert.doesNotMatch(shown, /sk-live-123/);
-    assert.match(shown, /configured/);
+    assert.equal(s.keyInMemory, false);
+    assert.equal(s.current.apiKey, undefined);
   });
-  it("rejects missing baseUrl", () => {
+  it("legacy env bootstrap still validates", () => {
     assert.throws(() => loadSystemOneConfig({}), /SYSTEM_ONE_BASE_URL/);
+    assert.throws(
+      () =>
+        loadSystemOneConfig({
+          SYSTEM_ONE_BASE_URL: "http://a/",
+          SYSTEM_ONE_TIMEOUT_MS: "nope",
+        }),
+      /positive number/,
+    );
+  });
+  it("blankSession starts empty with defaults", () => {
+    const s = blankSession();
+    assert.equal(s.current.baseUrl, "");
+    assert.equal(s.current.timeoutMs, 10_000);
+    assert.equal(s.keyInMemory, false);
+  });
+  it("timeout answers apply only when valid", () => {
+    const s = createSessionConfig({ SYSTEM_ONE_BASE_URL: "http://a/" });
+    applyConfigAnswers(s, {
+      baseUrl: "",
+      model: "",
+      apiKey: "",
+      timeoutMs: "5000",
+    });
+    assert.equal(s.current.timeoutMs, 5000);
+    applyConfigAnswers(s, {
+      baseUrl: "",
+      model: "",
+      apiKey: "",
+      timeoutMs: "0",
+    });
+    assert.equal(s.current.timeoutMs, 5000);
+    applyConfigAnswers(s, {
+      baseUrl: "",
+      model: "",
+      apiKey: "",
+      timeoutMs: "junk",
+    });
+    assert.equal(s.current.timeoutMs, 5000);
+  });
+  it("describeConfig shows endpoint, model, and timeout lines", () => {
+    const shown = describeConfig(
+      createSessionConfig({
+        SYSTEM_ONE_BASE_URL: "http://a/",
+        SYSTEM_ONE_MODEL: "m1",
+      }),
+    );
+    assert.match(shown, /endpoint: http:\/\/a\//);
+    assert.match(shown, /model: m1/);
+    assert.match(shown, /timeout: 10000ms/);
   });
 });

package/tests/render.test.ts

@@ -29,4 +29,19 @@ describe("render", () => {
     assert.match(text, /complex:[\s\S]*noul: 0\.82/);
     assert.match(text, /difficulty:[\s\S]*score: 1\.7/);
   });
+  it("renders score probabilities and flags unknown types", () => {
+    const text = renderSystemOneResult({
+      answers: {
+        difficulty: {
+          type: "score",
+          score: 1.7,
+          probabilities: { "0": 0.1, "2": 0.7 },
+          confidence: 0.84,
+        },
+        weird: { type: "mystery", value: 1 },
+      },
+    } as any);
+    assert.match(text, /difficulty:[\s\S]*0: 0\.1/);
+    assert.match(text, /weird:[\s\S]*unknown answer type: mystery/);
+  });
 });

package/tests/tool.test.ts

@@ -7,7 +7,7 @@ import { buildSystemOneTool } from "../src/tool.ts";
 
 describe("system_one tool", () => {
   it("delegates a mixed batch and preserves details", async () => {
-    const tool: any = buildSystemOneTool({
+    const tool = buildSystemOneTool({
       provider: new MockSystemOneProvider({
         answers: {
           t: {
@@ -29,14 +29,14 @@ describe("system_one tool", () => {
       },
       undefined,
       undefined,
-      {},
+      {} as never,
     );
     const text = JSON.stringify(res);
     assert.match(text, /"a"/);
-    assert.equal(res.details.answers.t.choice, "a");
+    assert.equal((res.details.answers.t as { choice: string }).choice, "a");
   });
   it("propagates provider errors by throwing (never error-results)", async () => {
-    const tool: any = buildSystemOneTool({
+    const tool = buildSystemOneTool({
       provider: {
         id: "boom",
         async evaluate() {
@@ -53,7 +53,7 @@ describe("system_one tool", () => {
         },
         undefined,
         undefined,
-        {},
+        {} as never,
       ),
       /down/,
     );
@@ -88,13 +88,12 @@ describe("system_one tool", () => {
         };
       },
     };
-    const tool: any = buildSystemOneTool({ provider: stub as any });
+    const tool = buildSystemOneTool({ provider: stub as any });
     const controller = new AbortController();
     const res = await tool.execute(
       "id-3",
       {
         state: "hi",
-        model: "jev-latest",
         questions: {
           c: {
             type: "choice",
@@ -110,12 +109,15 @@ describe("system_one tool", () => {
         },
       },
       controller.signal,
+      undefined,
+      {} as never,
     );
-    assert.equal(res.details.answers.c.choice, "a");
-    assert.equal(res.details.answers.n.noul, 0.8);
-    assert.equal(res.details.answers.s.score, 1.5);
+    assert.equal((res.details.answers.c as { choice: string }).choice, "a");
+    assert.equal((res.details.answers.n as { noul: number }).noul, 0.8);
+    assert.equal((res.details.answers.s as { score: number }).score, 1.5);
     assert.deepEqual(res.details.usage, { inputTokens: 5, outputTokens: 2 });
-    assert.equal(seenRequest.model, "jev-latest");
+    assert.deepEqual(res.details.metadata, { provider: "stub" });
     assert.equal(seenOptions.signal, controller.signal);
+    assert.equal(seenRequest.state, "hi");
   });
 });