gentle-pi 3.7.0 → 4.0.0

package/tests/packed-runner-owned-path.test.ts

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { resolveInstalledJitiStaticEntry } from "../scripts/test-packed-runner.mjs";
+
+function withAliasedConsumer(run: (consumer: string, sdkManifest: string, jitiRoot: string) => void): void {
+	const disposable = mkdtempSync(join(tmpdir(), "packed-owned-path-"));
+	try {
+		const actual = join(disposable, "actual");
+		const consumer = join(disposable, "alias", "consumer");
+		const actualConsumer = join(actual, "consumer");
+		const sdkRoot = join(actualConsumer, "node_modules", "@earendil-works", "pi-coding-agent");
+		const jitiRoot = join(actualConsumer, "node_modules", "jiti");
+		mkdirSync(sdkRoot, { recursive: true });
+		mkdirSync(join(jitiRoot, "dist"), { recursive: true });
+		symlinkSync(actual, join(disposable, "alias"), "dir");
+		writeFileSync(join(sdkRoot, "package.json"), JSON.stringify({ name: "@earendil-works/pi-coding-agent", version: "0.87.1", dependencies: { jiti: "2.7.0" } }));
+		writeFileSync(join(jitiRoot, "package.json"), JSON.stringify({ name: "jiti", version: "2.7.0", exports: { "./static": { types: "./dist/jiti.d.ts", import: "./dist/jiti.mjs" }, "./package.json": "./package.json" } }));
+		run(consumer, join(consumer, "node_modules", "@earendil-works", "pi-coding-agent", "package.json"), jitiRoot);
+	} finally {
+		rmSync(disposable, { recursive: true, force: true });
+	}
+}
+
+const checks = { sdkManifest: "sdk-manifest", sdkVersion: "sdk-version", jitiManifest: "jiti-manifest-owned", jitiStaticExport: "jiti-static-export", jitiEntry: "jiti-entry-owned", jitiVersion: "jiti-version" };
+
+test("accepts a canonical Jiti manifest beneath an aliased ancestor", () => {
+	withAliasedConsumer((consumer, sdkManifest, jitiRoot) => {
+		writeFileSync(join(jitiRoot, "dist", "jiti.mjs"), "export const createJiti = () => {};\n");
+		const seen: string[] = [];
+		const entry = resolveInstalledJitiStaticEntry(consumer, sdkManifest, "0.87.1", (check: string) => seen.push(check), checks);
+		assert.equal(entry, join(consumer, "node_modules", "jiti", "dist", "jiti.mjs"));
+		assert.equal(realpathSync.native(entry), join(realpathSync.native(jitiRoot), "dist", "jiti.mjs"));
+		assert.ok(seen.includes("jiti-manifest-owned"));
+	});
+});
+
+test("rejects a symlink within the owned Jiti static entry", () => {
+	withAliasedConsumer((consumer, sdkManifest, jitiRoot) => {
+		writeFileSync(join(jitiRoot, "dist", "real.mjs"), "export const createJiti = () => {};\n");
+		symlinkSync("real.mjs", join(jitiRoot, "dist", "jiti.mjs"));
+		assert.throws(() => resolveInstalledJitiStaticEntry(consumer, sdkManifest, "0.87.1", () => {}, checks), /refusing symbolic link in owned package/);
+	});
+});

package/tests/persona-single-channel.test.ts

@@ -262,7 +262,7 @@ test("Table A rule: wrapper :180/:181 + orchestrator :9,:12 self-description MER
 		);
 		assert.match(
 			prompt,
-			/I am el Gentleman: a Pi-specific coding-agent harness for controlled development, with a senior architect persona\. I run Organic Driven Development by default and SDD\/OpenSpec when explicitly selected, coordinate subagents, use phase artifacts, run commands, and edit files\. I am not a generic chatbot\./,
+			/I am el Gentleman: a Pi-specific coding-agent harness for controlled development, with a senior architect persona\. I run Organic Driven Development, coordinate subagents, track substantial work, run commands, and edit files\. I am not a generic chatbot\./,
 			`[${persona}] the richer translated self-description paragraph (orchestrator :9,:12) must survive in the wrapper`,
 		);
 	}
@@ -290,12 +290,12 @@ test("Table A rule: persona-mode selection (trimmed) survives; language clause N
 	}
 });
 
-test("Table A rule: SDD/OpenSpec artifacts + subagents core-capabilities bullet survives (KEEP once)", () => {
+test("Table A rule: ODD and subagents core-capabilities bullet survives (KEEP once)", () => {
 	for (const persona of ["gentleman", "neutral"] as const) {
 		const prompt = __testing.buildGentlePrompt(persona);
 		assert.match(
 			prompt,
-			/Mention ODD as the default workflow, SDD\/OpenSpec phase artifacts, and subagents as core capabilities\./,
+			/Mention ODD as the development workflow and subagents as a core capability\./,
 			`[${persona}] wrapper :182 rule must survive`,
 		);
 	}
@@ -385,10 +385,10 @@ test("Table B rule: LB5 exceptions kept verbatim in orchestrator (unique)", () =
 			/Ask a subagent to produce Spanish only when its output is intended to be pasted directly to the user/,
 			`[${persona}] LB5 exceptions bullet 2 must remain verbatim`,
 		);
-		assert.match(
+		assert.doesNotMatch(
 			prompt,
 			/SDD\/OpenSpec artifact content may follow the project's established language/,
-			`[${persona}] LB5 exceptions bullet 3 must remain verbatim`,
+			`[${persona}] retired artifact exception must be absent`,
 		);
 	}
 });
@@ -439,7 +439,7 @@ test("dup guard (exact-string): 'Do not claim portability outside the Pi runtime
 
 test("dup guard (exact-string): identity self-description sentence occurs exactly once", () => {
 	const selfDescription =
-		"I am el Gentleman: a Pi-specific coding-agent harness for controlled development, with a senior architect persona. I run Organic Driven Development by default and SDD/OpenSpec when explicitly selected, coordinate subagents, use phase artifacts, run commands, and edit files. I am not a generic chatbot.";
+		"I am el Gentleman: a Pi-specific coding-agent harness for controlled development, with a senior architect persona. I run Organic Driven Development, coordinate subagents, track substantial work, run commands, and edit files. I am not a generic chatbot.";
 	for (const persona of ["gentleman", "neutral"] as const) {
 		const prompt = __testing.buildGentlePrompt(persona);
 		assert.equal(

package/tests/provider-defect-handoff.test.ts

@@ -17,10 +17,7 @@ import test from "node:test";
 
 const REPO_ROOT = join(import.meta.dirname, "..");
 const DELEGATION_PATH = join(REPO_ROOT, "assets", "orchestrator-delegation.md");
-const SDD_WORKFLOW_PATH = join(REPO_ROOT, "assets", "sdd-orchestrator-workflow.md");
-
 const DELEGATION = readFileSync(DELEGATION_PATH, "utf8");
-const SDD_WORKFLOW = readFileSync(SDD_WORKFLOW_PATH, "utf8");
 
 const CHOICE_TOKENS = ["report_and_continue", "continue_without_reporting", "stop_here"] as const;
 
@@ -230,17 +227,12 @@ test("orchestrator-delegation.md does NOT reference the rc.3 canon", () => {
 });
 
 // ---------------------------------------------------------------------------
-// 3 — SDD points to the single complete handoff contract
+// 3 — The retained delegation contract owns the complete handoff
 // ---------------------------------------------------------------------------
 
-test("sdd-orchestrator-workflow.md points provider defects to the complete delegation contract", () => {
-	assert.match(SDD_WORKFLOW, /## Provider Defect Handoff/);
-	assert.match(
-		SDD_WORKFLOW,
-		/The full contract lives in `assets\/orchestrator-delegation\.md` under `#### Gentle AI Provider Defect Handoff \(MANDATORY\)`/i,
-	);
+test("retained delegation owns the complete provider defect handoff", () => {
 	assert.match(DELEGATION, /^#### Gentle AI Provider Defect Handoff \(MANDATORY\)$/m);
-	assert.doesNotMatch(SDD_WORKFLOW, /`report_and_continue`|`continue_without_reporting`|`stop_here`/);
+	assert.match(DELEGATION, /Both continue choices execute that exact captured decline invocation exactly once/);
 });
 
 test("the complete delegation handoff invokes `gentle-ai review mode disable` exactly once", () => {

package/tests/quiet-bash-runtime.test.ts

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+async function proveNativeBash() {
+	const { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices,
+		ModelRuntime, SessionManager, SettingsManager } = await import("@earendil-works/pi-coding-agent");
+	const cwd = process.cwd();
+	const agentDir = process.env.PI_CODING_AGENT_DIR!;
+	const shellPath = process.env.GENTLE_TEST_SHELL!;
+	// Hide Windows default discovery only inside this isolated child. The explicit
+	// shell remains usable; on POSIX the prefix also detects a recreated executor.
+	for (const key of Object.keys(process.env)) if (key.toLowerCase() === "path") process.env[key] = "";
+	process.env.ProgramFiles = join(cwd, "absent-git");
+	process.env["ProgramFiles(x86)"] = join(cwd, "absent-git-x86");
+	const modelRuntime = await ModelRuntime.create({ authPath: join(agentDir, "empty-auth.json"),
+		modelsPath: null, modelsStorePath: join(agentDir, "models-store.json"), allowModelNetwork: false });
+	for (const quiet of [false, true]) {
+		const runtime = await createAgentSessionRuntime(async ({ cwd, sessionManager, sessionStartEvent }) => {
+			const services = await createAgentSessionServices({ cwd, agentDir, modelRuntime,
+				settingsManager: SettingsManager.inMemory({ shellPath, shellCommandPrefix: "printf configured-prefix;",
+					retry: { enabled: false }, compaction: { enabled: false } }),
+				resourceLoaderOptions: { noExtensions: true, noSkills: true, noPromptTemplates: true,
+					noThemes: true, noContextFiles: true,
+					additionalExtensionPaths: quiet ? [fileURLToPath(new URL("../extensions/quiet-tools.ts", import.meta.url))] : [] },
+			});
+			assert.deepEqual(services.resourceLoader.getExtensions().errors, []);
+			return { ...(await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent, tools: ["bash"] })),
+				services, diagnostics: services.diagnostics };
+		}, { cwd, agentDir, sessionManager: SessionManager.inMemory(cwd) });
+		try {
+			await runtime.session.bindExtensions({ mode: "print" });
+			const bash = runtime.session.agent.state.tools.find(tool => tool.name === "bash");
+			assert.ok(bash);
+			const result = await bash.execute("configured-shell", { command: "printf native-ok" }, new AbortController().signal);
+			assert.equal(result.content.filter(part => part.type === "text").map(part => part.text).join("\n"),
+				"configured-prefixnative-ok", `quiet=${quiet}: native effective shell settings must survive`);
+			assert.equal(runtime.session.messages.length, 0);
+			console.log(`native Bash configured settings: quiet=${quiet} passed`);
+		} finally { await runtime.dispose(); }
+	}
+}
+
+if (process.env.GENTLE_TEST_BASH_CHILD === "1") {
+	await proveNativeBash();
+} else {
+	test("quiet tools preserve actual SDK configured Bash execution (#107)", (t) => {
+		const candidates = process.platform === "win32"
+			? [join(process.env.ProgramFiles ?? "C:\\Program Files", "Git", "bin", "bash.exe"), "C:\\Program Files\\Git\\usr\\bin\\bash.exe"]
+			: ["/bin/bash", "/usr/bin/bash"];
+		const shell = candidates.find(existsSync);
+		if (!shell) { t.skip("requires an installed Bash; no binary installation is performed"); return; }
+		const root = mkdtempSync(join(tmpdir(), "gentle-quiet-bash-sdk-"));
+		const cwd = join(root, "project");
+		const home = join(root, "home");
+		const agentDir = join(home, "agent");
+		for (const path of [cwd, agentDir]) mkdirSync(path, { recursive: true });
+		const env = { ...process.env, HOME: home, USERPROFILE: home, XDG_CONFIG_HOME: join(home, "config"),
+			PI_CODING_AGENT_DIR: agentDir, GENTLE_PI_AGENT_HOME: agentDir, GENTLE_PI_CONFIG_HOME: join(home, "gentle-config"),
+			PI_OFFLINE: "1", GENTLE_PI_QUIET_TOOLS: "1", GENTLE_TEST_BASH_CHILD: "1", GENTLE_TEST_SHELL: shell };
+		try {
+			const result = spawnSync(process.execPath, ["--experimental-strip-types", fileURLToPath(import.meta.url)],
+				{ cwd, env, encoding: "utf8", timeout: 30_000 });
+			assert.ifError(result.error);
+			assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}\nfixture: ${root}`);
+			assert.match(result.stdout, /quiet=false passed/);
+			assert.match(result.stdout, /quiet=true passed/);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+}