gentle-pi 3.7.0 → 4.0.0

package/tests/native-review-parity-runtime.test.ts

@@ -1,20 +1,21 @@
 import assert from "node:assert/strict";
 import { execFile } from "node:child_process";
-import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, realpath, rm, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import baseTest from "node:test";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 import {
 	GENTLE_AI_DEV_BINARY_ENV,
 	resolveGentleAiBinary,
 	type GentleAiDevBinaryEnvironment,
 } from "../lib/gentle-ai-binary.ts";
-import { NativeReviewCliV216 } from "../lib/native-review-cli.ts";
+import { createNodeExecFileAdapter, NativeReviewCliV216 } from "../lib/native-review-cli.ts";
+import { resolveSessionWorktree } from "../lib/session-worktree-registry.ts";
 import { CandidateViewRegistry } from "../lib/review-candidate-view.ts";
 import { decodeReviewLastEventClosureV1 } from "../lib/review-integration-v2.ts";
 import { decodeReviewLastEventClosureV1 as decodeRuntimeReviewLastEventClosureV1 } from "../runtime/review-integration-v2.mjs";
@@ -129,6 +130,102 @@ async function run(command: string, arguments_: readonly string[], cwd: string,
 	}
 }
 
+test("SDK explicit review delegates enabled-only non-Git preparation to the pinned native binary without START", async (t) => {
+	const previous: Record<string, string | undefined> = {};
+	for (const key of Object.keys(process.env).filter((key) => key.startsWith("GIT_"))) {
+		previous[key] = process.env[key];
+		delete process.env[key];
+	}
+	const home = await reviewEnabledHome(t);
+	for (const [key, value] of Object.entries({
+		GENTLE_PI_AGENT_HOME: join(home, "agent"), PI_CODING_AGENT_DIR: join(home, "agent"),
+		GENTLE_PI_CONFIG_HOME: join(home, "pi-config"), PI_OFFLINE: "1",
+		GENTLE_PI_REVIEW_RELAY_CONTRACT: "invalid-ambient-relay",
+	})) {
+		previous[key] = process.env[key];
+		process.env[key] = value;
+	}
+	t.after(() => {
+		for (const [key, value] of Object.entries(previous)) {
+			if (value === undefined) delete process.env[key]; else process.env[key] = value;
+		}
+	});
+	const version = await run(binary, ["version"], home);
+	t.diagnostic(`native binary=${binary}; version=${version.stdout.trim()}`);
+	const calls: string[][] = [];
+	const agentDir = process.env.GENTLE_PI_AGENT_HOME!;
+	await mkdir(agentDir, { recursive: true });
+	const modelRuntime = await ModelRuntime.create({
+		authPath: join(agentDir, "empty-auth.json"), modelsPath: null,
+		modelsStorePath: join(agentDir, "models-store.json"), allowModelNetwork: false,
+	});
+	const startup = async (cwd: string, enabled = true) => {
+		const before = calls.length;
+		const wasVersioned = resolveSessionWorktree(cwd, cwd) !== undefined;
+		// Production adapter overwrites the poisoned ambient relay declaration.
+		// Fresh native clients also prevent a cached refusal from masking later
+		// parent/broken-metadata scenarios without actually invoking STATUS.
+		const adapter = createNodeExecFileAdapter();
+		const native = new NativeReviewCliV216(async (request) => {
+			calls.push([...request.arguments]);
+			return adapter(request);
+		}, binary);
+		const resourceLoader = new DefaultResourceLoader({
+			cwd, agentDir, noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+			extensionFactories: [createGentleAiExtension({ nativeReviewCli: native, candidateViews: null, processEnv: {} })],
+		});
+		await resourceLoader.reload();
+		assert.deepEqual(resourceLoader.getExtensions().errors, []);
+		const { session } = await createAgentSession({
+			cwd, agentDir, resourceLoader, modelRuntime, sessionManager: SessionManager.inMemory(cwd), noTools: "builtin",
+			settingsManager: SettingsManager.inMemory({ retry: { enabled: false }, compaction: { enabled: false } }),
+		});
+		try {
+			await session.bindExtensions({ mode: "print" });
+			assert.equal(calls.slice(before).some(args => args[0] === "review" && args[1] === "status"), false, "passive non-Git startup cannot prepare");
+			session.setActiveToolsByName(["gentle_review"]);
+			const inspect = session.agent.state.tools.find(tool => tool.name === "gentle_review");
+			assert.ok(inspect, "real SDK registers the facade");
+			await inspect.execute("explicit-review", { operation: "inspect", workspaceRoot: cwd });
+			assert.equal(session.messages.length, 0, "explicit review entry must not begin a model turn");
+		} finally { await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" }); session.dispose(); }
+		const scenarioCalls = calls.slice(before);
+		if (!wasVersioned) assert.ok(scenarioCalls.some((args) => args[0] === "review" && args[1] === "mode"), "every non-Git explicit review invokes native mode");
+		const statuses = scenarioCalls.filter((args) => args[0] === "review" && args[1] === "status");
+		assert.equal(statuses.length > 0, enabled, "every on scenario invokes native STATUS; off cannot");
+		t.diagnostic(`startup cwd=${cwd}; STATUS calls=${statuses.length}`);
+	};
+	const plain = join(home, "enabled-project");
+	await mkdir(plain);
+	await writeFile(join(plain, "candidate.txt"), "candidate bytes\n");
+	await startup(plain);
+	assert.equal(existsSync(join(plain, ".git")), true, "explicit enabled review must reach native bootstrap");
+	assert.equal(await readFile(join(plain, "candidate.txt"), "utf8"), "candidate bytes\n");
+	assert.notEqual((await run("git", ["rev-parse", "--verify", "HEAD"], plain, true)).exitCode, 0, "HEAD remains unborn");
+	assert.equal((await run("git", ["remote"], plain)).stdout, "");
+	assert.equal(existsSync(join(plain, ".git", "gentle-ai", "reviews")), false, "entry does not create review lineage storage");
+	const nested = join(plain, "nested");
+	await mkdir(nested);
+	await startup(nested);
+	assert.equal(existsSync(join(nested, ".git")), false, "containing repository is reused");
+	const broken = join(home, "broken-project");
+	await mkdir(broken);
+	await writeFile(join(broken, ".git"), "gitdir: missing-metadata\n");
+	await startup(broken);
+	assert.equal(await readFile(join(broken, ".git"), "utf8"), "gitdir: missing-metadata\n");
+	const brokenChild = join(broken, "child");
+	await mkdir(brokenChild);
+	await startup(brokenChild);
+	assert.equal(existsSync(join(brokenChild, ".git")), false);
+	await run(binary, ["review", "mode", "disable", "--scope", "global", "--cwd", plain, "--json"], plain);
+	const off = join(home, "off-project");
+	await mkdir(off);
+	await startup(off, false);
+	assert.equal(existsSync(join(off, ".git")), false, "off explicit review leaves the target unversioned");
+	assert.equal(calls.some((args) => args[0] === "review" && args[1] === "start"), false);
+	t.diagnostic(`native SDK startup calls=${JSON.stringify(calls)}`);
+});
+
 test("generated runtime decoder consumes the captured terminal closure directly", async () => {
 	const fixture = JSON.parse(await readFile(join(packageRoot, "tests", "fixtures", "devbinary", "last-event-capture-result-approved.captured.json"), "utf8"));
 	const source = decodeReviewLastEventClosureV1(fixture);

package/tests/odd-integration.test.ts

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import test from "node:test";
+
+const read = (path: string) => readFileSync(new URL(`../${path}`, import.meta.url), "utf8");
+
+test("ODD continuity persists the task file and complete Engram mirror across resume", () => {
+	const memory = read("assets/orchestrator-memory.md");
+	assert.match(memory, /one feature document, not a separate plan file or topic/);
+	assert.match(memory, /odd\/tasks\/<feature-name>\.md/);
+	assert.match(memory, /odd\/<feature-name>\/tasks/);
+	assert.match(memory, /Mirror the full current document and repository-relative file locator/);
+	assert.match(memory, /Read back both writes; they are not atomic/);
+	assert.match(memory, /mirror pending/);
+	assert.match(memory, /On resume, use `mem_context`, then project\/feature-scoped `mem_search`, and `mem_get_observation`/);
+	assert.match(memory, /read the actual task file/);
+});
+
+test("optional research stays output-only and delegates to a general worker", () => {
+	const delegation = read("assets/orchestrator-delegation.md");
+	assert.match(delegation, /Recommend optional research only for a named uncertainty/);
+	assert.match(delegation, /Forward these research instructions to an existing fresh general exploration\/research worker/);
+	assert.match(delegation, /Research remains read-only and requires no new persistence or readiness machinery/);
+	assert.match(delegation, /If tools are unavailable, disclose limitations without inventing access or evidence/);
+});
+
+test("applicability, fallback and honest evidence flow through ODD actors", () => {
+	const wrapper = read("extensions/gentle-ai.ts");
+	const delegation = read("assets/orchestrator-delegation.md");
+	const support = read("assets/support/strict-tdd.md");
+	const worker = read("assets/agents/gentle-ai-worker.md");
+	const verifier = read("assets/agents/gentle-ai-verify.md");
+	assert.match(wrapper, /behavior changes with applicable runnable deterministic tests and a clear expected outcome/);
+	assert.match(delegation, /Test or framework presence alone does not establish applicability/);
+	for (const [actor, text] of [["implementation support", support], ["worker", worker], ["verifier", verifier]] as const) {
+		assert.match(text, /behavior changes with applicable runnable deterministic tests and a clear expected outcome/i, `${actor} must assess behavior-level applicability`);
+		assert.match(text, /passive documentation/i, `${actor} must handle passive docs`);
+		assert.match(text, /unavailable runner/i, `${actor} must handle an unavailable runner`);
+		assert.match(text, /ordinary functional or structural verification/i, `${actor} must verify fallbacks`);
+	}
+	assert.match(support, /no meaningful RED/);
+	assert.match(worker, /RED — add the smallest behavior-level test and capture its intended observed failure/);
+	assert.match(verifier, /execute only exact test, build, or lint commands explicitly authorized by the parent/);
+	assert.match(verifier, /Do not infer RED from a test file existing/);
+});
+
+test("retired SDD routes and assets are absent while ODD entry and generic workers remain", () => {
+	const core = read("assets/orchestrator.md");
+	const delegation = read("assets/orchestrator-delegation.md");
+	assert.match(core, /ODD \(Default Workflow, harness section above\) is mandatory on every request/);
+	assert.match(delegation, /generic writer chain is unavailable/);
+	for (const path of [
+		"assets/agents/gentle-ai-worker.md",
+		"assets/agents/gentle-ai-verify.md",
+		"assets/support/strict-tdd.md",
+	]) assert.equal(existsSync(new URL(`../${path}`, import.meta.url)), true, path);
+	for (const path of [
+		"assets/sdd-orchestrator-workflow.md",
+		"assets/support/sdd-status-contract.md",
+		"assets/agents/sdd-apply.md",
+		"assets/agents/sdd-research.md",
+		"assets/chains/sdd-full.chain.md",
+		"assets/chains/sdd-plan.chain.md",
+		"assets/chains/sdd-verify.chain.md",
+	]) assert.equal(existsSync(new URL(`../${path}`, import.meta.url)), false, path);
+	assert.doesNotMatch(core + delegation + read("extensions/gentle-ai.ts"), /(?:\/sdd-(?:init|explore|status|apply|verify|archive)|sdd-full\.chain|sdd-orchestrator-workflow\.md)/);
+});

package/tests/odd-phase-inference.test.ts

@@ -0,0 +1,213 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { inferOddPhase } from "../lib/odd-phase-inference.ts";
+
+// Deterministic, conservative tool -> ODD phase mapping for the Gentle Shell
+// working label. Unknown tools and ambiguous shell commands never change it.
+
+test("read-only file tools infer exploring", () => {
+	for (const tool of ["read", "grep", "find", "ls", "codegraph"]) {
+		assert.equal(inferOddPhase(tool, { path: "src/index.ts" }), "exploring", tool);
+	}
+});
+
+test("asking the user infers deciding", () => {
+	assert.equal(inferOddPhase("ask_user_choice", {}), "deciding");
+	assert.equal(inferOddPhase("ask_user_question", {}), "deciding");
+});
+
+test("todo and edits to ODD feature documents infer planning", () => {
+	assert.equal(inferOddPhase("todo", { items: [] }), "planning");
+	assert.equal(inferOddPhase("write", { path: "odd/tasks/feature.md" }), "planning");
+	assert.equal(inferOddPhase("edit", { path: "/repo/odd/tasks/feature.md" }), "planning");
+	assert.equal(inferOddPhase("edit", { path: "C:\\repo\\odd\\tasks\\feature.md" }), "planning");
+});
+
+test("edits and writes to other paths infer implementing", () => {
+	assert.equal(inferOddPhase("edit", { path: "lib/odd-phase.ts" }), "implementing");
+	assert.equal(inferOddPhase("write", { path: "tests/new.test.ts" }), "implementing");
+	assert.equal(inferOddPhase("write", {}), "implementing", "a write without a readable path is still a write");
+	assert.equal(inferOddPhase("edit", undefined), "implementing");
+});
+
+test("native review tools infer checking", () => {
+	for (const tool of ["gentle_review", "gentle_review_scope", "gentle_review_capture", "gentle_review_capture_group"]) {
+		assert.equal(inferOddPhase(tool, {}), "checking", tool);
+	}
+});
+
+test("shell test, typecheck, lint, and build commands infer checking", () => {
+	for (const command of [
+		"pnpm test",
+		"npm test",
+		"npm run test -- --watch=false",
+		"node --experimental-strip-types --test tests/odd-phase.test.ts",
+		"npx vitest run",
+		"jest --ci",
+		"go test ./...",
+		"cargo test",
+		"python -m pytest -q",
+		"pytest tests/",
+		"tsc --noEmit",
+		"pnpm typecheck",
+		"node scripts/check-types.mjs",
+		"pnpm lint",
+		"eslint .",
+		"npm run build",
+		"go build ./...",
+		"make",
+		"cd sub && make check",
+	]) {
+		assert.equal(inferOddPhase("bash", { command }), "checking", command);
+	}
+	assert.equal(inferOddPhase("powershell", { command: "npm test" }), "checking");
+});
+
+test("waiting on or reading CI results infers checking", () => {
+	for (const command of [
+		"gh pr checks 1511",
+		"gh pr checks 1511 --repo owner/name --watch --interval 20",
+		"sleep 30; gh pr checks 1511 --watch 2>&1 | tail -10",
+		"gh run watch 123",
+		"gh run view 123 --log-failed",
+		"gh run list --branch main",
+	]) {
+		assert.equal(inferOddPhase("bash", { command }), "checking", command);
+	}
+	for (const command of ["gh pr view 1511", "gh pr diff 1511", "gh issue list"]) {
+		assert.equal(inferOddPhase("bash", { command }), "exploring", command);
+	}
+});
+
+test("read-only shell inspection infers exploring", () => {
+	for (const command of [
+		"git status",
+		"git log --oneline -5",
+		"git diff --stat",
+		"git show HEAD",
+		"git branch -a",
+		"ls -la",
+		"cat package.json",
+		"head -20 README.md",
+		"tail -n 5 log.txt",
+		"grep -rn foo lib",
+		"rg oddPhase",
+		"find . -name '*.ts'",
+		"wc -l lib/odd-phase.ts",
+		"pwd",
+	]) {
+		assert.equal(inferOddPhase("bash", { command }), "exploring", command);
+	}
+});
+
+test("a checking segment wins over an exploring segment in the same command", () => {
+	assert.equal(inferOddPhase("bash", { command: "git status && pnpm test" }), "checking");
+	assert.equal(inferOddPhase("bash", { command: "pnpm test | tail -20" }), "checking");
+});
+
+// Real compound commands an orchestrator ran during one live session: loops,
+// command substitutions, quoted pipes, and stderr redirects are routine, so
+// read-only inspection must still read as exploring.
+test("real compound read-only shell commands infer exploring", () => {
+	for (const command of [
+		`cd /repo && git rev-parse --show-toplevel && ls -d .codegraph 2>/dev/null; git log -1 --oneline; grep -rniI "bridge" --include=*.ts -l . 2>/dev/null | grep -v node_modules | head -30`,
+		`ls ~/work | grep -i -E "shell|pi"; for d in ~/work/a ~/dev/b; do [ -d $d ] && echo "== $d" && cd $d && git log -1 --oneline && grep -rniI "bridge" -l . 2>/dev/null | grep -v node_modules | head -20; done`,
+		`cd ~/w && grep -rniI "bridge" src | grep -v test | head -15; echo ===; cat ~/.config/settings.json 2>/dev/null | head -40; cd ~/repo && git branch -a --contains 6776520be 2>/dev/null | head`,
+		`f=~/.local/bin/tool; ls -la $f; file -h $f; readlink -f $f; head -c 1500 "$(readlink -f $f)" | strings | head -40`,
+		`which -a pi; readlink -f "$(which pi)"; cd ~/work/pi 2>/dev/null && git branch --show-current && git rev-list --left-right --count HEAD...origin/main 2>/dev/null`,
+		`ps -axo pid,command | grep -E "gentle-shell|pi-coding-agent|/pi " | grep -v grep | cut -c1-300; echo ===; cd ~/w && grep -n "isInteractiveMode" -A8 lib/rpc-host.ts | head -30`,
+		`pgrep -P 96445; for p in 96445 $(pgrep -P 96445); do echo "== $p"; ps -o command= -p $p | cut -c1-250; lsof -p $p 2>/dev/null | grep -E "lib/(a|b)" | awk '{print $NF}' | sort -u | head; done`,
+		`d=~/.sessions; for x in $(grep -l "probe" $(find $d -name "*.jsonl" -mmin -120) 2>/dev/null); do echo "== $x"; grep -o '"toolName":"[^"]*"' $x | sort | uniq -c; done`,
+		`cd ~/w && git tag --contains 53d62fbf3 | head; git log -1 --format='%h %ad' --date=short 53d62fbf3; git tag --sort=-creatordate | head -3`,
+		`git -C ~/w remote -v && git worktree list && git stash list && git config --get user.name && gh pr view 1415 && jq .version package.json && sed -n '1,20p' README.md`,
+	]) {
+		assert.equal(inferOddPhase("bash", { command }), "exploring", command);
+	}
+});
+
+test("compound commands that mutate anything leave the label unchanged", () => {
+	for (const command of [
+		"git switch main 2>&1 && git pull --ff-only 2>&1 | tail -3",
+		"sed -i '' 's/a/b/' odd/tasks/f.md && grep -n x odd/tasks/f.md",
+		"ln -s ~/a node_modules && echo linked",
+		`git add f && git commit -q -m "x" && git log --oneline -3`,
+		"cat >> f.md <<'EOF'\nhello\nEOF",
+		"x=$(rm -rf dist); echo $x",
+		`for f in *.ts; do grep -l x "$f" && rm "$f"; done`,
+		"echo hi > out.txt",
+		"sort -o out.txt in.txt",
+		"git tag v1.0",
+		"git branch new-branch",
+		"git remote add origin https://example.com/r.git",
+		"git config user.name someone",
+		"ls $(touch marker)",
+		"grep x f | xargs rm",
+	]) {
+		assert.equal(inferOddPhase("bash", { command }), undefined, command);
+	}
+});
+
+// Inference runs synchronously on tool_execution_start, so a pathological
+// command must never backtrack exponentially and freeze the host.
+test("adversarial assignment runs classify in bounded time", () => {
+	for (const command of ["a=".repeat(26) + '"', "a=".repeat(26) + "\\\"", "a=".repeat(26) + "'"]) {
+		const start = performance.now();
+		assert.equal(inferOddPhase("bash", { command }), undefined, command);
+		assert.ok(performance.now() - start < 50, `${command} took ${performance.now() - start}ms`);
+	}
+});
+
+test("no-op-only commands leave the label unchanged", () => {
+	for (const command of ["sleep 4", "echo ===", "cd /repo && echo done", "true"]) {
+		assert.equal(inferOddPhase("bash", { command }), undefined, command);
+	}
+});
+
+test("ambiguous or mutating shell commands leave the label unchanged", () => {
+	for (const command of [
+		"git commit -m 'feat: x'",
+		"git push",
+		"rm -rf dist",
+		"echo hello",
+		"pnpm install",
+		"curl https://example.com",
+		"ls && rm -rf dist",
+		"",
+	]) {
+		assert.equal(inferOddPhase("bash", { command }), undefined, command);
+	}
+	assert.equal(inferOddPhase("bash", {}), undefined);
+	assert.equal(inferOddPhase("bash", { command: 42 }), undefined);
+	assert.equal(inferOddPhase("bash", undefined), undefined);
+});
+
+test("known delegated agents infer the parent work phase in foreground and background", () => {
+	for (const [agent, phase] of [
+		["gentle-ai-worker", "implementing"],
+		["gentle-ai-verify", "checking"],
+		["gentle-ai-explore", "exploring"],
+	] as const) {
+		for (const mode of ["task", "background"]) {
+			assert.equal(inferOddPhase("subagent_run", { agent, mode, task: "untrusted task prose" }), phase);
+		}
+	}
+});
+
+test("unknown or malformed delegation arguments never infer from task prose", () => {
+	for (const args of [
+		{}, null, "gentle-ai-worker", { agent: 5 }, { agent: "gentle-ai-writer" },
+		{ task: "gentle-ai-verify checking" }, { agent: "gentle-ai-verify-extra" },
+	]) assert.equal(inferOddPhase("subagent_run", args), undefined);
+	for (const tool of ["subagent_start", "subagent_wait", "gentle_odd_phase", "mem_save", "web_fetch", ""]) {
+		assert.equal(inferOddPhase(tool, {}), undefined, tool);
+	}
+});
+
+test("MCP-prefixed tool names are normalized before mapping", () => {
+	assert.equal(inferOddPhase("mcp__custom-tools__read", { path: "a.ts" }), "exploring");
+	assert.equal(inferOddPhase("mcp__custom-tools__edit", { path: "a.ts" }), "implementing");
+	assert.equal(inferOddPhase("mcp__custom-tools__write", { path: "odd/tasks/f.md" }), "planning");
+	assert.equal(inferOddPhase("mcp__custom-tools__bash", { command: "pnpm test" }), "checking");
+	assert.equal(inferOddPhase("mcp__custom-tools__mem_save", {}), undefined);
+	assert.equal(inferOddPhase("mcp__custom-tools__subagent_run", { agent: "gentle-ai-worker" }), "implementing");
+});