gentle-pi 3.7.0 → 4.0.0

package/tests/yolo-mode.test.ts

@@ -0,0 +1,261 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { captureReviewSessionIdentity, grantReviewSessionPermission, hasReviewSessionPermission, revokeReviewSessionPermission } from "../lib/review-session-standing-permission.ts";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
+import { YOLO_STATUS_TEXT } from "../lib/yolo-session-policy.ts";
+
+const ON_TEXT = "🚀 YOLO ON 🔥 — destructive confirmations remain";
+const USAGE = "Use /gentle:yolo enable|disable|status. State unchanged.";
+const STALE_MENU = "YOLO unchanged — the session changed while the menu was open.";
+const menuTitle = (state: "ON" | "OFF") => `🚀 Gentle YOLO 🔥 — full speed, destructive actions still ask (current: ${state})`;
+
+export function harness(env: NodeJS.ProcessEnv = {}) {
+	const commands = new Map<string, { handler: (args: string, ctx: ExtensionContext) => Promise<void> }>();
+	const handlers = new Map<string, Array<(event: unknown, ctx: ExtensionContext) => unknown>>();
+	const tools: string[] = [];
+	const notices: string[] = [];
+	const statuses = new Map<string, string | undefined>();
+	const widgets = new Map<string, unknown>();
+	let confirmations = 0;
+	let sessionId = "yolo-test";
+	const ctx = {
+		cwd: process.cwd(), mode: "tui", hasUI: true,
+		sessionManager: { getSessionId: () => sessionId },
+		ui: {
+			notify: (text: string) => notices.push(text),
+			setStatus: (key: string, text?: string) => statuses.set(key, text),
+			setWidget: (key: string, value: unknown) => widgets.set(key, value),
+			confirm: async () => { confirmations++; return false; },
+		},
+	} as unknown as ExtensionContext;
+	const pi = {
+		on: (name: string, fn: (event: unknown, ctx: ExtensionContext) => unknown) => {
+			const list = handlers.get(name) ?? []; list.push(fn); handlers.set(name, list);
+		},
+		registerCommand: (name: string, command: { handler: (args: string, ctx: ExtensionContext) => Promise<void> }) => commands.set(name, command),
+		registerTool: (tool: { name: string }) => tools.push(tool.name),
+		registerMessageRenderer() {}, registerFlag() {},
+		events: { emit() {}, on: () => () => {} },
+		getActiveTools: () => [],
+	} as unknown as ExtensionAPI;
+	createGentleAiExtension({ nativeReviewCli: null, candidateViews: null, processEnv: env,
+		resolveTelemetryTriggerBinary: () => { throw new Error("disabled in test"); },
+	})(pi);
+	return { ctx, commands, tools, notices, statuses, widgets, confirmations: () => confirmations,
+		setSessionId: (id: string) => { sessionId = id; },
+		command: async (args: string) => { const cmd = commands.get("gentle:yolo"); assert.ok(cmd, "/gentle:yolo registered"); await cmd.handler(args, ctx); },
+		setSelect: (select: (title: string, options: string[]) => Promise<string | undefined>) => { Object.assign(ctx.ui, { select }); },
+		emit: async (name: string, event: unknown) => {
+			let result: unknown; for (const fn of handlers.get(name) ?? []) { const next = await fn(event, ctx); if (next !== undefined) result = next; } return result;
+		},
+	};
+}
+
+test("only /gentle:yolo is registered and the ON text carries the rocket and fire markers", () => {
+	const h = harness();
+	assert.equal(h.commands.has("yolo"), false, "bare yolo command is not registered");
+	assert.ok(h.commands.has("gentle:yolo"));
+	assert.equal(YOLO_STATUS_TEXT, ON_TEXT);
+});
+
+test("human command enable/disable/status/invalid and status/widget clearing", async () => {
+	const h = harness();
+	assert.equal(h.tools.some((name) => name.includes("yolo")), false);
+	await h.command("status"); assert.match(h.notices.at(-1)!, /OFF/);
+	await h.command("enable");
+	assert.equal(h.statuses.get("gentle:yolo"), ON_TEXT);
+	assert.deepEqual(h.widgets.get("gentle:yolo"), [ON_TEXT]);
+	for (const invalid of ["invalid", "on", "off", "toggle"]) {
+		await h.command(invalid);
+		assert.equal(h.notices.at(-1), USAGE);
+		assert.equal(h.statuses.get("gentle:yolo"), ON_TEXT, `${invalid} leaves state unchanged`);
+	}
+	await h.command("status"); assert.match(h.notices.at(-1)!, /ON/);
+	await h.command("disable"); assert.equal(h.statuses.get("gentle:yolo"), undefined);
+	assert.equal(h.widgets.get("gentle:yolo"), undefined);
+	await h.command("status"); assert.match(h.notices.at(-1)!, /OFF/);
+});
+
+test("no argument without a select-capable UI reports status and never toggles", async () => {
+	const h = harness();
+	await h.command(""); assert.equal(h.notices.at(-1), "YOLO OFF");
+	assert.equal(h.statuses.get("gentle:yolo"), undefined);
+	await h.command("enable");
+	await h.command(""); assert.equal(h.notices.at(-1), ON_TEXT);
+	assert.equal(h.statuses.get("gentle:yolo"), ON_TEXT);
+	let prompts = 0;
+	h.setSelect(async () => { prompts++; return "disable"; });
+	Object.assign(h.ctx, { hasUI: false });
+	await h.command("");
+	assert.equal(prompts, 0, "headless callers never see the menu");
+	assert.match(h.notices.at(-1)!, /OFF/, "headless status reflects fail-closed scope, not a menu choice");
+});
+
+test("no-argument menu shows the fire title and live state; only an explicit selection changes it", async () => {
+	const h = harness();
+	const prompts: Array<{ title: string; options: string[] }> = [];
+	let answer: string | undefined;
+	h.setSelect(async (title, options) => { prompts.push({ title, options }); return answer; });
+	const notices = h.notices.length;
+	await h.command("");
+	assert.deepEqual(prompts.at(-1), { title: menuTitle("OFF"), options: ["enable", "disable", "status"] });
+	assert.equal(h.notices.length, notices, "cancel does nothing");
+	assert.equal(h.statuses.get("gentle:yolo"), undefined);
+	answer = "status"; await h.command("");
+	assert.equal(h.notices.at(-1), "YOLO OFF"); assert.equal(h.statuses.get("gentle:yolo"), undefined);
+	answer = "enable"; await h.command("");
+	assert.equal(h.statuses.get("gentle:yolo"), ON_TEXT); assert.equal(h.notices.at(-1), ON_TEXT);
+	answer = undefined; await h.command("");
+	assert.equal(prompts.at(-1)!.title, menuTitle("ON"));
+	assert.equal(h.statuses.get("gentle:yolo"), ON_TEXT, "cancel leaves ON unchanged");
+	answer = "disable"; await h.command("");
+	assert.equal(h.statuses.get("gentle:yolo"), undefined); assert.equal(h.notices.at(-1), "YOLO OFF");
+	const shown = prompts.length;
+	await h.command("status"); await h.command("invalid");
+	assert.equal(prompts.length, shown, "explicit arguments bypass the menu");
+	assert.equal(h.notices.at(-1), USAGE);
+});
+
+test("revocation wins over an activation still awaiting Git identity", async () => {
+	for (const reason of ["off", "reload", "new", "resume", "fork", "quit"]) {
+		const h = harness();
+		const pending = h.command("enable");
+		if (reason === "off") await h.command("disable");
+		else await h.emit("session_shutdown", { reason });
+		await pending;
+		await h.command("status"); assert.match(h.notices.at(-1)!, /OFF/);
+		assert.equal(h.widgets.get("gentle:yolo"), undefined);
+	}
+});
+
+test("child, headless, RPC and unidentified repository cannot activate", async () => {
+	for (const variant of ["child", "headless", "rpc", "no-repository"]) {
+		const h = harness(variant === "child" ? { GENTLE_PI_AGENTS_CHILD: "1" } : {});
+		if (variant === "headless") Object.assign(h.ctx, { hasUI: false });
+		if (variant === "rpc") Object.assign(h.ctx, { mode: "rpc" });
+		if (variant === "no-repository") Object.assign(h.ctx, { cwd: "/" });
+		await h.command("enable"); assert.notEqual(h.statuses.get("gentle:yolo"), ON_TEXT);
+		h.setSelect(async () => "enable");
+		await h.command(""); assert.notEqual(h.statuses.get("gentle:yolo"), ON_TEXT, `${variant} menu enable fails closed`);
+	}
+});
+
+test("structured primary prompt gains and loses directive; named child does not inherit", async () => {
+	const h = harness();
+	const options = { appendSystemPrompt: "base" };
+	const event = { systemPromptOptions: options, prompt: "task", systemPrompt: "base" };
+	await h.command("enable"); await h.emit("before_agent_start", event);
+	assert.match(options.appendSystemPrompt, /YOLO session standing permission/);
+	await h.command("disable"); await h.emit("before_agent_start", event);
+	assert.doesNotMatch(options.appendSystemPrompt, /YOLO session standing permission/);
+	await h.command("enable");
+	await h.emit("before_agent_start", { ...event, agent: { name: "worker" } });
+	assert.doesNotMatch(options.appendSystemPrompt, /YOLO session standing permission/);
+	assert.ok(await h.emit("tool_call", { toolName: "bash", input: { command: "git push origin main" } }), "named child has no push waiver");
+});
+
+test("session loss and shutdown (including reload) revoke visible state", async () => {
+	for (const reason of ["new", "resume", "fork", "reload", "quit"]) {
+		const h = harness(); await h.command("enable");
+		const event = { prompt: "task", systemPromptOptions: { appendSystemPrompt: "base" } };
+		await h.emit("before_agent_start", event);
+		assert.match(event.systemPromptOptions.appendSystemPrompt, /YOLO session standing permission/);
+		await h.emit("session_shutdown", { reason });
+		assert.equal(h.widgets.get("gentle:yolo"), undefined);
+		assert.equal(h.statuses.get("gentle:yolo"), undefined);
+		await h.emit("before_agent_start", event);
+		assert.doesNotMatch(event.systemPromptOptions.appendSystemPrompt, /YOLO session standing permission/);
+		await h.command("status"); assert.match(h.notices.at(-1)!, /OFF/);
+	}
+	const h = harness(); await h.command("enable"); h.setSessionId("replacement");
+	await h.command("status"); assert.match(h.notices.at(-1)!, /OFF/);
+});
+
+test("active YOLO waives only ordinary push after full destructive/guard evaluation", async () => {
+	const h = harness();
+	const call = (command: string) => h.emit("tool_call", { toolName: "bash", input: { command } });
+	assert.deepEqual(await call("git push origin main"), { block: true, reason: "Gentle AI safety policy blocked the command because it was not confirmed." });
+	await h.command("enable");
+	assert.equal(await call("git push origin main"), undefined);
+	assert.equal(h.confirmations(), 1);
+	for (const command of ["git push origin main && rm -rf ./data", `sh -c "psql -c 'DROP TABLE users'"`, "git push origin main && git rebase main", "git push --force origin main", "git push origin main && npm publish", "git -C /other push origin main", "sh -c 'git push origin main'"]) {
+		assert.ok(await call(command), command);
+	}
+	await h.command("disable"); assert.ok(await call("git push origin main"));
+});
+
+test("active command path preserves configured push confirmations and blocks, including legacy env override", async () => {
+	const configHome = mkdtempSync(join(tmpdir(), "gentle-yolo-config-"));
+	const previousHome = process.env.GENTLE_PI_CONFIG_HOME;
+	const previousAutonomy = process.env.GENTLE_PI_AUTONOMOUS_MODE;
+	process.env.GENTLE_PI_CONFIG_HOME = configHome;
+	try {
+		for (const envOverride of [undefined, "1"]) {
+			if (envOverride === undefined) delete process.env.GENTLE_PI_AUTONOMOUS_MODE;
+			else process.env.GENTLE_PI_AUTONOMOUS_MODE = envOverride;
+			for (const action of ["confirm", "block"]) {
+				writeFileSync(join(configHome, "runtime-guardrails.json"), JSON.stringify({ autonomousMode: false, guardedCommands: { gitPush: action } }));
+				const h = harness(); await h.command("enable");
+				assert.ok(await h.emit("tool_call", { toolName: "bash", input: { command: "git push origin main" } }));
+				assert.equal(h.confirmations(), action === "confirm" ? 1 : 0);
+			}
+		}
+	} finally {
+		if (previousHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME; else process.env.GENTLE_PI_CONFIG_HOME = previousHome;
+		if (previousAutonomy === undefined) delete process.env.GENTLE_PI_AUTONOMOUS_MODE; else process.env.GENTLE_PI_AUTONOMOUS_MODE = previousAutonomy;
+		rmSync(configHome, { recursive: true, force: true });
+	}
+});
+
+test("YOLO never grants or revokes separate review standing permission and never answers ask_user", async () => {
+	const h = harness();
+	const identity = await captureReviewSessionIdentity(h.ctx, {}); assert.ok(identity);
+	assert.equal(hasReviewSessionPermission(identity), false);
+	await h.command("enable"); assert.equal(hasReviewSessionPermission(identity), false);
+	grantReviewSessionPermission(identity);
+	await h.command("disable"); assert.equal(hasReviewSessionPermission(identity), true);
+	await h.command("enable");
+	const question = { toolName: "ask_user", input: { question: "Authorize recovery?", options: ["Approve", "Decline"] } };
+	const original = structuredClone(question);
+	assert.equal(await h.emit("tool_call", question), undefined);
+	assert.deepEqual(question, original);
+	assert.equal(h.confirmations(), 0);
+	assert.equal(hasReviewSessionPermission(identity), true);
+	revokeReviewSessionPermission(identity);
+});
+
+test("tool input and task text cannot activate; scope/UI loss removes instruction and widget", async () => {
+	const h = harness();
+	await h.emit("tool_call", { toolName: "bash", input: { command: "echo harmless", yolo: "on" } });
+	const event = { prompt: "/gentle:yolo enable", systemPromptOptions: { appendSystemPrompt: "base" } };
+	await h.emit("before_agent_start", event);
+	assert.doesNotMatch(event.systemPromptOptions.appendSystemPrompt, /YOLO session standing permission/);
+	await h.command("enable");
+	Object.assign(h.ctx, { cwd: "/" });
+	await h.emit("before_agent_start", event);
+	assert.equal(h.widgets.get("gentle:yolo"), undefined);
+	assert.doesNotMatch(event.systemPromptOptions.appendSystemPrompt, /YOLO session standing permission/);
+	Object.assign(h.ctx, { cwd: process.cwd() });
+	await h.command("status"); assert.match(h.notices.at(-1)!, /OFF/);
+	await h.command("enable"); Object.assign(h.ctx, { hasUI: false });
+	await h.emit("before_agent_start", event);
+	assert.equal(h.statuses.get("gentle:yolo"), undefined);
+});
+
+test("a session replaced while the menu is open cannot receive the enable choice", async () => {
+	const h = harness();
+	h.setSelect(async () => { h.setSessionId("replacement-session"); return "enable"; });
+	await h.command("");
+	assert.equal(h.statuses.get("gentle:yolo"), undefined, "stale menu choice never activates the new session");
+	assert.equal(h.notices.at(-1), STALE_MENU, "the discarded choice is reported, not silent");
+	h.setSelect(async () => { h.setSessionId("another-session"); return "disable"; });
+	await h.command("");
+	assert.equal(h.notices.at(-1), STALE_MENU, "a stale disable is reported too");
+	h.setSelect(async () => "status");
+	await h.command("");
+	assert.equal(h.notices.at(-1), "YOLO OFF");
+});

package/tests/yolo-session-policy.test.ts

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { YoloSessionPolicy, YOLO_DIRECTIVE, updateYoloPrompt, registerYoloSessionPolicy, discoverYoloUiAdapter } from "../lib/yolo-session-policy.ts";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ReviewSessionIdentity } from "../lib/review-session-standing-permission.ts";
+
+function identity(): ReviewSessionIdentity {
+	return { sessionManager: { getSessionId: () => "live" }, sessionId: "live", repositoryIdentity: "clone-a", worktreeRoot: "/repo" };
+}
+
+test("YOLO defaults off; explicit activation is exact-live-session and clone bound", () => {
+	const policy = new YoloSessionPolicy();
+	const live = identity();
+	assert.equal(policy.active(live), false);
+	assert.equal(policy.set(true, live), true);
+	assert.equal(policy.active({ ...live, worktreeRoot: "/sibling" }), true);
+	assert.equal(policy.active({ ...live, repositoryIdentity: "clone-b" }), false);
+	assert.equal(policy.active(live), false, "scope loss revokes, not merely hides");
+	for (const other of [undefined, { ...live, sessionId: "resumed" }, identity()]) {
+		policy.set(true, live);
+		assert.equal(policy.active(other), false);
+	}
+	assert.equal(policy.set(true, undefined), false);
+});
+
+test("off/reset/restart revoke and invalidate pending activation", () => {
+	const policy = new YoloSessionPolicy();
+	const live = identity();
+	const epoch = policy.epoch;
+	policy.reset();
+	assert.equal(policy.set(true, live, epoch), false);
+	policy.set(true, live);
+	policy.set(false, live);
+	assert.equal(policy.active(live), false);
+	policy.set(true, live);
+	policy.reset();
+	assert.equal(policy.active(live), false);
+	assert.equal(new YoloSessionPolicy().active(live), false);
+});
+
+test("legacy hosts without an event bus retain command registration but no menu adapter", async () => {
+	const commands: string[] = [];
+	const pi = { registerCommand: (name: string) => commands.push(name) } as unknown as ExtensionAPI;
+	assert.ok(registerYoloSessionPolicy(pi, {}));
+	assert.deepEqual(commands, ["gentle:yolo"], "bare yolo command is not registered");
+	assert.equal(await discoverYoloUiAdapter(pi, {} as ExtensionContext), undefined);
+});
+
+test("active-only structured directive qualifies defaults and is removed from reused options", () => {
+	const options = { appendSystemPrompt: "existing harness" };
+	updateYoloPrompt(options, true);
+	updateYoloPrompt(options, true);
+	assert.equal(options.appendSystemPrompt.split(YOLO_DIRECTIVE).length, 2);
+	assert.match(YOLO_DIRECTIVE, /default.*commit.*push.*PR/i);
+	assert.match(YOLO_DIRECTIVE, /ask_user/);
+	assert.match(YOLO_DIRECTIVE, /credentials/);
+	updateYoloPrompt(options, false);
+	assert.equal(options.appendSystemPrompt, "existing harness");
+});

package/themes/Gentle.json

@@ -5,6 +5,7 @@
     "bg": "#06080f",
     "bgPanel": "#06080f",
     "bgElement": "#06080f",
+    "userMessageBg": "#161D2E",
     "bgSubtle": "#0d0f14",
     "surfaceLine": "#0d0f14",
     "border": "#313342",
@@ -52,7 +53,7 @@
     "text": "text",
     "thinkingText": "muted",
     "selectedBg": "selection",
-    "userMessageBg": "bgElement",
+    "userMessageBg": "userMessageBg",
     "userMessageText": "text",
     "customMessageBg": "bgSubtle",
     "customMessageText": "text",

package/themes/Gentleman-Cute.json

@@ -5,6 +5,7 @@
     "bg": "#060407",
     "bgPanel": "#100A0F",
     "bgElement": "#100A0F",
+    "userMessageBg": "#2A1523",
     "bgSubtle": "#100A0F",
     "border": "#563040",
     "borderSubtle": "#2A1720",
@@ -45,7 +46,7 @@
     "scrollbarThumb": "border",
     "searchMatchBg": "deepPink",
     "searchMatchText": "text",
-    "userMessageBg": "bgElement",
+    "userMessageBg": "userMessageBg",
     "userMessageText": "text",
     "customMessageBg": "bgSubtle",
     "customMessageText": "text",

package/themes/Gentleman-Sexy.json

@@ -5,6 +5,7 @@
     "bg": "#060407",
     "bgPanel": "#100A0F",
     "bgElement": "#100A0F",
+    "userMessageBg": "#2E0F1F",
     "bgSubtle": "#100A0F",
     "border": "#563040",
     "borderSubtle": "#2A1720",
@@ -43,7 +44,7 @@
     "scrollbarThumb": "border",
     "searchMatchBg": "deepPink",
     "searchMatchText": "text",
-    "userMessageBg": "bgElement",
+    "userMessageBg": "userMessageBg",
     "userMessageText": "text",
     "customMessageBg": "bgSubtle",
     "customMessageText": "text",

package/assets/agents/sdd-apply.md

@@ -1,159 +0,0 @@
----
-name: sdd-apply
-description: Implement SDD tasks with strict TDD evidence and review workload guard.
-tools:
-  - read
-  - grep
-  - find
-  - edit
-  - write
-  - bash
-  - mem_search
-  - mem_get_observation
-  - mem_save
-  - mem_update
----
-
-You are the SDD apply executor for Gentle AI.
-
-## Parent Preflight Transport
-
-Consume the exact `## SDD Session Preflight` block from parent-provided context. It is parent authority, not a prompt to infer or persist defaults. If absent or malformed, return `blocked` without phase work. A delegated RPC child never confirms or persists SDD choices.
-
-## Skill Resolution Contract
-
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
-
-If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
-
-## Memory Contract
-
-Read your own input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
-
-Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
-- Tasks (required): `sdd/{change}/tasks`
-- Spec (required): `sdd/{change}/spec`
-- Design (required): `sdd/{change}/design`
-- Previous apply-progress (if it exists): `sdd/{change}/apply-progress` — read and MERGE with your new progress; do NOT overwrite.
-
-Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/apply-progress"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
-- Also update the tasks artifact checkboxes via the injected Engram update tool (`engram`/`both`) or file edit (`openspec`/`both`).
-- `openspec` / `both`: write/update the apply-progress and tasks files under `openspec/changes/{change}/`.
-- `none`: return progress inline.
-
-For `both`, read back each selected backend and report its actual result. File and Engram writes are not atomic: retain successful writes and cumulative progress, disclose failed or divergent copies, and do not claim complete persistence or switch stores to hide a failure.
-
-Never claim persistence you did not perform.
-
-## Status and Action Context Guard
-
-Before writing code, consume validated native `gentle-ai.sdd-status` v2 from the parent. If missing, request native read-only status for the selected change and canonical workspace. Never reconstruct readiness locally or from Engram artifacts; native `nextRecommended` and `phaseInstructions` own the route for every store. Reject malformed or unsupported actions before work, without prose inference or fallback.
-
-Read artifacts from the selected backend for implementation context, not as replacement lifecycle authority. Status grants no writes. Explicit continuation may prepare only the exact canonical marker path confirmed by the current human; denial, cancellation, missing UI, and workspace mismatch prohibit mutation. Marker preparation grants no source roots or persistent authority.
-
-Stop with `blocked` before editing if:
-
-- active change selection is missing or ambiguous;
-- native apply dependency is blocked;
-- required apply artifacts are missing (confirmed by artifact store);
-- `actionContext.mode: workspace-planning` and no `allowedEditRoots` are provided;
-- any target file is outside the authoritative workspace or allowed edit roots.
-
-If status says `applyState: all_done`, do not edit. Report that implementation is complete and return the fresh native recommendation (classically `archive`; an older provider may still require `verify`). Do not recommend apply again after all implementation tasks are complete.
-
-## Before Writing Code
-
-Read structured status, proposal, specs, design, tasks, existing code, tests, `apply-progress.md` if present, and `openspec/config.yaml` when present.
-
-## Review Workload Gate
-
-Before implementing, inspect `tasks.md` for `Review Workload Forecast` and these guard lines:
-
-```text
-Decision needed before apply: Yes|No
-Chained PRs recommended: Yes|No
-Chain strategy: stacked-to-main|feature-branch-chain|size-exception|pending
-400-line budget risk: Low|Medium|High
-```
-
-If any of these are true:
-
-- `Decision needed before apply: Yes`
-- `Chained PRs recommended: Yes`
-- `400-line budget risk: High`
-
-then continue only when the parent prompt gives a resolved delivery path:
-
-- `auto-chain` or chosen chained/stacked PR mode: implement only the assigned work-unit slice and report the PR boundary.
-- `exception-ok` or `size:exception`: continue only if the prompt explicitly says the maintainer accepts the exception.
-- `single-pr` above budget: continue only after explicit `size:exception` approval.
-
-If no delivery decision is provided, STOP before writing code and return `blocked` with the exact decision needed.
-
-The budget constrains how work is sliced, never the code itself. Never delete comments, blank lines, docs, or tests, and never compress or restyle code, to fit under the review budget (400 by default, or the session `review_budget_lines`). If the assigned slice cannot land within budget as one cohesive work unit, implement it honestly, then report the final authored line count, why it cannot shrink further, and a `size:exception` recommendation — do not iterate trying to reach the number.
-
-## Strict TDD Gate
-
-If `openspec/config.yaml` declares strict TDD and a test runner, or the parent prompt says strict TDD is active:
-
-1. Read the global Gentle AI strict-TDD support guidance when available. If a project-local `.pi/gentle-ai/support/strict-tdd.md` exists, treat it as an override.
-2. Follow RED → GREEN → TRIANGULATE → REFACTOR for every assigned task.
-3. Do not write production code before a failing test or equivalent RED test is written.
-4. Run relevant focused tests during GREEN and after refactors.
-5. Write a `TDD Cycle Evidence` table in `apply-progress.md`.
-
-If strict TDD is active and no external support file is available, follow the RED/GREEN/TRIANGULATE/REFACTOR contract from this prompt. Do not silently fall back to standard mode.
-
-## Task Completion Boundary
-
-Use native task progress and authorized scope to select and report the assigned work. Preserve historical ownership comments and task artifacts; do not parse their spelling or position into a local admission gate. Check off only actually completed implementation work with applicable proof, and leave unfinished work unchecked.
-
-After implementation completion, return fresh native status to the parent: classically archive, with explicitly optional verification. Never bypass an older provider that still selects verify. Archive composes applicable specs and records closure without a post-SDD RDD dependency.
-
-## Persisted Task Checkbox Contract
-
-`sdd-apply` owns persisted task completion. In all modes, including strict TDD, mark each completed implementation task in the persisted tasks artifact immediately after completion:
-
-- `openspec` / `both`: update `openspec/changes/{change}/tasks.md` from `- [ ]` to `- [x]` for completed tasks.
-- `engram` / `both`: update the `sdd/{change}/tasks` observation when memory tools are explicitly available.
-- `none`: report task progress inline and state that no persisted task artifact was updated.
-
-Internal todos and `apply-progress.md` are not enough completion evidence.
-
-Before returning, re-read the persisted tasks artifact and confirm every task you report as completed is visibly marked `- [x]`. If the artifact still shows a completed task as `- [ ]`, fix the checkbox before returning or return `blocked` explaining why it cannot be reconciled. Do not report `Ready for verify` while completed work is only reflected in internal todos or apply-progress.
-
-## Standard Mode
-
-If strict TDD is not active, implement assigned tasks against specs and design, update persisted task checkboxes as work completes, and record verification evidence.
-
-## Apply Progress
-
-Update `openspec/changes/{change}/apply-progress.md` cumulatively. If previous progress exists, merge it with new progress; never overwrite completed work.
-
-Include:
-
-- completed tasks and the matching persisted task checkbox updates;
-- files changed;
-- test commands run;
-- TDD evidence when strict TDD is active;
-- deviations from design;
-- remaining tasks, including exact unchecked `- [ ]` lines when any remain;
-- workload / PR boundary;
-- structured status consumed or produced, including `actionContext` warnings.
-
-Do NOT launch child subagents. Parent/orchestrator owns delegation. Never commit unless the user explicitly asks.
-
-Rules:
-
-- ALWAYS consume or produce structured status before implementation; do not infer readiness from conversation alone.
-- STOP on unsafe `actionContext` or edit roots.
-- Mark completed tasks in the persisted tasks artifact as you go, not only at the end.
-- Before returning, re-read the persisted tasks artifact and ensure completed tasks are visibly marked `- [x]`; internal todos are not completion evidence.
-
-Return the standard phase envelope with status, executive_summary, artifacts, next_recommended, risks, and skill_resolution.
-
-
-## Key Learnings Closing
-
-Close your final report text with a `## Key Learnings` block (no trailing colon). Use 1–5 numbered items, each a standalone factual sentence of at least 20 characters and at least 4 words. This applies to final report text only — not intermediate tool output or saved artifact content. The Engram memory provider automatically extracts and persists these items as passive capture; you do not parse the block or invoke passive-capture tools yourself. Omit the block when there is genuinely no reusable learning; no filler or speculation. This closing block is separate from explicit `mem_save` artifact/decision persistence.