gentle-pi 3.7.0 → 4.1.0

package/tests/package-manifest.test.ts

@@ -1,4 +1,6 @@
 import assert from "node:assert/strict";
+import { parseNpmPackResult } from "../scripts/npm-pack-result.mjs";
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import {
 	existsSync,
@@ -16,7 +18,10 @@ import ts from "typescript";
 import { fileURLToPath } from "node:url";
 import { applyModelConfig } from "../extensions/gentle-ai.ts";
 import { resolveGentlePiAgentHome } from "../lib/agent-home.ts";
-import { getPackageAssetOwner, installPackageAssets, installSddAssets, type PackageAssetOwner } from "../lib/sdd-preflight.ts";
+import { getPackageAssetOwner, installPackageAssets, type PackageAssetOwner } from "../lib/agent-assets.ts";
+import { AUDITED_PI_EDITOR_VERSIONS } from "../lib/vim-editor-adapter.ts";
+import { resolveProjectPiSdkVersion } from "../scripts/test-packed-runner.mjs";
+// Package installation is owned by lib/agent-assets.ts, not the retired SDD preflight.
 
 const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const MANAGED_EXEMPLAR_FILE = "gentle-ai-explore.md";
@@ -56,7 +61,7 @@ const V014_MANAGED_ASSETS = join(
 // gentle-ai-explore.md as their exemplar (packaged, absent from the v0.13
 // manifest) after review-refuter.md was retired together with every
 // Pi-authored adversarial review verdict.
-const MANAGED_EXEMPLAR_TOOLS = ["read", "grep", "find", "codegraph"];
+const MANAGED_EXEMPLAR_TOOLS = ["read", "grep", "find", "codegraph", "web_enable", "web_search", "source_check", "fetch_content", "get_search_content"];
 const RETIRED_ADVERSARIAL_AGENTS = ["review-refuter.md", "review-validator.md"];
 
 interface ManagedAssetsManifest {
@@ -76,13 +81,22 @@ interface PackageJsonPiManifest {
 	extensions?: string[];
 }
 
+interface PackageJsonPeerMetadata {
+	optional?: boolean;
+}
+
 interface PackageJson {
+	description?: string;
+	keywords?: string[];
 	version?: string;
 	files?: string[];
 	scripts?: Record<string, string>;
 	dependencies?: Record<string, string>;
 	peerDependencies?: Record<string, string>;
+	peerDependenciesMeta?: Record<string, PackageJsonPeerMetadata>;
+	optionalDependencies?: Record<string, string>;
 	devDependencies?: Record<string, string>;
+	engines?: Record<string, string>;
 	bundledDependencies?: string[];
 	bundleDependencies?: string[];
 	repository?: {
@@ -102,16 +116,106 @@ function readPackageJson(): PackageJson {
 	}
 }
 
+test("public docs and metadata advertise ODD and review without retired phase workflow", () => {
+	const manifest = readPackageJson();
+	assert.match(manifest.description ?? "", /ODD|Organic Driven Development/);
+	assert.match(manifest.description ?? "", /review/i);
+	assert.ok(manifest.keywords?.includes("odd"));
+	assert.ok(manifest.keywords?.includes("code-review"));
+	assert.ok(manifest.keywords?.every(keyword => !/sdd|openspec/i.test(keyword)));
+	for (const path of ["README.md", "docs/gentle-shell.md", "docs/readme-reference.md"]) {
+		const source = readFileSync(join(PACKAGE_ROOT, path), "utf8");
+		assert.match(source, /ODD|Organic Driven Development/, path);
+		assert.match(source, /review/i, path);
+		assert.doesNotMatch(source, /\bSDD\b|OpenSpec|\/gentle-sdd-init|\/gentle:install-sdd|\/gentle:sdd-preflight|\/sdd-/i, path);
+	}
+});
+
 test("technical reference declares the tested Pi minimum required for agent_settled", () => {
 	const manifest = readPackageJson();
-	assert.equal(manifest.peerDependencies?.["@earendil-works/pi-coding-agent"], ">=0.85.1");
-	assert.equal(manifest.devDependencies?.["@earendil-works/pi-coding-agent"], "0.85.1");
+	assert.equal(manifest.peerDependencies?.["@earendil-works/pi-coding-agent"], ">=0.99.1");
+	assert.equal(manifest.devDependencies?.["@earendil-works/pi-coding-agent"], ">=1.0.0");
+	assert.equal(manifest.peerDependenciesMeta?.["@earendil-works/pi-coding-agent"]?.optional, true);
+	assert.equal(manifest.engines?.node, ">=22.19.0");
+	for (const path of ["docs/readme-reference.md", "docs/gentle-shell.md"]) {
+		const source = readFileSync(join(PACKAGE_ROOT, path), "utf8");
+		assert.match(source, /Pi 0\.99\.1 or newer/, path);
+		assert.match(source, /open `>=1\.0\.0` development range/, path);
+		assert.doesNotMatch(source, /development tests pin Pi/, path);
+		// Docs name exactly the audited Vim editor releases, never a future one.
+		const auditedReleases = new Intl.ListFormat("en", { style: "long", type: "conjunction" })
+			.format(AUDITED_PI_EDITOR_VERSIONS.map(v => `\`${v.replace(/\./g, "\\.")}\``));
+		assert.match(source, new RegExp(`audited Pi ${auditedReleases}`), path);
+	}
 	const reference = readFileSync(join(PACKAGE_ROOT, "docs", "readme-reference.md"), "utf8");
-	assert.match(reference, /Pi 0\.85\.1 or newer/);
 	assert.match(reference, /agent_settled/);
 	assert.match(readFileSync(join(PACKAGE_ROOT, "README.md"), "utf8"), /\]\(docs\/readme-reference\.md(?:#[^)]+)?\)/);
 });
 
+test("packed runtime uses optional Pi host peers with one open development range and no duplicate direct dependencies", () => {
+	const manifest = readPackageJson();
+	for (const name of ["@earendil-works/pi-ai", "@earendil-works/pi-tui"]) {
+		assert.equal(manifest.peerDependencies?.[name], "*", name);
+		assert.equal(manifest.peerDependenciesMeta?.[name]?.optional, true, name);
+	}
+	// The devDependency specifier is policy (a range); the resolved install is
+	// one exact release shared by every Pi host package.
+	const installed = new Set<string>();
+	for (const name of ["@earendil-works/pi-coding-agent", "@earendil-works/pi-ai", "@earendil-works/pi-tui"]) {
+		assert.equal(manifest.devDependencies?.[name], ">=1.0.0", name);
+		const metadata = JSON.parse(readFileSync(join(PACKAGE_ROOT, "node_modules", name, "package.json"), "utf8")) as { name: string; version: string };
+		assert.equal(metadata.name, name);
+		installed.add(metadata.version);
+	}
+	assert.deepEqual([...installed], [resolveProjectPiSdkVersion(PACKAGE_ROOT)]);
+	for (const name of ["@earendil-works/pi-coding-agent", "@earendil-works/pi-ai", "@earendil-works/pi-tui"]) {
+		assert.equal(manifest.dependencies?.[name], undefined, name);
+		assert.equal(manifest.optionalDependencies?.[name], undefined, name);
+	}
+});
+
+// Fixture project roots let the resolver's range policy be tested without
+// touching the real install.
+function withPiSdkProject(range: unknown, installed: unknown, run: (root: string) => void): void {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-sdk-version-"));
+	try {
+		const sdk = join(root, "node_modules", "@earendil-works", "pi-coding-agent");
+		mkdirSync(sdk, { recursive: true });
+		writeFileSync(join(root, "package.json"), JSON.stringify({ devDependencies: { "@earendil-works/pi-coding-agent": range } }));
+		writeFileSync(join(sdk, "package.json"), JSON.stringify(installed));
+		run(root);
+	} finally {
+		rmSync(root, { recursive: true, force: true });
+	}
+}
+
+test("packed probes install the project-resolved Pi SDK release, never the devDependency specifier", () => {
+	const sdk = (version: unknown) => ({ name: "@earendil-works/pi-coding-agent", version });
+	for (const [range, version] of [[">=0.99.2", "0.99.2"], [">=0.99.2", "0.99.10"], [">=0.99.2", "1.0.0"], ["0.99.2", "0.99.2"]]) {
+		withPiSdkProject(range, sdk(version), (root) => assert.equal(resolveProjectPiSdkVersion(root), version, `${range} ${version}`));
+	}
+	for (const [range, installed, error] of [
+		[">=0.99.2", sdk("0.99.1"), /0\.99\.1 does not satisfy >=0\.99\.2/],
+		["0.99.1", sdk("0.99.2"), /0\.99\.2 does not satisfy 0\.99\.1/],
+		["*", sdk("0.99.2"), /exact or >= Pi SDK development range/],
+		["^0.99.2", sdk("0.99.2"), /exact or >= Pi SDK development range/],
+		[undefined, sdk("0.99.2"), /exact or >= Pi SDK development range/],
+		[">=0.99.2", sdk(">=0.99.2"), /exact release version/],
+		[">=0.99.2", sdk("0.99.3-rc.1"), /exact release version/],
+		[">=0.99.2", { name: "impostor", version: "0.99.2" }, /exact release version/],
+	] as const) {
+		withPiSdkProject(range, installed, (root) => assert.throws(() => resolveProjectPiSdkVersion(root), error, String(range)));
+	}
+	const installed = JSON.parse(readFileSync(join(PACKAGE_ROOT, "node_modules", "@earendil-works", "pi-coding-agent", "package.json"), "utf8")) as { version: string };
+	assert.equal(resolveProjectPiSdkVersion(PACKAGE_ROOT), installed.version);
+	const packedRunner = readFileSync(join(PACKAGE_ROOT, "scripts", "test-packed-runner.mjs"), "utf8");
+	for (const name of ["testSdkLifecyclePackedSession", "testWindowsStartupTimingPackedHelper", "testWindowsStartupTimingEnvironmentExperiment", "testUnhookedPackedImports"]) {
+		const probe = readNamedFunction(packedRunner, name);
+		assert.match(probe, /const sdkVersion = resolveProjectPiSdkVersion\(root, "[^"]+"\);/, name);
+		assert.doesNotMatch(probe, /devDependencies/, name);
+	}
+});
+
 test("package manifest has no obsolete native activation build surface", () => {
 	const packageJson = readPackageJson();
 	const manifest = JSON.stringify(packageJson);
@@ -123,6 +227,16 @@ test("package manifest has no obsolete native activation build surface", () => {
 	assert.doesNotMatch(packageJson.scripts?.prepublishOnly ?? "", /native:build/);
 });
 
+test("package verification excludes the retired init extension while retaining ODD and review resources", () => {
+	const verifier = readFileSync(join(PACKAGE_ROOT, "scripts", "verify-package-files.mjs"), "utf8");
+	assert.equal(existsSync(join(PACKAGE_ROOT, "extensions", "sdd-init.ts")), false);
+	assert.doesNotMatch(verifier, /^\s*"extensions\/sdd-init\.ts",?$/m);
+	assert.match(verifier, /existsSync\(join\(root, "extensions\/sdd-init\.ts"\)\)/);
+	for (const resource of ["extensions/gentle-ai.ts", "extensions/skill-registry.ts", "assets/orchestrator.md", "assets/orchestrator-delegation.md", "assets/agents/gentle-ai-worker.md", "assets/agents/review-risk.md", "assets/chains/4r-review.chain.md"]) {
+		assert.ok(verifier.includes(`"${resource}"`), `${resource} must remain required`);
+	}
+});
+
 test("package verification names the native review runtime boundary and packaged fixtures", () => {
 	const verifier = readFileSync(join(PACKAGE_ROOT, "scripts", "verify-package-files.mjs"), "utf8");
 	const manifest = readPackageJson();
@@ -140,6 +254,25 @@ test("package verification names the native review runtime boundary and packaged
 	);
 });
 
+test("double-click installers are attached to the release only after the verified publication", () => {
+	const workflow = readFileSync(join(PACKAGE_ROOT, ".github", "workflows", "publish.yml"), "utf8");
+	const job = workflow.match(/^ {2}installers:\n([\s\S]*?)(?=^ {2}[A-Za-z0-9_-]+:\n|(?![\s\S]))/m)?.[1];
+	assert.ok(job, "publish.yml has an installers job");
+	assert.match(job, /^ {4}needs: publish$/m, "installers wait for the verified npm publication");
+	assert.match(job, /^ {4}if: github\.repository == 'Gentleman-Programming\/gentle-shell'$/m);
+	assert.match(job, /^ {6}contents: write$/m, "only this job may write the release");
+	assert.match(job, /ref: \$\{\{ github\.sha \}\}/, "the installers come from the verified release commit");
+	assert.match(job, /persist-credentials: false/);
+	assert.match(job, /node scripts\/build-installer-bundles\.mjs --out "\$\{RUNNER_TEMP\}\/installers"/);
+	assert.match(job, /RELEASE_TAG: \$\{\{ needs\.publish\.outputs\.tag \}\}/, "the tag the publish job verified, not the raw input");
+	assert.match(job, /package-manager-cache: false/);
+	assert.match(workflow, /^ {4}outputs:\n {6}tag: \$\{\{ steps\.release\.outputs\.tag \}\}$/m, "publish exports its verified tag");
+	assert.match(job, /gh release upload "\$\{RELEASE_TAG\}" "\$\{RUNNER_TEMP\}"\/installers\/\* --repo "\$\{GITHUB_REPOSITORY\}" --clobber/);
+	const publish = workflow.match(/^ {2}publish:\n([\s\S]*?)(?=^ {2}installers:\n)/m)?.[1];
+	assert.ok(publish);
+	assert.doesNotMatch(publish, /contents: write/, "the npm publication job keeps read-only contents");
+});
+
 test("npm publication is bound to the exact package tag and triggering commit", () => {
 	const workflow = readFileSync(join(PACKAGE_ROOT, ".github", "workflows", "publish.yml"), "utf8");
 	const packageJson = readPackageJson();
@@ -298,20 +431,20 @@ test("package manifest installs pi-pretty through a wrapper without bundling nat
 	);
 });
 
-test("package verification binds the published Gentle AI v3.7.0 runtime pin", () => {
+test("package verification binds the published Gentle AI v4.1.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 = "3\.7\.0"/);
+	assert.match(installer, /INSTALLER_VERSION = "4\.1\.1"/);
 	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_PACKAGE.*GENTLE_AI_WINDOWS_SOURCE_MODULE/);
-	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:MQbzHlLdPklUQn0rVE9Mz94UygHsN2OPe7xMfPn9aGw="/);
+	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:\+WmZ2IvIOiJ8qtHa7wsjnYKNasem\+PByeOZ6HIjoAL8="/);
 	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, /v3\.7\.0/);
+	assert.match(verifier, /v4\.1\.1/);
 });
 
 
@@ -437,7 +570,7 @@ function readMarkdownSection(source: string, heading: string): string {
 
 function assertWorkerFallbackRouting(section: string, sectionName: string): void {
 	const boundedWriterPolicy = section.match(
-		/For bounded multi-file writes,[\s\S]*?(?=\n\n|\n\s*\d+\.|$)/,
+		/For a large task's bounded writes,[\s\S]*?(?=\n\n|\n\s*\d+\.|$)/,
 	)?.[0];
 	assert.ok(boundedWriterPolicy, `${sectionName} must define bounded writer routing`);
 
@@ -551,6 +684,36 @@ function installedAssetManifest(agentHome: string): ManagedAssetsManifest {
 	return JSON.parse(readFileSync(join(agentHome, "gentle-ai", "managed-assets.json"), "utf8"));
 }
 
+test("ODD delegation assets retain applicable test-first checks and independent review boundaries without SDD routing", () => {
+	const support = readFileSync(join(PACKAGE_ROOT, "assets/support/strict-tdd.md"), "utf8");
+	const explorer = readFileSync(join(PACKAGE_ROOT, "assets/agents/gentle-ai-explore.md"), "utf8");
+	const verifier = readFileSync(join(PACKAGE_ROOT, "assets/agents/gentle-ai-verify.md"), "utf8");
+	const worker = readFileSync(join(PACKAGE_ROOT, "assets/agents/gentle-ai-worker.md"), "utf8");
+	for (const source of [support, explorer, verifier, worker]) {
+		assert.doesNotMatch(source, /openspec\/config\.yaml|sdd-init|SDD phase protocols|generic non-SDD|sdd-verify|sdd\/\{project\}/i);
+	}
+	assert.match(support, /RED[\s\S]*GREEN[\s\S]*REFACTOR/);
+	assert.match(support, /behavior changes with applicable runnable deterministic tests and a clear expected outcome/i);
+	assert.match(support, /A test file merely existing is not proof of applicability or RED/i);
+	assert.match(support, /no meaningful RED[\s\S]*proportionate ordinary functional or structural verification/i);
+	assert.match(support, /Use only exact commands authorized by the parent/i);
+	assert.match(explorer, /read-only explorer for generic ODD work/);
+	assert.match(verifier, /read-only technical verifier for generic ODD work/);
+	assert.match(worker, /allowed edit surfaces/i);
+	assert.match(worker, /work-unit commit/i);
+	assert.match(worker, /review lifecycle.*parent/i);
+});
+
+test("delegation installation retains strict TDD support without installing SDD assets", () => {
+	withIsolatedAssetHome((agentHome) => {
+		installPackageAssets(agentHome, false, ["delegation"]);
+		const keys = Object.keys(installedAssetManifest(agentHome).assets);
+		assert.ok(keys.includes("gentle-ai/support/strict-tdd.md"));
+		assert.ok(keys.includes("gentle-ai/support/strict-tdd-verify.md"));
+		assert.ok(keys.every(key => !key.startsWith("agents/sdd-") && !key.startsWith("chains/sdd-") && !key.includes("sdd-status-contract")));
+	});
+});
+
 test("selective delegation installation owns only generic agents", () => {
 	withIsolatedAssetHome((agentHome) => {
 		const result = installPackageAssets(agentHome, false, ["delegation"]);
@@ -558,19 +721,21 @@ test("selective delegation installation owns only generic agents", () => {
 			"agents/gentle-ai-explore.md",
 			"agents/gentle-ai-verify.md",
 			"agents/gentle-ai-worker.md",
+			"gentle-ai/support/strict-tdd-verify.md",
+			"gentle-ai/support/strict-tdd.md",
 		]);
-		assert.deepEqual(result, { agents: 3, chains: 0, support: 0, skipped: 0 });
+		assert.deepEqual(result, { agents: 3, chains: 0, support: 2, skipped: 0 });
 		assert.deepEqual(readdirSync(join(agentHome, "agents")).sort(), [
 			"gentle-ai-explore.md", "gentle-ai-verify.md", "gentle-ai-worker.md",
 		]);
 		assert.equal(existsSync(join(agentHome, "chains")), false);
-		assert.equal(existsSync(join(agentHome, "gentle-ai", "support")), false);
+		assert.deepEqual(readdirSync(join(agentHome, "gentle-ai", "support")).sort(), ["strict-tdd-verify.md", "strict-tdd.md"]);
 	});
 });
 
 test("selective installation retires only assets belonging to the selected owner", () => {
 	withIsolatedAssetHome((agentHome) => {
-		installSddAssets(agentHome, false);
+		installPackageAssets(agentHome, false);
 		const manifestPath = join(agentHome, "gentle-ai", "managed-assets.json");
 		const manifest = installedAssetManifest(agentHome);
 		for (const name of RETIRED_ADVERSARIAL_AGENTS) {
@@ -578,7 +743,7 @@ test("selective installation retires only assets belonging to the selected owner
 			manifest.assets[`agents/${name}`] = sha256("Previously managed review agent\n");
 		}
 		writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-		for (const owner of ["delegation", "sdd"] as const) {
+		for (const owner of ["delegation"] as const) {
 			installPackageAssets(agentHome, true, [owner]);
 			assert.deepEqual(installedAssetManifest(agentHome), manifest);
 			for (const name of RETIRED_ADVERSARIAL_AGENTS) {
@@ -598,21 +763,13 @@ test("selective installation retires only assets belonging to the selected owner
 const EXPECTED_OWNER_ASSETS: Record<PackageAssetOwner, readonly string[]> = {
 	delegation: [
 		"agents/gentle-ai-explore.md", "agents/gentle-ai-verify.md", "agents/gentle-ai-worker.md",
+		"gentle-ai/support/strict-tdd.md", "gentle-ai/support/strict-tdd-verify.md",
 	],
 	review: [
 		"agents/jd-fix-agent.md", "agents/jd-judge-a.md", "agents/jd-judge-b.md",
 		"agents/review-readability.md", "agents/review-reliability.md",
 		"agents/review-resilience.md", "agents/review-risk.md", "chains/4r-review.chain.md",
 	],
-	sdd: [
-		"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-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",
-	],
 };
 
 function assetFileKeys(root: string, prefix = ""): string[] {
@@ -641,7 +798,7 @@ for (const owner of Object.keys(EXPECTED_OWNER_ASSETS) as PackageAssetOwner[]) {
 	});
 }
 
-test("legacy all-assets installation covers every packaged file with explicit ownership", () => {
+test("all-assets installation covers every retained packaged file with explicit ownership", () => {
 	const packaged = ["agents", "chains", "support"].flatMap(group =>
 		assetFileKeys(join(PACKAGE_ROOT, "assets", group), group === "support" ? "gentle-ai/support/" : `${group}/`),
 	).sort();
@@ -651,24 +808,24 @@ 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: 23, chains: 4, support: 3, skipped: 0 });
+		assert.deepEqual(installPackageAssets(agentHome, false), { agents: 10, chains: 1, support: 2, skipped: 0 });
 		assert.deepEqual(Object.keys(installedAssetManifest(agentHome).assets).sort(), packaged);
-		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 });
+		assert.deepEqual(installPackageAssets(agentHome, false), { agents: 0, chains: 0, support: 0, skipped: 13 });
+		assert.deepEqual(installPackageAssets(agentHome, true), { agents: 10, chains: 1, support: 2, skipped: 0 });
 	});
 });
 
 test("selective refresh preserves unselected ownership and selected user changes after an all-assets install", () => {
 	withIsolatedAssetHome((agentHome) => {
-		installSddAssets(agentHome, false);
+		installPackageAssets(agentHome, false);
 		const manifest = installedAssetManifest(agentHome);
 		const selectedUserKey = "agents/gentle-ai-explore.md";
-		const unselectedUserKey = "agents/sdd-apply.md";
+		const unselectedUserKey = "agents/review-risk.md";
 		for (const key of [selectedUserKey, unselectedUserKey, "agents/custom.md"]) {
 			writeFileSync(join(agentHome, key), "User-authored instructions\n");
 		}
 		const before = new Map(assetFileKeys(agentHome).map(key => [key, readFileSync(join(agentHome, key), "utf8")]));
-		assert.deepEqual(installPackageAssets(agentHome, true, ["delegation"]), { agents: 2, chains: 0, support: 0, skipped: 1 });
+		assert.deepEqual(installPackageAssets(agentHome, true, ["delegation"]), { agents: 2, chains: 0, support: 2, skipped: 1 });
 		delete manifest.assets[selectedUserKey];
 		assert.deepEqual(installedAssetManifest(agentHome), manifest);
 		for (const [key, content] of before) {
@@ -705,42 +862,94 @@ test("selective review migration adopts only untouched legacy copies and preserv
 				assert.equal(manifest.assets["agents/review-risk.md"], sha256(actual));
 			}
 			assert.equal(existsSync(join(agentHome, "agents", "sdd-apply.md")), false);
-			assert.equal(existsSync(join(agentHome, "gentle-ai", "support")), false);
+			assert.equal(existsSync(join(agentHome, "gentle-ai", "support", "strict-tdd.md")), true);
 		});
 	}
 });
 
-test("unowned legacy research migrates by exact normalized hash, preserving routing and user edits", () => {
-	// 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-"));
-	const previous = process.env.GENTLE_PI_AGENT_HOME;
+test("native pulse audio ships owned TypeScript sources without new dependencies or addons", () => {
+	const manifest = readPackageJson();
+	const verifier = readFileSync(join(PACKAGE_ROOT, "scripts", "verify-package-files.mjs"), "utf8");
+	const sources = [
+		"lib/notification-pulse-protocol.ts", "lib/notification-pulse-client.ts",
+		"lib/notification-pulse-stream.ts", "lib/notification-audio-native.ts",
+		"lib/notification-pulse-worker.ts",
+	];
+	for (const source of sources) {
+		assert.ok(existsSync(join(PACKAGE_ROOT, source)), `${source} must exist`);
+		assert.ok(verifier.includes(`"${source}"`), `${source} must be a required package resource`);
+	}
+	assert.ok(!manifest.files?.includes("native/"), "no native addon directory may ship");
+	for (const name of Object.keys(manifest.dependencies ?? {})) assert.doesNotMatch(name, /pulse|audio|sound|native/i, name);
+	for (const name of Object.keys(manifest.scripts ?? {})) assert.doesNotMatch(name, /pulse|native:build|audio:install/i, name);
+	for (const path of ["lib/notification-pulse-worker.ts", "lib/notification-audio-native.ts"]) {
+		const source = readFileSync(join(PACKAGE_ROOT, path), "utf8");
+		assert.doesNotMatch(source, /@earendil-works|\.node["']|addon/i, path);
+		assert.doesNotMatch(source, /postinstall|installer|download/i, path);
+	}
+});
+
+test("native windows audio ships an owned encoded-command adapter without scripts or dependencies", () => {
+	const manifest = readPackageJson();
+	const verifier = readFileSync(join(PACKAGE_ROOT, "scripts", "verify-package-files.mjs"), "utf8");
+	const path = "lib/notification-audio-windows.ts";
+	assert.ok(existsSync(join(PACKAGE_ROOT, path)), `${path} must exist`);
+	assert.ok(verifier.includes(`"${path}"`), `${path} must be a required package resource`);
+	for (const dependency of Object.keys(manifest.dependencies ?? {})) assert.doesNotMatch(dependency, /audio|sound|windows|powershell|native/i, dependency);
+	for (const script of Object.keys(manifest.scripts ?? {})) assert.doesNotMatch(script, /windows:build|powershell|audio:install/i, script);
+	const source = readFileSync(join(PACKAGE_ROOT, path), "utf8");
+	assert.match(source, /-EncodedCommand/, "the adapter must drive the trusted built-in PowerShell host with an encoded command");
+	assert.doesNotMatch(source, /\.ps1|ExecutionPolicy|\.node["']|addon/i, path);
+	assert.doesNotMatch(source, /postinstall|installer|download/i, path);
+});
+
+test("packed tarball excludes retired workflow paths while source retains legacy migration proof", () => {
+	const fixture = "tests/fixtures/legacy/sdd-research-v2.5.0.md";
+	assert.ok(existsSync(join(PACKAGE_ROOT, fixture)), "the historical source fixture must remain available to migration tests");
+	const destination = mkdtempSync(join(tmpdir(), "gentle-pi-pack-manifest-"));
 	try {
-		for (const edited of [false, true]) {
-			const agentHome = join(temporary, edited ? "edited" : "legacy");
-			process.env.GENTLE_PI_AGENT_HOME = agentHome;
-			mkdirSync(join(agentHome, "agents"), { recursive: true });
-			const target = join(agentHome, "agents", "sdd-research.md");
-			const routed = legacy.replace("name: sdd-research\n", "name: sdd-research\nmodel: custom/model\nthinking: high\n") + (edited ? "\nUser research restrictions.\n" : "");
-			writeFileSync(target, routed);
-			installSddAssets(temporary, true);
-			const actual = readFileSync(target, "utf8");
-			if (edited) assert.equal(actual, routed);
-			else {
-				assert.match(actual, /  - fetch_content/);
-				assert.match(actual, /model: custom\/model\nthinking: high/);
-				const ownership = JSON.parse(readFileSync(join(agentHome, "gentle-ai", "managed-assets.json"), "utf8"));
-				assert.equal(ownership.assets["agents/sdd-research.md"], sha256(actual));
-				installSddAssets(temporary, true);
-				assert.equal(readFileSync(target, "utf8"), actual, "subsequent refresh keeps adopted model routing");
-			}
+		const output = execFileSync("npm", ["pack", "--ignore-scripts", "--offline", "--json", "--pack-destination", destination], {
+			cwd: PACKAGE_ROOT,
+			encoding: "utf8",
+			maxBuffer: 8 * 1024 * 1024,
+		});
+		const [packed] = parseNpmPackResult(output);
+		assert.ok(packed?.files?.length, "npm pack must return a nonempty tar manifest");
+		assert.ok(packed.files.some(file => file.path === "tests/package-manifest.test.ts"), "other tests remain packed");
+		for (const path of [
+			"extensions/gentle-notifications.ts",
+			"lib/notification-audio.ts", "lib/notification-customize.ts", "lib/notification-events.ts", "lib/notification-policy.ts",
+			"lib/notification-scheduler.ts", "lib/notification-service.ts", "lib/notification-ui.ts",
+			"assets/sounds/success.wav", "assets/sounds/error.wav", "assets/sounds/attention.wav",
+			"assets/sounds/LICENSE.md", "docs/sound-notifications.md", "docs/sound-notifications-proposal.md",
+			"lib/notification-pulse-protocol.ts", "lib/notification-pulse-client.ts", "lib/notification-pulse-stream.ts",
+			"lib/notification-audio-native.ts", "lib/notification-pulse-worker.ts",
+			"lib/notification-audio-windows.ts",
+			"scripts/npm-pack-result.mjs",
+		]) {
+			assert.ok(packed.files.some(file => file.path === path), `${path} must be packed`);
 		}
+		assert.deepEqual(packed.files.filter(file => /sdd|openspec/i.test(file.path)).map(file => file.path), []);
 	} finally {
-		if (previous === undefined) delete process.env.GENTLE_PI_AGENT_HOME;
-		else process.env.GENTLE_PI_AGENT_HOME = previous;
-		rmSync(temporary, { recursive: true, force: true });
+		rmSync(destination, { recursive: true, force: true });
+	}
+});
+
+test("legacy research retirement requires exact ownership and preserves edited copies", () => {
+	const legacy = readFileSync(join(PACKAGE_ROOT, "tests/fixtures/legacy/sdd-research-v2.5.0.md"), "utf8");
+	const history = JSON.parse(readFileSync(join(PACKAGE_ROOT, "assets", "migrations", "managed-assets-v2.5.0.json"), "utf8"));
+	assert.equal(sha256(legacy), history.assets["agents/sdd-research.md"]);
+	for (const edited of [false, true]) {
+		withIsolatedAssetHome((agentHome) => {
+			mkdirSync(join(agentHome, "agents"), { recursive: true });
+			const target = join(agentHome, "agents", "sdd-research.md");
+			const content = edited ? `${legacy}\nUser research restrictions.\n` : legacy;
+			writeFileSync(target, content);
+			installPackageAssets(agentHome, true);
+			assert.equal(existsSync(target), edited);
+			if (edited) assert.equal(readFileSync(target, "utf8"), content);
+			assert.equal(installedAssetManifest(agentHome).assets["agents/sdd-research.md"], undefined);
+		});
 	}
 });
 
@@ -783,7 +992,7 @@ test("forced package installation preserves same-path user-authored agents and s
 		mkdirSync(dirname(samePathUserAgent), { recursive: true });
 		writeFileSync(samePathUserAgent, userAgentSource);
 
-		installSddAssets(temporaryProject, true);
+		installPackageAssets(temporaryProject, true);
 
 		assert.deepEqual(
 			readFileSync(samePathUserAgent),
@@ -861,7 +1070,7 @@ test("first forced sync migrates untouched v0.13 assets, preserves routing, and
 		writeFileSync(installedReviewRisk, routedLegacySource);
 		assert.equal(existsSync(managedAssetsManifest), false, "v0.13 had no ownership manifest");
 
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 
 		const migrated = readFileSync(installedReviewRisk, "utf8");
 		const currentPackageSource = readFileSync(
@@ -897,7 +1106,7 @@ test("first forced sync migrates untouched v0.13 assets, preserves routing, and
 		);
 		assert.notEqual(userEditedMigration, migrated, "the fixture must exercise post-migration drift");
 		writeFileSync(installedReviewRisk, userEditedMigration);
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 		assert.deepEqual(
 			readFileSync(installedReviewRisk),
 			Buffer.from(userEditedMigration),
@@ -932,7 +1141,7 @@ test("first forced sync migrates untouched v0.14 review contracts and preserves
 		mkdirSync(dirname(installedReviewRisk), { recursive: true });
 		writeFileSync(installedReviewRisk, routedLegacySource);
 
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 
 		const migrated = readFileSync(installedReviewRisk, "utf8");
 		assert.notEqual(migrated, routedLegacySource);
@@ -969,7 +1178,7 @@ test("first forced sync preserves a body-edited v0.13 asset byte-for-byte", () =
 		mkdirSync(dirname(installedReviewRisk), { recursive: true });
 		writeFileSync(installedReviewRisk, editedLegacySource);
 
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 
 		assert.deepEqual(readFileSync(installedReviewRisk), Buffer.from(editedLegacySource));
 		const manifest = JSON.parse(
@@ -1004,7 +1213,7 @@ test("forced package installation refreshes an asset recorded as package-managed
 
 	try {
 		process.env.GENTLE_PI_AGENT_HOME = temporaryAgentHome;
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 		assert.ok(existsSync(installedExemplar), "a missing package asset must install");
 		assert.ok(
 			existsSync(managedAssetsManifest),
@@ -1020,7 +1229,7 @@ test("forced package installation refreshes an asset recorded as package-managed
 		);
 		writeFileSync(managedAssetsManifest, JSON.stringify(manifest, null, 2));
 
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 
 		const refreshed = readAgentDefinition(installedExemplar);
 		assert.deepEqual(refreshed.tools, MANAGED_EXEMPLAR_TOOLS);
@@ -1050,13 +1259,13 @@ function assertManagedAgentUserEditIsPreserved(
 
 	try {
 		process.env.GENTLE_PI_AGENT_HOME = temporaryAgentHome;
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 		const installedSource = readFileSync(installedExemplar, "utf8");
 		const userEditedSource = editSource(installedSource);
 		assert.notEqual(userEditedSource, installedSource, `${editLabel} must alter the asset`);
 		writeFileSync(installedExemplar, userEditedSource);
 
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 
 		assert.deepEqual(
 			readFileSync(installedExemplar),
@@ -1102,8 +1311,8 @@ test("forced package installation preserves a thinking-only edit to a managed ag
 test("forced package installation preserves an ordinary body edit to a managed agent", () => {
 	assertManagedAgentUserEditIsPreserved("an ordinary body edit", (source) =>
 		source.replace(
-			"You are the read-only explorer for generic non-SDD work.",
-			"Preserve this user-authored body change. You are the read-only explorer for generic non-SDD work.",
+			"You are the read-only explorer for generic ODD work.",
+			"Preserve this user-authored body change. You are the read-only explorer for generic ODD work.",
 		),
 	);
 });
@@ -1122,7 +1331,7 @@ test("package model assignment keeps only package-managed agents owned", () => {
 
 	try {
 		process.env.GENTLE_PI_AGENT_HOME = temporaryAgentHome;
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 		writeFileSync(userAgent, userAgentSource);
 
 		applyModelConfig(PACKAGE_ROOT, {
@@ -1151,7 +1360,7 @@ test("package model assignment keeps only package-managed agents owned", () => {
 			"routing an arbitrary user agent must not relabel it as package-owned",
 		);
 
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true);
 		assert.equal(
 			readFileSync(installedExemplar, "utf8"),
 			readFileSync(join(PACKAGE_ROOT, "assets", "agents", MANAGED_EXEMPLAR_FILE), "utf8"),
@@ -1182,20 +1391,23 @@ test("jd-fix-agent packaged allowlist includes write tools", () => {
 	}
 });
 
-test("sdd-explore packages its CodeGraph-enabled exploration allowlist", () => {
-	const agentPath = join(PACKAGE_ROOT, "assets", "agents", "sdd-explore.md");
-	const { name, tools } = readAgentDefinition(agentPath);
-
-	assert.equal(name, "sdd-explore");
-	assert.deepEqual(tools, [
-		"read",
-		"grep",
-		"find",
-		"codegraph",
-		"edit",
-		"write",
-		"mem_save",
-	]);
+test("deleted SDD definitions remain absent from the installed catalog", () => {
+	const retired = [
+		...[
+			"apply", "archive", "design", "explore", "init", "onboard", "proposal",
+			"remediate", "research", "spec", "status", "tasks", "verify",
+		].map(name => `agents/sdd-${name}.md`),
+		"chains/sdd-full.chain.md", "chains/sdd-plan.chain.md", "chains/sdd-verify.chain.md",
+		"gentle-ai/support/sdd-status-contract.md",
+	];
+	withIsolatedAssetHome(agentHome => {
+		installPackageAssets(agentHome, false);
+		for (const key of retired) {
+			assert.equal(getPackageAssetOwner(key), undefined, key);
+			assert.equal(installedAssetManifest(agentHome).assets[key], undefined, key);
+			assert.equal(existsSync(join(agentHome, key)), false, key);
+		}
+	});
 });
 
 test("gentle-ai-worker packages the exact scoped writer contract", () => {
@@ -1296,8 +1508,11 @@ test("gentle-ai-worker packages the exact scoped writer contract", () => {
 	assert.match(memorySafety, /raw untrusted repository/);
 
 	const testDiscipline = readMarkdownSection(source, "Test discipline");
-	assert.match(testDiscipline, /Strict TDD is active/);
-	assert.match(testDiscipline, /not active/);
+	assert.match(testDiscipline, /Apply the ODD test-first policy by default for behavior changes with applicable runnable deterministic tests and a clear expected outcome/);
+	assert.match(testDiscipline, /Test presence alone does not establish applicability; no TUI toggle or per-task chat choice is needed/);
+	assert.match(testDiscipline, /RED[\s\S]*GREEN[\s\S]*PRESERVE[\s\S]*REFACTOR/);
+	assert.match(testDiscipline, /no meaningful RED[\s\S]*proportionate ordinary functional or structural verification/);
+	assert.match(testDiscipline, /Never claim RED\/GREEN evidence that was not observed/);
 	assert.match(
 		testDiscipline,
 		/Broad suites, builds, formatters, or linters may run only when explicitly authorized by the parent\./,
@@ -1306,13 +1521,13 @@ test("gentle-ai-worker packages the exact scoped writer contract", () => {
 	assert.doesNotMatch(testDiscipline, /clearly required by the repository contract/);
 });
 
-test("installSddAssets installs gentle-ai-worker with a loader-compatible scoped identity", () => {
+test("package installation gives gentle-ai-worker a loader-compatible scoped identity", () => {
 	const temporaryAgentHome = mkdtempSync(join(tmpdir(), "gentle-pi-agent-home-"));
 	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
 
 	try {
 		process.env.GENTLE_PI_AGENT_HOME = temporaryAgentHome;
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true, ["delegation"]);
 
 		const installedAgentsDir = join(temporaryAgentHome, "agents");
 		const installedAgentPath = join(installedAgentsDir, "gentle-ai-worker.md");
@@ -1398,7 +1613,7 @@ test("asset installation uses PI_CODING_AGENT_DIR as the Pi agent home when no e
 		delete process.env.GENTLE_PI_AGENT_HOME;
 		process.env.PI_CODING_AGENT_DIR = temporaryPiAgentDir;
 
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true, ["delegation"]);
 
 		const installedPath = join(temporaryPiAgentDir, "agents", "gentle-ai-explore.md");
 		assert.ok(existsSync(installedPath), "managed agents must install where Pi Subagents reads global definitions");
@@ -1409,7 +1624,7 @@ test("asset installation uses PI_CODING_AGENT_DIR as the Pi agent home when no e
 		);
 
 		process.env.GENTLE_PI_AGENT_HOME = explicitGentleHome;
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true, ["delegation"]);
 		assert.ok(
 			existsSync(join(explicitGentleHome, "agents", "gentle-ai-explore.md")),
 			"GENTLE_PI_AGENT_HOME remains the explicit test/operator override",
@@ -1433,7 +1648,7 @@ test("global model routing uses PI_CODING_AGENT_DIR for package-installed agents
 	try {
 		delete process.env.GENTLE_PI_AGENT_HOME;
 		process.env.PI_CODING_AGENT_DIR = temporaryPiAgentDir;
-		installSddAssets(PACKAGE_ROOT, true);
+		installPackageAssets(PACKAGE_ROOT, true, ["delegation"]);
 
 		const result = applyModelConfig(temporaryProject, {
 			"gentle-ai-explore": { model: "provider/model", thinking: "high" },
@@ -1458,7 +1673,7 @@ test("global model routing uses PI_CODING_AGENT_DIR for package-installed agents
 test("normal and forced installation copy generic agents with complete role contracts", () => {
 	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
 	const expectedTools = {
-		"gentle-ai-explore": ["read", "grep", "find", "codegraph"],
+		"gentle-ai-explore": ["read", "grep", "find", "codegraph", "web_enable", "web_search", "source_check", "fetch_content", "get_search_content"],
 		"gentle-ai-verify": ["read", "grep", "find", "bash"],
 	} as const;
 
@@ -1467,7 +1682,7 @@ test("normal and forced installation copy generic agents with complete role cont
 			const temporaryAgentHome = mkdtempSync(join(tmpdir(), "gentle-pi-generic-agents-"));
 			process.env.GENTLE_PI_AGENT_HOME = temporaryAgentHome;
 			try {
-				installSddAssets(PACKAGE_ROOT, force);
+				installPackageAssets(PACKAGE_ROOT, force, ["delegation"]);
 
 				for (const [name, tools] of Object.entries(expectedTools)) {
 					const packagedPath = join(PACKAGE_ROOT, "assets", "agents", `${name}.md`);
@@ -1476,7 +1691,7 @@ test("normal and forced installation copy generic agents with complete role cont
 					assert.equal(source, readFileSync(packagedPath, "utf8"));
 					assert.equal(installedName, name);
 					assert.deepEqual(installedTools, tools);
-					assert.match(source, /generic non-SDD work/);
+					assert.match(source, /generic ODD work/);
 					assert.match(source, /Do not (?:fix findings, delegate to child agents|delegate to child agents, commit)/);
 					if (name === "gentle-ai-explore") {
 						assert.match(source, /cwd-scoped `codegraph` tool/);
@@ -1488,9 +1703,9 @@ test("normal and forced installation copy generic agents with complete role cont
 					}
 					assert.match(source, /Do not (?:edit, write|edit, write, or fix findings)/);
 					assert.match(source, /compressed (?:handoff|evidence handoff)/);
-					assert.match(source, /Do not use SDD phase protocols or review lenses\./);
+					assert.match(source, /Do not use review lenses\. RDD review remains independent and parent-owned\./);
 					if (name === "gentle-ai-verify") {
-						assert.match(source, /exact test, build, or lint commands explicitly authorized by the parent/);
+						assert.match(source, /exact test, build, lint, or spec example commands explicitly authorized by the parent/);
 						assert.match(source, /only outputs the parent explicitly identified as expected/);
 						assert.match(source, /unexpected mutation as a blocker/);
 						assert.match(source, /do not clean it up or fix it/);
@@ -1506,16 +1721,30 @@ test("normal and forced installation copy generic agents with complete role cont
 	}
 });
 
-test("bounded implementation routing uses the same explicit fallback in both policy sections", () => {
+test("bounded implementation routing resolves the explicit canonical fallback reference", () => {
 	const routing = readFileSync(
 		join(PACKAGE_ROOT, "assets", "orchestrator-delegation.md"),
 		"utf8",
 	);
-	const simpleDelegation = readMarkdownSection(routing, "2. Simple Delegation");
+	const reference = "For bounded writes, follow the canonical Writer rule under Mandatory Delegation Triggers.";
+	const resolveSimpleDelegation = (source: string): string => {
+		const simpleDelegation = readMarkdownSection(source, "2. Simple Delegation");
+		assert.ok(simpleDelegation.split("\n").includes(reference), "Simple Delegation must name the exact canonical Writer rule");
+		const canonical = readMarkdownSection(source, "Mandatory Delegation Triggers");
+		assertWorkerFallbackRouting(canonical, "resolved Simple Delegation");
+		return canonical;
+	};
 	const mandatoryDelegation = readMarkdownSection(routing, "Mandatory Delegation Triggers");
 
-	assertWorkerFallbackRouting(simpleDelegation, "Simple Delegation");
+	assertWorkerFallbackRouting(resolveSimpleDelegation(routing), "Simple Delegation");
 	assertWorkerFallbackRouting(mandatoryDelegation, "Mandatory Delegation Triggers");
+	assert.throws(() => resolveSimpleDelegation(routing.replace(reference, "")), /must name the exact canonical Writer rule/);
+	assert.throws(() => resolveSimpleDelegation(routing.replace(reference, reference.replace("Mandatory Delegation Triggers", "Other Rule"))),
+		/must name the exact canonical Writer rule/);
+	assert.throws(() => resolveSimpleDelegation(routing.replace("#### Mandatory Delegation Triggers", "#### Missing Canonical Rule")),
+		/exactly one Mandatory Delegation Triggers section/);
+	assert.throws(() => resolveSimpleDelegation(routing.replace("user-configured `worker`", "unspecified worker")),
+		/must prefer the package-owned worker before a user-configured worker/);
 	assert.doesNotMatch(
 		routing,
 		/non-normative compatibility quotation|former wording is retained|no-runtime inline exception|superseded by the stop requirement/,
@@ -1531,15 +1760,12 @@ test("bounded implementation routing uses the same explicit fallback in both pol
 test("orchestrator routes generic roles without static RDD lens routing", () => {
 	for (const file of ["orchestrator.md", "orchestrator-delegation.md"]) {
 		const routing = readFileSync(join(PACKAGE_ROOT, "assets", file), "utf8");
-		assert.match(routing, /generic non-SDD exploration[\s\S]*`gentle-ai-explore`/);
-		assert.match(
-			routing,
-			/bounded (?:non-SDD )?(?:implementation|multi-file writes)[\s\S]*`gentle-ai-worker`/,
-		);
-		assert.match(routing, /generic non-SDD (?:technical )?verification[\s\S]*`gentle-ai-verify`/);
-		assert.match(routing, /SDD roles stay inside SDD|Use `sdd-explore` and `sdd-verify` only inside SDD/);
-		assert.match(routing, /(?:truly local )?read-only check(?:ing)? of (?:known )?1[-–]3 known files|1[-–]3-file read-only check/);
-		assert.match(routing, /(?:verification that |verification commands →).*executes? or delegates?|executing\/delegating verification commands/);
+		assert.match(routing, /`gentle-ai-explore`/);
+		assert.match(routing, /`gentle-ai-worker`/);
+		assert.match(routing, /`gentle-ai-verify`/);
+		assert.match(routing, /focused test and (?:the )?suite/);
+		// The Verification rule line itself must route high risk to the verifier.
+		assert.match(routing, /^\d\. \*\*Verification rule\*\*[^\n]*high[- ]risk[^\n]*`gentle-ai-verify`/m);
 		assert.match(routing, /missing(?: or |\/)unusable[\s\S]*native `Agent`[\s\S]*(?:the )?same read-only/);
 		assert.match(routing, /report (?:the )?fallback/);
 		assert.doesNotMatch(routing, /review lenses? (?:inside|only inside)|review lens routing/i);
@@ -1563,13 +1789,10 @@ test("pi-pretty wrapper uses cached ESM loading for compiled and pnpm symlink in
 	assert.match(wrapper, /quietToolsEnabled/);
 });
 
-test("Gentle Shell v3.7.0 package manifest declares the release version", () => {
+test("Gentle Shell v4.1.0 package manifest declares the release version", () => {
 	const packageJson = readPackageJson();
-	assert.equal(packageJson.version, "3.7.0", "the release manifest must be explicitly pinned to v3.7.0");
-	assert.equal(
-		packageJson.scripts?.test,
-		"node --experimental-strip-types --test tests/*.test.ts && pnpm run check:provider-contract && pnpm run test:harness",
-	);
+	assert.equal(packageJson.version, "4.1.0", "the release manifest must be explicitly pinned to v4.1.0");
+	assert.equal(packageJson.scripts?.test, "node scripts/run-test-suite.mjs");
 	assert.ok(packageJson.files?.includes("assets/"));
 	assert.ok(packageJson.files?.includes("contracts/"));
 
@@ -1610,13 +1833,13 @@ 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("package verification no longer requires the retired remediation actor", () => {
+	assert.doesNotMatch(readFileSync(join(PACKAGE_ROOT, "scripts/verify-package-files.mjs"), "utf8"), /^\s*"assets\/agents\/sdd-remediate\.md",?$/m);
 });
 
-test("SDD installation retires owned sync but preserves modified copies and unrelated owners", () => {
+test("package installation retires owned sync but preserves modified copies and unrelated owners", () => {
 	withIsolatedAssetHome((agentHome) => {
-		installSddAssets(agentHome, false);
+		installPackageAssets(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";
@@ -1625,13 +1848,11 @@ test("SDD installation retires owned sync but preserves modified copies and unre
 		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"]);
+		installPackageAssets(agentHome, true, ["delegation"]);
 		assert.equal(readFileSync(path, "utf8"), "User-modified sync instructions\n");
 		assert.equal(installedAssetManifest(agentHome).assets["agents/sdd-sync.md"], undefined);
 	});