gentle-pi 2.6.4 → 3.0.0

package/tests/native-choice-list.test.ts

@@ -85,6 +85,19 @@ test("native choice list presents one hovered wrapped option without changing se
 	assert.doesNotMatch(list.render(56).join("\n"), new RegExp(hoverBackground.replace(/[\[\]]/g, "\\$&")));
 });
 
+test("native choice list refreshes existing item content without changing selection", () => {
+	const items = [
+		{ id: "first", label: "First", description: "Initial detail." },
+		{ id: "second", label: "Second", description: "Second detail." },
+	];
+	const list = new NativeChoiceList(items, theme);
+	list.setSelectedIndex(1);
+	items[1]!.description = "Updated detail.";
+	list.refreshItems();
+	assert.equal(list.getSelectedItem()?.id, "second");
+	assert.match(stripTerminalSequences(list.render(40).join("\n")), /Updated detail\./);
+});
+
 test("native choice list ignores Kitty key releases", () => {
 	const list = new NativeChoiceList(
 		[{ id: "first", label: "First" }, { id: "second", label: "Second" }],

package/tests/native-review-capability-contract.test.ts

@@ -232,11 +232,25 @@ test("2.9.0 repeats 2.8.2 because the negotiated lane Pi consumes is unchanged",
 	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.8.2"] as Record<string, boolean>);
 });
 
+test("2.9.1 repeats 2.9.0 because the negotiated lane Pi consumes is unchanged", () => {
+	// v2.9.1 shipped restoring compatible OpenCode review consent (#4584) and
+	// deriving Claude Code SDD dispatch authority from the session transcript
+	// (#4575, #4551). Diffing contracts/review-integration/v2 and
+	// contracts/review-provider-contract between the v2.9.0 and v2.9.1 tags
+	// in the gentle-ai source tree showed zero byte changes, so this row
+	// repeats 2.9.0. riskEvidence and hint remain dark because neither is
+	// proven to reach Pi's negotiated START path.
+	const contract = NATIVE_CLI_CONTRACTS["2.9.1"] as Record<string, boolean>;
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.9.0"] as Record<string, boolean>);
+});
+
 test("no shipped version key was added beyond the pin bump", () => {
 	// Rows are promises to consumers, so a new key only ever appears in a
 	// dedicated commit alongside a pin bump, never as a side effect. v2.2.4 and
 	// v2.3.0 shipped upstream while Pi stayed on 2.2.3 and were never pinned,
 	// so they get no row: a row asserts ground truth measured against a binary
 	// Pi actually ran, and the table only has to be ascending, not gapless.
-	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0", "2.8.1", "2.8.2", "2.9.0"]);
+	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0", "2.8.1", "2.8.2", "2.9.0", "2.9.1"]);
 });

package/tests/native-review-cli.test.ts

@@ -1023,36 +1023,3 @@ test("all twelve native actions retain their exact tokens without prose routing"
 		assert.equal(decodeNativeSddStatusV2(status, { workspaceRoot: "/repo" }).nextRecommended, nextRecommended);
 	}
 });
-
-
-test("compact SDD bracket transports exact selection and remediation binding", async () => {
-	const revision = `sha256:${"a".repeat(64)}`;
-	const queued = queuedAdapter([{ stdout: JSON.stringify({ state: "proceed", token: revision }) }, { stdout: '{"state":"complete"}' }]);
-	const cli = client(queued.adapter);
-	const request = { workspaceRoot: "/repo", changeName: "fix", requestId: "acquire-one", workUnit: "correction", evidenceGoal: "Observed correction", maxAttempts: 1, maxChangedLines: 300, remediatesEvidenceRevision: revision };
-	assert.deepEqual(await cli.sddAttemptAcquire(request), { state: "proceed", token: revision });
-	assert.deepEqual(queued.calls[0].arguments, ["sdd-attempt", "acquire", "--cwd", "/repo", "--change", "fix", "--request-id", "acquire-one", "--work-unit", "correction", "--evidence-goal", "Observed correction", "--max-attempts", "1", "--max-changed-lines", "300", "--remediates-evidence-revision", revision]);
-	assert.deepEqual(await cli.sddAttemptSettle({ workspaceRoot: "/repo", changeName: "fix", token: revision, requestId: "settle-one", outcome: "interrupted", diagnosis: "Child could not spawn", harnessDisposition: "invalidated", cleanupEvidence: "No process created", processEvidence: "Spawn rejected", remediatesEvidenceRevision: revision }), { state: "complete" });
-	assert.equal(queued.calls[1].arguments.includes("--evidence-revision"), false);
-	assert.equal(queued.calls[1].timeoutMs, undefined);
-});
-
-test("compact SDD refuses malformed result and invalid terminal evidence before execution", async () => {
-	const queued = queuedAdapter([{ stdout: '{"state":"proceed"}' }, { stdout: '{"state":"blocked","reason":"budget"}' }]);
-	const cli = client(queued.adapter);
-	const request = { workspaceRoot: "/repo", changeName: "fix", requestId: "one", workUnit: "correction", evidenceGoal: "Observed correction" };
-	await assert.rejects(cli.sddAttemptAcquire(request), /schema incompatible/);
-	assert.deepEqual(await cli.sddAttemptAcquire(request), { state: "blocked", reason: "budget" });
-	await assert.rejects(cli.sddAttemptSettle({ ...request, token: `sha256:${"a".repeat(64)}`, outcome: "failed", diagnosis: "Test failed", harnessDisposition: "reused", cleanupEvidence: "Process exited", processEvidence: "Exit one" }), /evidence/i);
-	assert.equal(queued.calls.length, 2);
-});
-
-
-test("compact admission accepts native empty CAS and never redirects uncertainty into review", async () => {
-	const queued = queuedAdapter([{ stdout: '{"state":"blocked","reason":"budget"}' }, { stdout: "", timedOut: true }]);
-	const cli = client(queued.adapter);
-	const request = { workspaceRoot: "/repo", changeName: "fix", requestId: "one", workUnit: "fix", evidenceGoal: "Observed correction", expectedRevision: "" };
-	await cli.sddAttemptAcquire(request);
-	assert.equal(queued.calls[0].arguments[queued.calls[0].arguments.indexOf("--expected-revision") + 1], "");
-	await assert.rejects(cli.sddAttemptAcquire({ ...request, expectedRevision: undefined }), error => error instanceof NativeReviewCliError && error.mutationOutcome === "unknown" && error.nextAction === undefined);
-});

package/tests/odd-routing-contract.test.ts

@@ -0,0 +1,208 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { __testing } from "../extensions/gentle-ai.ts";
+
+// These are instruction-delivery contracts, not proof of autonomous model adherence.
+const read = (path: string) => readFileSync(join(import.meta.dirname, "..", path), "utf8");
+const core = read("assets/orchestrator.md");
+const delegation = read("assets/orchestrator-delegation.md");
+const memory = read("assets/orchestrator-memory.md");
+const wrapper = read("extensions/gentle-ai.ts");
+
+function containsAll(text: string, clauses: readonly string[]): void {
+	for (const clause of clauses) assert.ok(text.includes(clause), `missing contract: ${clause}`);
+}
+
+test("organic entry stays read-only without authorization and loads detail before work", () => {
+	containsAll(core, [
+		"Substantial authorized work: use ODD",
+		"ODD (Default Workflow, harness section above) is mandatory on every request",
+		"orchestrator-delegation.md",
+		"orchestrator-memory.md",
+	]);
+	containsAll(delegation, [
+		"Investigation, explanation, review, comparison, and proposal-only requests remain read-only",
+		"without a task or storage permission prompt",
+		"Small, understood work creates no durable task artifacts",
+	]);
+	assert.doesNotMatch(core + wrapper, /Prefer SDD\/OpenSpec artifacts|Substantial feature: suggest SDD organically/);
+	assert.doesNotMatch(core + delegation, /Suggest it when proposal\/spec\/design\/tasks|propose SDD only when durable proposal\/spec\/design\/tasks/);
+});
+
+test("research uses adaptive evidence gathering and existing general workers only", () => {
+	containsAll(delegation, [
+		"problem, intended outcome, constraints, and current evidence",
+		"no fixed questionnaire or mandatory rounds",
+		"one focused user question",
+		"stop and wait",
+		"workers return gaps to the parent",
+		"available authorized documentation/web tools",
+		"prefer primary sources",
+		"URLs or code locations",
+		"verified facts, assumptions, contradictions, freshness, and gaps",
+		"recommendation, tradeoffs, open questions, and implementation implications",
+		"Forward these research instructions",
+		"existing fresh general exploration/research worker",
+		"do not create a specialized agent or invoke `sdd-research`",
+		"no new persistence or readiness machinery",
+	]);
+});
+
+test("task sizing is explicitly advisory and forwarded without cosmetic savings", () => {
+	containsAll(delegation, [
+		"about 400 authored changed lines",
+		"additions plus deletions",
+		"not a task acceptance criterion, hard cap, counter-trigger, automatic stop, forced split, or RDD trigger",
+		"Forward this same advisory-only instruction",
+		"Never delete spaces, blank lines, or comments",
+		"never omit tests, minify, add gratuitous abstractions, or split artificially",
+		"Existing PR size gates remain unchanged",
+	]);
+});
+
+test("organic progress preserves both complete feature copies and reconciles actual evidence", () => {
+	containsAll(memory, [
+		"odd/tasks/<feature-name>.md",
+		"odd/<feature-name>/tasks",
+		"stable task IDs",
+		"full current document",
+		"repository-relative file locator",
+		"preserve valid completed and unrelated work",
+		"reopen invalidated items",
+		"Check off only observed outcomes",
+		"Read back both writes",
+		"not atomic",
+		"mirror pending",
+		"Preserve both versions",
+		"mem_context",
+		"mem_search",
+		"mem_get_observation",
+		"read the actual task file",
+		"not a third authority",
+	]);
+});
+
+test("assumption challenge and task checks do not activate or duplicate native review", () => {
+	containsAll(delegation, [
+		"at most one scoped independent read-only assumption challenge",
+		"high-consequence unproven premise",
+		"Deterministic failures need fixes",
+		"native RDD refuter",
+		"functional checks per task, not an RDD cycle per TODO",
+		"deliverable candidate boundary",
+		"native candidate risk assessment",
+		"gentle_review` with `{\"operation\":\"assess\"}",
+		"Passive/low",
+		"no reviewer or consent ceremony",
+		"only on grant",
+		"decline continues under ordinary policy",
+		"never infer low risk from a failed assessment",
+		"When RDD is disabled, do not start or prompt for RDD",
+	]);
+});
+
+test("user documentation shows recovery and candidate-level consent without claiming model proof", () => {
+	const docs = read("docs/readme-reference.md");
+	containsAll(docs, [
+		"## Organic Driven Development",
+		"```mermaid",
+		"Full feature memory and actual task file",
+		"Native candidate risk",
+		"advisory",
+		"Static prompt tests",
+		"autonomous",
+	]);
+	assert.ok(read("README.md").includes("#organic-driven-development"));
+});
+
+
+test("one feature document carries intent, accepted rationale and worker context", () => {
+	containsAll(memory, [
+		"one feature document, not a separate plan file or topic",
+		"objective, problem, why, scope, constraints",
+		"progress, verification evidence, and next step",
+		"concise rationale for meaningful accepted changes",
+		"Routine corrections stay with their tasks; no exhaustive decision journal",
+		"Accepted user, review, or verification changes",
+		"automatically update affected intent and TODOs",
+		"add genuinely new tasks or reopen invalidated items with a reason",
+		"Findings alone never authorize scope expansion or automatic acceptance",
+		"Before implementation or resume, the parent reads both the actual file and full observation",
+		"passes the locator and relevant context; workers read the document before edits",
+	]);
+	containsAll(read("assets/agents/gentle-ai-worker.md"), [
+		"Read the parent's ODD feature document locator before edits",
+		"Preserve valid completed work; return proposed intent/task changes and their reasons",
+	]);
+});
+
+test("ODD forwards configured TDD without equating test presence with enablement", () => {
+	containsAll(delegation, [
+		"Resolve effective TDD on/off from existing project/session configuration or explicit user choice",
+		"retain its source and exact test runner",
+		"Record resolved mode, source, and runner in the feature document when present",
+		"Tests or frameworks being present does not enable TDD",
+		"Forward mode, source, and runner on every implementation delegation; refresh on resume",
+		"When enabled, require observed RED before implementation, GREEN, then REFACTOR",
+		"When disabled, run ordinary functional checks, not no checks",
+		"If mode is unknown/conflicting or the runner is missing",
+		"resolve only the ambiguity affecting the next action",
+		"never invent precedence or a command, and never invoke sdd-init to determine ODD TDD",
+	]);
+	containsAll(read("assets/agents/gentle-ai-worker.md"), [
+		"Consume the parent's effective TDD mode, configuration/choice source, and exact runner",
+		"Missing or conflicting mode/source/runner is not disabled TDD",
+	]);
+	assert.doesNotMatch(wrapper, /If tests exist, use strict TDD/);
+});
+
+test("ODD protocol is always-on in the rendered system prompt and runs by default", () => {
+	const orderedClauses = [
+		"Default workflow: Organic Driven Development (MANDATORY)",
+		"predefined workflow of this orchestrator",
+		"SDD is a branch inside ODD",
+		"Never describe this workflow only when asked about it: run it.",
+		"1. **Authorize.**",
+		"2. **Explore.**",
+		"3. **Resolve uncertainty.**",
+		"4. **Classify.**",
+		"two or more meaningful implementation steps",
+		"5. **Track before the first write.**",
+		"Tell the user in one line which feature document was created and how many tasks it holds",
+		"6. **Implement task by task.**",
+		"7. **Close.**",
+		"Harness principles:",
+		"# el Gentleman Orchestrator",
+	];
+	for (const persona of ["gentleman", "neutral"] as const) {
+		const prompt = __testing.buildGentlePrompt(persona);
+		let cursor = -1;
+		for (const clause of orderedClauses) {
+			const index = prompt.indexOf(clause);
+			assert.ok(index !== -1, `[${persona}] missing contract: ${clause}`);
+			assert.ok(
+				index > cursor,
+				`[${persona}] clause out of order (must appear after the previous one): ${clause}`,
+			);
+			cursor = index;
+		}
+	}
+
+	assert.ok(
+		wrapper.includes("Organic Driven Development (ODD) is the predefined workflow for every request"),
+		"missing contract: extensions/gentle-ai.ts harness principle",
+	);
+	assert.ok(
+		wrapper.includes(
+			"I run Organic Driven Development by default and SDD/OpenSpec when explicitly selected",
+		),
+		"missing contract: extensions/gentle-ai.ts identity sentence",
+	);
+	assert.ok(
+		core.includes("ODD (Default Workflow, harness section above) is mandatory on every request"),
+		"missing contract: assets/orchestrator.md pointer sentence",
+	);
+	containsAll(core, ["orchestrator-delegation.md", "orchestrator-memory.md"]);
+});

package/tests/orchestrator-budget.test.ts

@@ -281,8 +281,8 @@ function isNormativeLine(line: string): boolean {
 }
 
 const fixtureLines = readFileSync(FIXTURE_PATH, "utf8").split("\n");
-// Fixture lines 187 and 191 predate the root-relative lazy-asset contract and
-// canonical-authority resolution. Keep their coverage by asserting the
+// Fixture line 36 is superseded by ODD (#1035); 187 and 191 predate
+// root-relative lazy assets and canonical-authority resolution. Keep coverage by asserting the
 // intentionally updated production wording instead of weakening the range.
 const CURRENT_SDD_WORKFLOW_PATH = "`sdd-orchestrator-workflow.md`";
 const CURRENT_HARD_PREFLIGHT_INVARIANT = "Hard preflight invariant: `openspec/config.yaml`, existing SDD changes, installed `.pi`/global SDD assets, or a todo named \"preflight\" are not session preflight. Do not mark SDD preflight complete, start `sdd-init`, launch SDD subagents/chains, or move to explore/proposal/spec/design/tasks until this session has an injected `## SDD Session Preflight` block or a canonical-authority resolution. Defaults and capability constraints may resolve fields without confirmation prompts; preserve unresolved-choice and safety gates.";
@@ -320,11 +320,26 @@ for (const range of DISPOSITION_MAP) {
 				if (raw === undefined || !isNormativeLine(raw)) continue;
 				const trimmed = raw.trim();
 				const expected =
+					ln === 36 ? "- Substantial authorized work: use ODD; track feature progress automatically." :
+					// #1051 keeps the selected store when memory is unavailable.
+					ln === 221 ? "do not switch the selected store" :
+					// Research returns findings; other phases keep direct backend ownership.
+					ln === 205 ? trimmed.replace("Each SDD phase", "Except for output-only `sdd-research`, each SDD phase") :
+					ln === 185 ? trimmed.replace("apply/verify/sync/archive", "apply/verify/archive") :
 					ln === 187
 						? CURRENT_SDD_WORKFLOW_PATH
 						: ln === 191
 							? CURRENT_HARD_PREFLIGHT_INVARIANT
 							: trimmed;
+				// #1051 retires the standalone sync row and its artifact key, not
+				// the surrounding memory/recovery contract or historical fixture.
+				if (ln === 216 || ln === 220) {
+					assert.ok(!targetContent.includes(trimmed), `retired sync contract remains at fixture:${ln}`);
+					assert.match(targetContent, /sdd\/<change>\/archive-report/);
+					assert.match(targetContent, /sdd\/<change>\/verify-report/);
+					assert.doesNotMatch(targetContent, /sdd\/<change>\/sync-report|\| `sdd-sync`/);
+					continue;
+				}
 				if (SUPERSEDED_LIFECYCLE_REVIEW_LINES.has(ln)) {
 					assert.ok(
 						!targetContent.includes(trimmed),

package/tests/package-manifest.test.ts

@@ -12,6 +12,7 @@ import {
 import { homedir, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
+import ts from "typescript";
 import { fileURLToPath } from "node:url";
 import { applyModelConfig } from "../extensions/gentle-ai.ts";
 import { resolveGentlePiAgentHome } from "../lib/agent-home.ts";
@@ -182,7 +183,7 @@ test("npm publication is bound to the exact package tag and triggering commit",
 		packageJson.repository,
 		{
 			type: "git",
-			url: "git+https://github.com/Gentleman-Programming/gentle-pi.git",
+			url: "git+https://github.com/Gentleman-Programming/gentle-shell.git",
 		},
 		"trusted publishing requires the exact case-sensitive npm repository identity",
 	);
@@ -218,11 +219,29 @@ test("generated runtime modules and packed-package checks are deterministic", ()
 	assert.match(ci, /pnpm run check:runtime-modules/);
 	assert.match(ci, /pnpm run test:packed-package/);
 	assert.match(generator, /Generated by scripts\/build-runtime-modules\.mjs/);
-	assert.match(packedRunner, /\["install"[^\]]*"--ignore-scripts=false"/s, "packed install must explicitly enable postinstall");
-	assert.doesNotMatch(packedRunner, /\["install"[^\]]*"--ignore-scripts"(?!\=false)/s);
-	assert.match(packedRunner, /execFileSync\("where\.exe", \["npm"\]/);
-	assert.match(packedRunner, /could not resolve npm-cli\.js without a command shell/);
-	assert.doesNotMatch(packedRunner, /ComSpec|cmd\.exe/);
+	const ordinaryPostinstall = readNamedFunction(packedRunner, "testHookedPackedRunner");
+	assert.match(ordinaryPostinstall, /\["install"[^\]]*"--ignore-scripts=false"/s, "ordinary packed install must explicitly enable postinstall");
+	assert.doesNotMatch(ordinaryPostinstall, /\["install"[^\]]*"--ignore-scripts"(?!\=false)/s);
+	for (const name of [
+		"testSdkLifecyclePackedSession",
+		"testWindowsStartupTimingPackedHelper",
+		"testWindowsStartupTimingEnvironmentExperiment",
+		"testUnhookedPackedImports",
+	]) {
+		const isolatedInstall = readNamedFunction(packedRunner, name);
+		assert.match(isolatedInstall, /\["install"[^\]]*"--ignore-scripts"(?!\=false)/s, `${name} must isolate installation scripts`);
+		assert.doesNotMatch(isolatedInstall, /\["install"[^\]]*"--ignore-scripts=false"/s, `${name} must not enable postinstall`);
+	}
+	const windowsNpmInvocation = readNamedFunction(packedRunner, "windowsNpmInvocation");
+	const runNpmWithEnv = readNamedFunction(packedRunner, "runNpmWithEnv");
+	assert.match(windowsNpmInvocation, /execFileSync\("where\.exe", \["npm"\]/);
+	assert.match(windowsNpmInvocation, /return \{ file: process\.execPath, prefix: \[installedCli\] \}/);
+	assert.match(windowsNpmInvocation, /return \{ file: path, prefix: \[\] \}/);
+	assert.match(windowsNpmInvocation, /could not resolve npm-cli\.js without a command shell/);
+	assert.doesNotMatch(windowsNpmInvocation, /ComSpec|cmd\.exe/);
+	assert.match(runNpmWithEnv, /execFileSync\(invocation\.file, \[\.\.\.invocation\.prefix, \.\.\.arguments_\]/);
+	assert.match(runNpmWithEnv, /\.\.\.options, env/);
+	assert.doesNotMatch(packedRunner, /shell\s*:\s*true/);
 	assert.match(packedRunner, /review", "capabilities", "--contract", "gentle-ai\.review-integration\/v2"/);
 	assert.doesNotMatch(packedRunner, /git-commit-transaction|transaction runner/i);
 });
@@ -247,8 +266,8 @@ test("package manifest installs pi-pretty through a wrapper without bundling nat
 
 	assert.equal(
 		packageJson.dependencies?.["@heyhuynhgiabuu/pi-pretty"],
-		"0.6.14",
-		"gentle-pi must install the tested pi-pretty version as a normal dependency",
+		"0.6.27",
+		"gentle-pi must install the tested pi-pretty version containing the model-visible result integrity fix",
 	);
 	assert.ok(
 		packageJson.pi?.extensions?.includes("./extensions"),
@@ -260,10 +279,22 @@ test("package manifest installs pi-pretty through a wrapper without bundling nat
 		),
 		"gentle-pi must not reference pnpm-unportable nested node_modules paths",
 	);
+	const piPrettyWrapperPath = join(PACKAGE_ROOT, "extensions", "pi-pretty.ts");
 	assert.ok(
-		existsSync(join(PACKAGE_ROOT, "extensions", "pi-pretty.ts")),
+		existsSync(piPrettyWrapperPath),
 		"gentle-pi must expose pi-pretty through a packaged wrapper extension",
 	);
+	const piPrettyWrapper = readFileSync(piPrettyWrapperPath, "utf8");
+	assert.match(
+		piPrettyWrapper,
+		/import\("@heyhuynhgiabuu\/pi-pretty"\)/,
+		"the wrapper must use the compiled-runtime-safe ESM loader",
+	);
+	assert.doesNotMatch(
+		piPrettyWrapper,
+		/requireFromRealPackage\("@heyhuynhgiabuu\/pi-pretty"\)/,
+		"the wrapper must not resolve the pi-pretty package root through createRequire",
+	);
 	assert.ok(
 		existsSync(join(PACKAGE_ROOT, "extensions", "quiet-tools.ts")),
 		"gentle-pi must expose quiet built-in tool rendering through a packaged extension",
@@ -278,20 +309,20 @@ test("package manifest installs pi-pretty through a wrapper without bundling nat
 	);
 });
 
-test("package verification binds the published Gentle AI v2.9.0 runtime pin", () => {
+test("package verification binds the published Gentle AI v2.9.1 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\.9\.0"/);
+	assert.match(installer, /INSTALLER_VERSION = "2\.9\.1"/);
 	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_PACKAGE.*GENTLE_AI_WINDOWS_SOURCE_MODULE/);
-	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:WqmYw1UfVYCbtOxU1uTuiYq9\+ROCUIDrmKIOjyYggQI="/);
+	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:roCuxlF\+L4YOb1X0los4RpjcLfxAmwmHxteSQMcfThY="/);
 	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\.9\.0/);
+	assert.match(verifier, /v2\.9\.1/);
 });
 
 
@@ -355,6 +386,46 @@ function nestedContractFields(contract: string, parent: string): string[] {
 	return contractFields(nestedBlock.join("\n"), 2);
 }
 
+function readNamedFunction(source: string, name: string): string {
+	const fileName = "test-packed-runner.mjs";
+	const options: ts.CompilerOptions = {
+		allowJs: true,
+		noLib: true,
+		noResolve: true,
+		target: ts.ScriptTarget.Latest,
+	};
+	const host = ts.createCompilerHost(options, true);
+	host.getSourceFile = (requested, languageVersion) =>
+		requested === fileName
+			? ts.createSourceFile(requested, source, languageVersion, true, ts.ScriptKind.JS)
+			: undefined;
+	host.fileExists = (requested) => requested === fileName;
+	host.readFile = (requested) => requested === fileName ? source : undefined;
+	host.getCurrentDirectory = () => ".";
+	host.writeFile = () => {};
+	const program = ts.createProgram([fileName], options, host);
+	const sourceFile = program.getSourceFile(fileName);
+	assert.ok(sourceFile, "packed runner source must be available to the in-memory compiler host");
+	assert.equal(program.getSyntacticDiagnostics(sourceFile).length, 0, "packed runner source must have no syntactic diagnostics");
+	const declarations = sourceFile.statements.filter(
+		(statement): statement is ts.FunctionDeclaration =>
+			ts.isFunctionDeclaration(statement) && statement.name?.text === name,
+	);
+	assert.equal(declarations.length, 1, `packed runner must define exactly one top-level ${name}`);
+	const declaration = declarations[0];
+	assert.ok(declaration.body, `${name} must have a complete function body`);
+	assert.ok(declaration.body.end > declaration.body.pos, `${name} must have a non-empty function body`);
+	return source.slice(declaration.getStart(sourceFile), declaration.end);
+}
+
+test("readNamedFunction fails closed for missing, duplicate, and incomplete declarations", () => {
+	assert.equal(readNamedFunction("function target() { return 1; }\nfunction neighbor() { return 2; }\n", "target"), "function target() { return 1; }");
+	assert.throws(() => readNamedFunction("const target = () => {};\n", "target"), /exactly one top-level target/);
+	assert.throws(() => readNamedFunction("function target() {}\nfunction target() {}\n", "target"), /exactly one top-level target/);
+	assert.throws(() => readNamedFunction("function target() {\n", "target"), /packed runner source must have no syntactic diagnostics/);
+	assert.throws(() => readNamedFunction("function target() {}\nfunction neighbor( {}\n", "target"), /packed runner source must have no syntactic diagnostics/);
+});
+
 function readMarkdownSection(source: string, heading: string): string {
 	const lines = source.split(/\r?\n/);
 	const matches = lines.flatMap((line, index) => {
@@ -548,7 +619,7 @@ const EXPECTED_OWNER_ASSETS: Record<PackageAssetOwner, readonly string[]> = {
 		"agents/sdd-apply.md", "agents/sdd-archive.md", "agents/sdd-design.md",
 		"agents/sdd-explore.md", "agents/sdd-init.md", "agents/sdd-onboard.md",
 		"agents/sdd-proposal.md", "agents/sdd-remediate.md", "agents/sdd-research.md", "agents/sdd-spec.md",
-		"agents/sdd-status.md", "agents/sdd-sync.md", "agents/sdd-tasks.md", "agents/sdd-verify.md",
+		"agents/sdd-status.md", "agents/sdd-tasks.md", "agents/sdd-verify.md",
 		"chains/sdd-full.chain.md", "chains/sdd-plan.chain.md", "chains/sdd-verify.chain.md",
 		"gentle-ai/support/sdd-status-contract.md", "gentle-ai/support/strict-tdd-verify.md",
 		"gentle-ai/support/strict-tdd.md",
@@ -591,10 +662,10 @@ test("legacy all-assets installation covers every packaged file with explicit ow
 		assert.equal(getPackageAssetOwner(key), undefined, "unknown assets must not default to SDD");
 	}
 	withIsolatedAssetHome((agentHome) => {
-		assert.deepEqual(installSddAssets(agentHome, false), { agents: 24, chains: 4, support: 3, skipped: 0 });
+		assert.deepEqual(installSddAssets(agentHome, false), { agents: 23, chains: 4, support: 3, skipped: 0 });
 		assert.deepEqual(Object.keys(installedAssetManifest(agentHome).assets).sort(), packaged);
-		assert.deepEqual(installSddAssets(agentHome, false), { agents: 0, chains: 0, support: 0, skipped: 31 });
-		assert.deepEqual(installSddAssets(agentHome, true), { agents: 24, chains: 4, support: 3, skipped: 0 });
+		assert.deepEqual(installSddAssets(agentHome, false), { agents: 0, chains: 0, support: 0, skipped: 30 });
+		assert.deepEqual(installSddAssets(agentHome, true), { agents: 23, chains: 4, support: 3, skipped: 0 });
 	});
 });
 
@@ -651,14 +722,8 @@ test("selective review migration adopts only untouched legacy copies and preserv
 });
 
 test("unowned legacy research migrates by exact normalized hash, preserving routing and user edits", () => {
-	const packaged = readFileSync(join(PACKAGE_ROOT, "assets", "agents", "sdd-research.md"), "utf8");
-	const oldAdmission = "- Evidence grants for this runtime are `documentation=[]; open-web=[]`. Never infer evidence capability from bash, persistence tools, or any inherited tool; persistence tools are not evidence grants. Unsupported or undeclared classes deny admission and emit no claims.\n- Because this runtime declares no evidence grants, retain the selected request, persist a `blocked` outcome with no claims, and stop.\n";
-	const legacy = packaged
-		.replace(/## Parent Preflight Transport\n[\s\S]*?(?=## Skill Resolution Contract)/, "")
-		.replace(/## Bounded artifact handoff\n[\s\S]*?(?=## Memory Contract)/, "")
-		.replace(/  - fetch_content\n  - web_search\n  - source_check\n  - get_search_content\n/, "")
-		.replace(/- Use the injected `## SDD Research Capabilities`[\s\S]*?(?=- Admission denial)/, oldAdmission)
-		.replace(/Use `done` only when all selected questions[\s\S]*?product decisions remain separately confirmed by the parent\./i, "For this runtime the outcome is `blocked` with an admission denial and no claims.");
+	// Historical bytes must not be reconstructed from the evolving current agent.
+	const legacy = readFileSync(join(PACKAGE_ROOT, "tests/fixtures/legacy/sdd-research-v2.5.0.md"), "utf8");
 	const manifest = JSON.parse(readFileSync(join(PACKAGE_ROOT, "assets", "migrations", "managed-assets-v2.5.0.json"), "utf8"));
 	assert.equal(sha256(legacy), manifest.assets["agents/sdd-research.md"], "fixture reconstruction must match observed old package bytes");
 	const temporary = mkdtempSync(join(tmpdir(), "gentle-research-migration-"));
@@ -1496,22 +1561,22 @@ test("orchestrator routes generic roles without static RDD lens routing", () =>
 	assert.match(core, /this package invents no lifecycle instructions/);
 });
 
-test("pi-pretty wrapper uses real package path resolution for pnpm symlink installs", () => {
+test("pi-pretty wrapper uses cached ESM loading for compiled and pnpm symlink installs", () => {
 	const wrapper = readFileSync(
 		join(PACKAGE_ROOT, "extensions", "pi-pretty.ts"),
 		"utf8",
 	);
 
-	assert.match(wrapper, /realpathSync/);
-	assert.match(wrapper, /createRequire/);
-	assert.match(wrapper, /@heyhuynhgiabuu\/pi-pretty/);
+	assert.doesNotMatch(wrapper, /realpathSync|createRequire/);
+	assert.match(wrapper, /piPrettyExtensionPromise/);
+	assert.match(wrapper, /import\("@heyhuynhgiabuu\/pi-pretty"\)/);
 	assert.match(wrapper, /PI_PRETTY_SUPPRESSED_TOOL_NAMES/);
 	assert.match(wrapper, /quietToolsEnabled/);
 });
 
-test("v2.6.4 release package and runtime stop before publication", () => {
+test("v3.0.0 release package and runtime stop before publication", () => {
 	const packageJson = readPackageJson();
-	assert.equal(packageJson.version, "2.6.4", "the release manifest must remain explicitly pinned to v2.6.4");
+	assert.equal(packageJson.version, "3.0.0", "the release manifest must remain explicitly pinned to v3.0.0");
 	assert.equal(
 		packageJson.scripts?.test,
 		"node --experimental-strip-types --test tests/*.test.ts && pnpm run check:provider-contract && pnpm run test:harness",
@@ -1559,3 +1624,26 @@ test("technical reference documents dynamic Gentle AI RDD ownership and the inst
 test("package verification explicitly requires the managed remediation actor", () => {
 	assert.match(readFileSync(join(PACKAGE_ROOT, "scripts/verify-package-files.mjs"), "utf8"), /assets\/agents\/sdd-remediate\.md/);
 });
+
+test("SDD installation retires owned sync but preserves modified copies and unrelated owners", () => {
+	withIsolatedAssetHome((agentHome) => {
+		installSddAssets(agentHome, false);
+		const path = join(agentHome, "agents/sdd-sync.md");
+		const manifestPath = join(agentHome, "gentle-ai/managed-assets.json");
+		const legacy = "Previously managed sync executor\n";
+		const manifest = installedAssetManifest(agentHome);
+		manifest.assets["agents/sdd-sync.md"] = sha256(legacy);
+		writeFileSync(path, legacy);
+		writeFileSync(manifestPath, JSON.stringify(manifest));
+		installPackageAssets(agentHome, true, ["delegation"]);
+		assert.equal(readFileSync(path, "utf8"), legacy);
+		installPackageAssets(agentHome, true, ["sdd"]);
+		assert.equal(existsSync(path), false);
+		assert.equal(installedAssetManifest(agentHome).assets["agents/sdd-sync.md"], undefined);
+		writeFileSync(path, "User-modified sync instructions\n");
+		writeFileSync(manifestPath, JSON.stringify(manifest));
+		installPackageAssets(agentHome, true, ["sdd"]);
+		assert.equal(readFileSync(path, "utf8"), "User-modified sync instructions\n");
+		assert.equal(installedAssetManifest(agentHome).assets["agents/sdd-sync.md"], undefined);
+	});
+});

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 work with SDD\/OpenSpec when the task justifies it, 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 by default and SDD\/OpenSpec when explicitly selected, coordinate subagents, use phase artifacts, 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`,
 		);
 	}
@@ -295,7 +295,7 @@ test("Table A rule: SDD/OpenSpec artifacts + subagents core-capabilities bullet
 		const prompt = __testing.buildGentlePrompt(persona);
 		assert.match(
 			prompt,
-			/Mention SDD\/OpenSpec phase artifacts and subagents as core capabilities\./,
+			/Mention ODD as the default workflow, SDD\/OpenSpec phase artifacts, and subagents as core capabilities\./,
 			`[${persona}] wrapper :182 rule must survive`,
 		);
 	}
@@ -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 work with SDD/OpenSpec when the task justifies it, 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 by default and SDD/OpenSpec when explicitly selected, coordinate subagents, use phase artifacts, 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(