gentle-pi 2.4.0 → 2.6.0

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

@@ -0,0 +1,331 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parseRemediationPlan, remediationEvidence, observeRemediationTool, type RemediationObservations, type RemediationPlan, type RemediationScope, type TaskRequest } from "../lib/agents-runner.ts";
+import { NATIVE_REVIEW_ERROR_CODE, NATIVE_REVIEW_OPERATION, NativeReviewCliError, type NativeReviewCli } from "../lib/native-review-cli.ts";
+import { remediationUnresolved } from "../lib/agents-history.ts";
+import type { TaskRecord } from "../lib/agents-protocol.ts";
+
+const testCwd = process.cwd();
+const human = { hasUI: true, ui: { confirm: async () => true } } as unknown as Pick<ExtensionContext, "hasUI" | "ui">;
+const shellScope = (cwd: string, commands: string[]): RemediationScope => ({ cwd, commands, editPaths: [], allowedEditRoots: [cwd] });
+const revision = `sha256:${"a".repeat(64)}`;
+const plan: RemediationPlan = { cwd: testCwd, commands: ["pnpm test"], runtimeHarness: { naReason: "Not applicable because this correction changes only static assets." }, rollback: { boundary: "Revert the changed asset and paired test", command: "git diff --check" } };
+function state(): RemediationObservations { return { failedEvidenceRevision: revision, plan: parseRemediationPlan(plan, testCwd), observations: [], pending: {}, invalid: false }; }
+function observed(s: RemediationObservations, command: string, id: string, exitCode: number | null = 0, overrides: Record<string, unknown> = {}) {
+	observeRemediationTool(s, { type: "tool_execution_start", toolName: "bash", toolCallId: id, args: { command } });
+	observeRemediationTool(s, { type: "tool_execution_end", toolName: "bash", toolCallId: id, isError: false, result: { content: [{ type: "text", text: "concrete command output" }], details: { remediationCommand: { toolCallId: id, command, cwd: testCwd, exitCode, ...overrides } } } });
+}
+test("remediation evidence requires every exact planned command and rollback observation", () => {
+	const s = state();
+	assert.equal(remediationEvidence(s), undefined);
+	observed(s, "pnpm test", "a");
+	assert.equal(remediationEvidence(s), undefined);
+	observed(s, "git diff --check", "b");
+	const evidence = remediationEvidence(s);
+	assert.equal(evidence.failed_evidence_revision, revision);
+	assert.equal(evidence.commands[0].exit_code, 0);
+	assert.match(evidence.commands[0].result, /sha256:/);
+	assert.equal(evidence.runtime_harness.status, "not_applicable");
+	assert.equal(evidence.rollback.boundary, plan.rollback.boundary);
+});
+for (const fault of ["nonzero", "null", "cwd", "id", "truncated", "unmatched"]) test(`remediation refuses ${fault} without parsing prose`, () => {
+	const s = state();
+	observed(s, fault === "unmatched" ? "echo passed" : "pnpm test", "a", fault === "nonzero" ? 1 : fault === "null" ? null : 0, fault === "cwd" ? { cwd: "/other" } : fault === "id" ? { toolCallId: "wrong" } : fault === "truncated" ? { truncated: true } : {});
+	observed(s, "git diff --check", "b");
+	assert.equal(remediationEvidence(s), undefined);
+});
+test("remediation plan is bounded and cannot select another working directory", () => {
+	assert.throws(() => parseRemediationPlan({ ...plan, cwd: "/other" }, testCwd), /plan/);
+	assert.throws(() => parseRemediationPlan({ ...plan, commands: [] }, testCwd), /plan/);
+	assert.throws(() => parseRemediationPlan({ ...plan, runtimeHarness: { naReason: "N/A" } }, testCwd), /plan/);
+});
+
+
+test("remediation shell captures numeric exit, preserves stock errors and executes once", async () => {
+	const { remediationBash } = await import("../extensions/gentle-agents.ts");
+	for (const exitCode of [0, 7, null]) {
+		let calls = 0;
+		const shell = remediationBash(testCwd, { exec: async (command, cwd, options) => {
+			calls++; assert.equal(command, "pnpm test"); assert.equal(cwd, testCwd);
+			options.onData(Buffer.from("real output")); return { exitCode };
+		} }, shellScope(testCwd, ["pnpm test"]));
+		const run = shell.definition.execute("call", { command: "pnpm test" }, undefined, undefined, undefined);
+		if (exitCode === 7) await assert.rejects(run, /code 7/); else await run;
+		const patch = shell.result({ toolCallId: "call", details: { fullOutputPath: "/retained", remediationCommand: { exitCode: 99 } } } as unknown as Parameters<typeof shell.result>[0]);
+		const details = patch.details as typeof patch.details & { fullOutputPath?: string };
+		assert.equal(details.remediationCommand.exitCode, exitCode);
+		assert.equal(details.remediationCommand.command, "pnpm test");
+		assert.equal(details.remediationCommand.cwd, testCwd);
+		assert.equal(details.fullOutputPath, "/retained");
+		assert.equal(shell.result({ toolCallId: "call" }), undefined);
+		assert.equal(calls, 1);
+	}
+});
+
+
+test("remediation owner and packaged actor are installed through existing ownership", async () => {
+	const { getPackageAssetOwner } = await import("../lib/sdd-preflight.ts");
+	const { readFileSync } = await import("node:fs");
+	assert.equal(getPackageAssetOwner("agents/sdd-remediate.md"), "sdd");
+	assert.match(readFileSync("assets/agents/sdd-remediate.md", "utf8"), /SDD remediate executor/);
+});
+
+test("native remediation admission refuses unsupported owner before acquire", async () => {
+	const { admitManagedRemediation } = await import("../extensions/gentle-agents.ts");
+	let acquires = 0;
+	await assert.rejects(admitManagedRemediation({ agent: { name: "sdd-remediate", filePath: "/absent" }, sddChange: { changeName: "fix", workspaceRoot: testCwd, phase: "remediate", failedEvidenceRevision: revision }, cwd: testCwd } as unknown as TaskRequest, {}, { sddAttemptAcquire: async () => { acquires++; } } as unknown as NativeReviewCli, async () => {}), /unsupported/i);
+	assert.equal(acquires, 0);
+});
+
+
+test("admitted remediation retains exact settlement before one lost-reply replay", async () => {
+	const { admitManagedRemediation } = await import("../extensions/gentle-agents.ts");
+	const { resolve } = await import("node:path");
+	const { readFileSync } = await import("node:fs");
+	const path = resolve("assets/agents/sdd-remediate.md");
+	const { parseAgentDefinition } = await import("../lib/agents-config.ts");
+	const agent = parseAgentDefinition(readFileSync(path, "utf8"), path, "global");
+	assert.ok("instructions" in agent);
+	const saved = [], calls = [];
+	const request = { agent, sddChange: { changeName: "fix", workspaceRoot: testCwd, phase: "remediate", failedEvidenceRevision: revision }, cwd: testCwd } as unknown as TaskRequest;
+	const native = { sddStatus: async () => ({ schemaName: "gentle-ai.sdd-status", schemaVersion: 2, artifactStore: "openspec", planningHome: { mode: "repo-local", path: `${testCwd}/openspec` }, changeRoot: `${testCwd}/openspec/changes/fix`, dependencies: Object.fromEntries(["proposal", "specs", "design", "tasks", "apply", "verify", "archive"].map(key => [key, "ready"])), phaseInstructions: { apply: [], verify: [], remediate: ["Correct evidence"], archive: [] }, blockedReasons: [], nextRecommended: "remediate", changeName: "fix", actionContext: { mode: "repo-local", workspaceRoot: testCwd, allowedEditRoots: [testCwd] }, remediationState: { required: true, complete: false, failedEvidenceRevision: revision } }), sddAttemptAcquire: async input => { calls.push(["acquire", input]); return { state: "proceed", token: "opaque-admitted" }; }, sddAttemptSettle: async input => { assert.equal(saved.at(-1).sddRemediation.settle.requestId, input.requestId); calls.push(["settle", structuredClone(input)]); if (calls.length === 2) throw new Error("lost reply"); return { state: "complete" as const }; } } as unknown as NativeReviewCli;
+	const admitted = await admitManagedRemediation(request, { plan, attempt: { requestId: "a", workUnit: "fix", evidenceGoal: "Observed correction", maxAttempts: 1, maxChangedLines: 200 } }, native, async task => { saved.push(structuredClone(task)); }, human, { id: "prepared", cwd: testCwd, agent: "sdd-remediate", status: "queued" } as unknown as TaskRecord);
+	const task = { id: "task", cwd: testCwd, status: "completed", sddRemediation: admitted.sddRemediation } as unknown as TaskRecord & { sddRemediation: typeof admitted.sddRemediation };
+	observed(task.sddRemediation, "pnpm test", "one"); observed(task.sddRemediation, "git diff --check", "two");
+	await admitted.finalizeRemediation(task, { spawned: true, exited: true, cleanupConfirmed: true });
+	assert.equal(calls.filter(([verb]) => verb === "acquire").length, 1);
+	assert.equal(calls.filter(([verb]) => verb === "settle").length, 2);
+	assert.deepEqual(calls[1], calls[2]);
+	assert.equal(calls[1][1].outcome, "passed");
+	assert.equal(calls[1][1].remediatesEvidenceRevision, revision);
+	assert.equal(JSON.parse(calls[1][1].remediationEvidence).failed_evidence_revision, revision);
+});
+
+
+async function admissionFixture(overrides = {}, persist: (task: TaskRecord) => Promise<void> = async () => {}, agentPatch = {}, attemptPatch = {}, context: Pick<ExtensionContext, "hasUI" | "ui"> = human) {
+	const { admitManagedRemediation } = await import("../extensions/gentle-agents.ts");
+	const { parseAgentDefinition } = await import("../lib/agents-config.ts");
+	const { readFileSync } = await import("node:fs");
+	const { resolve } = await import("node:path");
+	const path = resolve("assets/agents/sdd-remediate.md");
+	const request = { agent: { ...parseAgentDefinition(readFileSync(path, "utf8"), path, "global"), ...agentPatch }, cwd: testCwd, sddChange: { changeName: "fix", workspaceRoot: testCwd, phase: "remediate", failedEvidenceRevision: revision } } as unknown as TaskRequest;
+	const calls = [];
+	const native = { sddStatus: async () => ({ schemaName: "gentle-ai.sdd-status", schemaVersion: 2, artifactStore: "openspec", planningHome: { mode: "repo-local", path: `${testCwd}/openspec` }, changeRoot: `${testCwd}/openspec/changes/fix`, dependencies: Object.fromEntries(["proposal", "specs", "design", "tasks", "apply", "verify", "archive"].map(key => [key, "ready"])), phaseInstructions: { apply: [], verify: [], remediate: ["Correct evidence"], archive: [] }, blockedReasons: [], nextRecommended: "remediate", changeName: "fix", actionContext: { mode: "repo-local", workspaceRoot: testCwd, allowedEditRoots: [testCwd] }, remediationState: { required: true, complete: false, failedEvidenceRevision: revision } }), sddAttemptAcquire: async input => { calls.push(["acquire", input]); return { state: "proceed", token: "opaque" }; }, sddAttemptSettle: async input => { calls.push(["settle", input]); return { state: "proceed" as const }; }, ...overrides } as unknown as NativeReviewCli;
+	const admitted = await admitManagedRemediation(request, { plan, attempt: { requestId: "a", workUnit: "fix", evidenceGoal: "Observed correction", untrackedScope: "select", expectedUntrackedInventory: revision, intendedUntracked: ["new file.ts"], ...attemptPatch } }, native, persist, context, { id: "prepared", cwd: testCwd, agent: "sdd-remediate", status: "queued" } as unknown as TaskRecord);
+	return { admitted, calls, task: { id: "one", status: "failed", sddRemediation: admitted.sddRemediation } as unknown as TaskRecord & { sddRemediation: typeof admitted.sddRemediation } };
+}
+for (const state of ["blocked", "complete"]) test(`native ${state} refuses without settlement`, async () => {
+	let settles = 0;
+	await assert.rejects(admissionFixture({ sddAttemptAcquire: async () => ({ state }), sddAttemptSettle: async () => { settles++; } }), new RegExp(state));
+	assert.equal(settles, 0);
+});
+for (const status of ["failed", "cancelled", "timed_out"] as const) test(`terminal ${status} settles without passing evidence and retains exact untracked scope`, async () => {
+	const { admitted, calls, task } = await admissionFixture(); task.status = status;
+	await admitted.finalizeRemediation(task, { spawned: true, exited: true, cleanupConfirmed: true });
+	const payload = calls[1][1];
+	assert.equal(payload.outcome, status === "failed" ? "failed" : "interrupted");
+	assert.equal(payload.remediationEvidence, undefined);
+	assert.equal(typeof payload.evidenceRevision, status === "failed" ? "string" : "undefined");
+	assert.deepEqual(payload.intendedUntracked, calls[0][1].intendedUntracked);
+	assert.equal(payload.expectedUntrackedInventory, revision);
+});
+test("failure to retain settlement never mutates native; two lost replies retain uncertainty", async () => {
+	const failed = await admissionFixture({}, async task => { if (task.sddRemediation.settle) throw new Error("disk failure"); });
+	await assert.rejects(failed.admitted.finalizeRemediation(failed.task, { spawned: false, exited: false, cleanupConfirmed: true }), /disk failure/);
+	assert.equal(failed.calls.length, 1);
+	let replies = 0;
+	const lost = await admissionFixture({ sddAttemptSettle: async () => { replies++; throw new Error("lost"); } });
+	await lost.admitted.finalizeRemediation(lost.task, { spawned: false, exited: false, cleanupConfirmed: true });
+	assert.equal(replies, 2); assert.equal(lost.task.sddRemediation.settlementUncertain, true);
+	assert.equal(lost.task.sddRemediation.settle.outcome, "interrupted");
+});
+test("runtime harness requires its own observed command; malformed content cannot pass", () => {
+	const s = state(); s.plan.runtimeHarness = { command: "pnpm run harness" };
+	observed(s, "pnpm test", "test"); observed(s, "git diff --check", "rollback");
+	assert.equal(remediationEvidence(s), undefined);
+	observed(s, "pnpm run harness", "harness"); assert.equal(remediationEvidence(s).runtime_harness.status, "passed");
+	const malformed = state();
+	observeRemediationTool(malformed, { type: "tool_execution_start", toolName: "bash", toolCallId: "a", args: { command: "pnpm test" } });
+	observeRemediationTool(malformed, { type: "tool_execution_end", toolName: "bash", toolCallId: "a", isError: false, result: { content: [null], details: { remediationCommand: { toolCallId: "a", command: "pnpm test", cwd: testCwd, exitCode: 0 } } } });
+	observed(malformed, "git diff --check", "b"); assert.equal(remediationEvidence(malformed), undefined);
+});
+
+
+test("stock local shell wrapper observes real exit zero and preserves cancellation", async () => {
+	const { remediationBash } = await import("../extensions/gentle-agents.ts");
+	const { createBashToolDefinition } = await import("@earendil-works/pi-coding-agent");
+	const shell = remediationBash(process.cwd(), undefined, shellScope(process.cwd(), ["printf wrapper-proof", "sleep 30"]));
+	assert.deepEqual(shell.definition.parameters, createBashToolDefinition(process.cwd()).parameters);
+	const result = await shell.definition.execute("real", { command: "printf wrapper-proof" }, undefined, undefined, undefined);
+	const [content] = result.content;
+	assert.ok(content?.type === "text");
+	assert.equal(content.text, "wrapper-proof");
+	assert.equal(shell.result({ toolCallId: "real", details: result.details }).details.remediationCommand.exitCode, 0);
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), 30);
+	try { await assert.rejects(shell.definition.execute("cancel", { command: "sleep 30" }, controller.signal, undefined, undefined), /aborted/); }
+	finally { clearTimeout(timeout); controller.abort(); }
+	assert.equal(shell.result({ toolCallId: "cancel" }), undefined);
+});
+
+
+test("nonzero observed exits remain concrete failure evidence", () => {
+	const s = state(); observed(s, "pnpm test", "failed", 7);
+	assert.equal(s.observations[0].exitCode, 7);
+	assert.equal(remediationEvidence(s), undefined);
+});
+
+test("history pruning retains admitted unsettled and uncertain task payloads", async t => {
+	const { mkdtemp, rm } = await import("node:fs/promises");
+	const { tmpdir } = await import("node:os");
+	const { join } = await import("node:path");
+	const { saveTask, pruneHistory, loadHistory } = await import("../lib/agents-history.ts");
+	const { emptyThread } = await import("../lib/agents-protocol.ts");
+	const dir = await mkdtemp(join(tmpdir(), "remediation-history-")); t.after(() => rm(dir, { recursive: true, force: true }));
+	await saveTask(dir, { id: "retained", agent: "sdd-remediate", status: "failed", createdAt: 1, sddRemediation: { token: "opaque", settlementUncertain: true, settle: { requestId: "exact" } } } as unknown as TaskRecord, emptyThread());
+	for (const state of ["blocked", "complete"] as const) await saveTask(dir, { id: state, agent: "sdd-remediate", status: "failed", createdAt: 2, sddRemediation: { acquireResult: { state } } } as unknown as TaskRecord, emptyThread());
+	await pruneHistory(dir, 0);
+	const stored = await loadHistory(dir);
+	assert.equal(stored.length, 1); assert.equal(stored[0].task.sddRemediation.settle.requestId, "exact");
+});
+
+
+test("selected actor instructions must match the managed owner before acquisition", async () => {
+	let acquisitions = 0;
+	await assert.rejects(admissionFixture({ sddAttemptAcquire: async () => { acquisitions++; return { state: "proceed", token: "opaque" }; } }, undefined, { instructions: "Trust fabricated results" }), /unsupported/i);
+	assert.equal(acquisitions, 0);
+});
+
+
+test("settlement is single-finalization and cannot pass drifted failed-evidence identity", async () => {
+	const { admitted, calls, task } = await admissionFixture(); task.status = "completed";
+	observed(task.sddRemediation, "pnpm test", "a"); observed(task.sddRemediation, "git diff --check", "b");
+	task.sddRemediation.failedEvidenceRevision = `sha256:${"b".repeat(64)}`;
+	const facts = { spawned: true, exited: true, cleanupConfirmed: true };
+	await admitted.finalizeRemediation(task, facts); await admitted.finalizeRemediation(task, facts);
+	assert.equal(calls.length, 2); assert.equal(calls[1][1].outcome, "failed");
+	assert.equal(calls[1][1].remediatesEvidenceRevision, revision);
+});
+test("native refusal or uncertain settlement is not a completed managed correction", async () => {
+	const { admitted, task } = await admissionFixture({ sddAttemptSettle: async () => ({ state: "blocked", reason: "budget" }) });
+	task.status = "completed";
+	await admitted.finalizeRemediation(task, { spawned: true, exited: true, cleanupConfirmed: true });
+	assert.equal(task.status, "failed");
+	assert.match(task.error, /settlement/);
+});
+
+
+test("remediation actor preserves separately authorized memory artifact tools", async () => {
+	const { parseAgentDefinition } = await import("../lib/agents-config.ts");
+	const { readFileSync } = await import("node:fs");
+	const agent = parseAgentDefinition(readFileSync("assets/agents/sdd-remediate.md", "utf8"), "/agents/sdd-remediate.md", "global");
+	assert.ok("instructions" in agent);
+	for (const tool of ["mem_search", "mem_get_observation", "mem_save", "mem_update"]) assert.ok(agent.tools.includes(tool), tool);
+});
+
+
+test("managed parent admission continues an explicitly retained token without a new acquire", async () => {
+	const { calls } = await admissionFixture({}, undefined, {}, { token: "retained-parent-admission" });
+	assert.equal(calls.length, 1);
+	assert.equal(calls[0][1].token, "retained-parent-admission");
+});
+
+
+test("R3-duplicate-command-evidence requires a distinct execution for every indexed slot", () => {
+	const s = state(); s.plan.commands = ["pnpm test", "pnpm test"];
+	s.plan.runtimeHarness = { command: "pnpm test" }; s.plan.rollback.command = "pnpm test";
+	for (let index = 0; index < 4; index++) {
+		observed(s, "pnpm test", `slot-${index}`);
+		assert.equal(remediationEvidence(s) === undefined, index < 3);
+	}
+	assert.deepEqual(s.observations.map(item => item.slot), [0, 1, 2, 3]);
+	observed(s, "pnpm test", "slot-0");
+	assert.equal(remediationEvidence(s), undefined, "reused call identity cannot produce evidence");
+});
+
+
+test("R1 confirms exact canonical paths and commands; data, denial and symlinks grant nothing", async t => {
+	const { confirmRemediationScope, remediationToolAllowed } = await import("../extensions/gentle-agents.ts");
+	const { mkdtempSync, writeFileSync, symlinkSync, rmSync } = await import("node:fs");
+	const { tmpdir } = await import("node:os"); const { join } = await import("node:path");
+	const cwd = mkdtempSync(join(tmpdir(), "remediation-scope-")); t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	const target = join(cwd, "allowed.ts"); writeFileSync(target, "original"); symlinkSync(target, join(cwd, "alias.ts"));
+	const candidate = { ...plan, cwd, editPaths: [target] }, native = { mode: "repo-local", workspaceRoot: cwd, allowedEditRoots: [cwd] };
+	let shown = "", confirmations = 0;
+	const ui = { hasUI: true, ui: { confirm: async (_title: string, text: string) => { shown = text; confirmations++; return true; } } } as unknown as Pick<ExtensionContext, "hasUI" | "ui">;
+	const scope = await confirmRemediationScope(candidate, native, ui);
+	assert.match(shown, /pnpm test/); assert.ok(shown.includes(target)); assert.ok(shown.includes(cwd));
+	assert.equal(remediationToolAllowed(scope, cwd, "write", { path: target }), true);
+	for (const tool of ["mem_search", "mem_get_observation", "mem_save", "mem_update"]) assert.equal(remediationToolAllowed(scope, cwd, tool, { id: 7, project: "other", content: "outside" }), false);
+	assert.equal(remediationToolAllowed(scope, cwd, "write", { path: join(cwd, "other.ts") }), false);
+	assert.equal(remediationToolAllowed(scope, cwd, "bash", { command: "pnpm test; touch outside" }), false);
+	for (const bad of [{ ...candidate, editPaths: [join(cwd, "alias.ts")] }, { ...candidate, editPaths: [cwd] }, { ...candidate, editPaths: [target, target] }]) await assert.rejects(confirmRemediationScope(bad, native, ui));
+	assert.equal(confirmations, 1);
+	for (const context of [undefined, { hasUI: false, ui: ui.ui }, { hasUI: true, ui: { confirm: async () => false } }, { hasUI: true, ui: { confirm: async () => undefined } }]) await assert.rejects(confirmRemediationScope(candidate, native, context as unknown as Pick<ExtensionContext, "hasUI" | "ui">), /authorization/);
+});
+
+
+test("R3/R4 acquire request is durable before mutation and token before actor admission", async () => {
+	const records = [], calls = [];
+	const { admitted } = await admissionFixture({ sddAttemptAcquire: async request => {
+		assert.deepEqual(records.at(-1).sddRemediation.acquire, request);
+		assert.equal(records.at(-1).sddRemediation.token, undefined);
+		calls.push(structuredClone(request)); if (calls.length === 1) throw new Error("lost acquire reply");
+		return { state: "proceed", token: "native-returned" };
+	} }, async task => { records.push(structuredClone(task)); });
+	assert.equal(calls.length, 2); assert.deepEqual(calls[0], calls[1]);
+	assert.equal(records.at(-1).sddRemediation.token, "native-returned");
+	assert.equal(admitted.sddRemediation.token, "native-returned");
+});
+test("R3/R4 acquire persistence failure refuses before native mutation", async () => {
+	let mutations = 0;
+	await assert.rejects(admissionFixture({ sddAttemptAcquire: async () => { mutations++; return { state: "proceed", token: "unsafe" }; } }, async () => { throw new Error("disk full"); }), /disk full/);
+	assert.equal(mutations, 0);
+});
+
+
+test("R1 denial/headless/cancellation gives zero acquisition and durable mutation", async () => {
+	for (const context of [{ hasUI: false }, { hasUI: true, ui: { confirm: async () => false } }, { hasUI: true, ui: { confirm: async () => undefined } }, { hasUI: true, ui: { confirm: async () => { throw new Error("cancelled"); } } }]) {
+		let acquisitions = 0, persistence = 0;
+		await assert.rejects(admissionFixture({ sddAttemptAcquire: async () => { acquisitions++; } }, async () => { persistence++; }, {}, {}, context as unknown as Pick<ExtensionContext, "hasUI" | "ui">));
+		assert.equal(acquisitions, 0); assert.equal(persistence, 0);
+	}
+});
+test("R1 child invokes only the exact confirmed command/cwd/count with distinct call IDs", async () => {
+	const { remediationBash } = await import("../extensions/gentle-agents.ts");
+	let executions = 0;
+	const shell = remediationBash(testCwd, { exec: async () => { executions++; return { exitCode: 0 }; } }, shellScope(testCwd, ["pnpm test", "pnpm test"]));
+	const execute = (id: string, command: string, cwd = testCwd) => shell.definition.execute(id, { command }, undefined, undefined, cwd === testCwd ? undefined : { cwd } as unknown as ExtensionContext);
+	await assert.rejects(execute("outside", "pnpm test; touch outside"), /authorization/);
+	await assert.rejects(execute("cwd", "pnpm test", "/other"), /authorization/);
+	assert.equal(executions, 0);
+	await execute("one", "pnpm test"); await assert.rejects(execute("one", "pnpm test"), /authorization/);
+	await execute("two", "pnpm test"); await assert.rejects(execute("three", "pnpm test"), /authorization/);
+	assert.equal(executions, 2);
+});
+test("R3/R4 known non-mutating acquire failures retain retryable blocked history while ambiguity remains unresolved", async () => {
+	for (const error of [new TypeError("invalid acquire request"), new NativeReviewCliError(NATIVE_REVIEW_ERROR_CODE.UNAVAILABLE, NATIVE_REVIEW_OPERATION.SDD_ATTEMPT, true, false, "native launch unavailable")]) {
+		let calls = 0; const retained = [];
+		await assert.rejects(admissionFixture({ sddAttemptAcquire: async () => { calls++; throw error; } }, async task => { retained.push(structuredClone(task)); }), error);
+		assert.equal(calls, 1);
+		assert.deepEqual(retained.at(-1).sddRemediation.acquireResult, { state: "blocked" });
+		assert.equal(remediationUnresolved(retained.at(-1)), false);
+	}
+	let calls = 0; const retained = [];
+	await assert.rejects(admissionFixture({ sddAttemptAcquire: async () => { calls++; throw new Error("lost reply"); } }, async task => { retained.push(structuredClone(task)); }), /Unknown acquire/);
+	assert.equal(calls, 2); assert.equal(retained.at(-1).sddRemediation.acquireUncertain, true);
+	assert.equal(remediationUnresolved(retained.at(-1)), true);
+	assert.deepEqual(retained[0].sddRemediation.acquire, retained.at(-1).sddRemediation.acquire);
+	calls = 0;
+	await assert.rejects(admissionFixture({ sddAttemptAcquire: async () => { calls++; return { state: "proceed", token: "returned" }; } }, async task => { if (task.sddRemediation.token) throw new Error("token disk failure"); }), /token disk failure/);
+	assert.equal(calls, 1);
+});
+
+
+test("remediation actor explains one-launch human authority and indexed command evidence", async () => {
+	const { readFileSync } = await import("node:fs");
+	const text = readFileSync("assets/agents/sdd-remediate.md", "utf8");
+	assert.match(text, /fresh host UI confirmation/); assert.match(text, /each repeated command.*separate execution/);
+	assert.match(text, /reconcile.*without.*another actor/);
+});

package/tests/sdd-native-managed-uptake.test.ts

@@ -0,0 +1,253 @@
+import assert from "node:assert/strict";
+import { execFileSync, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { appendFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { AgentRunner, type ChildLike, type TaskRequest } from "../lib/agents-runner.ts";
+import { TaskStore } from "../lib/agents-protocol.ts";
+import { parseAgentDefinition } from "../lib/agents-config.ts";
+import { Type } from "typebox";
+import { RESEARCH_CHILD_TOOLS_ENV } from "../lib/sdd-research-capabilities.ts";
+import { admitManagedRemediation } from "../extensions/gentle-agents.ts";
+
+import { NativeReviewCliV216, createNodeExecFileAdapter } from "../lib/native-review-cli.ts";
+
+const self = fileURLToPath(import.meta.url);
+const source = dirname(dirname(self));
+const binary = process.env.SDD_TEST_PRODUCER;
+const childRole = process.env.UPTAKE_CHILD === "1";
+const digest = (value: string | Buffer) => createHash("sha256").update(value).digest("hex");
+const json = (path: string) => JSON.parse(readFileSync(path, "utf8"));
+const cost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+
+// The model is a finite local script, not a provider call or an actor verdict.
+// SDK/extension hooks, tools, session persistence, RPC and AgentRunner are real.
+export async function launch(): Promise<void> {
+	const sdk = await import("@earendil-works/pi-coding-agent");
+	const ai = await import("@earendil-works/pi-ai");
+	const args = process.argv.slice(1), value = (flag: string) => args[args.indexOf(flag) + 1];
+	const paths = args.flatMap((arg, i) => arg === "--extension" ? [args[i + 1]] : []);
+	const home = process.env.GENTLE_PI_AGENT_HOME!;
+	const runtimeModels = await sdk.ModelRuntime.create({ credentials: new ai.InMemoryCredentialStore(), modelsPath: join(home, "models.json"), modelsStorePath: join(home, "models-store.json"), allowModelNetwork: false });
+	const settings = sdk.SettingsManager.inMemory({ retry: { enabled: false }, compaction: { enabled: false } });
+	let turn = 0;
+	const script = json(process.env.UPTAKE_SCRIPT!);
+	const runtime = await sdk.createAgentSessionRuntime(async ({ cwd, sessionManager, sessionStartEvent }) => {
+		const services = await sdk.createAgentSessionServices({ cwd, agentDir: home, modelRuntime: runtimeModels, settingsManager: settings, resourceLoaderOptions: {
+			noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+			additionalExtensionPaths: paths, appendSystemPrompt: [value("--append-system-prompt")],
+			extensionFactories: [pi => {
+				pi.registerProvider("uptake-control", { baseUrl: "http://127.0.0.1:1", apiKey: "offline-control", api: "openai-completions", models: [{ id: "control", name: "control", reasoning: false, input: ["text"], cost, contextWindow: 200000, maxTokens: 1000 }],
+					streamSimple: (model, context) => {
+						writeFileSync(join(process.env.UPTAKE_RUN!, `input-${turn}.json`), JSON.stringify(context));
+						const calls = script[turn++] ?? [];
+						const stopReason = calls.length ? "toolUse" as const : "stop" as const;
+						const message: AssistantMessage = { role: "assistant", content: calls.length ? calls.map(([name, arguments_], i) => ({ type: "toolCall", id: `${turn}-${i}`, name, arguments: arguments_ })) : [{ type: "text", text: "Controlled script exhausted; not acceptance." }], api: model.api, provider: model.provider, model: model.id, usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost }, stopReason, timestamp: Date.now() };
+						const stream = ai.createAssistantMessageEventStream();
+						queueMicrotask(() => { stream.push({ type: "start", partial: message }); stream.push({ type: "done", reason: stopReason, message }); stream.end(message); });
+						return stream;
+					},
+				});
+			}],
+		} });
+		assert.deepEqual(services.resourceLoader.getExtensions().errors, []);
+		if (args.includes("--gentle-sdd-change")) services.resourceLoader.getExtensions().runtime.flagValues.set("gentle-sdd-change", value("--gentle-sdd-change"));
+		return { ...(await sdk.createAgentSessionFromServices({ services, sessionManager, sessionStartEvent, model: runtimeModels.getModel("uptake-control", "control"), tools: value("--tools").split(",") })), services, diagnostics: services.diagnostics };
+	}, { cwd: process.cwd(), agentDir: home, sessionManager: sdk.SessionManager.create(process.cwd(), value("--session-dir")) });
+	await sdk.runRpcMode(runtime);
+}
+
+// A local documentation capability with real extension provenance and an observable effect.
+export default function controlledDocumentation(pi) {
+	pi.registerTool({ name: "fetch_content", label: "Controlled documentation", description: "Read the isolated documentation fixture only", parameters: Type.Object({}), execute: async () => {
+		appendFileSync(join(process.env.UPTAKE_RUN!, "fetch-calls"), "called\n");
+		return { content: [{ type: "text", text: "Independent controlled documentation bytes" }], details: {} };
+	} });
+	pi.on("session_start", (_event, ctx) => {
+		writeFileSync(join(process.env.UPTAKE_RUN!, "inventory.json"), JSON.stringify(pi.getAllTools()));
+		writeFileSync(join(process.env.UPTAKE_RUN!, "startup.json"), JSON.stringify({ cwd: ctx.cwd, flag: pi.getFlag("gentle-sdd-change"), grant: process.env.GENTLE_PI_SDD_REMEDIATION_PLAN }));
+	});
+}
+
+if (!childRole) test("installed AI producer → fixed Pi extensions → managed child input and tools", { skip: !binary, timeout: 90000 }, async t => {
+	assert.ok(binary && resolve(binary) === binary && existsSync(binary), "Explicit independently built AI binary required");
+	const producerIdentity = json(`${binary}.identity.json`);
+	assert.equal(producerIdentity.sourceRevision, "01e6fac15df169e8993e02549b9edcbd01abc0ee");
+	assert.equal(producerIdentity.sha256, digest(readFileSync(binary)), "Producer bytes must match the independent build record");
+	const root = mkdtempSync(join(tmpdir(), "pi-native-uptake-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const cwd = join(root, "workspace"), home = join(root, "profile"), pkg = join(root, "pi");
+	const change = join(cwd, "openspec", "changes", "uptake");
+	mkdirSync(join(change, "specs", "sample"), { recursive: true });
+	mkdirSync(home); mkdirSync(pkg);
+	execFileSync("git", ["init", "--quiet", cwd]);
+	for (const name of ["assets", "extensions", "lib", "runtime", "contracts", "scripts", "package.json", "tests"]) cpSync(join(source, name), join(pkg, name), { recursive: true });
+	symlinkSync(join(source, "node_modules"), join(pkg, "node_modules"), "dir");
+	execFileSync(process.execPath, ["scripts/build-runtime-modules.mjs", "--write"], { cwd: pkg });
+	const previousHome = process.env.GENTLE_PI_AGENT_HOME;
+	process.env.GENTLE_PI_AGENT_HOME = home;
+	try {
+		const { installPackageAssets } = await import(join(pkg, "lib", "sdd-preflight.ts"));
+		installPackageAssets(cwd, false, ["sdd"]);
+	} finally {
+		if (previousHome === undefined) delete process.env.GENTLE_PI_AGENT_HOME; else process.env.GENTLE_PI_AGENT_HOME = previousHome;
+	}
+	const manifest = json(join(home, "gentle-ai", "managed-assets.json"));
+	const actor = (phase: string) => {
+		const path = join(home, "agents", `sdd-${phase}.md`);
+		const bytes = readFileSync(path, "utf8");
+		assert.equal(digest(bytes), manifest.assets[`agents/sdd-${phase}.md`]);
+		assert.equal(bytes, readFileSync(join(pkg, "assets", "agents", `sdd-${phase}.md`), "utf8"));
+		const definition = parseAgentDefinition(bytes, path, "global");
+		if (!("instructions" in definition)) throw new Error(`Invalid fixture agent: ${phase}`);
+		return definition;
+	};
+	for (const phase of ["apply", "research", "remediate"]) assert.equal(actor(phase).name, `sdd-${phase}`);
+	writeFileSync(join(change, "proposal.md"), "Native uptake controlled fixture\n");
+	writeFileSync(join(change, "design.md"), "Read-only controlled fixture\n");
+	writeFileSync(join(change, "specs", "sample", "spec.md"), "### Requirement: Controlled boundary\n#### Scenario: Read\n");
+	writeFileSync(join(change, "tasks.md"), "- [ ] Read controlled fixture\n");
+	const native = new NativeReviewCliV216(createNodeExecFileAdapter(), binary);
+	const status = await native.sddStatus({ changeName: "uptake", workspaceRoot: cwd });
+	assert.equal(status.schemaName, "gentle-ai.sdd-status"); assert.equal(status.schemaVersion, 2);
+	assert.equal(status.nextRecommended, "apply");
+	await t.test("installed host suppresses continuation for read-only and excluded-marker answers", async () => {
+		const { createGentleAiExtension } = await import(join(pkg, "extensions", "gentle-ai.ts"));
+		for (const answer of [false, undefined]) {
+			const verbs: string[] = [], confirmations: string[] = [], notices: string[] = [];
+			const commands = new Map();
+			const adapter = createNodeExecFileAdapter();
+			const client = new NativeReviewCliV216(request => { verbs.push(request.arguments[0]); return adapter(request); }, binary);
+			createGentleAiExtension({ nativeReviewCli: client, processEnv: {} })({ on() {}, events: { emit() {} }, registerTool() {}, registerCommand: (name, command) => commands.set(name, command.handler), sendUserMessage: () => assert.fail("Unexpected launch"), sendMessage: () => assert.fail("Unexpected launch") });
+			const context = { cwd, hasUI: true, ui: { notify: text => notices.push(text), confirm: async (_title, text) => { confirmations.push(text); return answer; } } };
+			await commands.get("gentle-sdd-status")("uptake --json", context);
+			assert.deepEqual(JSON.parse(notices[0]), status);
+			assert.equal(confirmations.length, 0);
+			await commands.get("gentle-sdd-continue")("uptake --json", context);
+			assert.deepEqual(verbs, ["sdd-status", "sdd-status"]);
+			assert.equal(confirmations.length, 1);
+			assert.ok(confirmations[0].includes(join(change, ".gentle-ai-instance")));
+			assert.equal(existsSync(join(change, ".gentle-ai-instance")), false);
+		}
+	});
+	const fixed = [join(pkg, "extensions", "gentle-ai.ts"), join(pkg, "extensions", "gentle-agents.ts")];
+	const docExtension = join(pkg, "tests", "sdd-native-managed-uptake.test.ts");
+	const selection = { documentation: { tools: ["fetch_content"], extensions: { fetch_content: docExtension } } };
+	async function run(id: string, phase: "apply" | "research" | "remediate", script: unknown[], options: Record<string, any> = {}) {
+		const directory = join(root, id); mkdirSync(directory);
+		const scriptPath = join(directory, "script.json"); writeFileSync(scriptPath, JSON.stringify(script));
+		const events: any[] = [], launches: any[] = [];
+		const runner = new AgentRunner(new TaskStore(), { maxConcurrency: 1, stallTimeoutMs: 15000 }, {
+			pi: { command: process.execPath, args: ["--experimental-strip-types", "--input-type=module", "--eval", `import(${JSON.stringify(docExtension)}).then(m=>m.launch())`, "--"] },
+			now: Date.now, schedule: (fn, ms) => { const timer = setTimeout(fn, ms); return () => clearTimeout(timer); },
+			spawn: (command, args, spawnOptions): ChildLike => {
+				launches.push({ args, cwd: spawnOptions.cwd });
+				const child = spawn(command, args, { ...spawnOptions, stdio: ["pipe", "pipe", "pipe"] });
+				let buffer = "";
+				child.stdout.on("data", data => { buffer += data; const lines = buffer.split("\n"); buffer = lines.pop()!; for (const line of lines) { try { events.push(JSON.parse(line)); } catch { /* Diagnostics are not RPC evidence. */ } } });
+				child.stderr.on("data", data => appendFileSync(join(directory, "stderr.log"), data));
+				return child as unknown as ChildLike;
+			},
+		}, { askUser: async () => ({ cancelled: true }) });
+		try {
+			const task = runner.run({ agent: { ...actor(phase), ...(phase === "research" ? { tools: ["read", "write", "fetch_content"] } : {}) }, prompt: "Controlled boundary probe only; no implementation or acceptance.", label: undefined, context: phase === "research" ? JSON.stringify(status) : undefined, mode: "task", cwd, parentSessionId: "uptake", model: undefined, thinking: undefined, sessionDir: join(directory, "sessions"), resumeSessionPath: undefined, env: { PATH: process.env.PATH, HOME: home, PI_CODING_AGENT_DIR: home, GENTLE_PI_AGENT_HOME: home, PI_OFFLINE: "1", UPTAKE_CHILD: "1", UPTAKE_RUN: directory, UPTAKE_SCRIPT: scriptPath, GENTLE_PI_GENTLE_AI_DEV_BINARY: binary, ...(phase === "research" ? { [RESEARCH_CHILD_TOOLS_ENV]: JSON.stringify(["read", "write", "fetch_content"]) } : {}), ...options.env }, extensionPaths: [...fixed, ...(options.absentTool ? [] : [docExtension])], researchSelection: selection, researchArtifact: options.artifact, sddRemediation: options.remediation, ...(phase === "research" ? {} : { sddChange: { phase, changeName: "uptake", workspaceRoot: cwd, ...options.selection } }) });
+			const result = await runner.waitFor(task.id);
+			assert.equal(launches.length, 1);
+			assert.deepEqual(launches[0].args.flatMap((arg, i, args) => arg === "--extension" ? [args[i + 1]] : []), [...fixed, ...(options.absentTool ? [] : [docExtension])]);
+			writeFileSync(join(directory, "events.json"), JSON.stringify(events));
+			writeFileSync(join(directory, "launch.json"), JSON.stringify(launches));
+			if (process.env.UPTAKE_EVIDENCE_DIR) cpSync(directory, join(process.env.UPTAKE_EVIDENCE_DIR, id), { recursive: true });
+			return { result, events, directory, input: existsSync(join(directory, "input-0.json")) ? json(join(directory, "input-0.json")) : undefined };
+		} finally { runner.cancelAll(); }
+	}
+	const ended = (run, name: string) => run.events.filter(event => event.type === "tool_execution_end" && event.toolName === name);
+	await t.test("native apply context and installed actor reach actual model/tool input", async () => {
+		const observed = await run("apply", "apply", [[["read", { path: join(change, "proposal.md") }]]]);
+		assert.equal(observed.result.status, "completed", JSON.stringify(observed.result));
+		assert.ok(observed.input.systemPrompt.includes(JSON.stringify(status, null, 2)));
+		assert.ok(observed.input.systemPrompt.includes(actor("apply").instructions));
+		assert.equal(ended(observed, "read").length, 1); assert.equal(ended(observed, "read")[0].isError, false);
+		assert.match(JSON.stringify(ended(observed, "read")[0].result), /Native uptake controlled fixture/);
+	});
+	const path = join(change, "research.md"), initial = '{"revision":1,"outcome":"blocked"}', next = '{"revision":2,"outcome":"partial","intent":"retain docs request"}';
+	const artifact = { store: "openspec", worktree: cwd, changeName: "uptake", retainedIntent: "retain docs request", locators: [{ artifact: "research", path, revision: 1, digest: digest(initial) }] };
+	writeFileSync(path, initial);
+	for (const absentTool of [true, false]) await t.test(`research provisioning absent=${absentTool} retains bounded denial persistence`, async () => {
+		const content = absentTool ? next : '{"revision":3,"outcome":"partial","intent":"retain docs request"}';
+		if (!absentTool) { artifact.locators[0].revision = 2; artifact.locators[0].digest = digest(next); }
+		const observed = await run(`research-${absentTool}`, "research", [[["fetch_content", {}]], [["read", { path }]], [["write", { path, content }]], [["read", { path }]], [["write", { path: join(cwd, "forbidden"), content }]]], { artifact, absentTool });
+		assert.equal(observed.result.status, "completed", JSON.stringify(observed.result));
+		assert.ok(JSON.stringify(observed.input).includes("gentle-ai.sdd-status"));
+		assert.equal(ended(observed, "fetch_content")[0].isError, absentTool);
+		assert.equal(existsSync(join(observed.directory, "fetch-calls")), !absentTool);
+		assert.equal(readFileSync(path, "utf8"), content);
+		assert.equal(existsSync(join(cwd, "forbidden")), false);
+		assert.equal(ended(observed, "write")[1].isError, true);
+		assert.match(JSON.stringify(ended(observed, "read").at(-1).result), /Readback identity matched/);
+		if (!absentTool) assert.equal(json(join(observed.directory, "inventory.json")).find(tool => tool.name === "fetch_content").sourceInfo.path, docExtension);
+	});
+	for (const fault of ["stale", "worktree"]) await t.test(`research ${fault} refuses before mutation`, async () => {
+		const bytes = readFileSync(path, "utf8");
+		const scope = { ...artifact, worktree: fault === "worktree" ? root : cwd, locators: [{ ...artifact.locators[0], revision: 3, digest: fault === "stale" ? "0".repeat(64) : digest(bytes) }] };
+		const observed = await run(`research-${fault}`, "research", [[["read", { path }]], [["write", { path, content: '{"revision":4}' }]]], { artifact: scope });
+		assert.equal(ended(observed, "read")[0].isError, true);
+		assert.equal(ended(observed, "write")[0].isError, true);
+		assert.equal(readFileSync(path, "utf8"), bytes);
+	});
+
+	await t.test("wrong native worktree refuses actual child tool work", async () => {
+		const observed = await run("wrong-worktree", "apply", [[["read", { path: join(change, "proposal.md") }]]], { selection: { workspaceRoot: root } });
+		assert.match(observed.input.systemPrompt, /SDD selection blocked/);
+		assert.equal(ended(observed, "read").length, 1);
+		assert.equal(ended(observed, "read")[0].isError, true);
+	});
+	await t.test("missing installed typed remediation asset refuses before native acquire", async () => {
+		const definition = actor("remediate");
+		const bytes = readFileSync(definition.filePath);
+		rmSync(definition.filePath);
+		let acquires = 0;
+		try {
+			await assert.rejects(admitManagedRemediation({ agent: definition, cwd, sddChange: { phase: "remediate", changeName: "uptake", workspaceRoot: cwd, failedEvidenceRevision: `sha256:${"a".repeat(64)}` } } as unknown as TaskRequest, {}, { ...native, sddAttemptAcquire: async () => { acquires++; throw new Error("Must not acquire"); } } as unknown as import("../lib/native-review-cli.ts").NativeReviewCli, async () => {}), /unsupported/i);
+			assert.equal(acquires, 0);
+		} finally { writeFileSync(definition.filePath, bytes); }
+	});
+	await t.test("native failed-evidence identity reaches the installed distinct remediation child; stale binding refuses", async () => {
+		writeFileSync(join(change, "tasks.md"), "- [x] Controlled fixture complete\n");
+		// A declared failing verification fixture, never a passing evidence claim.
+		const failed = `sha256:${"a".repeat(64)}`;
+		writeFileSync(join(change, "verify-report.md"), ["```yaml", "schema: gentle-ai.verify-result/v1", `evidence_revision: ${failed}`, "verdict: fail", "blockers: 1", "critical_findings: 0", "requirements: 1/1", "scenarios: 1/1", "test_command: false", "test_exit_code: 1", `test_output_hash: sha256:${digest("")}`, "build_command: true", "build_exit_code: 0", `build_output_hash: sha256:${digest("")}`, "```"].join("\n"));
+		const remediationStatus = await native.sddStatus({ changeName: "uptake", workspaceRoot: cwd });
+		assert.equal(remediationStatus.nextRecommended, "remediate");
+		assert.equal(remediationStatus.remediationState.failedEvidenceRevision, failed);
+		const plan = { cwd, editPaths: [join(change, "proposal.md")], commands: ["true"], runtimeHarness: { naReason: "No correction harness because this controlled boundary performs no source correction or acceptance." }, rollback: { boundary: "Remove the isolated controlled fixture only", command: "true" } };
+		const remediation = { failedEvidenceRevision: failed, plan, scope: { cwd, commands: ["true", "true"], editPaths: [join(change, "proposal.md")], allowedEditRoots: [cwd] }, observations: [], pending: {}, invalid: false };
+		const observed = await run("remediate", "remediate", [[["read", { path: join(change, "proposal.md") }]]], { selection: { failedEvidenceRevision: failed }, remediation });
+		assert.ok(observed.input.systemPrompt.includes(JSON.stringify(remediationStatus, null, 2)), observed.input.systemPrompt.slice(-9000));
+		assert.ok(observed.input.systemPrompt.includes(actor("remediate").instructions));
+		assert.equal(ended(observed, "read")[0].isError, false, JSON.stringify({ ended: ended(observed, "read"), startup: json(join(observed.directory, "startup.json")) }));
+		const stale = await run("stale-remediation", "remediate", [[["read", { path: join(change, "proposal.md") }]]], { selection: { failedEvidenceRevision: `sha256:${"b".repeat(64)}` }, remediation });
+		assert.match(stale.input.systemPrompt, /Stale remediation selection/);
+		assert.equal(ended(stale, "read")[0].isError, true);
+	});
+
+	const buildFiles: Record<string, string> = {};
+	const inventory = (directory: string) => {
+		for (const entry of readdirSync(join(pkg, directory), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+			const name = join(directory, entry.name);
+			if (entry.isDirectory()) inventory(name); else if (entry.isFile()) buildFiles[name] = digest(readFileSync(join(pkg, name)));
+		}
+	};
+	for (const directory of ["assets", "extensions", "lib", "runtime", "contracts", "scripts"]) inventory(directory);
+	buildFiles["package.json"] = digest(readFileSync(join(pkg, "package.json")));
+	const tuple = { aiSource: producerIdentity.sourceRevision, aiBinary: producerIdentity.sha256, piHead: execFileSync("git", ["rev-parse", "HEAD"], { cwd: source, encoding: "utf8" }).trim(), piBuild: digest(JSON.stringify(buildFiles)), buildFiles, manifest, contract: "gentle-ai.sdd-status/v2" };
+	if (process.env.UPTAKE_EVIDENCE_DIR) {
+		writeFileSync(join(process.env.UPTAKE_EVIDENCE_DIR, "tuple.json"), JSON.stringify(tuple, null, 2));
+		cpSync(join(home, "agents"), join(process.env.UPTAKE_EVIDENCE_DIR, "installed-agents"), { recursive: true });
+	}
+	t.diagnostic(JSON.stringify({ aiSource: tuple.aiSource, aiBinary: tuple.aiBinary, piHead: tuple.piHead, piBuild: tuple.piBuild, contract: tuple.contract }));
+
+});