gentle-pi 3.1.0 → 3.2.0

package/tests/review-candidate-view.test.ts

@@ -10,6 +10,7 @@ import { join, resolve } from "node:path";
 import test from "node:test";
 import { gzipSync } from "node:zlib";
 import {
+	BASE_REF_ACCEPTED_FORMS,
 	CandidateViewRegistry,
 	CandidateViewError,
 	hasExpectedExecutableBits,
@@ -20,6 +21,7 @@ import {
 	digestChangedPathManifest,
 	injectReviewCandidateView,
 	readCandidateContextManifestPage,
+	resolveCanonicalCandidateBase,
 	type NativeCandidateProjectionDescriptor,
 } from "../lib/review-candidate-view.ts";
 import { assertCandidateOwnerParent, assertTrustedWindowsOwner, prepareCandidateOwnerParent, setWindowsAclAuthorityForTesting, validatePrivateWindowsDacl, validatePrivateWindowsOwner, WindowsDaclValidationError, WindowsOwnerValidationError } from "../lib/review-candidate-view-owner.ts";
@@ -653,6 +655,59 @@ test("explicit base resolution preserves structured for-each-ref output-limit di
 	assert.doesNotMatch(failure.message, /sensitive base-reference output/);
 });
 
+test("resolving an abbreviated commit id as an explicit base ref names the accepted forms", (t) => {
+	const contributorRoot = repository(t);
+	const fullId = git(contributorRoot, "rev-parse", "HEAD");
+	const abbreviated = fullId.slice(0, 7);
+	assert.throws(
+		() => resolveCanonicalCandidateBase(contributorRoot, abbreviated),
+		(error: unknown) => {
+			assert.ok(error instanceof CandidateViewError);
+			assert.equal(error.reason, "base-ref-unresolvable");
+			assert.match(error.message, /accepted forms/);
+			assert.ok(error.message.includes(BASE_REF_ACCEPTED_FORMS));
+			assert.match(error.message, /abbreviated commit ids are not accepted/);
+			return true;
+		},
+	);
+});
+
+test("resolving an ambiguous explicit base ref names the accepted forms", (t) => {
+	const contributorRoot = repository(t);
+	git(contributorRoot, "tag", "dupe");
+	git(contributorRoot, "branch", "dupe");
+	assert.throws(
+		() => resolveCanonicalCandidateBase(contributorRoot, "dupe"),
+		(error: unknown) => {
+			assert.ok(error instanceof CandidateViewError);
+			assert.equal(error.reason, "base-ref-ambiguous");
+			assert.match(error.message, /accepted forms/);
+			assert.ok(error.message.includes(BASE_REF_ACCEPTED_FORMS));
+			return true;
+		},
+	);
+});
+
+test("resolving an explicit base ref that names a tree, not a commit, reports it as unresolvable with the accepted forms instead of a generic git failure", (t) => {
+	const contributorRoot = repository(t);
+	const treeId = "b".repeat(40);
+	const executor: CandidateGitExecutor = (file, arguments_, options) => {
+		if (arguments_.at(-1) === `${treeId}^{commit}`) throw Object.assign(new Error("fatal: not a commit"), { status: 128, stdout: Buffer.from("") });
+		return execFileSync(file, arguments_, options);
+	};
+	let failure: unknown;
+	try {
+		new CandidateViewRegistry(executor).create({ contributorRoot, baseRef: treeId });
+	} catch (error) {
+		failure = error;
+	}
+	assert.ok(failure instanceof CandidateViewError);
+	assert.equal(failure.reason, "base-ref-unresolvable");
+	assert.match(failure.message, /it does not name a commit/);
+	assert.match(failure.message, /accepted forms/);
+	assert.ok(failure.message.includes(BASE_REF_ACCEPTED_FORMS));
+});
+
 test("every synchronous candidate-view Git command receives the explicit 64 MiB output limit", (t) => {
 	const calls: Array<{ arguments: readonly string[]; maxBuffer: number | undefined }> = [];
 	const executor: CandidateGitExecutor = (file, arguments_, options) => {

package/tests/runtime-harness.mjs

@@ -1250,24 +1250,26 @@ async function run() {
 			await inputHook({ text: "vamos con sdd", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
-		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
-		assert.equal(existsSync(join(lazySddCwd, ".pi", "chains", "sdd-full.chain.md")), false);
-		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
-		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-status.md")), true);
-		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), false);
-		assert.equal(existsSync(join(globalAgentHome, "gentle-ai", "support", "sdd-status-contract.md")), true);
-		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
-		assert.equal(ctx.ui.selections.length, 1, "first interactive SDD trigger confirms session suggestions");
-		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: explicit session choice/);
 		assert.deepEqual(
 			await inputHook({ text: "please use sdd for this change", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
-		assert.equal(ctx.ui.selections.length, 1, "natural SDD triggers reuse confirmed session choices");
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "chains", "sdd-full.chain.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), false);
+		assert.equal(ctx.ui.selections.length, 0, "natural-language SDD text has no input-hook side effect");
+
 		assert.deepEqual(
 			await inputHook({ text: "/sdd", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-status.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "gentle-ai", "support", "sdd-status-contract.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
+		assert.equal(ctx.ui.selections.length, 1, "first slash SDD trigger confirms session suggestions");
+		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: explicit session choice/);
 		assert.deepEqual(
 			await inputHook({ text: "/sdd plan", source: "interactive" }, ctx),
 			{ action: "continue" },

package/tests/sdd-managed-runtime-settlement.test.ts

@@ -75,9 +75,9 @@ test("remediation actor preserves separately authorized memory artifact tools",
 
 test("R1 confirms exact canonical paths and commands; data, denial and symlinks grant nothing", async t => {
 	const { confirmRemediationScope, remediationToolAllowed } = await import("../extensions/gentle-agents.ts");
-	const { mkdtempSync, writeFileSync, symlinkSync, rmSync } = await import("node:fs");
+	const { mkdtempSync, realpathSync, writeFileSync, symlinkSync, rmSync } = await import("node:fs");
 	const { tmpdir } = await import("node:os"); const { join } = await import("node:path");
-	const cwd = mkdtempSync(join(tmpdir(), "remediation-scope-")); t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "remediation-scope-"))); t.after(() => rmSync(cwd, { recursive: true, force: true }));
 	const target = join(cwd, "allowed.ts"); writeFileSync(target, "original"); symlinkSync(target, join(cwd, "alias.ts"));
 	const candidate = { ...plan, cwd, editPaths: [target] }, native = { mode: "repo-local", workspaceRoot: cwd, allowedEditRoots: [cwd] };
 	let shown = "", confirmations = 0;

package/tests/sdd-preflight-rpc-input.test.ts

@@ -8,17 +8,12 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 import { isSddPreflightTrigger, sddPreflightDiskPath } from "../lib/sdd-preflight.ts";
 
-// gentle-pi#1001: the natural-language SDD `input` hook called the parent-only
-// preflight resolver for every matching prompt, RPC children included.
-// `ensureSddPreflight` rejects RPC by design, the hook caught that rejection and
-// answered `handled`, and Pi's `AgentSession.prompt()` accepts handled input and
-// returns before `before_agent_start` and the model loop. A delegated child
-// therefore ACKed a prompt it never ran: no agent_start, zero turns, zero tool
-// calls, and a stall that only surfaced as the runner's inactivity timeout.
-//
-// An RPC child consumes the parent-rendered preflight block transported in its
-// task context. It must never originate preflight, and the interceptor must
-// never consume a delegated prompt on its behalf.
+// The `input` hook is syntax-only: slash SDD commands may originate preflight
+// in an interactive parent, while ordinary natural-language text always reaches
+// the model. Natural-language SDD selection belongs to the parent/orchestrator;
+// dispatch and before_agent_start gates enforce preflight at the action boundary.
+// RPC children consume the parent-rendered preflight block transported in task
+// context and never originate preflight.
 
 type InputResult = { action: "continue" | "handled" };
 type InputHandler = (event: { text?: unknown }, ctx: ExtensionContext) => Promise<InputResult>;
@@ -52,13 +47,11 @@ function ctx(overrides: Record<string, unknown>): ExtensionContext {
 	} as unknown as ExtensionContext;
 }
 
-test("the delegated task text reaches the preflight interceptor", () => {
-	// Guards the premise of the tests below: if the classifier stops matching
-	// this text they would pass for the wrong reason.
-	assert.equal(isSddPreflightTrigger(DELEGATED_SDD_TASK), true);
+test("natural-language SDD task text bypasses the input preflight interceptor", () => {
+	assert.equal(isSddPreflightTrigger(DELEGATED_SDD_TASK), false);
 });
 
-test("an RPC child's matching prompt is not consumed by the preflight interceptor", async () => {
+test("an RPC child's natural-language SDD prompt is not consumed by the input hook", async () => {
 	const input = inputHook();
 	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-rpc-input-"));
 	const notifications: string[] = [];
@@ -95,27 +88,34 @@ test("an RPC child's ordinary prompt still continues", async () => {
 	}
 });
 
-test("an interactive parent still resolves preflight for a matching prompt", async () => {
+test("an interactive parent's natural-language SDD request has no input-hook side effect", async () => {
 	const input = inputHook();
-	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-parent-input-"));
+	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-parent-natural-input-"));
+	try {
+		const result = await input(
+			{ text: DELEGATED_SDD_TASK },
+			ctx({ cwd, hasUI: false, sessionManager: { getSessionId: () => "sdd-preflight-natural-parent" } }),
+		);
+		assert.deepEqual(result, { action: "continue" });
+		assert.equal(existsSync(sddPreflightDiskPath(cwd)), false, "text alone must not persist preflight");
+	} finally {
+		await rm(cwd, { recursive: true, force: true });
+	}
+});
+
+test("an interactive parent still resolves preflight for an explicit slash SDD command", async () => {
+	const input = inputHook();
+	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-parent-slash-input-"));
 	const agentHome = await mkdtemp(join(tmpdir(), "gentle-pi-parent-agent-home-"));
 	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
 	process.env.GENTLE_PI_AGENT_HOME = agentHome;
 	try {
 		const result = await input(
-			{ text: DELEGATED_SDD_TASK },
-			ctx({
-				cwd,
-				hasUI: false,
-				sessionManager: { getSessionId: () => "sdd-preflight-interactive-parent" },
-			}),
+			{ text: "/sdd-new feature" },
+			ctx({ cwd, hasUI: false, sessionManager: { getSessionId: () => "sdd-preflight-slash-parent" } }),
 		);
 		assert.deepEqual(result, { action: "continue" });
-		assert.equal(
-			existsSync(sddPreflightDiskPath(cwd)),
-			true,
-			"the parent remains the only actor that resolves and persists preflight",
-		);
+		assert.equal(existsSync(sddPreflightDiskPath(cwd)), true, "slash SDD commands still resolve preflight");
 	} finally {
 		if (previousAgentHome === undefined) delete process.env.GENTLE_PI_AGENT_HOME;
 		else process.env.GENTLE_PI_AGENT_HOME = previousAgentHome;

package/tests/sdd-preflight.test.ts

@@ -507,20 +507,25 @@ test("only a structurally valid parent-rendered preflight block can reach an SDD
 	assert.equal(isParentConfirmedSddPreflightContext("## SDD Session Preflight\ncaller-authored defaults"), false);
 });
 
-test("affirmative natural-language SDD requests trigger preflight without matching a finite phrase list", () => {
+test("natural-language SDD text never triggers input preflight", () => {
+	// Natural-language intent belongs to the parent/orchestrator. The input hook
+	// is syntax-only; execution gates enforce preflight when an SDD action is
+	// actually attempted.
 	for (const text of [
 		"quiero hacer un proyecto con SDD",
 		"I want to build this with SDD",
 		"por favor usemos SDD para este cambio",
-	]) {
-		assert.equal(isSddPreflightTrigger(text), true, text);
-	}
-	for (const text of [
+		"do SDD for this change",
+		"haz SDD para este cambio",
+		"continue the SDD change",
 		"Should we use SDD?",
 		"no quiero usar SDD por ahora",
-		"no necesito usar SDD",
-		"I don't want to use SDD",
 		"I use SDD sometimes",
+		"necesito reportar un bug del preflight de SDD",
+		"I need to report a bug in the SDD preflight",
+		"quiero comparar SDD con ODD",
+		"I want to review the SDD proposal",
+		"necesito una explicación de SDD",
 	]) {
 		assert.equal(isSddPreflightTrigger(text), false, text);
 	}

package/tests/windows-hidden-processes.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { createRequire, syncBuiltinESMExports } from "node:module";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
@@ -102,7 +102,7 @@ async function captureOwnedRoutes(t: TestContext): Promise<{ captures: Capture[]
 	const cp = childProcess();
 	const original = { execFileSync: cp.execFileSync, execFile: cp.execFile, spawnSync: cp.spawnSync };
 	const captures: Capture[] = [];
-	const cwd = mkdtempSync(join(tmpdir(), "gentle-pi-windows-hidden-workspace-"));
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-windows-hidden-workspace-")));
 	t.after(() => rmSync(cwd, { recursive: true, force: true }));
 	mkdirSync(join(cwd, ".git"), { recursive: true });
 	const fakeSync = ((command: string, args: readonly string[], options: Options = {}) => {

package/themes/Gentleman-Cute.json

@@ -40,7 +40,7 @@
     "muted": "muted",
     "dim": "dim",
     "text": "text",
-    "thinkingText": "muted",
+    "thinkingText": "softRose",
     "selectedBg": "selection",
     "scrollbarThumb": "border",
     "searchMatchBg": "deepPink",