gentle-pi 4.2.0 → 4.4.0

package/tests/agent-risk-escalation.test.ts

@@ -5,15 +5,17 @@ import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 import { NATIVE_REVIEW_MODE_SOURCE, type NativeReviewCli } from "../lib/native-review-cli.ts";
 import {
 	decodeAgentRiskEscalation,
-	escalatedRisk,
 	HIGH_RISK_ITEMS,
 	REVIEW_ASSESSMENT_SCHEMA,
 	VERIFICATION_TIER,
+	verificationRisk,
 } from "../lib/review-risk-assessment.ts";
 
 // gentle-shell#1494 S6: the agent may raise a candidate's risk to high by
 // citing one item of the shared high-risk list, never lower it. The raise
-// travels inside the existing assess call; no new operation.
+// travels inside the existing assess call; no new operation. Verification by
+// named risk: that escalation is now the only way to get the independent
+// verifier; a native high or unassessable tier informs only.
 
 test("the high-risk list has exactly the six items of the always-on Task Size section", () => {
 	assert.deepEqual(Object.keys(HIGH_RISK_ITEMS).map(Number), [1, 2, 3, 4, 5, 6]);
@@ -45,23 +47,25 @@ test("decodeAgentRiskEscalation rejects unknown items, empty or oversized reason
 	}
 });
 
-test("escalatedRisk raises passive and medium to high and never lowers", () => {
+// Replaces the escalatedRisk test: the plan risk is high only with an
+// escalation; without one a native high or unassessable tier becomes medium.
+test("verificationRisk makes every escalated tier high and maps the rest to passive or medium", () => {
 	const escalation = { item: 3 as const, reason: "changes a published export" };
-	assert.equal(escalatedRisk(VERIFICATION_TIER.PASSIVE, escalation), VERIFICATION_TIER.HIGH);
-	assert.equal(escalatedRisk(VERIFICATION_TIER.MEDIUM, escalation), VERIFICATION_TIER.HIGH);
-	assert.equal(escalatedRisk(VERIFICATION_TIER.HIGH, escalation), VERIFICATION_TIER.HIGH);
-	assert.equal(escalatedRisk(VERIFICATION_TIER.UNASSESSABLE, escalation), VERIFICATION_TIER.UNASSESSABLE);
-	for (const tier of Object.values(VERIFICATION_TIER)) assert.equal(escalatedRisk(tier, undefined), tier);
+	for (const tier of Object.values(VERIFICATION_TIER)) assert.equal(verificationRisk(tier, escalation), VERIFICATION_TIER.HIGH, tier);
+	assert.equal(verificationRisk(VERIFICATION_TIER.PASSIVE, undefined), VERIFICATION_TIER.PASSIVE);
+	for (const tier of [VERIFICATION_TIER.MEDIUM, VERIFICATION_TIER.HIGH, VERIFICATION_TIER.UNASSESSABLE]) {
+		assert.equal(verificationRisk(tier, undefined), VERIFICATION_TIER.MEDIUM, tier);
+	}
 });
 
-function assessTool(): { execute: (id: string, params: Record<string, unknown>, signal: AbortSignal | undefined, onUpdate: undefined, ctx: ExtensionContext) => Promise<{ details: unknown }> } {
+function assessTool(nativeRisk: "passive" | "medium" | "high" = "medium"): { execute: (id: string, params: Record<string, unknown>, signal: AbortSignal | undefined, onUpdate: undefined, ctx: ExtensionContext) => Promise<{ details: unknown }> } {
 	const tools = new Map<string, any>();
 	const pi = { on() {}, registerCommand() {}, registerTool(tool: { name: string }) { tools.set(tool.name, tool); } } as unknown as ExtensionAPI;
 	const nativeReviewCli: Partial<NativeReviewCli> = {
 		reviewMode: async () => ({ operation: "status", scope: "clone", status: { global: "off", cloneLocal: "off", effective: "off", source: NATIVE_REVIEW_MODE_SOURCE.GLOBAL } }),
 		assess: async () => ({
 			schema: REVIEW_ASSESSMENT_SCHEMA,
-			risk: "medium",
+			risk: nativeRisk,
 			reasons: [],
 			changedPaths: 1,
 			changedLines: 3,
@@ -121,3 +125,26 @@ test("gentle_review assess: agentEscalation says whether the escalation changed
 	const { details } = await tool.execute("esc-5", { operation: "assess", input }, undefined, undefined, ctx);
 	assert.equal((details as { agentEscalation: { applied: boolean } }).agentEscalation.applied, true, "medium raised to high is applied");
 });
+
+test("gentle_review assess: a native high without an escalation informs only and adds no verifier", async () => {
+	const tool = assessTool("high");
+	for (const writer of [{ writerModelId: "openai/gpt-6.1-sol", writerEffort: "high" }, { writerModelId: "openai/gpt-5-mini", writerEffort: "low" }]) {
+		const { details } = await tool.execute("esc-6", { operation: "assess", input: JSON.stringify(writer) }, undefined, undefined, ctx);
+		const plan = details as { risk: string; nativeRisk: string; plan: { independentVerifier: boolean; writerSelfVerification: boolean } };
+		assert.equal(plan.nativeRisk, VERIFICATION_TIER.HIGH);
+		assert.equal(plan.risk, VERIFICATION_TIER.MEDIUM, writer.writerModelId);
+		assert.equal(plan.plan.writerSelfVerification, true);
+		assert.equal(plan.plan.independentVerifier, false, `${writer.writerModelId}: neither a native high nor the writer's model adds a verifier`);
+	}
+});
+
+test("gentle_review assess: an escalation over a native high is what adds the verifier", async () => {
+	const tool = assessTool("high");
+	const input = JSON.stringify({ escalate: { item: 1, reason: "rewrites stored records" } });
+	const { details } = await tool.execute("esc-7", { operation: "assess", input }, undefined, undefined, ctx);
+	const plan = details as { risk: string; nativeRisk: string; agentEscalation: { applied: boolean }; plan: { independentVerifier: boolean } };
+	assert.equal(plan.nativeRisk, VERIFICATION_TIER.HIGH);
+	assert.equal(plan.risk, VERIFICATION_TIER.HIGH);
+	assert.equal(plan.agentEscalation.applied, true, "without the escalation the plan would be medium");
+	assert.equal(plan.plan.independentVerifier, true);
+});

package/tests/agents-config.test.ts

@@ -14,6 +14,7 @@ import {
 	parseFrontmatter,
 	parseModelRef,
 	resolveAgentProfile,
+	unmatchedProfileKeys,
 	withPinnedModelProfiles,
 } from "../lib/agents-config.ts";
 import { THINKING_LEVELS } from "../lib/model-routing-authority.ts";
@@ -247,3 +248,63 @@ test("a pinned profile replaces subagent routing and leaves every other default
 	// repository can pin "everything inherits" without touching the global store.
 	assert.deepEqual(withPinnedModelProfiles(global, {}).modelProfiles, {});
 });
+
+// Issue #2196 rework (PR #2233 maintainer decision): role keys that name no
+// discovered agent must be reported, with a did-you-mean suggestion, instead of
+// being silently ignored while the child inherits the orchestrator model.
+test("unmatchedProfileKeys reports profile keys that match no discovered agent", () => {
+	const worker = {
+		name: "gentle-ai-worker",
+		description: "",
+		filePath: "/x/worker.md",
+		scope: "global" as const,
+		instructions: "",
+		model: undefined,
+		thinking: undefined,
+		mode: undefined,
+		tools: [],
+	};
+	const explore = { ...worker, name: "gentle-ai-explore" };
+	const profiles = {
+		worker: { model: { provider: "nan", id: "glm5.3" }, thinking: undefined },
+		WORKER: { model: { provider: "nan", id: "glm5.3" }, thinking: undefined },
+		review_risk: { model: undefined, thinking: "high" as const },
+		explore: { model: undefined, thinking: undefined },
+	};
+	assert.deepEqual(unmatchedProfileKeys(profiles, [worker, explore]), [
+		{ key: "worker", suggestion: "gentle-ai-worker" },
+		{ key: "WORKER", suggestion: "gentle-ai-worker" },
+		{ key: "review_risk", suggestion: undefined },
+		{ key: "explore", suggestion: "gentle-ai-explore" },
+	]);
+	// A key that exactly matches an agent name never reports, and an empty
+	// profile set reports nothing.
+	assert.deepEqual(unmatchedProfileKeys({ "gentle-ai-worker": { model: undefined, thinking: undefined } }, [worker]), []);
+	assert.deepEqual(unmatchedProfileKeys({}, [worker]), []);
+});
+
+// Cortex QA adversarial follow-up (R5 pin): the did-you-mean mapping exists to
+// make a misconfiguration visible, never to resolve; a short key must keep
+// yielding an unresolved profile so the role inherits frontmatter and default
+// routing exactly as before the fix.
+test("resolveAgentProfile never resolves through the suggestion mapping", () => {
+	const worker = {
+		name: "gentle-ai-worker",
+		description: "",
+		filePath: "/x/worker.md",
+		scope: "global" as const,
+		instructions: "",
+		model: { provider: "openai-codex", id: "gpt-5.6-terra" },
+		thinking: undefined,
+		mode: undefined,
+		tools: [],
+	};
+	const config = parseAgentsConfig(
+		{ model_profiles: { worker: { model: "nan/glm5.3", effort: "high" } } },
+		undefined,
+	);
+	const resolved = resolveAgentProfile(worker, config);
+	assert.equal(resolved.model?.provider, "openai-codex", "the short key must not route; the agent frontmatter model wins");
+	assert.equal(resolved.source.model, "definition");
+	assert.ok(unmatchedProfileKeys(config.modelProfiles, [worker]).some((entry) => entry.key === "worker" && entry.suggestion === "gentle-ai-worker"), "the same short key is still reported with its suggestion");
+});

package/tests/agents-fake-child.ts

@@ -17,7 +17,7 @@ export interface FakeChild {
 	message(event: Record<string, unknown>): void;
 }
 
-export function fakeChild(options: { exitOnKill?: boolean; pid?: number } = {}): FakeChild {
+export function fakeChild(options: { exitOnKill?: boolean; exitOnStdinEnd?: boolean; pid?: number } = {}): FakeChild {
 	const emitter = new EventEmitter();
 	const stdin = new PassThrough();
 	const stdout = new PassThrough();
@@ -38,6 +38,13 @@ export function fakeChild(options: { exitOnKill?: boolean; pid?: number } = {}):
 			stdout.write(`${JSON.stringify({ type: "response", id: command.id, command: command.type, success: true, data })}\n`);
 		}
 	});
+	const origEnd = stdin.end.bind(stdin);
+	stdin.end = ((...args: unknown[]) => {
+		const res = (origEnd as Function)(...args);
+		// Preserve existing fixtures while allowing EOF and signal exits to vary independently.
+		if (options.exitOnStdinEnd ?? options.exitOnKill ?? true) queueMicrotask(() => emitter.emit("exit", 0, null));
+		return res;
+	}) as typeof stdin.end;
 	const child: ChildLike = {
 		pid: options.pid,
 		stdin,

package/tests/agents-protocol.test.ts

@@ -10,7 +10,9 @@ import {
 	TASK_STATUS,
 	taskLabel,
 	TaskStore,
+	TERMINAL_RETENTION,
 	THREAD_ITEM,
+	isFinished,
 	type TaskRecord,
 } from "../lib/agents-protocol.ts";
 
@@ -274,6 +276,36 @@ test("TaskStore notifies only the listeners of the task that changed and keeps s
 	assert.deepEqual(store.thread("missing"), emptyThread());
 });
 
+// Finished tasks must release their weight: a bounded window of the most
+// recent ones stays readable, older ones leave the store entirely, and a
+// terminal task's listeners go quiet after the one final transition.
+test("TaskStore keeps a bounded window of finished tasks and silences terminal listeners", () => {
+	const store = new TaskStore();
+	const seen: string[] = [];
+	store.add(record({ id: "watched", status: TASK_STATUS.RUNNING, lastActivityAt: 1 }));
+	store.add(record({ id: "filler", status: TASK_STATUS.RUNNING, lastActivityAt: 2 }));
+	store.subscribe("watched", (task) => seen.push(task.status));
+	// `watched` completes the window once it finishes, so the next terminal
+	// task evicts exactly the oldest one.
+	for (let index = 0; index < TERMINAL_RETENTION - 1; index += 1) {
+		store.add(record({ id: `done-${index}`, status: TASK_STATUS.COMPLETED, lastActivityAt: 10 + index }));
+	}
+	assert.equal(store.list().filter((task) => isFinished(task.status)).length, TERMINAL_RETENTION - 1, "retained finished tasks stay at the cap");
+	assert.ok(store.get("watched") && store.get("filler"), "running tasks are never evicted");
+	store.update("watched", { status: TASK_STATUS.COMPLETED, endedAt: 50 });
+	assert.deepEqual(seen, ["completed"], "the terminal transition itself still notifies exactly once");
+	store.apply("watched", { type: TASK_EVENT.TEXT, text: "late" }, 60);
+	assert.deepEqual(seen, ["completed"], "a terminal task's listener stays quiet afterwards");
+	store.add(record({ id: "newest", status: TASK_STATUS.COMPLETED, lastActivityAt: 1_000 }));
+	assert.equal(store.get("done-0"), undefined, "the oldest finished task is evicted");
+	assert.ok(store.get("done-1") && store.get("newest"), "recent finished tasks remain readable");
+	assert.ok(store.get("filler"), "running tasks survive eviction");
+	assert.equal(store.list().filter((task) => isFinished(task.status)).length, TERMINAL_RETENTION);
+	assert.deepEqual(store.thread("done-0"), emptyThread(), "an evicted task's thread weight is released");
+	assert.ok(store.thread("done-1").limits.maxItems > 0, "a retained finished task stays renderable");
+	assert.equal(store.summary().finished, TERMINAL_RETENTION, "summaries reflect the bounded window");
+});
+
 test("TaskStore.apply moves the task to waiting on ask, back to running on any later event, and counts turns", () => {
 	const store = new TaskStore();
 	store.add(record({ id: "a", status: TASK_STATUS.RUNNING }));