gentle-pi 3.7.0 → 4.0.0

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

@@ -45,7 +45,7 @@ test("research uses adaptive evidence gathering and existing general workers onl
 		"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`",
+		"do not create a specialized agent or create a new workflow",
 		"no new persistence or readiness machinery",
 	]);
 });
@@ -129,7 +129,7 @@ test("ODD closes each task with a work-unit commit and reviews the commit or PR
 		"keep a running count from work-unit commits",
 		"`ask-on-risk` (default), `auto-chain`, `single-pr`, or `exception-ok`",
 		"apply the chosen strategy before the next commit",
-		"`ask-on-risk` asks once for the chain strategy, `stacked-to-main` or `feature-branch-chain`",
+		"`ask-on-risk` asks once using the ordered oversized-delivery menu",
 		"`auto-chain` asks only for a missing chain strategy and slices automatically",
 		"Cache both choices, and record slice boundaries",
 		"Resolve the `work-unit-commits` and `chained-pr` skills by registry name",
@@ -145,10 +145,38 @@ test("ODD closes each task with a work-unit commit and reviews the commit or PR
 		"Close task with a work-unit commit",
 		"RDD enabled at work-unit commit boundary",
 		"Running authored lines over 400",
-		"Apply delivery strategy: chained PR slice",
+		"Apply selected delivery strategy",
+		"Single PR; no chain artifacts",
 	]);
 });
 
+test("delivery instructions and docs preserve localized ordered outcomes and override chaining", () => {
+	for (const text of [delegation, read("docs/readme-reference.md")]) {
+		// English prose is documentation evidence, not mandatory runtime UI copy.
+		const outcomes = ["chain_strategy=feature-branch-chain", "chain_strategy=stacked-to-main", "delivery_strategy=single-pr"];
+		let previous = -1;
+		for (const outcome of outcomes) {
+			const index = text.indexOf(outcome);
+			assert.ok(index > previous, `missing or out-of-order semantic outcome: ${outcome}`);
+			previous = index;
+		}
+		assert.match(text, /1\. .*feature\/tracker.*feature-branch-chain/i);
+		assert.match(text, /2\. .*verified default\/main.*stacked-to-main/i);
+		assert.match(text, /3\. .*single PR.*least recommended.*delivery_strategy=single-pr/i);
+		containsAll(text, [
+			"delivery_strategy=single-pr", "not a `chain_strategy` token",
+			"overrides the pending chaining path", "clear the chain choice",
+			"suppress later chain prompts", "not automatically select `exception-ok`",
+			"destination repository's documented contribution/size policy",
+			"not a universal label requirement", "no tracker, child dependency diagram, or Chain Context",
+			"complete user-facing question", "every option label, description, and recommendation marker",
+			"active user's conversation language", "unchanged and untranslated",
+			"English examples are illustrative and localizable, not mandatory copy",
+		]);
+		assert.doesNotMatch(text, /single-pr.*requires? `size:exception`/i);
+	}
+});
+
 test("user documentation shows recovery and candidate-level consent without claiming model proof", () => {
 	const docs = read("docs/readme-reference.md");
 	containsAll(docs, [
@@ -184,24 +212,26 @@ test("one feature document carries intent, accepted rationale and worker context
 	]);
 });
 
-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 defaults to applicable test-first without chat or TUI activation", () => {
+	const worker = read("assets/agents/gentle-ai-worker.md");
+	const verify = read("assets/agents/gentle-ai-verify.md");
+	const support = read("assets/support/strict-tdd.md") + read("assets/support/strict-tdd-verify.md");
+	const skill = read("skills/gentle-ai/SKILL.md");
+	for (const text of [core, delegation, worker, verify, support, skill, wrapper]) {
+		containsAll(text, ["applicable", "RED", "GREEN"]);
+		assert.doesNotMatch(text, /(?:configured TDD mode|Strict TDD Mode is enabled|explicit user choice|test presence does not enable it|tests existing does not activate it)/i);
+	}
+	for (const [actor, text] of [["core", core], ["delegation", delegation], ["extension", wrapper], ["skill", skill]] as const) {
+		assert.match(text, /behavior changes with applicable runnable deterministic tests and a clear expected outcome/i, `${actor} must require applicability, not test presence`);
+		assert.match(text, /passive documentation/i, `${actor} must handle passive docs`);
+		assert.match(text, /unavailable runner/i, `${actor} must handle unavailable runners`);
+		assert.match(text, /ordinary functional or structural verification/i, `${actor} must specify fallback checks`);
+	}
+	containsAll(delegation, ["by default", "Forward this policy"]);
+	containsAll(worker, ["before implementation", "ordinary functional or structural verification", "no meaningful RED"]);
+	containsAll(verify, ["observed RED", "observed GREEN", "exception"]);
+	assert.doesNotMatch(skill, /SDD|OpenSpec/i, "the ODD-only skill must not prime SDD");
+	assert.doesNotMatch(core + delegation + worker + support + skill + wrapper, /If tests exist, use strict TDD/i);
 });
 
 test("mandatory delegation triggers are behavioral in the lazy canonical port and the always-on ODD step", () => {
@@ -212,12 +242,12 @@ test("mandatory delegation triggers are behavioral in the lazy canonical port an
 		"**Mapping trigger",
 		"**Writer trigger",
 		"**Preparation trigger:**",
-		"**Long-session backstop",
+		"**Context backstop:**",
 		"pause and delegate the next bounded unit of work",
 		"**Route declaration:**",
 		"record the chosen route per task",
 		"so skipped delegation is observable instead of silent",
-		"These triggers never select SDD and never create SDD artifacts",
+		"These triggers only choose between direct inline and delegated direct inside ODD",
 	]) {
 		assert.ok(delegation.includes(clause), `lazy canonical port is missing mandatory delegation clause: ${clause}`);
 	}
@@ -233,19 +263,19 @@ test("mandatory delegation triggers are behavioral in the lazy canonical port an
 
 test("core and lazy canonical trigger lists agree in numbering and semantics", () => {
 	for (const entry of [
-		"1. **4-file rule**",
+		"1. **Evidence-budget rule**",
 		"2. **Multi-file write rule**",
 		"3. **Incident rule**",
-		"4. **Long-session rule**",
+		"4. **Context backstop**",
 		"5. **Verification rule**",
 	]) {
 		assert.ok(core.includes(entry), `always-on core trigger list is missing: ${entry}`);
 	}
 	for (const entry of [
-		"1. **Mapping trigger (4-file rule):**",
+		"1. **Mapping trigger (Evidence-budget rule):**",
 		"2. **Writer trigger (Multi-file write rule):**",
 		"3. **Incident rule:**",
-		"4. **Long-session backstop (Long-session rule):**",
+		"4. **Context backstop:**",
 		"5. **Verification rule**",
 	]) {
 		assert.ok(delegation.includes(entry), `lazy canonical trigger list is missing: ${entry}`);
@@ -255,17 +285,41 @@ test("core and lazy canonical trigger lists agree in numbering and semantics", (
 		"**Write rule**",
 		"**Context rule**",
 		"**Per-action rule**",
-		"**Optional SDD rule**",
 	]) {
 		assert.ok(!delegation.includes(stale), `reconciled canonical list retains stale trigger framing: ${stale}`);
 	}
 });
 
+// Evidence-budget rule (gentle-shell#1587, measured in gentle-ai#5139): every
+// routing surface states the same numbers, and the retired file-count and
+// tool-call triggers are gone from all of them.
+test("evidence-budget numbers agree across routing surfaces and retired triggers are gone", () => {
+	const surfaces: Record<string, string> = {
+		"assets/orchestrator.md": core,
+		"assets/orchestrator-delegation.md": delegation,
+		"skills/gentle-ai/SKILL.md": read("skills/gentle-ai/SKILL.md"),
+	};
+	for (const [path, text] of Object.entries(surfaces)) {
+		containsAll(text, [
+			"**Evidence-budget rule**",
+			"at most 3 calls",
+			"~10k tokens",
+			"at most ~2k tokens",
+			"`path:line`",
+			"~150k tokens",
+			"Context backstop",
+		]);
+		assert.doesNotMatch(text, /4-file rule|20 tool calls|5 exploratory (?:file )?reads/, `${path} keeps a retired trigger`);
+	}
+	for (const agent of ["assets/agents/gentle-ai-explore.md", "assets/agents/gentle-ai-verify.md"]) {
+		containsAll(read(agent), ["at most ~2k tokens", "`path:line`"]);
+	}
+});
+
 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.**",
@@ -277,6 +331,7 @@ test("ODD protocol is always-on in the rendered system prompt and runs by defaul
 		"Tell the user in one line which feature document was created and how many tasks it holds",
 		"6. **Implement task by task.**",
 		"7. **Close.**",
+		"call `gentle_odd_phase` only when the primary session's ODD phase actually changes",
 		"Harness principles:",
 		"# el Gentleman Orchestrator",
 	];
@@ -298,15 +353,11 @@ test("ODD protocol is always-on in the rendered system prompt and runs by defaul
 		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",
-	);
+	// The parent owns the injected identity; its migration is outside this suite's edit surface.
 	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"]);
+	assert.doesNotMatch(core + delegation + memory, /SDD|sdd-|OpenSpec|openspec/i);
 });

package/tests/orchestrator-budget.test.ts

@@ -35,7 +35,6 @@ const MIN_CONTROLLED_LONG_ASSETS_ROOT_CHARS = 93;
 
 const LAZY_ASSET_NAMES = [
 	"orchestrator.md",
-	"sdd-orchestrator-workflow.md",
 	"orchestrator-delegation.md",
 	"orchestrator-memory.md",
 	"orchestrator-skills.md",
@@ -193,16 +192,17 @@ const TARGET_FILE: Record<Target, string> = {
 // Line numbers below are 1-indexed against tests/fixtures/orchestrator.pre-diet.md
 // (frozen byte-identical copy of assets/orchestrator.md at 23,047 B / 312 lines).
 const DISPOSITION_MAP: DispositionRange[] = [
-	{ lines: [1, 4], target: "core", label: "Header + bind" },
+	{ lines: [1, 4], target: "replaced", label: "Header + bind: retired phase qualification" },
 	{ lines: [5, 8], target: "core", label: "Identity Contract" },
 	{ lines: [9, 13], target: "core", label: "Core Role" },
 	{ lines: [15, 15], target: "core", label: "Language Boundary heading" },
 	{ lines: [17, 17], target: "core", label: "Language Boundary LB1 pointer" },
 	{ lines: [19, 19], target: "delegation", label: "Language Boundary LB2 (subagent-English)" },
-	{ lines: [21, 21], target: "core", label: "Language Boundary LB3 (artifact language)" },
+	{ lines: [21, 21], target: "replaced", label: "Language Boundary LB3: retired artifact types" },
 	{ lines: [23, 23], target: "core", label: "Language Boundary LB4 (public comment language)" },
-	{ lines: [25, 29], target: "delegation", label: "Language Boundary LB5 (exceptions)" },
-	{ lines: [31, 40], target: "core", label: "Mental Model" },
+	{ lines: [25, 28], target: "delegation", label: "Language Boundary LB5 (exceptions)" },
+	{ lines: [29, 29], target: "obsolete", label: "Retired artifact exception" },
+	{ lines: [31, 40], target: "replaced", label: "Mental Model: ODD-only" },
 	{ lines: [42, 42], target: "core", label: "Work Routing Ladder heading" },
 	{
 		lines: [44, 97],
@@ -251,7 +251,7 @@ const DISPOSITION_MAP: DispositionRange[] = [
 		target: "obsolete",
 		label: "Parent-selected review lens table replaced by native RAR lens ownership (#312)",
 	},
-	{ lines: [183, 191], target: "core", label: "SDD Workflow pointer" },
+	{ lines: [183, 191], target: "obsolete", label: "Retired workflow pointer" },
 	{ lines: [193, 193], target: "core", label: "Memory Contract heading" },
 	{
 		lines: [195, 195],
@@ -263,9 +263,9 @@ const DISPOSITION_MAP: DispositionRange[] = [
 		target: "replaced",
 		label: "Verbose non-SDD memory forwarding replaced by compact ownership (#3417)",
 	},
-	{ lines: [203, 230], target: "memory", label: "Memory Contract SDD phases table + artifact keys + lifecycle rule" },
+	{ lines: [203, 230], target: "replaced", label: "Retired phase keys; memory lifecycle remains" },
 	{ lines: [232, 232], target: "core", label: "Skill Registry Protocol heading" },
-	{ lines: [234, 253], target: "skills", label: "Skill Registry Protocol detail" },
+	{ lines: [234, 253], target: "replaced", label: "Skill resolution retained without phase roles" },
 	{ lines: [255, 255], target: "core", label: "Intent-Driven Skill Discovery heading" },
 	{ lines: [257, 276], target: "skills", label: "Intent-Driven Skill Discovery detail" },
 	{ lines: [278, 283], target: "core", label: "Safety" },
@@ -284,8 +284,6 @@ const fixtureLines = readFileSync(FIXTURE_PATH, "utf8").split("\n");
 // 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.";
 const SUPERSEDED_LIFECYCLE_REVIEW_LINES = new Set([
 	70,
 	// 74/77: the loose mode-choice background lines were replaced by the
@@ -321,25 +319,7 @@ for (const range of DISPOSITION_MAP) {
 				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;
-				}
+					trimmed;
 				if (SUPERSEDED_LIFECYCLE_REVIEW_LINES.has(ln)) {
 					assert.ok(
 						!targetContent.includes(trimmed),
@@ -370,11 +350,11 @@ for (const range of DISPOSITION_MAP) {
 
 test("core-alone: load-bearing direct-delegation tokens remain without lazy union", () => {
 	const core = readRealAsset("orchestrator.md");
-	assert.match(core, /4-file rule/);
+	assert.match(core, /Evidence-budget rule/);
 	assert.match(core, /Multi-file write rule/);
 	assert.match(core, /Incident rule/);
 	assert.match(core, /Verification rule/);
-	assert.match(core, /Long-session rule/);
+	assert.match(core, /Context backstop/);
 });
 
 test("core-alone: dynamic Gentle AI ownership replaces package lifecycle instructions", () => {
@@ -420,7 +400,7 @@ test("relocated lazy bodies are not double-delivered in the always-on core", ()
 	);
 	assert.doesNotMatch(
 		rendered,
-		/### SDD phases/,
+		/### Organic feature continuity/,
 		"memory-only body leaked into the always-on core",
 	);
 	assert.doesNotMatch(
@@ -472,7 +452,7 @@ test("every compressed lazy-file pointer in the core still names the material it
 		},
 		{
 			file: "orchestrator-memory.md",
-			mustName: ["Phase table", "artifact keys"],
+			mustName: ["ODD task continuity", "memory lifecycle"],
 		},
 		{
 			file: "orchestrator-skills.md",
@@ -497,10 +477,5 @@ test("every compressed lazy-file pointer in the core still names the material it
 			);
 		}
 	}
-	// The SDD workflow pointer was never compressed to a bare filename; its
-	// surrounding paragraphs already name the material at length.
-	assert.match(
-		core,
-		/SDD phases, native dispatcher rules, status contract, preflight\/init guards, artifact-store policy, execution mode, Strict TDD forwarding, phase result contract, and review workload guard/,
-	);
+	assert.doesNotMatch(core, /SDD|sdd-|OpenSpec|openspec/i);
 });

package/tests/orchestrator-rdd-ownership.test.ts

@@ -72,18 +72,18 @@ test("rendered parent prompt keeps the RDD boundary while omitting lifecycle mir
 	assert.ok(Buffer.byteLength(rendered, "utf8") <= 8192, "the rendered parent prompt must stay below the reduced 8 KiB budget");
 });
 
-test("static prompts retain normal SDD and delegated-work guidance", () => {
-	for (const heading of ["## SDD Workflow (lazy-loaded)", "## Memory Contract"]) {
+test("static prompts retain ODD and delegated-work guidance without SDD", () => {
+	for (const heading of ["## Memory Contract", "## Work Routing Ladder"]) {
 		assert.ok(core.includes(heading), `core lost ${heading}`);
 	}
 	for (const heading of [
 		"### Delegation Rules",
 		"#### Background Subagent Policy",
 		"#### Allowed edit surfaces (MANDATORY)",
-		"### 3. SDD (optional)",
 	]) {
 		assert.ok(delegation.includes(heading), `delegation lost ${heading}`);
 	}
+	assert.doesNotMatch(staticPrompts, /SDD|sdd-|OpenSpec|openspec/i);
 });
 
 test("always-on parent prompt requires a narrow writer edit surface before launch", () => {

package/tests/overlay-repaint.test.ts

@@ -0,0 +1,74 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { withOverlayRepaint } from "../lib/overlay-repaint.ts";
+import type { TUI } from "@earendil-works/pi-tui";
+
+// Overlay close repaint: wrapping an overlay's done callback must tear the
+// overlay down first (done), then force a FULL terminal repaint
+// (invalidate + requestRender) so a fullscreen overlay's stale cell state
+// cannot survive the close. Paint failures are swallowed; done failures are not.
+
+function fakeTui() {
+	const calls: string[] = [];
+	const tui = {
+		invalidate: () => {
+			calls.push("invalidate");
+		},
+		requestRender: () => {
+			calls.push("requestRender");
+		},
+	} as unknown as TUI;
+	return { tui, calls };
+}
+
+test("withOverlayRepaint: forces a full render (requestRender(true)) after done", () => {
+	const calls: string[] = [];
+	const tui = {
+		requestRender: (force?: boolean) => {
+			calls.push(`requestRender:${force === true}`);
+		},
+	} as unknown as TUI;
+	const close = withOverlayRepaint<string | null>(tui, (result) => {
+		calls.push(`done:${String(result)}`);
+	});
+	close(null);
+	assert.deepEqual(calls, ["done:null", "requestRender:true"]);
+});
+
+test("withOverlayRepaint: forwards null results (plain close)", () => {
+	const calls: string[] = [];
+	const tui = {
+		requestRender: (force?: boolean) => {
+			calls.push(`requestRender:${force === true}`);
+		},
+	} as unknown as TUI;
+	const seen: Array<string | null> = [];
+	const close = withOverlayRepaint<string | null>(tui, (result) => {
+		seen.push(result);
+	});
+	close(null);
+	assert.deepEqual(seen, [null]);
+	assert.deepEqual(calls, ["requestRender:true"]);
+});
+
+test("withOverlayRepaint: paint failure is swallowed, done result still delivered", () => {
+	const seen: Array<string | null> = [];
+	const tui = {
+		requestRender: () => {
+			throw new Error("EIO");
+		},
+	} as unknown as TUI;
+	const close = withOverlayRepaint<string | null>(tui, (result) => {
+		seen.push(result);
+	});
+	assert.doesNotThrow(() => close(null));
+	assert.deepEqual(seen, [null]);
+});
+
+test("withOverlayRepaint: done failure propagates (overlay contract, not paint)", () => {
+	const { tui } = fakeTui();
+	const close = withOverlayRepaint<string | null>(tui, () => {
+		throw new Error("overlay teardown failed");
+	});
+	assert.throws(() => close(null), /overlay teardown failed/);
+});