pi-verdict 0.9.0 → 0.9.1

package/README.md

@@ -109,7 +109,7 @@ pi-verdict runs on both [pi](https://github.com/badlogic/pi-mono) and [oh-my-pi]
 - `denyPaths` are plain paths you declare **protected** — touches trigger a terminal ask you adjudicate (non-interactive → deny); the classifier never learns the paths themselves, only that they exist. `grep`/`find`/`ls` compare their whole **search scope**: an omitted `path` (pi's default: the current directory) or a parent directory of a declared path triggers the ask as well. A fresh install pre-fills a **starter list** (`~/.ssh/`, `~/.gnupg`, `~/.mc`, shell rc/profile files), active from the first session after the initial run (any config change applies to new sessions) — a pre-filled *user declaration*, not a built-in floor: edit or empty it freely, add your own (`~/Documents/private`, …) alongside; existing configs are never rewritten
 - `builtinDenyFloor: false` turns off the built-in danger/path floor (your risk; the self-protection layer below always stays on)
 - `classifierModel` pins the classifier model, e.g. `"zai/glm-5.3-flash:low"` (thinking suffix supported; default: session model with thinking off)
-- `classifierModel: "typesafe/jev-latest"` opts into the bundled **jev decisions adapter** — gray-zone verdicts via TypeSafe's jev on OpenRouter (`/api/alpha/decisions`), reusing your pi OpenRouter login; experimental, see [ADR-0003](docs/adr/0003-jev-decisions-adapter.md)
+- `classifierModel: "typesafe/jev-latest"` opts into the bundled **jev decisions adapter** — gray-zone verdicts via TypeSafe's jev (OpenRouter by default, or TypeSafe's official API directly with `PI_VERDICT_JEV_TRANSPORT=typesafe`); experimental, see [ADR-0003](docs/adr/0003-jev-decisions-adapter.md)
 - `audit: true` records every **gray-zone adjudication** (the full transcript sent to the classifier, its raw response, the parsed verdict) as JSONL under `~/.pi/agent/verdicts/<sessionId>.jsonl` — one file per session, the 20 most recent kept. Local-only and full-fidelity (protected-path plaintext may appear — it never leaves your machine; [ADR-0002](docs/adr/0002-deny-paths-deterministic-ask.md) boundary note); the agent can neither read nor write the directory. `/automode` shows the audit state and path while on
 - `notifyAllows: true` notifies on every **classifier allow** (reason + action line — e.g. jev's probability breakdown); default `false` keeps passes silent. Mechanical passes (your own allow rules, protected-path confirms) never notify; shadow-cache annotations stay debug-only; with both switches on the notification appears once
 
@@ -118,17 +118,17 @@ No built-in allowlist — every "always allow" claim is yours ([why](docs/config
 ### Jev decisions backend (experimental — [ADR-0003](docs/adr/0003-jev-decisions-adapter.md))
 
 1. Install a version that ships the adapter (v0.8+): `pi install npm:pi-verdict`
-2. Get your OpenRouter credentials ready (OpenRouter is the only transport for now)
-   - run `/login openrouter` inside pi
-   - or `export OPENROUTER_API_KEY=sk-or-v1...` in your shell
+2. Pick a transport (both serve the same decisions wire contract):
+   - **OpenRouter (default)**: run `/login openrouter` inside pi, or `export OPENROUTER_API_KEY=sk-or-v1...` in your shell
+   - **TypeSafe direct (official v1 API)**: grab a self-service key at console.typesafe.ai, then `export TYPESAFE_API_KEY=apikey_...` and `export PI_VERDICT_JEV_TRANSPORT=typesafe`
 3. Point the classifier at jev (applies to new sessions)
    - persistent: edit `~/.pi/agent/config/pi-verdict.json` outside pi and set `{ "classifierModel": "typesafe/jev-latest" }`
    - or try it once: `PI_AUTO_MODE_MODEL=typesafe/jev-latest pi`
 
 **Limits**:
-- **Provider**: OpenRouter only, for now
+- **Transports**: OpenRouter decisions (default) or TypeSafe direct — on the TypeSafe transport per-call cost shows $0 (its API does not report it)
 - **Hosts**: pi only. On omp the setting warns and falls back to the session model; and it must never be selected as the session model (no text generation — selecting it warns)
-- **Escape hatch**: `PI_VERDICT_JEV_URL` overrides the decisions endpoint (alpha API)
+- **Escape hatch**: `PI_VERDICT_JEV_URL` overrides the active transport's endpoint (OpenRouter's is an alpha API)
 
 ### Self-protection (the gate guards itself — [ADR-0001](docs/adr/0001-self-protection-layer.md))
 

package/README.zh-CN.md

@@ -111,7 +111,7 @@ pi-verdict 同时支持 [pi](https://github.com/badlogic/pi-mono) 与 [oh-my-pi]
 - `denyPaths` 是你声明**受保护**的普通路径列表:触碰触发**终局 ask** 由你裁决(非交互降级 deny);分类器只被告知路径**存在**,路径明文永不出本机。`grep`/`find`/`ls` 按**整个搜索范围**比较:省略 `path`(pi 默认:当前目录)或传入位于声明路径之上的父目录,同样触发 ask。全新安装会预填一份**入门列表**(`~/.ssh/`、`~/.gnupg`、`~/.mc`、shell rc/profile 文件),自初次运行后的第一个会话起生效(一切配置变更均自新会话生效)——它是预填的*用户声明*而非内置 floor:可随意增删清空,也可与自己的路径(`~/Documents/private`、……)并列;既有配置永不被改写
 - `builtinDenyFloor: false` 整体关闭内置危险/路径拦截(风险自担;下方自保护层永远开启)
 - `classifierModel` 指定分类器模型,如 `"zai/glm-5.3-flash:low"`(支持思考后缀;缺省 = 会话模型且显式关思考)
-- `classifierModel: "typesafe/jev-latest"` 启用随包的 **jev 决策适配器**——灰区裁决经 OpenRouter 的 TypeSafe jev(`/api/alpha/decisions`)完成,复用 pi 的 OpenRouter 登录态;实验性质,详见 [ADR-0003](docs/adr/0003-jev-decisions-adapter.md)
+- `classifierModel: "typesafe/jev-latest"` 启用随包的 **jev 决策适配器**——灰区裁决经 TypeSafe jev 完成(默认 OpenRouter,或 `PI_VERDICT_JEV_TRANSPORT=typesafe` 直连官方 API);实验性质,详见 [ADR-0003](docs/adr/0003-jev-decisions-adapter.md)
 - `audit: true` 把每次**灰区裁决**(发给分类器的完整转录、其原始响应、解析出的裁决)以 JSONL 记录到 `~/.pi/agent/verdicts/<sessionId>.jsonl`——按会话一分文件,保留最近 20 个。仅存本机且全保真(受保护路径明文可能出现——永不出本机;[ADR-0002](docs/adr/0002-deny-paths-deterministic-ask.md) 边界注);agent 对该目录读写双拒。开启时 `/automode` 会显示审计状态与路径
 - `notifyAllows: true` 对每次 **classifier 放行**发通知(reason + action 行——如 jev 的概率分解);默认 `false` 保持放行静默。机械放行(你自己的 allow 规则、protected-path 确认)永不通知;shadow 标注仍属 debug;两开关同开时通知只出现一次
 
@@ -120,17 +120,17 @@ pi-verdict 同时支持 [pi](https://github.com/badlogic/pi-mono) 与 [oh-my-pi]
 ### Jev 决策后端(实验性——[ADR-0003](docs/adr/0003-jev-decisions-adapter.md))
 
 1. 安装含适配器的版本( v0.8 及以上):  `pi install npm:pi-verdict`
-2. 备好 OpenRouter 凭证（暂时只支持 OpenRouter）
-  - pi 内执行 `/login openrouter`
-  - 或 shell 里 `export OPENROUTER_API_KEY=sk-or-v1...`
+2. 选一条 transport(两条走同一 decisions wire 契约):
+  - **OpenRouter(默认)**: pi 内执行 `/login openrouter`,或 shell 里 `export OPENROUTER_API_KEY=sk-or-v1...`
+  - **TypeSafe 直连(官方 v1 API)**: 在 console.typesafe.ai 自助发 key,然后 `export TYPESAFE_API_KEY=apikey_...` 并 `export PI_VERDICT_JEV_TRANSPORT=typesafe`
 3. 把分类器指到 jev（新会话生效）
   - 持久：在 pi 之外编辑 `~/.pi/agent/config/pi-verdict.json` 并设置 `{ "classifierModel": "typesafe/jev-latest" }`
   - 或者临时试一把：`PI_AUTO_MODE_MODEL=typesafe/jev-latest pi`
 
 **限制**:
-- **Provider**: 暂时只支持 OpenRouter
+- **Transport**: OpenRouter decisions(默认)或 TypeSafe 直连——TypeSafe 侧单次成本显示 $0(其 API 不返回 cost)
 - **宿主**:仅支持pi。omp 上该设置会警告并回退会话模型。也绝不能选作会话主模型(不生成文本,选中即警告)
-- **逃生口**:`PI_VERDICT_JEV_URL` 可覆盖 decisions 端点(alpha 接口)
+- **逃生口**:`PI_VERDICT_JEV_URL` 可覆盖当前 transport 的端点(OpenRouter 侧为 alpha 接口)
 
 ### 自保护(门禁守护自身——[ADR-0001](docs/adr/0001-self-protection-layer.md))
 

package/extensions/jev-adapter.ts

@@ -2,18 +2,29 @@
  * pi-verdict jev adapter (ADR-0003) — exposes TypeSafe's jev decisions model
  * as a pi provider (`typesafe/jev-latest`) so `classifierModel` can name it.
  *
- * jev is not an LLM: OpenRouter serves it only through the decisions endpoint
- * (`POST /api/alpha/decisions`, request `{model, state, questions}`), which is
- * why the model cannot ride pi's built-in `openrouter` provider. This adapter
- * translates the classifier's completion call into one `choice` question and
- * synthesizes the `<verdict>…</verdict>` contract text from the typed answer.
+ * jev is not an LLM: its decisions API takes `{state, questions}` and returns
+ * typed answers, which is why the model cannot ride pi's chat-completions
+ * providers. Two transports (PI_VERDICT_JEV_TRANSPORT, default `openrouter`),
+ * whose wire contracts are isomorphic except for the model slug
+ * (live-verified 2026-09-19: same `{state, questions}` body; answers carry
+ * choice/probabilities/confidence; usage snake_case, TypeSafe's own API omits
+ * `cost` and mapUsage defaults it to 0):
+ *   - `openrouter`: POST /api/alpha/decisions, model `~typesafe/jev-latest`,
+ *     credentials reuse pi's OpenRouter login with OPENROUTER_API_KEY fallback
+ *     (no second credential channel);
+ *   - `typesafe`: POST api.typesafe.ai/v1/systemone, model `jev-latest` —
+ *     TypeSafe's official v1 API. pi has no typesafe login, so TYPESAFE_API_KEY
+ *     is this transport's only source, still resolved through the provider
+ *     auth pipeline rather than a bare fetch (ADR-0003 amendment).
  *
- * Credentials reuse pi's OpenRouter login (no second credential channel):
- * request-time auth resolves via `ctx.modelRegistry.getProviderAuth("openrouter")`
- * with `OPENROUTER_API_KEY` as fallback. Because `hasConfiguredAuth` reads a
- * sync snapshot built before any extension event fires, the provider is
- * re-registered on `session_start` to re-run the availability check with the
- * stashed resolver (see ADR-0003).
+ * This adapter translates the classifier's completion call into one `choice`
+ * question and synthesizes the `<verdict>…</verdict>` contract text from the
+ * typed answer. The transport is pinned at provider creation (env is
+ * process-constant), so provider metadata, auth, and request routing always
+ * agree. Because `hasConfiguredAuth` reads a sync snapshot built
+ * before any extension event fires, the provider is re-registered on
+ * `session_start` to re-run the availability check with the stashed
+ * resolver (see ADR-0003).
  *
  * Known limitations (ADR-0003): the classifier system prompt — including the
  * denyPaths existence hint — does not reach jev; jev treats state as data and
@@ -36,11 +47,63 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export const PROVIDER_ID = "typesafe";
 export const MODEL_ID = "jev-latest";
-/** Wire slug OpenRouter resolves to the newest jev snapshot. */
-export const WIRE_MODEL = "~typesafe/jev-latest";
 export const API_ID = "jev-decisions";
-export const DEFAULT_DECISIONS_URL = "https://openrouter.ai/api/alpha/decisions";
-export const DECISIONS_URL = process.env.PI_VERDICT_JEV_URL?.trim() || DEFAULT_DECISIONS_URL;
+
+export const TRANSPORTS = ["openrouter", "typesafe"] as const;
+export type Transport = (typeof TRANSPORTS)[number];
+
+/** Everything that differs between transports, in one place: the decisions
+ * endpoint, the model slug it expects (OpenRouter wants the `~latest` alias;
+ * TypeSafe's own API wants the bare slug), the provider/auth display names,
+ * the credential sources, and the missing-key error hint. PI_VERDICT_JEV_URL
+ * overrides either endpoint. */
+export interface TransportConfig {
+	/** Decisions endpoint (PI_VERDICT_JEV_URL overrides). */
+	url: string;
+	/** Model slug this endpoint expects. */
+	wireModel: string;
+	providerName: string;
+	authName: string;
+	/** Env var carrying the API key. */
+	keyEnv: "OPENROUTER_API_KEY" | "TYPESAFE_API_KEY";
+	/** Pi provider-auth id when a pi login exists to reuse; absent = env-only. */
+	loginProvider?: "openrouter";
+	/** Completes "no API key resolved (…)". */
+	keyHint: string;
+}
+
+export const TRANSPORT_DEFAULTS: Record<Transport, TransportConfig> = {
+	openrouter: {
+		url: "https://openrouter.ai/api/alpha/decisions",
+		wireModel: "~typesafe/jev-latest",
+		providerName: "TypeSafe (jev via OpenRouter)",
+		authName: "OpenRouter credentials (reused for jev)",
+		keyEnv: "OPENROUTER_API_KEY",
+		loginProvider: "openrouter",
+		keyHint: "openrouter login or OPENROUTER_API_KEY",
+	},
+	typesafe: {
+		url: "https://api.typesafe.ai/v1/systemone",
+		wireModel: "jev-latest",
+		providerName: "TypeSafe (jev direct)",
+		authName: "TYPESAFE_API_KEY",
+		keyEnv: "TYPESAFE_API_KEY",
+		keyHint: "TYPESAFE_API_KEY",
+	},
+};
+
+/** Unknown or unset values fall back to `openrouter` (the historical default). */
+export function activeTransport(): Transport {
+	return process.env.PI_VERDICT_JEV_TRANSPORT?.trim().toLowerCase() === "typesafe" ? "typesafe" : "openrouter";
+}
+
+export function decisionsUrl(transport: Transport = activeTransport()): string {
+	return process.env.PI_VERDICT_JEV_URL?.trim() || TRANSPORT_DEFAULTS[transport].url;
+}
+
+export function wireModel(transport: Transport = activeTransport()): string {
+	return TRANSPORT_DEFAULTS[transport].wireModel;
+}
 
 const VERDICTS = ["allow", "ask", "deny"] as const;
 type Verdict = (typeof VERDICTS)[number];
@@ -84,8 +147,8 @@ export function extractState(context: { messages: unknown[] }): string {
 	return state;
 }
 
-export function buildDecisionsBody(state: string, wireModel: string = WIRE_MODEL): Record<string, unknown> {
-	return { model: wireModel, state, questions: VERDICT_QUESTIONS };
+export function buildDecisionsBody(state: string, model: string = wireModel()): Record<string, unknown> {
+	return { model, state, questions: VERDICT_QUESTIONS };
 }
 
 interface DecisionAnswer {
@@ -130,7 +193,7 @@ function mapUsage(u: unknown): AssistantMessage["usage"] {
 	};
 }
 
-function streamDecisions(model: Model<string>, context: Context, options: StreamOptions | SimpleStreamOptions | undefined, fetcher: typeof fetch): AssistantMessageEventStream {
+function streamDecisions(transport: Transport, model: Model<string>, context: Context, options: StreamOptions | SimpleStreamOptions | undefined, fetcher: typeof fetch): AssistantMessageEventStream {
 	const stream = createAssistantMessageEventStream();
 	void (async () => {
 		const output: AssistantMessage = {
@@ -146,11 +209,11 @@ function streamDecisions(model: Model<string>, context: Context, options: Stream
 		try {
 			stream.push({ type: "start", partial: output });
 			const apiKey = options?.apiKey;
-			if (!apiKey) throw new Error("jev adapter: no API key resolved (openrouter login or OPENROUTER_API_KEY)");
-			const response = await fetcher(DECISIONS_URL, {
+			if (!apiKey) throw new Error(`jev adapter: no API key resolved (${TRANSPORT_DEFAULTS[transport].keyHint})`);
+			const response = await fetcher(decisionsUrl(transport), {
 				method: "POST",
 				headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
-				body: JSON.stringify(buildDecisionsBody(extractState(context))),
+				body: JSON.stringify(buildDecisionsBody(extractState(context), wireModel(transport))),
 				signal: options?.signal,
 			});
 			const text = await response.text();
@@ -181,50 +244,62 @@ function streamDecisions(model: Model<string>, context: Context, options: Stream
 	return stream;
 }
 
-/** Input $0.042/MTok, output free (research/typesafe-jev-classifiermodel.md,
- * verified against live usage.cost). Context ceiling is undocumented upstream;
+/** Input $0.042/MTok, output free (research/typesafe-jev-classifiermodel.md).
+ * OpenRouter settles per-call cost in usage; TypeSafe's own API omits it and
+ * mapUsage defaults it to 0. Context ceiling is undocumented upstream;
  * 30k matches the classifier transcript budget with margin. */
-const JEV_MODEL: Model<typeof API_ID> = {
-	id: MODEL_ID,
-	name: "Jev (latest, decisions)",
-	api: API_ID,
-	provider: PROVIDER_ID,
-	baseUrl: DECISIONS_URL,
-	reasoning: false,
-	input: ["text"],
-	cost: { input: 0.042, output: 0, cacheRead: 0, cacheWrite: 0 },
-	contextWindow: 30_000,
-	maxTokens: 512,
-};
+function jevModel(transport: Transport): Model<typeof API_ID> {
+	return {
+		id: MODEL_ID,
+		name: "Jev (latest, decisions)",
+		api: API_ID,
+		provider: PROVIDER_ID,
+		baseUrl: decisionsUrl(transport),
+		reasoning: false,
+		input: ["text"],
+		cost: { input: 0.042, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 30_000,
+		maxTokens: 512,
+	};
+}
 
 type OpenRouterKeyResolver = () => Promise<string | undefined>;
 
 export function createJevProvider(openRouterKey: OpenRouterKeyResolver | undefined, fetcher: typeof fetch = fetch): Provider {
+	// Transport is pinned at creation: env is constant for the process
+	// lifetime, and pinning keeps provider metadata, auth, and request
+	// routing in agreement (no half-switched state).
+	const transport = activeTransport();
+	const config = TRANSPORT_DEFAULTS[transport];
 	return createProvider({
 		id: PROVIDER_ID,
-		name: "TypeSafe (jev via OpenRouter)",
-		baseUrl: DECISIONS_URL,
+		name: config.providerName,
+		baseUrl: decisionsUrl(transport),
 		auth: {
-			// Ambient-only (no login): credentials come from pi's OpenRouter
-			// login or the env fallback, never from a typesafe-specific store.
+			// Ambient-only (no login): the openrouter transport reuses pi's
+			// OpenRouter login or the env fallback; the typesafe transport has
+			// no pi credential store (pi has no typesafe provider) and reads
+			// TYPESAFE_API_KEY only. Neither path opens a second channel.
 			apiKey: {
-				name: "OpenRouter credentials (reused for jev)",
+				name: config.authName,
 				resolve: async () => {
 					let key: string | undefined;
-					try {
-						key = await openRouterKey?.();
-					} catch {
-						/* getProviderAuth may reject on auth-store errors; env still applies */
+					if (config.loginProvider) {
+						try {
+							key = await openRouterKey?.();
+						} catch {
+							/* getProviderAuth may reject on auth-store errors; env still applies */
+						}
 					}
-					key ||= process.env.OPENROUTER_API_KEY?.trim();
-					return key ? { auth: { apiKey: key }, source: "openrouter" } : undefined;
+					key ||= process.env[config.keyEnv]?.trim();
+					return key ? { auth: { apiKey: key }, source: transport } : undefined;
 				},
 			},
 		},
-		models: [JEV_MODEL],
+		models: [jevModel(transport)],
 		api: {
-			stream: (m, c, o) => streamDecisions(m, c, o, fetcher),
-			streamSimple: (m, c, o) => streamDecisions(m, c, o, fetcher),
+			stream: (m, c, o) => streamDecisions(transport, m, c, o, fetcher),
+			streamSimple: (m, c, o) => streamDecisions(transport, m, c, o, fetcher),
 		},
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-verdict",
-	"version": "0.9.0",
+	"version": "0.9.1",
 	"description": "A minimal permission gate for Pi in the style of Claude Code's auto mode",
 	"author": "Jesset (https://github.com/jesset)",
 	"type": "module",