gentle-pi 2.7.0 → 3.0.0

package/tests/sdd-research-capabilities.test.ts

@@ -1,10 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, symlinkSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createHash } from "node:crypto";
-import { parseResearchArtifactIntent, researchArtifactCall, researchArtifactReadback, type ResearchArtifactIntent } from "../lib/sdd-research-capabilities.ts";
+import { readFileSync } from "node:fs";
 import { childArguments } from "../lib/agents-runner.ts";
 import { resolveResearchCapabilities, researchAgent, renderResearchCapabilities } from "../lib/sdd-research-capabilities.ts";
 import type { AgentDefinition } from "../lib/agents-config.ts";
@@ -19,7 +15,7 @@ test("approved active external tools reach the actual child CLI allowlist", () =
  const pi = inventory(["read", "write", "fetch_content", "web_search", "source_check", "get_search_content", "bash", "mcp"]);
  const result = researchAgent(agent, pi, both);
  const args = childArguments({ agent: result.agent, sessionDir: "sessions" } as never);
- assert.equal(args[args.indexOf("--tools") + 1], "read,write,fetch_content,web_search,source_check,get_search_content,subagent_parent_message");
+ assert.equal(args[args.indexOf("--tools") + 1], "fetch_content,web_search,source_check,get_search_content,subagent_parent_message");
  assert.equal(result.capabilities.documentation.status, "available");
  assert.equal(result.capabilities["open-web"].status, "available");
 });
@@ -31,19 +27,19 @@ test("class-specific grants remain exact when both classes are explicitly select
  assert.match(renderResearchCapabilities(caps), /documentation: available; tools=\["fetch_content"\]/);
  assert.deepEqual(resolveResearchCapabilities(inventory(["web_search"])).documentation.tools, []);
  assert.deepEqual(resolveResearchCapabilities(inventory(["web_search"]))["open-web"].tools, ["web_search"]);
- assert.deepEqual(researchAgent(agent, inventory(names), both).agent.tools, agent.tools);
+ assert.deepEqual(researchAgent(agent, inventory(names), both).agent.tools, agent.tools.filter(name => !["read", "write"].includes(name)));
  const instructions = readFileSync(new URL("../assets/agents/sdd-research.md", import.meta.url), "utf8");
- assert.match(instructions, /Persist grants per source class exactly as observed/);
+ assert.match(instructions, /Report grants per source class exactly as observed/);
  assert.match(instructions, /never copy the child tool union into each class/);
  assert.match(instructions, /research_selection/);
  assert.match(instructions, /sourceInfo\.path/);
  assert.match(instructions, /--extension/);
- assert.match(instructions, /research_artifact/);
- assert.match(instructions, /revision_count/);
- assert.match(instructions, /full bounded write/);
- assert.match(instructions, /identical store.*worktree/);
+ assert.match(instructions, /output-only/);
+ assert.doesNotMatch(instructions, /revision_count/);
+ assert.match(instructions, /parent owns.*persistence/);
+
 });
-test("open-web requires all four canonical tools, each active and unrestricted", () => {
+test("open-web exposes available authorized tools without a completeness gate", () => {
  const required = ["web_search", "source_check", "fetch_content", "get_search_content"];
  for (const missing of required) {
   const remaining = required.filter(name => name !== missing);
@@ -53,7 +49,7 @@ test("open-web requires all four canonical tools, each active and unrestricted",
    resolveResearchCapabilities(inventory(required), remaining),
    researchAgent(agent, inventory(remaining), both).capabilities,
   ]) {
-   assert.equal(caps["open-web"].status, "blocked", `${missing} must deny open-web`);
+   assert.equal(caps["open-web"].status, "available", `${missing} must not deny other tools`);
    assert.match(caps["open-web"].reason, new RegExp(missing));
    assert.equal(caps.documentation.status, missing === "fetch_content" ? "blocked" : "available");
   }
@@ -63,14 +59,14 @@ test("restrictions, inactive tools and unknown tools never become grants", () =>
  const pi = inventory(["fetch_content", "web_search", "mcp", "mcp__context7", "bash"]);
  const caps = resolveResearchCapabilities(pi, ["web_search"]);
  assert.equal(caps.documentation.status, "blocked");
- assert.equal(caps["open-web"].status, "blocked");
- assert.deepEqual(researchAgent({ ...agent, tools: ["read", "write"] } as never, pi).agent.tools, ["read", "write"]);
+ assert.equal(caps["open-web"].status, "available");
+ assert.deepEqual(researchAgent({ ...agent, tools: ["read", "write"] } as never, pi).agent.tools, []);
  assert.equal(resolveResearchCapabilities(inventory(["mcp", "mcp__context7"])).documentation.status, "blocked");
  const inactive = { ...pi, getActiveTools: () => [] };
  assert.equal(resolveResearchCapabilities(inactive).documentation.status, "blocked");
 });
 test("documentation can run independently of unavailable open-web search", () => {
- const caps = resolveResearchCapabilities(inventory(["fetch_content"]));
+ const caps = researchAgent(agent, inventory(["fetch_content"]), documentation).capabilities;
  assert.equal(caps.documentation.status, "available");
  assert.equal(caps["open-web"].status, "blocked");
  assert.match(renderResearchCapabilities(caps), /official/);
@@ -84,15 +80,15 @@ test("SDK-only tools and unavailable inventory fail closed", () => {
 
 test("selected documentation never inherits available open-web routes or arbitrary extensions", () => {
  const result = researchAgent(agent, inventory(agent.tools), documentation);
- assert.deepEqual(result.agent.tools, ["read", "write", "fetch_content"]);
+ assert.deepEqual(result.agent.tools, ["fetch_content"]);
  assert.deepEqual(result.extensionPaths, ["/installed/web.ts"]);
  assert.equal(result.capabilities["open-web"].status, "blocked");
  for (const selection of [undefined, {}, { documentation: grant(["fetch_content", "web_search"]) }, { documentation: { tools: ["fetch_content"], extensions: { fetch_content: "/other.ts" } } }]) {
-  assert.deepEqual(researchAgent(agent, inventory(agent.tools), selection).agent.tools, ["read", "write"]);
+  assert.deepEqual(researchAgent(agent, inventory(agent.tools), selection).agent.tools, []);
  }
 });
 
-test("selected grants refuse missing, inactive, SDK, restricted and unknown routes without removing local authorization", () => {
+test("selected grants refuse missing, inactive, SDK, restricted and unknown routes while research remains output-only", () => {
  const local = ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"];
  const definition = { ...agent, tools: [...local, ...both["open-web"].tools, "bash", "mcp"] };
  for (const missing of both["open-web"].tools) {
@@ -104,153 +100,15 @@ test("selected grants refuse missing, inactive, SDK, restricted and unknown rout
    [full, definition.tools.filter(name => name !== missing)],
   ] as const) {
    const result = researchAgent({ ...definition, tools: [...tools] }, pi, { "open-web": both["open-web"] });
-   assert.deepEqual(result.agent.tools, local, missing);
-   assert.equal(result.capabilities["open-web"].status, "blocked");
+   assert.deepEqual(result.agent.tools, both["open-web"].tools.filter(name => name !== missing), missing);
+   assert.equal(result.capabilities["open-web"].status, "available");
    assert.deepEqual(result.capabilities["open-web"].tools, both["open-web"].tools.filter(name => name !== missing));
   }
  }
  for (const selection of [{ unknown: grant(["fetch_content"]), ...documentation }, { toString: {}, ...documentation }, { documentation: grant(["mcp"]) }]) {
-  assert.deepEqual(researchAgent(definition, inventory(definition.tools), selection).agent.tools, local);
+  assert.deepEqual(researchAgent(definition, inventory(definition.tools), selection).agent.tools, []);
  }
  const allowed = researchAgent(definition, inventory(definition.tools), { "open-web": both["open-web"] });
- assert.deepEqual(allowed.agent.tools, [...local, ...both["open-web"].tools]);
+ assert.deepEqual(allowed.agent.tools, both["open-web"].tools);
  assert.deepEqual(allowed.capabilities.documentation.tools, []);
 });
-
-const digest = (bytes: string) => createHash("sha256").update(bytes).digest("hex");
-test("artifact intent narrows exact paths and topics without granting tools or replacement scope", () => {
- const cwd = mkdtempSync(join(tmpdir(), "research-bounds-"));
- try {
-  const path = join(cwd, "openspec/changes/demo/research.md");
-  mkdirSync(join(cwd, "openspec/changes/demo"), { recursive: true });
-  const bytes = '{"revision":1,"outcome":"blocked"}';
-  writeFileSync(path, bytes);
-  const locator = { artifact: "research", revision: 1, digest: digest(bytes), path, engram: { id: 7, project: "pi", topic_key: "sdd/demo/research", revision_count: 2 } };
-  const intent: ResearchArtifactIntent = { store: "both", worktree: cwd, changeName: "demo", retainedIntent: "docs requested; fetch missing", locators: [locator] };
-  const scope = parseResearchArtifactIntent(intent, cwd);
-  for (const name of ["read", "edit", "write", "grep"]) assert.equal(researchArtifactCall(scope, cwd, name, { path }), 0);
-  assert.equal(researchArtifactCall(scope, cwd, "mem_get_observation", { id: 7 }), 0);
-  assert.equal(researchArtifactCall(scope, cwd, "mem_save", { project: "pi", topic_key: "sdd/demo/research" }), 0);
-  assert.equal(researchArtifactCall(scope, cwd, "mem_search", { project: "pi", query: "sdd/demo/research" }), 0);
-  for (const [name, input] of [["write", { path: join(cwd, "source.ts") }], ["read", {}], ["find", { path: cwd }], ["mem_get_observation", { id: 8 }], ["mem_search", { project: "pi", query: "sdd/demo/research", all_projects: true }], ["mem_save", { project: "other", topic_key: "sdd/demo/research" }]] as const) {
-   assert.throws(() => researchArtifactCall(scope, cwd, name, input), /scope/);
-  }
-  assert.throws(() => researchArtifactCall(scope, tmpdir(), "write", { path }), /worktree/);
-  symlinkSync(path, join(cwd, "alias"));
-  assert.throws(() => researchArtifactCall(scope, cwd, "read", { path: join(cwd, "alias") }), /scope/);
-  rmSync(path);
-  symlinkSync(join(cwd, "missing-target"), path);
-  assert.throws(() => researchArtifactCall(scope, cwd, "write", { path }), /ENOENT|scope/);
-  rmSync(path);
-  writeFileSync(path, bytes);
-  for (const patch of [{ worktree: tmpdir() }, { store: "engram" }, { retainedIntent: "replacement" }, { locators: [{ ...locator, digest: "0".repeat(64) }] }]) {
-   assert.throws(() => parseResearchArtifactIntent({ ...intent, ...patch }, cwd, scope), /scope|worktree|stale/);
-  }
-  const none = parseResearchArtifactIntent({ ...intent, store: "none", locators: [] }, cwd);
-  assert.throws(() => researchArtifactCall(none, cwd, "write", { path }), /scope/);
-  const explore = parseResearchArtifactIntent({ ...intent, store: "openspec", locators: [{ ...locator, artifact: "explore", path: join(cwd, "openspec/changes/demo/explore.md"), engram: undefined }] }, cwd);
-  assert.throws(() => researchArtifactCall(explore, cwd, "write", { path: explore.locators[0].path }), /scope/);
-  const corrected = { ...intent, locators: [{ ...locator, revision: 2, digest: digest("corrected"), engram: { ...locator.engram, revision_count: 3 } }] };
-  assert.equal(parseResearchArtifactIntent(corrected, cwd, scope).retainedIntent, intent.retainedIntent);
-  assert.throws(() => parseResearchArtifactIntent({ ...intent, locators: [{ ...locator, path: cwd }] }, cwd), /scope/);
- } finally { rmSync(cwd, { recursive: true, force: true }); }
-});
-
-test("only actual exact OpenSpec bytes and Engram metadata satisfy readback identity", () => {
- const cwd = mkdtempSync(join(tmpdir(), "research-readback-"));
- try {
-  const bytes = '{"revision":3,"outcome":"done"}';
-  const locator = { artifact: "research", revision: 3, digest: digest(bytes), path: join(cwd, "openspec/changes/demo/research.md"), engram: { id: 7, project: "pi", topic_key: "sdd/demo/research", revision_count: 4 } };
-  const scope = parseResearchArtifactIntent({ store: "both", worktree: cwd, changeName: "demo", retainedIntent: "docs", locators: [locator] }, cwd);
-  const observation = { ...locator.engram, content: bytes };
-  assert.equal(researchArtifactReadback(scope.locators[0], "read", bytes), true);
-  assert.equal(researchArtifactReadback(scope.locators[0], "mem_get_observation", observation), true);
-  for (const patch of [{ id: 9 }, { project: "other" }, { topic_key: "sdd/other/research" }, { revision_count: 3 }, { revision_count: undefined }, { content: bytes + " " }]) {
-   assert.equal(researchArtifactReadback(scope.locators[0], "mem_get_observation", { ...observation, ...patch }), false);
-  }
-  for (const bad of ["", bytes + " ", '{"revision":2,"outcome":"done"}', { verified: true }, null]) assert.equal(researchArtifactReadback(scope.locators[0], "read", bad), false);
-  assert.equal(researchArtifactReadback(scope.locators[0], "mem_search", [observation]), false, "search is discovery, not full readback");
- } finally { rmSync(cwd, { recursive: true, force: true }); }
-});
-
-
-test("R4 research write crash reload requires durable desired identity and actual backend readback", async t => {
- const { default: gentleAgents } = await import("../extensions/gentle-agents.ts");
- const { appendFileSync } = await import("node:fs");
- const cwd = mkdtempSync(join(tmpdir(), "research-crash-")); t.after(() => rmSync(cwd, { recursive: true, force: true }));
- for (const store of ["openspec", "engram", "both"] as const) {
-  const path = join(cwd, "openspec/changes/demo/research.md"), history = join(cwd, `${store}.jsonl`), memory = join(cwd, `${store}-memory.json`);
-  mkdirSync(join(cwd, "openspec/changes/demo"), { recursive: true }); writeFileSync(history, "");
-  const bytes = '{"revision":1}', next = '{"revision":2}', digest = value => createHash("sha256").update(value).digest("hex");
-  const engram = { id: 12, project: "pi", topic_key: "sdd/demo/research", revision_count: 1 };
-  writeFileSync(path, bytes); writeFileSync(memory, JSON.stringify({ ...engram, content: bytes }));
-  const scope: ResearchArtifactIntent = { store, worktree: cwd, changeName: "demo", retainedIntent: "retain uncertainty", locators: [{ artifact: "research", revision: 1, digest: digest(bytes), ...(store !== "engram" ? { path } : {}), ...(store !== "openspec" ? { engram } : {}) }] };
-  const entries = () => readFileSync(history, "utf8").trim().split("\n").filter(Boolean).map(line => JSON.parse(line));
-  const start = (durable = true) => {
-   const hooks = new Map(), active = ["read", "write", "mem_get_observation", "mem_save"];
-   const pi = { on: (name, fn) => hooks.set(name, fn), getAllTools: () => active.map(name => ({ name })), getActiveTools: () => active, appendEntry: (customType, data) => appendFileSync(history, JSON.stringify({ type: "custom", customType, data }) + "\n") };
-   const ctx = { cwd, sessionManager: { getEntries: entries, getSessionFile: () => durable ? history : undefined } };
-   gentleAgents(pi as never, { GENTLE_PI_AGENTS_CHILD: "1", GENTLE_PI_RESEARCH_TOOLS: JSON.stringify(active), GENTLE_PI_RESEARCH_ARTIFACT: JSON.stringify(scope) });
-   hooks.get("before_agent_start")({ systemPrompt: "research" }, ctx);
-   const call = (toolName, input, toolCallId = "call") => hooks.get("tool_call")({ toolName, input, toolCallId }, ctx);
-   const read = toolName => {
-    const input = toolName === "read" ? { path } : { id: 12 }; assert.equal(call(toolName, input), undefined);
-    return hooks.get("tool_result")({ toolName, input, toolCallId: "call", content: [{ type: "text", text: readFileSync(toolName === "read" ? path : memory, "utf8") }], isError: false }, ctx);
-   };
-   return { call, read, result: (toolName, input, toolCallId) => hooks.get("tool_result")({ toolName, input, toolCallId, content: [{ type: "text", text: "saved" }], isError: false }, ctx) };
-  };
-  const unpersisted = start(false); if (store !== "engram") unpersisted.read("read"); if (store !== "openspec") unpersisted.read("mem_get_observation");
-  assert.equal(unpersisted.call(store === "engram" ? "mem_save" : "write", store === "engram" ? { project: "pi", topic_key: engram.topic_key, content: next } : { path, content: next })?.block, true, "in-memory session cannot authorize durable mutation");
-  writeFileSync(history, "");
-  let child = start(); if (store !== "engram") child.read("read"); if (store !== "openspec") child.read("mem_get_observation");
-  const local = store !== "engram", tool = local ? "write" : "mem_save", input = local ? { path, content: next } : { project: "pi", topic_key: engram.topic_key, content: next };
-  assert.equal(child.call(tool, input, "crash-write"), undefined);
-  assert.ok(JSON.stringify(entries()).includes(digest(next)), "desired identity must precede backend mutation");
-  if (store === "both") {
-   child.result(tool, input, "crash-write");
-   const before = readFileSync(history, "utf8");
-   for (const content of ['{"revision":3}', '{"revision":2,"different":true}']) {
-    assert.equal(child.call("mem_save", { project: "pi", topic_key: engram.topic_key, content }, "diverge")?.block, true);
-    assert.equal(readFileSync(history, "utf8"), before, "mismatch refused before checkpoint or mutation");
-   }
-   assert.equal(child.call("mem_save", { project: "pi", topic_key: engram.topic_key, content: next }, "matching"), undefined);
-  }
-  if (local) writeFileSync(path, next); else writeFileSync(memory, JSON.stringify({ ...engram, content: next, revision_count: 2 }));
-  // Recreate extension solely from retained session bytes; no mutation result delivered.
-  child = start(); const readback = child.read(local ? "read" : "mem_get_observation");
-  if (store === "both") {
-   assert.equal(child.read("mem_get_observation").isError, true, "partial hybrid never converges");
-   assert.equal(child.call(tool, { ...input, content: '{"revision":3}' })?.block, true);
-  } else {
-   assert.match(readback.content.at(-1).text, /all selected stores/);
-   child = start(); assert.match(child.read(local ? "read" : "mem_get_observation").content.at(-1).text, /all selected stores/, "accepted recovery survives another reload");
-   assert.equal(child.call(tool, { ...input, content: '{"revision":3}' }), undefined);
-   child = start(); assert.equal(child.read(local ? "read" : "mem_get_observation").isError, true, "crash before actual mutation refuses stale bytes");
-   assert.equal(child.call(tool, { ...input, content: '{"revision":4}' })?.block, true);
-  }
- }
-});
-
-
-test("R4 corrupted or broadened durable research scope is not a restart grant", async t => {
- const { parseResearchPersistence } = await import("../lib/sdd-research-capabilities.ts");
- const cwd = mkdtempSync(join(tmpdir(), "research-journal-")); t.after(() => rmSync(cwd, { recursive: true, force: true }));
- const locator = { artifact: "research", revision: 1, digest: "a".repeat(64), engram: { id: 12, project: "pi", topic_key: "sdd/demo/research", revision_count: 1 } };
- const scope: ResearchArtifactIntent = { store: "engram", worktree: cwd, changeName: "demo", retainedIntent: "retain uncertainty", locators: [locator] };
- const snapshot = { version: 1, scope, accepted: {}, writes: { "0:mem_get_observation": { revision: 2, digest: "b".repeat(64) } }, operation: { toolCallId: "write", tool: "mem_save", index: 0 } };
- assert.doesNotThrow(() => parseResearchPersistence(snapshot, scope, cwd));
- const hybrid: ResearchArtifactIntent = { ...scope, store: "both", locators: [{ ...locator, path: join(cwd, "openspec/changes/demo/research.md") }] };
- for (const desired of [{ revision: 3, digest: "b".repeat(64) }, { revision: 2, digest: "c".repeat(64) }]) {
-  assert.throws(() => parseResearchPersistence({ ...snapshot, scope: hybrid, writes: { ...snapshot.writes, "0:read": desired } }, hybrid, cwd), /divergent/i);
- }
- assert.doesNotThrow(() => parseResearchPersistence({ ...snapshot, scope: hybrid, writes: { ...snapshot.writes, "0:read": snapshot.writes["0:mem_get_observation"] } }, hybrid, cwd));
- for (const bad of [{ ...snapshot, accepted: "unknown" }, { ...snapshot, writes: { "0:mem_get_observation": null } }, { ...snapshot, accepted: { "0:mem_get_observation": null } }, { ...snapshot, scope: { ...scope, store: "none", locators: [] } }, { ...snapshot, writes: { "0:mem_get_observation": { revision: 1, digest: "a".repeat(64) } } }]) assert.throws(() => parseResearchPersistence(bad, scope, cwd));
- for (const engram of [{ ...locator.engram, id: 13 }, { ...locator.engram, project: "other" }, { ...locator.engram, topic_key: "sdd/other/research" }]) assert.throws(() => parseResearchPersistence(snapshot, { ...scope, locators: [{ ...locator, engram }] }, cwd));
-});
-
-
-test("research actor explains crash readback without store substitution or replay", () => {
- const text = readFileSync("assets/agents/sdd-research.md", "utf8");
- assert.match(text, /physical session history/); assert.match(text, /crash.*desired identity/);
- assert.match(text, /checkpoint.*not.*readback/i);
-});

package/tests/sdd-selection-transport.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
@@ -92,12 +92,14 @@ test("selected SDD change snapshots at task construction and reaches child start
 	const concurrent = spawned[1]![spawned[1]!.indexOf("--gentle-sdd-change") + 1]!;
 	assert.deepEqual(JSON.parse(serialized), { changeName: "alpha", workspaceRoot: root, phase: "apply" });
 	assert.deepEqual(JSON.parse(concurrent), { changeName: "beta", workspaceRoot: root, phase: "apply" });
-	const startup = __testing.resolveSddChangeStartup(serialized, root, "sdd-apply");
+	const authority = { ...commandStatus(root), nextRecommended: "apply", blockedReasons: [],
+		dependencies: { ...commandStatus(root).dependencies, apply: "ready" } };
+	const startup = await nativeStartup(serialized, root, "sdd-apply", { sddStatus: async () => authority });
 	assert.equal(startup.status.changeName, "alpha");
-	assert.equal(startup.status.nextRecommended, "sdd-propose");
+	assert.equal(startup.status.nextRecommended, "apply");
 });
 
-test("selected native v2 archive authority is injected whole and never falls back to the local resolver", async (t) => {
+test("selected native v2 archive authority is injected whole without a competing local projection", async (t) => {
 	const root = workspace(t);
 	const serialized = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "archive" });
 	const nativeAuthority = {
@@ -114,31 +116,16 @@ test("selected native v2 archive authority is injected whole and never falls bac
 		nextRecommended: "archive",
 	};
 	const nativeCalls: unknown[] = [];
-	let localResolverCalls = 0;
-	const startup = await (__testing as unknown as {
-		resolveSelectedNativeSddChangeStartup(
-			serialized: unknown,
-			cwd: string,
-			agentName: string,
-			native: { sddStatus?: (request: unknown) => Promise<unknown> },
-			localResolver: () => unknown,
-		): Promise<{ selection: { changeName: string; workspaceRoot: string; phase: string }; status: unknown }>;
-	}).resolveSelectedNativeSddChangeStartup(serialized, root, "sdd-archive", {
+	const startup = await nativeStartup(serialized, root, "sdd-archive", {
 		sddStatus: async (request) => { nativeCalls.push(request); return nativeAuthority; },
-	}, () => {
-		localResolverCalls += 1;
-		// Simulates local v1's missing sync-report.md result: it must never
-		// overlay the native archive-ready authority.
-		return { dependencies: { verify: "all_done", sync: "blocked", archive: "blocked" } };
 	});
 
 	assert.deepEqual(startup.selection, { changeName: "alpha", workspaceRoot: root, phase: "archive" });
 	assert.equal(startup.status, nativeAuthority, "the validated native status object is injected without a local overlay");
 	assert.deepEqual(nativeCalls, [{ changeName: "alpha", workspaceRoot: root }]);
-	assert.equal(localResolverCalls, 0);
 });
 
-test("selected native v2 failures fail closed without consulting the local resolver", async (t) => {
+test("selected native v2 failures fail closed without local status reconstruction", async (t) => {
 	const root = workspace(t);
 	const serialized = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "archive" });
 	const valid = {
@@ -163,66 +150,17 @@ test("selected native v2 failures fail closed without consulting the local resol
 		{ sddStatus: async () => ({ ...valid, blockedReasons: "invalid" }) },
 	];
 	for (const native of failures) {
-		let localResolverCalls = 0;
-		await assert.rejects(
-			() => (__testing as unknown as {
-				resolveSelectedNativeSddChangeStartup(
-					serialized: unknown, cwd: string, agentName: string,
-					native: { sddStatus?: () => Promise<unknown> }, localResolver: () => unknown,
-				): Promise<unknown>;
-			}).resolveSelectedNativeSddChangeStartup(serialized, root, "sdd-archive", native, () => { localResolverCalls += 1; return {}; }),
-			/SDD selection native status/i,
-		);
-		assert.equal(localResolverCalls, 0);
+		await assert.rejects(() => nativeStartup(serialized, root, "sdd-archive", native), /SDD selection native status/i);
 	}
+	await assert.rejects(() => nativeStartup(serialized, root, "sdd-archive", { sddStatus: async () => valid }), /native status.*blocks|cannot execute/i);
 
-	await assert.rejects(
-		() => (__testing as unknown as {
-			resolveSelectedNativeSddChangeStartup(
-				serialized: unknown, cwd: string, agentName: string,
-				native: { sddStatus?: () => Promise<unknown> }, localResolver: () => unknown,
-			): Promise<unknown>;
-		}).resolveSelectedNativeSddChangeStartup(serialized, root, "sdd-archive", { sddStatus: async () => valid }, () => {
-			throw new Error("local resolver must not run");
-		}),
-		/native status.*blocks|cannot execute/i,
-	);
-
-	const syncSerialized = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "sync" });
-	const localStatus = __testing.resolveSddChangeStartup(syncSerialized, root, "sdd-sync").status;
-	const syncNativeCalls: unknown[] = [];
-	const syncLocalCalls: unknown[] = [];
-	const sync = await (__testing as unknown as {
-		resolveSelectedNativeSddChangeStartup(
-			serialized: unknown, cwd: string, agentName: string,
-			native: { sddStatus?: (request: unknown) => Promise<unknown> }, localResolver: (options: unknown) => unknown,
-		): Promise<{ status: unknown }>;
-	}).resolveSelectedNativeSddChangeStartup(syncSerialized, root, "sdd-sync", {
-		sddStatus: async (request) => { syncNativeCalls.push(request); throw new Error("native must not run"); },
-	}, (options) => {
-		syncLocalCalls.push(options);
-		return localStatus;
-	});
-	assert.equal(sync.status, localStatus, "selected sync injects the exact local status");
-	assert.deepEqual(syncLocalCalls, [{ cwd: root, workspaceRoot: root, changeName: "alpha", includeInstructions: true }]);
-	assert.deepEqual(syncNativeCalls, []);
-
-	await assert.rejects(
-		() => (__testing as unknown as {
-			resolveSelectedNativeSddChangeStartup(
-				serialized: unknown, cwd: string, agentName: string,
-				native: { sddStatus?: () => Promise<unknown> }, localResolver: () => typeof localStatus,
-			): Promise<unknown>;
-		}).resolveSelectedNativeSddChangeStartup(syncSerialized, root, "sdd-sync", undefined, () => ({ ...localStatus, changeName: "beta" })),
-		/mismatched status/i,
-	);
 });
 
 function nativeStartup(
 	serialized: unknown,
 	cwd: string,
 	agentName: string,
-	native: { sddStatus: (request: unknown) => Promise<unknown> },
+	native: { sddStatus?: (request: unknown) => Promise<unknown> },
 ) {
 	return (__testing as unknown as {
 		resolveSelectedNativeSddChangeStartup(
@@ -275,24 +213,24 @@ test("a native verify evidence-refresh route starts under its own blocker while
 	}
 });
 
-test("a throwing SDD selection flag reader fails closed without resolving an unselected status", (t) => {
+test("a throwing SDD selection flag reader fails closed without resolving an unselected status", async (t) => {
 	const root = workspace(t);
 	assert.equal(__testing.readSddChangeFlag({ getFlag: () => false } as never), undefined);
 	const selection = __testing.readSddChangeFlag({
 		getFlag() { throw new Error("flag reader failed"); },
 	} as never);
 	let resolverCalls = 0;
-	assert.throws(
-		() => __testing.resolveSddChangeStartup(selection, root, "sdd-apply", () => {
+	await assert.rejects(
+		() => nativeStartup(selection, root, "sdd-apply", { sddStatus: async () => {
 			resolverCalls += 1;
 			throw new Error("status resolver must not run");
-		}),
+		} }),
 		/SDD selection must be a JSON string/i,
 	);
 	assert.equal(resolverCalls, 0);
 });
 
-test("selected SDD startup fails closed for malformed identity, root, phase, symlink, and resolver errors", (t) => {
+test("selected SDD startup fails closed for malformed identity, root, phase, symlink, and resolver errors", async (t) => {
 	const root = workspace(t);
 	const selected = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "apply" });
 	const outside = mkdtempSync(join(tmpdir(), "gentle-pi-sdd-selection-outside-"));
@@ -308,11 +246,11 @@ test("selected SDD startup fails closed for malformed identity, root, phase, sym
 		JSON.stringify({ changeName: "alpha", workspaceRoot: join(root, "wrong"), phase: "apply" }),
 		JSON.stringify({ changeName: "alpha", workspaceRoot: escaped, phase: "apply" }),
 	]) {
-		assert.throws(() => __testing.resolveSddChangeStartup(value, root, "sdd-apply"), /SDD selection/i);
+		await assert.rejects(() => nativeStartup(value, root, "sdd-apply", {}), /SDD selection/i);
 	}
-	assert.throws(() => __testing.resolveSddChangeStartup(selected, root, "sdd-verify"), /phase/i);
-	assert.throws(
-		() => __testing.resolveSddChangeStartup(selected, root, "sdd-apply", () => { throw new Error("resolver failed"); }),
+	await assert.rejects(() => nativeStartup(selected, root, "sdd-verify", {}), /phase/i);
+	await assert.rejects(
+		() => nativeStartup(selected, root, "sdd-apply", { sddStatus: async () => { throw new Error("resolver failed"); } }),
 		/resolver failed/i,
 	);
 });
@@ -395,14 +333,10 @@ test("before_agent_start resolves the unnamed packaged executor and renders nati
 	for (const phase of ["apply", "verify", "remediate", "archive"] as const) {
 		const phasePrompt = readFileSync(new URL(`../assets/agents/sdd-${phase}.md`, import.meta.url), "utf8").replace(/^---\n[\s\S]*?\n---\n/, "");
 		serialized = undefined;
-		nativeReply = { ...status, nextRecommended: phase, ...(phase === "remediate" ? { remediationState: { required: true, complete: false, failedEvidenceRevision: `sha256:${"a".repeat(64)}` } } : {}) };
+		nativeReply = { ...status, nextRecommended: phase, dependencies: { ...status.dependencies, ...(phase === "remediate" ? {} : { [phase]: "ready" }) }, ...(phase === "remediate" ? { remediationState: { required: true, complete: false, failedEvidenceRevision: `sha256:${"a".repeat(64)}` } } : {}) };
 		assert.doesNotMatch((await hooks.get("before_agent_start")!({ systemPrompt: phasePrompt }, ctx)).systemPrompt, /SDD selection blocked:/);
 		assert.equal((await callTool({ toolName: "read", input: {} }, ctx))?.block, undefined, `${phase} accepts its matching native recommendation`);
 	}
-	const syncPrompt = readFileSync(new URL("../assets/agents/sdd-sync.md", import.meta.url), "utf8").replace(/^---\n[\s\S]*?\n---\n/, "");
-	calls.length = 0; nativeReply = { ...status, changeName: null };
-	assert.doesNotMatch((await hooks.get("before_agent_start")!({ systemPrompt: syncPrompt }, ctx)).systemPrompt, /SDD selection blocked:/);
-	assert.deepEqual(calls, [], "manual sync remains local and never consults native discovery");
 	serialized = JSON.stringify(selection);
 	for (const blockedReply of [
 		{ ...status, dependencies: { ...status.dependencies, apply: "blocked" }, blockedReasons: ["missing native prerequisite"] },
@@ -426,8 +360,16 @@ test("producer v2 preservation: selected status is read-only and retains all sev
 	assert.equal(first, second);
 	const status = decodeNativeSddStatusV2(JSON.parse(first), { changeName: "alpha", workspaceRoot: root });
 	assert.deepEqual(Object.keys(status.dependencies).sort(), ["apply", "archive", "design", "proposal", "specs", "tasks", "verify"]);
-	assert.deepEqual(Object.keys(status.phaseInstructions!).sort(), ["apply", "archive", "remediate", "verify"]);
+	assert.deepEqual(Object.keys(status.phaseInstructions!).sort(), "remediate" in status.phaseInstructions!
+		? ["apply", "archive", "remediate", "verify"] : ["apply", "archive", "verify"]);
 	assert.equal(status.nextRecommended, "propose");
+	if (!("remediate" in status.phaseInstructions!)) {
+		assert.throws(() => execFileSync(process.env.SDD_TEST_PRODUCER!, ["sdd-verify-validate"], {
+			encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
+		}), (error: unknown) => error instanceof Error && "stderr" in error && /unknown command/.test(String(error.stderr)));
+		const verifier = readFileSync(new URL("../assets/agents/sdd-verify.md", import.meta.url), "utf8");
+		assert.doesNotMatch(verifier, /sdd-verify-validate|gentle-ai\.verify-result\/v1/);
+	}
 	const verbs: string[] = [];
 	const adapter = createNodeExecFileAdapter();
 	const native = new NativeReviewCliV216(async (request) => { verbs.push(request.arguments[0]!); return adapter(request); }, process.env.SDD_TEST_PRODUCER!);
@@ -473,6 +415,156 @@ function commandStatus(root: string) {
 	};
 }
 
+test("classical native instructions reach selected apply, verify and archive startup unchanged", async (t) => {
+	const root = workspace(t);
+	for (const phase of ["apply", "verify", "archive"] as const) {
+		const legacy = commandStatus(root);
+		const { remediate: _legacyOnly, ...phaseInstructions } = legacy.phaseInstructions;
+		const status = { ...legacy, phaseInstructions, blockedReasons: [], nextRecommended: phase,
+			dependencies: { ...legacy.dependencies, [phase]: "ready" } };
+		const calls: unknown[] = [];
+		const result = await nativeStartup(JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase }), root, `sdd-${phase}`, {
+			sddStatus: async (request) => { calls.push(request); return status; },
+		});
+		assert.equal(result.status, status, "transport preserves the provider's original object");
+		assert.equal("remediate" in result.status.phaseInstructions!, false, "never synthesize retired instructions");
+		assert.deepEqual(calls, [{ changeName: "alpha", workspaceRoot: root }]);
+	}
+});
+
+test("native instruction compatibility does not admit incomplete or foreign phase records", (t) => {
+	const root = workspace(t), legacy = commandStatus(root);
+	const { remediate: _legacyOnly, ...classical } = legacy.phaseInstructions;
+	const request = { changeName: "alpha", workspaceRoot: root };
+	assert.equal(decodeNativeSddStatusV2(legacy, request), legacy, "pinned producer remains supported");
+	for (const phaseInstructions of [
+		{ ...classical, verify: undefined }, { ...classical, remediate: undefined },
+		{ ...classical, remediate: "not an instruction list" }, { ...classical, sync: [] },
+		{ ...classical, unknown: [] },
+	]) assert.throws(() => decodeNativeSddStatusV2({ ...legacy, phaseInstructions }, request));
+	assert.throws(() => decodeNativeSddStatusV2({ ...legacy, phaseInstructions: classical,
+		nextRecommended: "remediate", remediationState: { required: true, complete: false, failedEvidenceRevision: `sha256:${"a".repeat(64)}` },
+	}, request), /remediation/i);
+});
+
+test("producer instructions reach actual selected-child startup without provider replacement", { skip: !process.env.SDD_TEST_PRODUCER }, async (t) => {
+	const root = workspace(t), change = join(root, "openspec/changes/alpha");
+	rmSync(join(root, "openspec/changes/beta"), { recursive: true });
+	execFileSync("git", ["init", "--quiet", root]);
+	mkdirSync(join(change, "specs/feature"), { recursive: true });
+	for (const [path, content] of Object.entries({ "proposal.md": "# Proposal\n", "design.md": "# Design\n",
+		"specs/feature/spec.md": "# Spec\n", "tasks.md": "- [ ] 1.1 Implement\n" })) writeFileSync(join(change, path), content);
+	const invoked: string[] = [];
+	const adapter = createNodeExecFileAdapter();
+	const native = new NativeReviewCliV216(async (request) => {
+		invoked.push(request.arguments[0]!);
+		return adapter(request);
+	}, process.env.SDD_TEST_PRODUCER!);
+	t.after(() => assert.ok(invoked.every((verb) => verb === "sdd-status"), "registered startup never invokes attempt acquire/settle"));
+	const status = await native.sddStatus!({ workspaceRoot: root, changeName: "alpha" });
+	assert.equal(status.nextRecommended, "apply");
+	let selection: string | undefined = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "apply" });
+	const hooks = new Map<string, (event: unknown, ctx: ExtensionContext) => Promise<{ systemPrompt: string }>>();
+	const pi = { on(name: string, hook: never) { hooks.set(name, hook); }, events: { emit() {} },
+		registerCommand() {}, registerTool() {}, getFlag: () => selection, getActiveTools: () => [],
+	} as unknown as ExtensionAPI;
+	const ctx = { cwd: root, hasUI: false, sessionManager: { getSessionId: () => root } } as unknown as ExtensionContext;
+	await ensureSddPreflight(ctx, { pi, installAssets: () => ({ agents: 0, chains: 0, support: 0, skipped: 0 }) });
+	createGentleAiExtension({ nativeReviewCli: native, processEnv: {},
+		resolveTelemetryTriggerBinary: () => { throw new Error("no telemetry in producer test"); },
+	})(pi);
+	const result = await hooks.get("before_agent_start")!({ systemPrompt: "SDD apply executor" }, ctx);
+	assert.doesNotMatch(result.systemPrompt, /SDD selection blocked:/);
+	assert.ok(result.systemPrompt.includes(JSON.stringify(status, null, 2)));
+	assert.match(result.systemPrompt, /### apply instructions/);
+	writeFileSync(join(change, "tasks.md"), "- [x] 1.1 Implement\n");
+	const completed = await native.sddStatus!({ workspaceRoot: root, changeName: "alpha" });
+	// The current pin requests verify; the classical producer requests archive.
+	// This slice consumes either producer, without changing its chosen route.
+	const next = "remediate" in completed.phaseInstructions! ? "verify" : "archive";
+	assert.equal(completed.nextRecommended, next);
+	selection = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: next });
+	const completion = await hooks.get("before_agent_start")!({ systemPrompt: `SDD ${next} executor` }, ctx);
+	assert.doesNotMatch(completion.systemPrompt, /SDD selection blocked:/);
+	assert.ok(completion.systemPrompt.includes(JSON.stringify(completed, null, 2)));
+	for (const selected of [true, false]) {
+		for (const phase of new Set([next, "verify"])) {
+			selection = selected ? JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase }) : undefined;
+			const result = await hooks.get("before_agent_start")!({ systemPrompt: `SDD ${phase} executor` }, ctx);
+			assert.doesNotMatch(result.systemPrompt, /SDD selection blocked:/);
+			assert.ok(result.systemPrompt.includes(JSON.stringify(completed, null, 2)));
+		}
+	}
+	writeFileSync(join(change, "verify-report.md"), "# Verification\nPASS\n");
+	const practical = await native.sddStatus!({ workspaceRoot: root, changeName: "alpha" });
+	assert.equal(practical.nextRecommended, next, "plain PASS cannot bypass a legacy provider's emitted evidence requirements");
+	if (next === "verify") assert.ok(practical.blockedReasons.some((reason) => reason.includes("verification evidence")));
+	for (const selected of [true, false]) {
+		selection = selected ? JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: next }) : undefined;
+		const result = await hooks.get("before_agent_start")!({ systemPrompt: `SDD ${next} executor` }, ctx);
+		assert.doesNotMatch(result.systemPrompt, /SDD selection blocked:/);
+		assert.ok(result.systemPrompt.includes(JSON.stringify(practical, null, 2)), "forward exact current provider instructions, including legacy evidence requirements");
+	}
+	writeFileSync(join(change, "tasks.md"), "- [ ] 1.1 Implement\n");
+	const partial = await native.sddStatus!({ workspaceRoot: root, changeName: "alpha" });
+	selection = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "verify" });
+	const partialVerify = await hooks.get("before_agent_start")!({ systemPrompt: "SDD verify executor" }, ctx);
+	if (partial.dependencies.verify === "ready") {
+		assert.doesNotMatch(partialVerify.systemPrompt, /SDD selection blocked:/);
+		assert.ok(partialVerify.systemPrompt.includes(JSON.stringify(partial, null, 2)));
+	} else {
+		assert.match(partialVerify.systemPrompt, /SDD selection blocked:/, "do not override the pinned provider's verification readiness");
+	}
+	for (const selected of [true, false]) {
+		selection = selected ? JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "archive" }) : undefined;
+		assert.match((await hooks.get("before_agent_start")!({ systemPrompt: "SDD archive executor" }, ctx)).systemPrompt, /SDD selection blocked:/);
+	}
+	const outside = join(root, "..", "ungranted-source.ts");
+	writeFileSync(join(change, "tasks.md"), `- [ ] Edit \`${outside}\`\n`);
+	const denied = await native.sddStatus!({ workspaceRoot: root, changeName: "alpha" });
+	assert.ok(denied.blockedReasons.some((reason) => reason.includes("edit_authority_missing")));
+	assert.deepEqual(denied.actionContext.allowedEditRoots, [root]);
+	selection = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "archive" });
+	assert.match((await hooks.get("before_agent_start")!({ systemPrompt: "SDD archive executor" }, ctx)).systemPrompt, /SDD selection blocked:/);
+
+	// Optional local integration proof uses the real Engram CLI, but never the
+	// user's data directory. No in-memory status substitute proves persistence.
+	if (process.env.SDD_TEST_ENGRAM) {
+		const originalData = process.env.ENGRAM_DATA_DIR;
+		const originalProject = process.env.ENGRAM_PROJECT;
+		try {
+			process.env.ENGRAM_PROJECT = "pi-sdd-parity-fixture";
+			writeFileSync(join(root, "openspec/config.yaml"), "sdd:\n  artifact_store: engram\n");
+			rmSync(join(root, "openspec/changes"), { recursive: true });
+			for (const complete of [false, true]) {
+				await t.test(`persisted Engram complete=${complete}`, async () => {
+					process.env.ENGRAM_DATA_DIR = join(root, `memory-${complete}`);
+					for (const [kind, content] of Object.entries({ proposal: "# Proposal", spec: "# Spec", design: "# Design",
+						tasks: complete ? "- [x] 1.1 Implement" : "- [ ] 1.1 Implement" })) {
+						execFileSync(process.env.SDD_TEST_ENGRAM!, ["save", `sdd/alpha/${kind}`, content, "--project", "pi-sdd-parity-fixture", "--scope", "project"], { cwd: root, stdio: "pipe" });
+					}
+					const memory = await native.sddStatus!({ workspaceRoot: root, changeName: "alpha" });
+					assert.equal(memory.artifactStore, "engram");
+					assert.equal(memory.nextRecommended, complete ? next : "apply");
+					for (const selected of [true, false]) {
+						selection = selected ? JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: memory.nextRecommended }) : undefined;
+						const result = await hooks.get("before_agent_start")!({ systemPrompt: `SDD ${memory.nextRecommended} executor` }, ctx);
+						assert.doesNotMatch(result.systemPrompt, /SDD selection blocked:/);
+						assert.ok(result.systemPrompt.includes(JSON.stringify(memory, null, 2)));
+					}
+					if (!complete) {
+						selection = JSON.stringify({ changeName: "alpha", workspaceRoot: root, phase: "archive" });
+						assert.match((await hooks.get("before_agent_start")!({ systemPrompt: "SDD archive executor" }, ctx)).systemPrompt, /SDD selection blocked:/);
+					}
+				});
+			}
+		} finally {
+			if (originalData === undefined) delete process.env.ENGRAM_DATA_DIR; else process.env.ENGRAM_DATA_DIR = originalData;
+			if (originalProject === undefined) delete process.env.ENGRAM_PROJECT; else process.env.ENGRAM_PROJECT = originalProject;
+		}
+	}
+});
+
 test("status command renders native facts without confirmation, mutation, or phase launch", async (t) => {
 	const root = workspace(t);
 	const status = commandStatus(root);