gentle-pi 2.6.0 → 2.6.2

package/tests/package-manifest.test.ts

@@ -101,13 +101,14 @@ function readPackageJson(): PackageJson {
 	}
 }
 
-test("package declares the tested Pi minimum required for agent_settled", () => {
+test("technical reference declares the tested Pi minimum required for agent_settled", () => {
 	const manifest = readPackageJson();
 	assert.equal(manifest.peerDependencies?.["@earendil-works/pi-coding-agent"], ">=0.85.1");
 	assert.equal(manifest.devDependencies?.["@earendil-works/pi-coding-agent"], "0.85.1");
-	const readme = readFileSync(join(PACKAGE_ROOT, "README.md"), "utf8");
-	assert.match(readme, /Pi 0\.85\.1 or newer/);
-	assert.match(readme, /agent_settled/);
+	const reference = readFileSync(join(PACKAGE_ROOT, "docs", "readme-reference.md"), "utf8");
+	assert.match(reference, /Pi 0\.85\.1 or newer/);
+	assert.match(reference, /agent_settled/);
+	assert.match(readFileSync(join(PACKAGE_ROOT, "README.md"), "utf8"), /\]\(docs\/readme-reference\.md(?:#[^)]+)?\)/);
 });
 
 test("package manifest has no obsolete native activation build surface", () => {
@@ -229,12 +230,12 @@ test("generated runtime modules and packed-package checks are deterministic", ()
 test("package manifest ships and runs the checked-in package-local Gentle AI installer", () => {
 	const packageJson = readPackageJson();
 	const verifier = readFileSync(join(PACKAGE_ROOT, "scripts", "verify-package-files.mjs"), "utf8");
-	const readme = readFileSync(join(PACKAGE_ROOT, "README.md"), "utf8");
+	const reference = readFileSync(join(PACKAGE_ROOT, "docs", "readme-reference.md"), "utf8");
 
 	assert.equal(packageJson.scripts?.postinstall, "node scripts/install-gentle-ai.mjs");
-	assert.match(readme, /run `node scripts\/install-gentle-ai\.mjs`/, "missing-binary recovery documentation must use the package postinstall entrypoint");
-	assert.match(readme, /installed `gentle-pi` package directory/, "recovery documentation must name the package working directory");
-	assert.match(readme, /if `GENTLE_PI_SKIP_GENTLE_AI_INSTALL` is set, remove or unset it before/i, "recovery documentation must prevent the installer skip from repeating");
+	assert.match(reference, /run `node scripts\/install-gentle-ai\.mjs`/, "missing-binary recovery documentation must use the package postinstall entrypoint");
+	assert.match(reference, /installed `gentle-pi` package directory/, "recovery documentation must name the package working directory");
+	assert.match(reference, /if `GENTLE_PI_SKIP_GENTLE_AI_INSTALL` is set, remove or unset it before/i, "recovery documentation must prevent the installer skip from repeating");
 	assert.ok(packageJson.files?.includes("scripts/"));
 	assert.match(verifier, /"scripts\/install-gentle-ai\.mjs"/);
 	assert.match(verifier, /"scripts\/gentle-ai-installer\.mjs"/);
@@ -277,20 +278,20 @@ test("package manifest installs pi-pretty through a wrapper without bundling nat
 	);
 });
 
-test("package verification binds the published Gentle AI v2.8.0 runtime pin", () => {
+test("package verification binds the published Gentle AI v2.8.2 runtime pin", () => {
 	const installer = readFileSync(join(PACKAGE_ROOT, "scripts", "gentle-ai-installer.mjs"), "utf8");
 	const binary = readFileSync(join(PACKAGE_ROOT, "lib", "gentle-ai-binary.ts"), "utf8");
 	const verifier = readFileSync(join(PACKAGE_ROOT, "scripts", "verify-package-files.mjs"), "utf8");
 
-	assert.match(installer, /INSTALLER_VERSION = "2\.8\.0"/);
+	assert.match(installer, /INSTALLER_VERSION = "2\.8\.2"/);
 	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_PACKAGE.*GENTLE_AI_WINDOWS_SOURCE_MODULE/);
-	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:QNdrYDxq\/Bi08o9PCk0jc4r5YObLdFmRCLXjKMqsze8="/);
+	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:54VJ0ruRiPc6MbNw4iFmlcBkQFOyF5D8iHY0A54Ivug="/);
 	assert.match(installer, /GOTOOLCHAIN: "local"/);
 	assert.match(installer, /GOSUMDB: "sum\.golang\.org"/);
 	assert.match(binary, /GENTLE_AI_VERSION = INSTALLER_VERSION/);
 	assert.match(binary, /GO_SUMDB_SOURCE_BUILD/);
 	assert.match(binary, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM/);
-	assert.match(verifier, /v2\.8\.0/);
+	assert.match(verifier, /v2\.8\.2/);
 });
 
 
@@ -1508,9 +1509,9 @@ test("pi-pretty wrapper uses real package path resolution for pnpm symlink insta
 	assert.match(wrapper, /quietToolsEnabled/);
 });
 
-test("v2.6.0 release package and runtime stop before publication", () => {
+test("v2.6.2 release package and runtime stop before publication", () => {
 	const packageJson = readPackageJson();
-	assert.equal(packageJson.version, "2.6.0", "the release manifest must remain explicitly pinned to v2.6.0");
+	assert.equal(packageJson.version, "2.6.2", "the release manifest must remain explicitly pinned to v2.6.2");
 	assert.equal(
 		packageJson.scripts?.test,
 		"node --experimental-strip-types --test tests/*.test.ts && pnpm run check:provider-contract && pnpm run test:harness",
@@ -1540,8 +1541,8 @@ test("bounded review keeps the Judgment Day skill contract at canon metadata ver
 	assert.doesNotMatch(frontmatter, /^  version: "1\.4"$/m);
 });
 
-test("README documents dynamic Gentle AI RDD ownership and the installed permission boundary", () => {
-	const readme = readFileSync(join(PACKAGE_ROOT, "README.md"), "utf8");
+test("technical reference documents dynamic Gentle AI RDD ownership and the installed permission boundary", () => {
+	const reference = readFileSync(join(PACKAGE_ROOT, "docs", "readme-reference.md"), "utf8");
 	for (const clause of [
 		"Gentle AI dynamically supplies runtime-specific RDD instructions",
 		"does not define an RDD lifecycle",
@@ -1549,9 +1550,9 @@ test("README documents dynamic Gentle AI RDD ownership and the installed permiss
 		"package-managed isolated installation",
 		"Project and user overrides may shadow a package asset",
 	]) {
-		assert.ok(readme.includes(clause), `README missing dynamic RDD clause: ${clause}`);
+		assert.ok(reference.includes(clause), `technical reference missing dynamic RDD clause: ${clause}`);
 	}
-	assert.doesNotMatch(readme, /New ordinary review uses compact `gentle_review` `start -> finalize -> validate`\./);
+	assert.doesNotMatch(reference, /New ordinary review uses compact `gentle_review` `start -> finalize -> validate`\./);
 });
 
 

package/tests/review-authority-recovery-docs.test.ts

@@ -2,21 +2,21 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import test from "node:test";
 
-const README = readFileSync("README.md", "utf8");
+const TECHNICAL_REFERENCE = readFileSync("docs/readme-reference.md", "utf8");
 const CONTROLLER = readFileSync("extensions/gentle-ai.ts", "utf8");
 
-test("recovery guidance documents the narrow published native maintenance contract", () => {
-	assert.match(README, /abandon.*quarantine-legacy.*reconcile-authority.*explicit v2\.1\.11 maintenance/i);
-	assert.match(README, /predecessor lineage and revision.*successor lineage and revision/i);
-	assert.match(README, /exact seven-line.*anomalies=unchanged_target,malformed_recovery_authorization/i);
-	assert.match(README, /fresh interactive approval/i);
-	assert.match(README, /quarantine only the bound invalid compact-v2 recovery successor/i);
-	assert.match(README, /predecessor stays untouched/i);
-	assert.match(README, /repair-legacy-alias.*unsupported historical v1 operation alias/i);
-	assert.match(README, /model supplies only lineage, actor, and reason/i);
-	assert.match(README, /review dispose-result.*unsupported.*pending.*design/i);
-	assert.match(README, /RESET.*RECOVER.*destructive/i);
-	assert.match(README, /typed envelopes/i);
+test("technical reference documents the narrow published native maintenance contract", () => {
+	assert.match(TECHNICAL_REFERENCE, /abandon.*quarantine-legacy.*reconcile-authority.*explicit v2\.1\.11 maintenance/i);
+	assert.match(TECHNICAL_REFERENCE, /predecessor lineage and revision.*successor lineage and revision/i);
+	assert.match(TECHNICAL_REFERENCE, /exact seven-line.*anomalies=unchanged_target,malformed_recovery_authorization/i);
+	assert.match(TECHNICAL_REFERENCE, /fresh interactive approval/i);
+	assert.match(TECHNICAL_REFERENCE, /quarantine only the bound invalid compact-v2 recovery successor/i);
+	assert.match(TECHNICAL_REFERENCE, /predecessor stays untouched/i);
+	assert.match(TECHNICAL_REFERENCE, /repair-legacy-alias.*unsupported historical v1 operation alias/i);
+	assert.match(TECHNICAL_REFERENCE, /model supplies only lineage, actor, and reason/i);
+	assert.match(TECHNICAL_REFERENCE, /review dispose-result.*unsupported.*pending.*design/i);
+	assert.match(TECHNICAL_REFERENCE, /RESET.*RECOVER.*destructive/i);
+	assert.match(TECHNICAL_REFERENCE, /typed envelopes/i);
 });
 
 test("controller help keeps authorization, blocked outcomes, and recovery boundaries explicit", () => {

package/tests/review-controller-native-routing.test.ts

@@ -298,6 +298,55 @@ test("approved acknowledgement burn tears down the retained candidate view and k
 	assert.ok(registry.hasProjection(lineageId, contributorRoot), "terminal approved cleanup keeps the lineage projection");
 });
 
+// gentle-ai#4003: the native burn is the committed authority outcome. A Pi-side
+// candidate-view teardown failure after it must never be reported as a failed
+// acknowledgement, or the caller cannot tell that authority was consumed.
+test("approved acknowledgement reports the burn truthfully when candidate-view cleanup fails after it", async (t) => {
+	const lineageId = "acknowledge-approved-deferred-cleanup";
+	const contributorRoot = candidateRepository(t);
+	writeFileSync(join(contributorRoot, "tracked.txt"), "candidate\n");
+	let failWorktreeRemove = true;
+	const registry = new CandidateViewRegistry((file, arguments_, options) => {
+		if (failWorktreeRemove && arguments_[0] === "worktree" && arguments_[1] === "remove") {
+			failWorktreeRemove = false;
+			throw Object.assign(new Error("simulated worktree removal failure"), { status: 128 });
+		}
+		return execFileSync(file, arguments_, options);
+	});
+	t.after(() => registry.cleanupAll());
+	const view = registry.create({ contributorRoot });
+	registry.retain(view.token, lineageId);
+	const statusRequests: unknown[] = [];
+	let acknowledgements = 0;
+	const native = {
+		targetStatus: async (request: unknown) => { statusRequests.push(request); return approvedAcknowledgementStatus(lineageId, contributorRoot); },
+		acknowledgeApproved: async () => { acknowledgements += 1; },
+	} as unknown as NativeReviewCli;
+
+	const completed = await __testing.executeReviewControllerOperation({ operation: "acknowledge-approved", lineageId }, contributorRoot, native, undefined, registry);
+
+	assert.equal(acknowledgements, 1, "exactly one native burn");
+	assert.equal(statusRequests.length, 1, "no STATUS reconciliation after a cleanup-only failure");
+	assert.equal(completed.status, "closed");
+	assert.equal(completed.outcome, "native-approved-acknowledgement-completed");
+	assert.equal(completed.authority, "burned");
+	assert.equal(completed.mutation_performed, true);
+	assert.equal(completed.mutation_outcome, "committed");
+	assert.deepEqual(completed.candidate_view_cleanup, {
+		status: "deferred",
+		diagnostics: { code: "candidate-view-git-failure", message: "candidate-view Git command worktree failed; inspect the candidate state before any new START" },
+		next_action: "retry-candidate-view-cleanup-or-remove-the-view-out-of-band",
+	});
+	assert.ok(existsSync(view.root), "a failed teardown preserves the candidate view");
+	assert.ok(registry.hasProjection(lineageId, contributorRoot), "the lineage projection survives the deferred cleanup");
+
+	// The residue stays recoverable: the registry still owns the view, so a
+	// later terminal cleanup removes it without replaying the burn.
+	registry.cleanupTerminal(lineageId, "approved", contributorRoot);
+	assert.equal(existsSync(view.root), false);
+	assert.equal(acknowledgements, 1);
+});
+
 test("ambiguous acknowledgement reconciles STATUS once without replaying the provider vector", async () => {
 	const lineageId = "ambiguous-acknowledgement";
 	let statusCalls = 0;

package/tests/review-ledger-contract.test.ts

@@ -19,6 +19,7 @@ const JD_SKILL = "skills/judgment-day/SKILL.md";
 const JD_PROMPTS = "skills/judgment-day/references/prompts-and-formats.md";
 const GENTLE_SKILL = "skills/gentle-ai/SKILL.md";
 const README = "README.md";
+const TECHNICAL_REFERENCE = "docs/readme-reference.md";
 const CHAIN = "assets/chains/4r-review.chain.md";
 const SDD_WORKFLOW = "assets/sdd-orchestrator-workflow.md";
 const RELEASE_SKILL = "skills/release/SKILL.md";
@@ -132,7 +133,8 @@ test("canonical contract defines compact risk, causal admission, correction, CAS
 		/untrusted repository content.*malformed inputs.*stale authority.*path drift.*external callers/i,
 		...JUDGMENT_DAY_DISCOVERY_PATTERNS,
 	]);
-	assert.match(read(README), /Review outcomes and receipt state are informational; commit, push, pull-request, and release delivery follow ordinary repository policy\./);
+	assert.match(read(TECHNICAL_REFERENCE), /Review outcomes and receipt state are informational; commit, push, pull-request, and release delivery follow ordinary repository policy\./);
+	assert.match(read(README), /\]\(docs\/readme-reference\.md(?:#[^)]+)?\)/);
 	assert.doesNotMatch(read(README), /one one-shot authorization for the exact command/i);
 	assert.doesNotMatch(read(README), /review-publication-gate/i);
 });
@@ -365,14 +367,14 @@ test("Judgment Day fix routing has one canonical shape and never falls back to g
 	assert.match(read(SDD_WORKFLOW), /\| default\s+\| balanced\s+\| SDD phase fallback; never a Judgment Day role\s+\|/);
 });
 
-test("orchestrator, injected skill, and README defer RDD lifecycle ownership to Gentle AI", () => {
+test("orchestrator, injected skill, and technical reference defer RDD lifecycle ownership to Gentle AI", () => {
 	const boundary = "This package injects the mirrored provider-bundle review execution contract into this session's system prompt at start; Gentle AI writes nothing into the Pi system prompt, and this package owns everything else here. Absent that mirrored contract, this package invents no lifecycle instructions.";
 	const orchestrator = union(ORCHESTRATOR);
 	assert.ok(orchestrator.includes(boundary), "orchestrator must carry the sole static ownership boundary");
 
 	for (const [label, content] of [
 		[GENTLE_SKILL, read(GENTLE_SKILL)],
-		[README, read(README)],
+		[TECHNICAL_REFERENCE, read(TECHNICAL_REFERENCE)],
 	] as const) {
 		assertMatches(label, content, [
 			/Gentle AI dynamically supplies runtime-specific RDD instructions/i,
@@ -388,8 +390,8 @@ test("orchestrator, injected skill, and README defer RDD lifecycle ownership to
 	}
 });
 
-test("README documents the dynamic runtime authority boundary without an old package route", () => {
-	const content = read(README);
+test("technical reference documents the dynamic runtime authority boundary without an old package route", () => {
+	const content = read(TECHNICAL_REFERENCE);
 	assert.match(content, /Gentle AI dynamically supplies runtime-specific RDD instructions/i);
 	assert.match(content, /does not define an RDD lifecycle/i);
 	assert.doesNotMatch(content, /New ordinary review uses compact `gentle_review` `start -> finalize -> validate`\./);

package/tests/runtime-metrics-children.test.ts

@@ -6,11 +6,9 @@ import { runInNewContext } from "node:vm";
 import { parseAgentClass } from "../lib/runtime-metrics.ts";
 import { parseAgentDefinition, type AgentDefinition } from "../lib/agents-config.ts";
 import { normalizeRpcEvent, TASK_EVENT } from "../lib/agents-protocol.ts";
-import { lookupPiCatalogName } from "../lib/runtime-metrics-pi-identity.ts";
 import { ChildComposition, childEvent, classifyBuiltinAgent, launchSelection } from "../lib/runtime-metrics-children.ts";
 import { encodeNativeRuntimeEvent } from "../lib/runtime-metrics-native.ts";
 
-await lookupPiCatalogName({ provider: "openai", modelId: "gpt-4o" });
 const asset = new URL("../assets/agents/gentle-ai-worker.md", import.meta.url);
 const definition = parseAgentDefinition(readFileSync(asset, "utf8"), asset.pathname, "global");
 assert.ok("instructions" in definition);
@@ -123,7 +121,10 @@ test("launch distribution and each observed combination remain independent and p
 	assert.equal(view.settled, 1);
 	assert.equal(view.statuses.completed, 1);
 	assert.ok(!JSON.stringify(view).includes("local-"));
-	const privateLaunch = launchSelection({ ...workerDefinition, instructions: "private" }, { provider: "private", id: "private-model" }, "private-effort");
+	// "Private Vendor Co" fails the schema provider pattern (space, uppercase),
+	// unlike a genuine lowercase slug such as "private" that would now legitimately
+	// pass through as an open-weight provider name.
+	const privateLaunch = launchSelection({ ...workerDefinition, instructions: "private" }, { provider: "Private Vendor Co", id: "private-model" }, "private-effort");
 	const filtered = childEvent("local-session", "other", privateLaunch, "failed", {
 		coverage: "final_assistant_messages_only", agentSettled: false, responses: [response("private-model", "private-native")], droppedResponses: 0,
 	});

package/tests/runtime-metrics-extension.test.ts

@@ -2,14 +2,12 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import runtimeMetrics from "../extensions/runtime-metrics.ts";
 import { parseAgentClass, type RuntimeMetricBucket } from "../lib/runtime-metrics.ts";
-import { createPiCatalogNameLookup, type PiCatalogName } from "../lib/runtime-metrics-pi-identity.ts";
+import { encodeNativeRuntimeEvent } from "../lib/runtime-metrics-native.ts";
 import { CHILD_METRICS_EVENT, childEvent } from "../lib/runtime-metrics-children.ts";
 import { normalizeRpcEvent, TASK_EVENT } from "../lib/agents-protocol.ts";
 
 const tick = () => new Promise<void>(resolve => setImmediate(resolve));
-type CatalogLookup = NonNullable<NonNullable<Parameters<typeof runtimeMetrics>[2]>["lookup"]>;
-function harness(env: NodeJS.ProcessEnv = {}, lookup?: CatalogLookup,
-	classify?: (input: unknown) => PiCatalogName, mode: "tui" | "print" = "tui", shutdownWaitMs = 1500) {
+function harness(env: NodeJS.ProcessEnv = {}, mode: "tui" | "print" = "tui", shutdownWaitMs = 1500, model: unknown = { provider: "openai", id: "gpt-4o" }) {
 	const handlers = new Map<string, Function>();
 	const listeners = new Map<string, Function>();
 	let session = "first";
@@ -17,13 +15,13 @@ function harness(env: NodeJS.ProcessEnv = {}, lookup?: CatalogLookup,
 	let signal!: AbortSignal;
 	const sent: RuntimeMetricBucket[][] = [];
 	const launches: unknown[] = [];
-	const ctx: any = { cwd: "/fixture", mode, model: { provider: "openai", id: "gpt-4o" },
+	const ctx: any = { cwd: "/fixture", mode, model,
 		sessionManager: { getSessionId: () => session, getEntries: () => assert.fail("no reconstruction") } };
 	const pi: any = { on: (name: string, handler: Function) => handlers.set(name, handler),
 		getThinkingLevel: () => "high", registerCommand() {},
 		appendEntry: () => assert.fail("no metrics persistence"),
 		events: { on: (name: string, handler: Function) => { listeners.set(name, handler); return () => listeners.delete(name); } } };
-	runtimeMetrics(pi, env, { lookup, classify, now: () => 0, shutdownWaitMs, send: (rows, _cwd, deps) => {
+	runtimeMetrics(pi, env, { now: () => 0, shutdownWaitMs, send: (rows, _cwd, deps) => {
 		sent.push(structuredClone(rows)); launches.push(structuredClone(deps?.launches)); signal = deps!.signal!;
 		return new Promise(resolve => { finish = () => resolve("discarded"); });
 	} });
@@ -38,30 +36,41 @@ const final = (input = 7) => ({ role: "assistant", provider: "openai", model: "g
 	providerThinkingLevel: "low", stopReason: "stop", usage: { input, output: 3, cacheRead: 0 },
 	content: [{ text: "private response" }], errorMessage: "private error", path: "/private" });
 
-test("message classification retries a failed catalog load without awaiting it", async () => {
-	let calls = 0;
-	const publicName = Object.freeze({ classification: "catalog_public", modelId: "gpt-4o" }) satisfies PiCatalogName;
-	const catalog = new Map([[JSON.stringify(["openai", "gpt-4o"]), publicName]]);
-	const catalogLookup = createPiCatalogNameLookup(async () => {
-		calls++;
-		if (calls === 1) throw new Error("transient catalog failure");
-		return catalog;
-	});
-	const h = harness({}, catalogLookup.lookup, catalogLookup.classify);
-	h.emit("session_start");
-	await tick();
-	assert.equal(calls, 1);
-	assert.equal(h.emit("message_end", { message: final() }), undefined);
-	assert.equal(calls, 2);
+test("a generic open-weight selection reaches the wire by name; no catalog probe or gate", async () => {
+	const h = harness({}, "tui", 1500, { provider: "nan", id: "deepseek-v4-flash" });
+	await h.emit("session_start");
+	h.emit("turn_start"); h.emit("before_provider_request");
+	h.emit("message_end", { message: { role: "assistant", provider: "nan", model: "deepseek-v4-flash",
+		providerThinkingLevel: "low", stopReason: "stop", usage: { input: 3, output: 2 } } });
 	await tick();
 	assert.equal(h.sent.length, 1);
-	assert.equal(h.sent[0][0].observedModelId, "unknown", "the racing row remains fail-closed");
-	await h.finish();
-	h.emit("message_end", { message: final(8) });
+	assert.equal(h.sent[0][0].selectedProvider, "nan");
+	assert.equal(h.sent[0][0].selectedModelId, "deepseek-v4-flash");
+	const encoded = encodeNativeRuntimeEvent(h.sent[0]);
+	assert.ok(encoded);
+	const row = JSON.parse(encoded).rows[0];
+	assert.deepEqual(row.model, { provider: "nan", id: "deepseek-v4-flash" });
+	assert.equal(row.model_evidence, "selected");
+	await h.finish(); h.emit("session_shutdown");
+});
+
+test("an ambiguous turn with no captured selection still reports the observed model, as selected evidence", async () => {
+	const h = harness({}, "tui", 1500, { provider: "nan", id: "deepseek-v4-flash" });
+	await h.emit("session_start");
+	// No turn_start/before_provider_request: the turn is ambiguous, so no
+	// selection was captured for this response.
+	h.emit("message_end", { message: { role: "assistant", provider: "nan", model: "glm5.3",
+		providerThinkingLevel: "low", stopReason: "stop", usage: { input: 3, output: 2 } } });
 	await tick();
-	assert.equal(h.sent[1][0].observedModelId, "gpt-4o", "a later row uses the recovered catalog");
-	await h.finish();
-	h.emit("session_shutdown");
+	assert.equal(h.sent.length, 1);
+	assert.equal(h.sent[0][0].selectedModelId, "unknown");
+	assert.equal(h.sent[0][0].observedModelId, "glm5.3");
+	const encoded = encodeNativeRuntimeEvent(h.sent[0]);
+	assert.ok(encoded);
+	const row = JSON.parse(encoded).rows[0];
+	assert.deepEqual(row.model, { provider: "nan", id: "glm5.3" });
+	assert.equal(row.model_evidence, "selected");
+	await h.finish(); h.emit("session_shutdown");
 });
 
 test("final callback returns before blocked transport; busy and duplicate messages drop", async () => {
@@ -97,7 +106,7 @@ test("replacement before launch cancels stale work; shutdown does not await a bl
 });
 
 test("print shutdown joins an accepted orchestrator delivery before disposing", async () => {
-	const h = harness({}, undefined, undefined, "print", 50); await h.emit("session_start");
+	const h = harness({}, "print", 50); await h.emit("session_start");
 	h.emit("message_end", { message: final() }); await tick();
 	let stopped = false;
 	const shutdown = h.emit("session_shutdown").then(() => { stopped = true; });
@@ -109,7 +118,7 @@ test("print shutdown joins an accepted orchestrator delivery before disposing",
 });
 
 test("print shutdown joins an accepted child launch and response delivery", async () => {
-	const h = harness({}, undefined, undefined, "print", 50); await h.emit("session_start");
+	const h = harness({}, "print", 50); await h.emit("session_start");
 	const observation = normalizeRpcEvent({ type: "message_end", message: final() }, { observeResponses: true })
 		.find(event => event.type === TASK_EVENT.RESPONSE_OBSERVATION);
 	assert.ok(observation?.type === TASK_EVENT.RESPONSE_OBSERVATION);
@@ -127,7 +136,7 @@ test("print shutdown joins an accepted child launch and response delivery", asyn
 });
 
 test("print shutdown aborts a delivery after the bounded join deadline", async () => {
-	const h = harness({}, undefined, undefined, "print", 5); await h.emit("session_start");
+	const h = harness({}, "print", 5); await h.emit("session_start");
 	h.emit("message_end", { message: final() }); await tick();
 	await h.emit("session_shutdown");
 	assert.equal(h.signal().aborted, true);
@@ -135,7 +144,7 @@ test("print shutdown aborts a delivery after the bounded join deadline", async (
 });
 
 test("interactive shutdown never joins a blocked delivery", async () => {
-	const h = harness({}, undefined, undefined, "tui", 50); await h.emit("session_start");
+	const h = harness({}, "tui", 50); await h.emit("session_start");
 	h.emit("message_end", { message: final() }); await tick();
 	assert.equal(h.emit("session_shutdown"), undefined);
 	assert.equal(h.signal().aborted, true);

package/tests/runtime-metrics-model.test.ts

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { normalizeRuntimeModel } from "../lib/runtime-metrics.ts";
+
+// Data-driven family-pattern normalizer (gentle-pi#968 / gentle-ai#4536). Rules:
+// - non-string or empty provider or id -> {provider: "unknown", id: "unknown"};
+// - id is trimmed, the LAST "/"-separated segment is kept, then lowercased; it is
+//   public only when it matches the schema id pattern within its maxLength,
+//   otherwise the id becomes "custom";
+// - provider is trimmed and lowercased; it is kept when it matches the schema
+//   provider pattern, otherwise it becomes "custom";
+// - when the id is not public the provider becomes "custom" too, except for the
+//   "opencode" provider, which yields "opencode"/"custom";
+// - the literal "unknown"/"unknown" and "custom"/"custom" pairs pass through.
+const cases: Array<[string, unknown, unknown, { provider: string; id: string }]> = [
+	["open-weight family on an arbitrary provider stays public", "nan", "deepseek-v4-flash", { provider: "nan", id: "deepseek-v4-flash" }],
+	["a short version suffix without a separator is still public", "nan", "glm5.3", { provider: "nan", id: "glm5.3" }],
+	["multiple suffix groups without a leading separator are still public", "nan", "glm5.3-flash", { provider: "nan", id: "glm5.3-flash" }],
+	["only the last '/'-separated id segment is kept", "nano-gpt", "TEE/glm-5.3", { provider: "nano-gpt", id: "glm-5.3" }],
+	["a nested provider path in the id is dropped, keeping the outer provider", "openrouter", "deepseek/deepseek-v4-flash", { provider: "openrouter", id: "deepseek-v4-flash" }],
+	["provider and id are lowercased", "OpenAI", "GPT-5.6-Sol", { provider: "openai", id: "gpt-5.6-sol" }],
+	["a long dotted/dashed anthropic id stays public", "anthropic", "claude-sonnet-5-20260101", { provider: "anthropic", id: "claude-sonnet-5-20260101" }],
+	["an id with no recognized family prefix collapses provider and id to custom", "acme", "acme-internal-finetune", { provider: "custom", id: "custom" }],
+	["a public id with a non-conforming provider is emitted as custom/<id>", "Acme Corp", "gpt-5.6", { provider: "custom", id: "gpt-5.6" }],
+	["an id longer than the schema maxLength collapses to custom/custom", "anthropic", `claude-${"x".repeat(64)}`, { provider: "custom", id: "custom" }],
+	["opencode keeps its provider identity even for a private id", "opencode", "private-thing", { provider: "opencode", id: "custom" }],
+	["empty provider and id fail closed to unknown/unknown", "", "", { provider: "unknown", id: "unknown" }],
+];
+
+for (const [name, provider, id, expected] of cases) {
+	test(`normalizeRuntimeModel: ${name}`, () => {
+		assert.deepEqual(normalizeRuntimeModel(provider, id), expected);
+	});
+}
+
+test("non-string provider or id fails closed to unknown/unknown", () => {
+	for (const [provider, id] of [[undefined, "gpt-5.6"], ["openai", undefined], [null, null], [42, "gpt-5.6"], ["openai", { id: "gpt-5.6" }]] as const) {
+		assert.deepEqual(normalizeRuntimeModel(provider, id), { provider: "unknown", id: "unknown" });
+	}
+});
+
+test("whitespace-only provider or id fails closed to unknown/unknown", () => {
+	assert.deepEqual(normalizeRuntimeModel("   ", "gpt-5.6"), { provider: "unknown", id: "unknown" });
+	assert.deepEqual(normalizeRuntimeModel("openai", "   "), { provider: "unknown", id: "unknown" });
+});
+
+test("literal unknown/unknown passes through without pattern matching", () => {
+	assert.deepEqual(normalizeRuntimeModel("unknown", "unknown"), { provider: "unknown", id: "unknown" });
+	assert.deepEqual(normalizeRuntimeModel("Unknown", "UNKNOWN"), { provider: "unknown", id: "unknown" });
+});
+
+test("literal custom/custom passes through", () => {
+	assert.deepEqual(normalizeRuntimeModel("custom", "custom"), { provider: "custom", id: "custom" });
+});
+
+test("surrounding whitespace is trimmed before matching", () => {
+	assert.deepEqual(normalizeRuntimeModel("  nan  ", "  deepseek-v4-flash  "), { provider: "nan", id: "deepseek-v4-flash" });
+});
+
+// The mirrored pattern is unambiguous (every suffix group starts with a
+// mandatory separator), so a long alphanumeric run followed by an invalid
+// character cannot trigger catastrophic backtracking in V8. The bound below
+// is generous on purpose: it catches an exponential regression, not jitter.
+test("a pathological 64-character id is rejected in linear time", () => {
+	const ids = [`gpt${"a".repeat(60)}!`, `glm${"5".repeat(60)}/`, `deepseek${"x".repeat(55)}-`];
+	const started = performance.now();
+	for (let round = 0; round < 50; round++) for (const id of ids) {
+		assert.deepEqual(normalizeRuntimeModel("nan", id), { provider: "custom", id: "custom" });
+	}
+	assert.ok(performance.now() - started < 500, "normalizer must not backtrack catastrophically");
+});
+
+test("attached run then separated groups stays public", () => {
+	assert.deepEqual(normalizeRuntimeModel("nan", "glm5.3-flash:thinking"), { provider: "nan", id: "glm5.3-flash:thinking" });
+	assert.deepEqual(normalizeRuntimeModel("nan", "gpt-1-2-3-4-5-6-7-8-9"), { provider: "custom", id: "custom" });
+});

package/tests/runtime-metrics-native.test.ts

@@ -75,18 +75,84 @@ test("encoder filters custom identities and never promotes SDK model to response
 	row.agentClass = "private-agent" as any; row.effort = "private-effort" as any;
 	row.error = "authentication";
 	const encoded = JSON.parse(native.encodeNativeRuntimeEvent([row])!);
-	assert.deepEqual(encoded.rows[0].model, { provider: "custom", id: "custom" });
+	// "private-model" never normalizes to a public id, so it never claims
+	// response evidence; the row falls through to the still-public selection
+	// (source()'s default selectedModelId "gpt-5.4") instead of leaking it or
+	// collapsing a perfectly good selected identity to custom/custom.
+	assert.deepEqual(encoded.rows[0].model, { provider: "openai", id: "gpt-5.4" });
+	assert.equal(encoded.rows[0].model_evidence, "selected");
 	assert.equal(encoded.rows[0].agent_class, "unknown");
 	assert.equal(encoded.rows[0].selected_effort, "unavailable");
 	assert.equal(encoded.rows[0].error_category, "auth");
 	assert.ok(!JSON.stringify(encoded).includes("private"));
-	row.responseModelId = "unknown";
-	const selected = JSON.parse(native.encodeNativeRuntimeEvent([row])!);
-	assert.equal(selected.rows[0].model_evidence, "selected");
-	assert.deepEqual(selected.rows[0].model, { provider: "openai", id: "gpt-5.4" });
 	row.selectedModelId = "unknown";
-	const unknown = JSON.parse(native.encodeNativeRuntimeEvent([row])!);
-	assert.equal(unknown.rows[0].model_evidence, "unknown");
+	const observedFallback = JSON.parse(native.encodeNativeRuntimeEvent([row])!);
+	// With no public selected model either, it falls through once more, but
+	// source()'s default observedModelId ("private-alias") is not public either.
+	assert.equal(observedFallback.rows[0].model_evidence, "unknown");
+	assert.deepEqual(observedFallback.rows[0].model, { provider: "unknown", id: "unknown" });
+});
+
+test("a public observed model is a fallback evidence tier, behind response and selected", () => {
+	const row = source();
+	row.responseModelId = "unknown"; row.selectedModelId = "unknown"; row.observedModelId = "glm5.3-flash"; row.provider = "nan";
+	const encoded = JSON.parse(native.encodeNativeRuntimeEvent([row])!);
+	assert.deepEqual(encoded.rows[0].model, { provider: "nan", id: "glm5.3-flash" });
+	assert.equal(encoded.rows[0].model_evidence, "selected", "the transport has no separate observed evidence category");
+	// A public response model still wins over a public observed model.
+	const withResponse = source();
+	withResponse.selectedModelId = "unknown"; withResponse.observedModelId = "glm5.3-flash"; withResponse.provider = "nan";
+	const encodedResponse = JSON.parse(native.encodeNativeRuntimeEvent([withResponse])!);
+	assert.equal(encodedResponse.rows[0].model_evidence, "response");
+	// A public selected model still wins over a public observed model.
+	const withSelected = source();
+	withSelected.responseModelId = "unknown"; withSelected.observedModelId = "glm5.3-flash"; withSelected.provider = "nan";
+	const encodedSelected = JSON.parse(native.encodeNativeRuntimeEvent([withSelected])!);
+	assert.equal(encodedSelected.rows[0].model_evidence, "selected");
+	assert.deepEqual(encodedSelected.rows[0].model, { provider: withSelected.selectedProvider, id: withSelected.selectedModelId });
+	// A non-public observed model still falls through to unknown/unknown.
+	const noEvidence = source();
+	noEvidence.responseModelId = "unknown"; noEvidence.selectedModelId = "unknown"; noEvidence.observedModelId = "private-alias";
+	const encodedUnknown = JSON.parse(native.encodeNativeRuntimeEvent([noEvidence])!);
+	assert.deepEqual(encodedUnknown.rows[0].model, { provider: "unknown", id: "unknown" });
+	assert.equal(encodedUnknown.rows[0].model_evidence, "unknown");
+});
+
+test("every encoded model satisfies the schema's anyOf, by pattern or by sentinel", () => {
+	const idRule = schema.$defs.model.anyOf[0].properties.id as { pattern: string };
+	const providerRule = schema.$defs.model.anyOf[0].properties.provider as { pattern: string };
+	const idPattern = new RegExp(idRule.pattern);
+	const providerPattern = new RegExp(providerRule.pattern);
+	const sentinels = schema.$defs.model.anyOf.slice(1) as Array<{ properties: { provider: { const: string }; id: { const: string } } }>;
+	function matchesSchema(model: { provider: string; id: string }): boolean {
+		if (providerPattern.test(model.provider) && idPattern.test(model.id)) return true;
+		return sentinels.some(({ properties }) => properties.provider.const === model.provider && properties.id.const === model.id);
+	}
+	// Response/selected/observed rows only ever win evidence with an id that is
+	// already public, so their encoded model is either the public-pattern
+	// branch or the terminal unknown/unknown sentinel. The custom/custom and
+	// opencode/custom sentinels are reachable only through a launch row, which
+	// (already upstream-classified, always "selected" evidence) is paired
+	// through the same normalizer unconditionally.
+	const rows: RuntimeMetricBucket[] = [
+		source(),
+		{ ...source(), provider: "nan", selectedProvider: "nan", selectedModelId: "deepseek-v4-flash", responseModelId: "unknown" },
+		{ ...source(), responseModelId: "unknown", selectedModelId: "unknown", observedModelId: "unknown" },
+	];
+	const launches = [
+		{ evidence: "launch_configuration" as const, agentClass: parseAgentClass("worker")!, selectedProvider: "opencode", selectedModelId: "custom", selectedEffort: "high" as const, launches: 1 },
+		{ evidence: "launch_configuration" as const, agentClass: parseAgentClass("worker")!, selectedProvider: "custom", selectedModelId: "custom", selectedEffort: "high" as const, launches: 1 },
+		{ evidence: "launch_configuration" as const, agentClass: parseAgentClass("worker")!, selectedProvider: "unknown", selectedModelId: "unknown", selectedEffort: "high" as const, launches: 1 },
+	];
+	const payload = native.encodeNativeRuntimeEvent(rows, launches);
+	assert.ok(payload);
+	const decoded = JSON.parse(payload).rows as Array<{ model: { provider: string; id: string } }>;
+	assert.equal(decoded.length, rows.length + launches.length);
+	for (const row of decoded) assert.ok(matchesSchema(row.model), `model ${JSON.stringify(row.model)} must satisfy $defs.model.anyOf`);
+	assert.deepEqual(decoded.map(row => row.model), [
+		{ provider: "openai", id: "gpt-5.4" }, { provider: "nan", id: "deepseek-v4-flash" }, { provider: "unknown", id: "unknown" },
+		{ provider: "opencode", id: "custom" }, { provider: "custom", id: "custom" }, { provider: "unknown", id: "unknown" },
+	]);
 });
 
 function fixture() {