gentle-pi 0.8.0 → 0.9.2

package/assets/agents/sdd-apply.md

@@ -34,11 +34,15 @@ Never claim persistence you did not perform.
 
 Before writing code, consume structured SDD status from the parent prompt. If missing, produce the same fields using this lookup order: project override `.pi/gentle-ai/support/sdd-status-contract.md`, then globally installed `~/.pi/agent/gentle-ai/support/sdd-status-contract.md`, then the embedded status contract. Do not use `assets/support/...` as a runtime path; that is only the package source path before installation.
 
+**Non-authoritative store carve-out:** when the native status JSON shows `nextRecommended: "resolve-via-engram"` (covers `artifactStore: engram`, `artifactStore: none`, and `artifactStore: both` without an `openspec/` directory), the status is non-authoritative. Do not treat `applyState`, `dependencies`, or `blockedReasons` from that status as real blockers. Resolve readiness as follows:
+- `engram` (or `both` without openspec/): search Engram for `sdd/{change}/tasks`, `sdd/{change}/spec`, and `sdd/{change}/design` using `mem_search` + `mem_get_observation`. Proceed with implementation once those artifacts are confirmed present.
+- `none`: there is no persistent backend. Return artifacts inline and ask the user to provide required inputs (tasks, spec, design) or acknowledge that no persistent artifact store is available.
+
 Stop with `blocked` before editing if:
 
 - active change selection is missing or ambiguous;
-- `applyState: blocked`;
-- required apply artifacts are missing;
+- `applyState: blocked` **and the status is authoritative** (openspec or both store);
+- required apply artifacts are missing (confirmed by artifact store);
 - `actionContext.mode: workspace-planning` and no `allowedEditRoots` are provided;
 - any target file is outside the authoritative workspace or allowed edit roots.
 

package/assets/agents/sdd-archive.md

@@ -34,6 +34,10 @@ Archive a completed SDD change. In file-backed modes, this requires canonical sp
 
 Before archive work, consume structured SDD status from the parent prompt. If missing, produce the same fields using this lookup order: project override `.pi/gentle-ai/support/sdd-status-contract.md`, then globally installed `~/.pi/agent/gentle-ai/support/sdd-status-contract.md`, then the embedded status contract. Do not use `assets/support/...` as a runtime path; that is only the package source path before installation.
 
+**Non-authoritative store carve-out:** when the native status JSON shows `nextRecommended: "resolve-via-engram"` (covers `artifactStore: engram`, `artifactStore: none`, and `artifactStore: both` without an `openspec/` directory), the status is non-authoritative. Do not treat `dependencies` or `blockedReasons` (including `not_applicable` dependency states) from that status as real blockers. Resolve readiness as follows:
+- `engram` (or `both` without openspec/): refer to the Artifact Store Modes section — resolve readiness by checking Engram for `sdd/{change}/verify-report` using `mem_search` + `mem_get_observation`, then record the archive report in Engram without filesystem sync or folder moves.
+- `none`: there is no persistent backend. Return a closure summary inline and ask the user to confirm that verification has passed before proceeding.
+
 Stop with `blocked` if:
 
 - active change selection is missing or ambiguous;

package/assets/agents/sdd-status.md

@@ -98,6 +98,8 @@ If parent context reports `workspace-planning` and no `allowedEditRoots`, mark a
 - `sync` is `ready` when verify-report exists and has no unresolved `FAIL`, `BLOCKED`, `CRITICAL`, or verification blockers; it is `not_applicable` for `engram`/`none` modes.
 - `archive` is `ready` only when verify-report is passing, sync-report exists or sync is not applicable, and no unchecked implementation tasks remain. CRITICAL verification issues have no override. Explicit recorded exceptions are limited to non-critical partial archives or stale-checkbox reconciliation when apply-progress/verify-report prove completion.
 
+**Non-authoritative carve-out:** when `nextRecommended: "resolve-via-engram"` or `isNonAuthoritative: true` is set on the status object, the `dependencies`, `applyState`, and `blockedReasons` fields are non-authoritative — they must not be treated as real blockers. This condition applies when the artifact store is `engram`, `none`, or `both` without an `openspec/` directory present on disk. For `engram`/`both-without-openspec`, resolve readiness directly from Engram using `mem_search` + `mem_get_observation` on the change topic keys (`sdd/{change}/proposal`, `sdd/{change}/spec`, `sdd/{change}/design`, `sdd/{change}/tasks`, etc.). For `none`, return inline status or ask the user — do not use the engine's `not_applicable`/`blockedReasons` as real gate failures.
+
 ## Output
 
 Return the standard phase envelope with status, executive_summary, artifacts, next_recommended, risks, and skill_resolution. Include the structured status block in `artifacts` or `executive_summary`.

package/assets/agents/sdd-sync.md

@@ -37,6 +37,8 @@ Sync file-backed SDD change specs into canonical `openspec/specs/` without movin
 
 Before syncing, consume structured SDD status from the parent prompt. If missing, produce the same fields using this lookup order: project override `.pi/gentle-ai/support/sdd-status-contract.md`, then globally installed `~/.pi/agent/gentle-ai/support/sdd-status-contract.md`, then the embedded status contract. Do not use `assets/support/...` as a runtime path; that is only the package source path before installation.
 
+**Non-authoritative carve-out:** when native status JSON shows `nextRecommended: "resolve-via-engram"` (covers `artifactStore: engram`, `artifactStore: none`, and `artifactStore: both` without an `openspec/` directory), the status is non-authoritative. Do not treat `dependencies` or `blockedReasons` from that status as real blockers. For `engram` store, refer to the Artifact Store Modes section — sync is not applicable; return a report explaining that canonical spec merge is not supported in Engram-only mode.
+
 Stop with `blocked` if:
 
 - active change selection is missing or ambiguous;

package/assets/agents/sdd-verify.md

@@ -32,10 +32,14 @@ Never claim persistence you did not perform.
 
 Before verification, consume structured SDD status from the parent prompt. If missing, produce the same fields using this lookup order: project override `.pi/gentle-ai/support/sdd-status-contract.md`, then globally installed `~/.pi/agent/gentle-ai/support/sdd-status-contract.md`, then the embedded status contract. Do not use `assets/support/...` as a runtime path; that is only the package source path before installation.
 
+**Non-authoritative store carve-out:** when the native status JSON shows `nextRecommended: "resolve-via-engram"` (covers `artifactStore: engram`, `artifactStore: none`, and `artifactStore: both` without an `openspec/` directory), the status is non-authoritative. Do not treat `dependencies` or `blockedReasons` from that status as real blockers. Resolve readiness as follows:
+- `engram` (or `both` without openspec/): check Engram for `sdd/{change}/tasks` and `sdd/{change}/apply-progress` using `mem_search` + `mem_get_observation`. Proceed with verification once those artifacts are confirmed present.
+- `none`: there is no persistent backend. Return the verification report inline and ask the user to provide required inputs (tasks, apply-progress) or acknowledge that no persistent artifact store is available.
+
 Stop with `blocked` if:
 
 - active change selection is missing or ambiguous;
-- `tasks.md` / the tasks artifact is missing or empty;
+- `tasks.md` / the tasks artifact is missing or empty (confirmed by artifact store);
 - `actionContext.mode: workspace-planning` and no `allowedEditRoots` are provided;
 - implementation ownership or target files cannot be proven inside the authoritative workspace or allowed edit roots.
 

package/assets/orchestrator.md

@@ -197,7 +197,8 @@ Rules:
 - `/sdd-continue` is the native dispatcher command: resolve status, choose the next ready phase, and carry status/instructions into the subagent prompt.
 - `sdd-apply`, `sdd-verify`, `sdd-sync`, and `sdd-archive` must obey parent-provided native status; they must not reconstruct readiness from prompt inference when status JSON is present.
 - Do not launch a phase when native status marks that dependency `blocked`.
-- `sdd-archive` cannot proceed unless native status says archive is ready.
+- `sdd-archive` cannot proceed unless native status says `dependencies.archive` is `ready` or `all_done` — UNLESS the store carve-out is active (`nextRecommended: "resolve-via-engram"`), in which case resolve archive readiness from Engram instead of treating `not_applicable` as a gate failure.
+- **Non-authoritative store carve-out:** when `nextRecommended: "resolve-via-engram"` is set, native status is **not authoritative**. This applies to `artifactStore: engram`, `artifactStore: none`, and `artifactStore: both` when the `openspec/` directory does not exist. For non-authoritative stores: resolve readiness from Engram using `mem_search` + `mem_get_observation` on the change topic keys (`sdd/{change-name}/proposal`, `sdd/{change-name}/spec`, `sdd/{change-name}/design`, `sdd/{change-name}/tasks`, etc.). Do **not** treat `blockedReasons` or `not_applicable` dependency states from the native engine as real blockers when the store carve-out is active.
 
 ## SDD Status Contract
 

package/assets/support/sdd-status-contract.md

@@ -54,18 +54,19 @@ taskProgress:
   complete: 0
   remaining: 0
   unchecked: []
-applyState: blocked | all_done | ready
+applyState: blocked | all_done | ready | not_applicable
 dependencies:
-  apply: blocked | ready | all_done
-  verify: blocked | ready | all_done
+  apply: blocked | ready | all_done | not_applicable
+  verify: blocked | ready | all_done | not_applicable
   sync: blocked | ready | all_done | not_applicable
-  archive: blocked | ready | all_done
+  archive: blocked | ready | all_done | not_applicable
 actionContext:
   mode: repo-local | workspace-planning
   workspaceRoot: <absolute path>
   allowedEditRoots: [<absolute paths>]
   warnings: []
 nextRecommended: <command-or-action>
+isNonAuthoritative: false  # boolean; true when the native engine is not authoritative for the store
 ```
 
 ## Apply State
@@ -73,6 +74,7 @@ nextRecommended: <command-or-action>
 - `blocked`: required apply artifacts are missing, task selection is ambiguous, or action context makes edits unsafe.
 - `all_done`: tasks artifact exists and every implementation task is checked `[x]`.
 - `ready`: tasks artifact exists, at least one implementation task remains unchecked, and edit scope is safe.
+- `not_applicable`: emitted for non-authoritative stores (see Engine Authority by Store). This is NOT a blocker.
 
 ## Dependency States
 
@@ -80,6 +82,7 @@ nextRecommended: <command-or-action>
 - `verify` is `ready` when tasks exist and either apply-progress exists or the tasks artifact shows all intended implementation work complete. Unchecked implementation tasks remain CRITICAL blockers for full archive readiness.
 - `sync` is `ready` only when verify-report exists and has no unresolved `FAIL`, `BLOCKED`, `CRITICAL`, or verification blockers. `engram`/`none` modes may mark sync `not_applicable`.
 - `archive` is `ready` only when verify-report exists, sync is complete or not applicable, and tasks are complete. CRITICAL verification issues have no override. Explicit recorded exceptions are limited to non-critical partial archives or stale-checkbox reconciliation when apply-progress/verify-report prove completion.
+- `not_applicable`: emitted for non-authoritative stores (engram, none, and both when no `openspec/` directory exists) when `nextRecommended: "resolve-via-engram"` is active. `not_applicable` is NOT a gate failure — readiness must be resolved from Engram instead of from these fields.
 
 ## Action Context Guard
 
@@ -89,6 +92,11 @@ The orchestrator MUST carry `actionContext` into any phase launch.
 - If `allowedEditRoots` is present, only edit or move files within those roots.
 - If a phase cannot prove a file is inside the authoritative workspace or allowed edit roots, stop and ask for clarification.
 
+## Engine Authority by Store
+
+- `openspec` and `both` (when `openspec/` directory exists): the native status engine resolves artifact state from disk and is authoritative. Phase executors must obey it.
+- `engram`, `none`, and `both` (when `openspec/` directory does NOT exist): the native status engine cannot read Engram artifacts. It returns `nextRecommended: "resolve-via-engram"` and empty `blockedReasons`. This output is **non-authoritative**. The orchestrator must resolve readiness directly from Engram using `mem_search` + `mem_get_observation` on the change topic keys (`sdd/{change-name}/proposal`, `sdd/{change-name}/spec`, etc.) instead of relying on the engine's dependency states. The `artifactStore` field still reflects the real chosen store value (e.g. `"both"`) and must not be rewritten.
+
 ## Status Output
 
 Every command or agent that acts on a change MUST show or consume status before doing phase work:

package/extensions/gentle-ai.ts

@@ -1982,6 +1982,7 @@ export default function gentleAi(pi: ExtensionAPI): void {
 			? `\n\n${renderNativeSddPhasePrompt(resolveSddStatus({
 				cwd: ctx.cwd,
 				includeInstructions: true,
+				artifactStore: prefs?.artifactStore,
 			}), phase)}`
 			: "";
 		const gentlePrompt = isNamedAgent || isSddAgent
@@ -2040,6 +2041,7 @@ export default function gentleAi(pi: ExtensionAPI): void {
 			cwd: ctx.cwd,
 			changeName: parsed.changeName,
 			includeInstructions: true,
+			artifactStore: getSddPreflightPreferences(ctx)?.artifactStore,
 		});
 		ctx.ui.notify(
 			parsed.json ? JSON.stringify(status, null, 2) : renderSddStatusMarkdown(status),
@@ -2067,6 +2069,7 @@ export default function gentleAi(pi: ExtensionAPI): void {
 			cwd: ctx.cwd,
 			changeName: parsed.changeName,
 			includeInstructions: true,
+			artifactStore: getSddPreflightPreferences(ctx)?.artifactStore,
 		});
 		ctx.ui.notify(
 			parsed.json ? JSON.stringify(status, null, 2) : renderSddDispatcherMarkdown(status),

package/lib/sdd-preflight.ts

@@ -3,6 +3,9 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { SddArtifactStore } from "./sdd-status.ts";
+
+export type { SddArtifactStore };
 
 const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const ASSETS_DIR = join(PACKAGE_ROOT, "assets");
@@ -12,7 +15,6 @@ function gentlePiAgentHome(): string {
 }
 
 export type SddExecutionMode = "interactive" | "auto";
-export type SddArtifactStore = "openspec" | "engram" | "both";
 export type SddChainedPrStrategy =
 	| "auto-forecast"
 	| "ask-always"
@@ -66,6 +68,60 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// ---------------------------------------------------------------------------
+// Durable store — survives restarts, resumed sessions, and non-SDD agent starts
+// ---------------------------------------------------------------------------
+
+export function sddPreflightDiskPath(cwd: string): string {
+	return join(cwd, ".pi", "gentle-ai", "sdd-preflight.json");
+}
+
+export function readSddPreflightFromDisk(cwd: string): SddPreflightPreferences | undefined {
+	const path = sddPreflightDiskPath(cwd);
+	if (!existsSync(path)) return undefined;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (!isRecord(parsed)) return undefined;
+		// Validate required fields to guard against stale/corrupt writes
+		const { executionMode, artifactStore, chainedPrStrategy, reviewBudgetLines, engramAvailable, prompted } = parsed;
+		if (
+			(executionMode !== "interactive" && executionMode !== "auto") ||
+			(artifactStore !== "openspec" && artifactStore !== "engram" && artifactStore !== "both" && artifactStore !== "none") ||
+			typeof reviewBudgetLines !== "number" ||
+			typeof engramAvailable !== "boolean" ||
+			typeof prompted !== "boolean"
+		) {
+			return undefined;
+		}
+		const normalizedChain: SddChainedPrStrategy =
+			chainedPrStrategy === "ask-always" ||
+			chainedPrStrategy === "single-pr-default" ||
+			chainedPrStrategy === "force-chained"
+				? (chainedPrStrategy as SddChainedPrStrategy)
+				: "auto-forecast";
+		return {
+			executionMode,
+			artifactStore,
+			chainedPrStrategy: normalizedChain,
+			reviewBudgetLines,
+			engramAvailable,
+			prompted,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+export function writeSddPreflightToDisk(cwd: string, prefs: SddPreflightPreferences): void {
+	try {
+		const path = sddPreflightDiskPath(cwd);
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, JSON.stringify(prefs, null, 2));
+	} catch {
+		// Disk write failures are non-fatal; in-memory cache is the primary store
+	}
+}
+
 function copyDirectoryFiles(
 	sourceDir: string,
 	targetDir: string,
@@ -295,6 +351,7 @@ export async function ensureSddPreflight(
 			);
 		}
 		sddPreflightBySession.set(sessionKey, prefs);
+		writeSddPreflightToDisk(ctx.cwd, prefs);
 		return prefs;
 	})();
 	sddPreflightInFlight.set(sessionKey, promise);
@@ -308,5 +365,14 @@ export async function ensureSddPreflight(
 export function getSddPreflightPreferences(
 	ctx: ExtensionContext,
 ): SddPreflightPreferences | undefined {
-	return sddPreflightBySession.get(sddPreflightSessionKey(ctx));
+	const sessionKey = sddPreflightSessionKey(ctx);
+	const cached = sddPreflightBySession.get(sessionKey);
+	if (cached) return cached;
+	// Cache miss: check the durable disk store (survives restarts and non-SDD agent starts)
+	const persisted = readSddPreflightFromDisk(ctx.cwd);
+	if (persisted) {
+		sddPreflightBySession.set(sessionKey, persisted);
+		return persisted;
+	}
+	return undefined;
 }

package/lib/sdd-status.ts

@@ -6,10 +6,10 @@ import {
 	type DomainCollision,
 } from "./openspec-guardrails.ts";
 
-export type SddArtifactStore = "openspec";
+export type SddArtifactStore = "openspec" | "engram" | "both" | "none";
 export type ArtifactState = "missing" | "done" | "partial";
 export type DependencyState = "blocked" | "ready" | "all_done" | "not_applicable";
-export type ApplyState = "blocked" | "ready" | "all_done";
+export type ApplyState = "blocked" | "ready" | "all_done" | "not_applicable";
 export type SddPhase = "apply" | "verify" | "sync" | "archive";
 
 export interface SddArtifactPaths {
@@ -76,6 +76,14 @@ export interface SddStatus {
 	nextRecommended: string;
 	instructions?: SddPhaseInstructions;
 	blockedReasons: string[];
+	/**
+	 * True when the native status engine is not authoritative for the selected
+	 * artifact store (engram, none, or both without an openspec/ directory).
+	 * When true, `dependencies`, `applyState`, and `blockedReasons` must not be
+	 * treated as real blockers — resolve readiness from Engram instead.
+	 * Defaults to false on all authoritative (openspec / both-with-disk) paths.
+	 */
+	isNonAuthoritative: boolean;
 }
 
 export interface ResolveSddStatusOptions {
@@ -83,6 +91,7 @@ export interface ResolveSddStatusOptions {
 	changeName?: string;
 	includeInstructions?: boolean;
 	workspaceRoot?: string;
+	artifactStore?: SddArtifactStore;
 }
 
 const EMPTY_PATHS: SddArtifactPaths = {
@@ -187,7 +196,7 @@ function reportIsClearlyPassing(path: string | undefined): boolean {
 	return hasPassSignal && !hasBlocker;
 }
 
-function emptyStatus(cwd: string, changeName: string | null, blockedReasons: string[]): SddStatus {
+function emptyStatus(cwd: string, changeName: string | null, blockedReasons: string[], artifactStore: SddArtifactStore = "openspec", isNonAuthoritative = false): SddStatus {
 	const root = resolve(cwd);
 	const changesDir = join(root, "openspec", "changes");
 	const actionContext: SddActionContext = {
@@ -200,7 +209,7 @@ function emptyStatus(cwd: string, changeName: string | null, blockedReasons: str
 		schemaName: "gentle-pi.sdd-status",
 		schemaVersion: 1,
 		changeName,
-		artifactStore: "openspec",
+		artifactStore,
 		planningHome: { root, changesDir },
 		changeRoot: null,
 		artifactPaths: { ...EMPTY_PATHS },
@@ -228,6 +237,7 @@ function emptyStatus(cwd: string, changeName: string | null, blockedReasons: str
 		collisions: [],
 		nextRecommended: blockedReasons[0] ?? "Start an SDD change.",
 		blockedReasons,
+		isNonAuthoritative,
 	};
 }
 
@@ -239,6 +249,14 @@ export function listActiveOpenSpecChanges(cwd: string): string[] {
 
 export function renderPhaseInstructions(status: SddStatus): SddPhaseInstructions {
 	const change = status.changeName ?? "<unresolved>";
+	if (status.applyState === "not_applicable") {
+		return {
+			apply: ["Readiness is resolved from Engram; per-phase instructions not applicable."],
+			verify: ["Readiness is resolved from Engram; per-phase instructions not applicable."],
+			sync: ["Readiness is resolved from Engram; per-phase instructions not applicable."],
+			archive: ["Readiness is resolved from Engram; per-phase instructions not applicable."],
+		};
+	}
 	return {
 		apply: [
 			`Change: ${change}`,
@@ -280,7 +298,75 @@ export function renderPhaseInstructions(status: SddStatus): SddPhaseInstructions
 	};
 }
 
+/**
+ * Build the single canonical non-authoritative SddStatus.
+ * All non-authoritative return sites must call this instead of constructing by hand.
+ */
+function nonAuthoritativeStatus(cwd: string, changeName: string | null, store: SddArtifactStore, includeInstructions?: boolean): SddStatus {
+	const root = resolve(cwd);
+	const actionContext: SddActionContext = {
+		mode: "repo-local",
+		workspaceRoot: root,
+		allowedEditRoots: [root],
+		warnings: [],
+	};
+	const status: SddStatus = {
+		schemaName: "gentle-pi.sdd-status",
+		schemaVersion: 1,
+		changeName,
+		artifactStore: store,
+		planningHome: { root, changesDir: "" },
+		changeRoot: null,
+		artifactPaths: { ...EMPTY_PATHS },
+		contextFiles: { ...EMPTY_PATHS },
+		artifacts: {
+			proposal: "missing",
+			specs: "missing",
+			design: "missing",
+			tasks: "missing",
+			applyProgress: "missing",
+			verifyReport: "missing",
+			syncReport: "missing",
+		},
+		taskProgress: { total: 0, complete: 0, remaining: 0, unchecked: [] },
+		applyState: "not_applicable",
+		dependencies: { apply: "not_applicable", verify: "not_applicable", sync: "not_applicable", archive: "not_applicable" },
+		actionContext,
+		relationships: {
+			dependsOn: [],
+			supersedes: [],
+			amends: [],
+			conflictsWith: [],
+			sameDomainActiveChanges: [],
+		},
+		collisions: [],
+		nextRecommended: "resolve-via-engram",
+		blockedReasons: [],
+		isNonAuthoritative: true,
+	};
+	if (includeInstructions) status.instructions = renderPhaseInstructions(status);
+	return status;
+}
+
 export function resolveSddStatus(options: ResolveSddStatusOptions): SddStatus {
+	// Safety net: when the store is unknown (undefined) and there is no openspec/ directory
+	// on disk, don't emit the openspec "no changes / blocked" status — it would be a false
+	// block for an engram or none session that hasn't been identified yet. Treat it as
+	// non-authoritative instead. A genuine openspec session will have the directory.
+	const hasOpenSpecDir = existsSync(join(resolve(options.cwd), "openspec"));
+	const store: SddArtifactStore =
+		options.artifactStore ?? (hasOpenSpecDir ? "openspec" : "none");
+
+	// Single decision point: non-authoritative when the disk engine cannot resolve authoritatively.
+	// Cases:
+	//   - store engram or none: always non-authoritative (no disk backing)
+	//   - store both, no openspec/ dir: non-authoritative (no disk to scan)
+	// The both-with-openspec cases are handled below after listing active changes.
+	if (store === "engram" || store === "none" || (store === "both" && !hasOpenSpecDir)) {
+		const changeName = options.changeName?.trim() || null;
+		return nonAuthoritativeStatus(options.cwd, changeName, store, options.includeInstructions);
+	}
+
 	const root = resolve(options.cwd);
 	const changesDir = join(root, "openspec", "changes");
 	const activeChanges = listActiveOpenSpecChanges(root);
@@ -291,16 +377,30 @@ export function resolveSddStatus(options: ResolveSddStatusOptions): SddStatus {
 		if (activeChanges.length === 1) {
 			changeName = activeChanges[0];
 		} else if (activeChanges.length === 0) {
-			return emptyStatus(root, null, ["No active SDD changes found."]);
+			// store both + openspec/ present + zero active changes + no changeName:
+			// The change may live only in Engram — non-authoritative, not a false block.
+			// Pure openspec with zero changes is a real block (run sdd-new).
+			if (store === "both") {
+				return nonAuthoritativeStatus(options.cwd, null, store, options.includeInstructions);
+			}
+			return emptyStatus(root, null, ["No active SDD changes found."], store);
 		} else {
+			// Multiple active changes and no changeName: legit selection prompt (changes DO exist
+			// on disk). Keep the existing authoritative ambiguous-selection behavior for both stores.
 			return emptyStatus(root, null, [
 				`Change selection is ambiguous: ${activeChanges.join(", ")}.`,
-			]);
+			], store);
 		}
 	}
 
 	if (!activeChanges.includes(changeName)) {
-		return emptyStatus(root, changeName, [`Active change not found: ${changeName}.`]);
+		// store both + openspec/ present + named change NOT found on disk:
+		// The change may live only in Engram — non-authoritative.
+		// Pure openspec still blocks (legit "run sdd-new").
+		if (store === "both") {
+			return nonAuthoritativeStatus(options.cwd, changeName, store, options.includeInstructions);
+		}
+		return emptyStatus(root, changeName, [`Active change not found: ${changeName}.`], store);
 	}
 
 	const changeRoot = join(changesDir, changeName);
@@ -405,7 +505,7 @@ export function resolveSddStatus(options: ResolveSddStatusOptions): SddStatus {
 		schemaName: "gentle-pi.sdd-status",
 		schemaVersion: 1,
 		changeName,
-		artifactStore: "openspec",
+		artifactStore: store,
 		planningHome: { root, changesDir },
 		changeRoot,
 		artifactPaths,
@@ -428,17 +528,29 @@ export function resolveSddStatus(options: ResolveSddStatusOptions): SddStatus {
 			: undefined,
 		nextRecommended,
 		blockedReasons,
+		isNonAuthoritative: false,
 	};
 	if (options.includeInstructions) status.instructions = renderPhaseInstructions(status);
 	return status;
 }
 
+export function isNonAuthoritativeStatus(status: SddStatus): boolean {
+	return status.isNonAuthoritative;
+}
+
 export function renderNativeSddPhasePrompt(status: SddStatus, phase?: SddPhase): string {
 	const selectedInstructions = phase ? status.instructions?.[phase] : undefined;
+	const isNonAuthoritative = isNonAuthoritativeStatus(status);
+	const authorityLine = isNonAuthoritative
+		? `This status is non-authoritative (artifact store: ${status.artifactStore}). The orchestrator must resolve readiness from Engram instead.`
+		: "The parent/orchestrator resolved this status deterministically. Treat it as authoritative over prompt inference.";
+	const blockLine = isNonAuthoritative
+		? `Do not block phase work based on this status — resolve readiness from Engram using mem_search + mem_get_observation on the change topic keys (sdd/{change}/proposal, sdd/{change}/spec, sdd/{change}/design, sdd/{change}/tasks, etc.) instead.`
+		: "Do not run phase work when this status marks the phase blocked; return the blockers instead.";
 	return [
 		"## Native SDD Status Engine",
-		"The parent/orchestrator resolved this status deterministically. Treat it as authoritative over prompt inference.",
-		"Do not run phase work when this status marks the phase blocked; return the blockers instead.",
+		authorityLine,
+		blockLine,
 		...(phase && selectedInstructions
 			? ["", `### ${phase} instructions`, ...selectedInstructions.map((line) => `- ${line}`)]
 			: []),
@@ -450,6 +562,29 @@ export function renderNativeSddPhasePrompt(status: SddStatus, phase?: SddPhase):
 }
 
 export function renderSddDispatcherMarkdown(status: SddStatus): string {
+	const isNonAuthoritative = isNonAuthoritativeStatus(status);
+	const statusSection = isNonAuthoritative
+		? [
+				"### Non-authoritative store — resolve via Engram",
+				`This status is non-authoritative (artifact store: ${status.artifactStore}).`,
+				"Resolve readiness directly from Engram using mem_search + mem_get_observation on the change topic keys:",
+				`- sdd/${status.changeName ?? "<change>"}/proposal`,
+				`- sdd/${status.changeName ?? "<change>"}/spec`,
+				`- sdd/${status.changeName ?? "<change>"}/design`,
+				`- sdd/${status.changeName ?? "<change>"}/tasks`,
+				`- sdd/${status.changeName ?? "<change>"}/apply-progress (if present)`,
+				`- sdd/${status.changeName ?? "<change>"}/verify-report (if present)`,
+				"Do not treat blockedReasons or dependency states from this status as real blockers.",
+			].join("\n")
+		: status.blockedReasons.length > 0
+			? ["### Blocked", ...status.blockedReasons.map((reason) => `- ${reason}`)].join("\n")
+			: "### Ready\nThe next phase may be delegated with the attached status JSON and phase instructions.";
+	// For non-authoritative status, skip the unsafe SddPhase cast on nextRecommended
+	const instructionsSection = isNonAuthoritative
+		? []
+		: (status.instructions?.[status.nextRecommended.replace(/^sdd-/, "") as SddPhase] ?? []).map(
+				(line) => `- ${line}`,
+			);
 	return [
 		`## Native SDD Dispatcher: ${status.changeName ?? "unresolved"}`,
 		"",
@@ -459,14 +594,11 @@ export function renderSddDispatcherMarkdown(status: SddStatus): string {
 		`sync: ${status.dependencies.sync}`,
 		`archive: ${status.dependencies.archive}`,
 		"",
-		status.blockedReasons.length > 0
-			? ["### Blocked", ...status.blockedReasons.map((reason) => `- ${reason}`)].join("\n")
-			: "### Ready\nThe next phase may be delegated with the attached status JSON and phase instructions.",
-		"",
-		"### Instructions for next phase",
-		...((status.instructions?.[status.nextRecommended.replace(/^sdd-/, "") as SddPhase] ?? [])
-			.map((line) => `- ${line}`)),
+		statusSection,
 		"",
+		...(instructionsSection.length > 0
+			? ["### Instructions for next phase", ...instructionsSection, ""]
+			: []),
 		"### Status JSON",
 		"```json",
 		JSON.stringify(status, null, 2),
@@ -515,6 +647,8 @@ export function parseSddStatusCommandArgs(args: string): { changeName?: string;
 }
 
 export function sddStatusSeverity(status: SddStatus): "info" | "warning" {
+	// Non-authoritative status has no real blockers — always info
+	if (isNonAuthoritativeStatus(status)) return "info";
 	return status.blockedReasons.length > 0 || Object.values(status.dependencies).includes("blocked")
 		? "warning"
 		: "info";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.8.0",
+  "version": "0.9.2",
   "description": "Turn Pi into el Gentleman: a senior-architect development harness with SDD/OpenSpec, subagents, strict TDD evidence, review guardrails, and skill discovery.",
   "license": "MIT",
   "type": "module",

package/tests/sdd-preflight.test.ts

@@ -0,0 +1,113 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import {
+	readSddPreflightFromDisk,
+	sddPreflightDiskPath,
+	writeSddPreflightToDisk,
+	type SddPreflightPreferences,
+} from "../lib/sdd-preflight.ts";
+
+async function workspace(): Promise<string> {
+	return mkdtemp(join(tmpdir(), "gentle-pi-sdd-preflight-"));
+}
+
+const SAMPLE_PREFS: SddPreflightPreferences = {
+	executionMode: "auto",
+	artifactStore: "engram",
+	chainedPrStrategy: "auto-forecast",
+	reviewBudgetLines: 400,
+	engramAvailable: true,
+	prompted: true,
+};
+
+test("sddPreflightDiskPath returns project-local .pi/gentle-ai/sdd-preflight.json", async () => {
+	const cwd = await workspace();
+	const path = sddPreflightDiskPath(cwd);
+	assert.equal(path, join(cwd, ".pi", "gentle-ai", "sdd-preflight.json"));
+});
+
+test("writeSddPreflightToDisk creates parent dirs and writes valid JSON", async () => {
+	const cwd = await workspace();
+	writeSddPreflightToDisk(cwd, SAMPLE_PREFS);
+
+	const path = sddPreflightDiskPath(cwd);
+	assert.ok(existsSync(path));
+	const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+	assert.deepEqual(parsed, SAMPLE_PREFS);
+});
+
+test("readSddPreflightFromDisk returns undefined when no file exists", async () => {
+	const cwd = await workspace();
+	assert.equal(readSddPreflightFromDisk(cwd), undefined);
+});
+
+test("readSddPreflightFromDisk returns persisted prefs after write", async () => {
+	const cwd = await workspace();
+	writeSddPreflightToDisk(cwd, SAMPLE_PREFS);
+
+	const loaded = readSddPreflightFromDisk(cwd);
+	assert.deepEqual(loaded, SAMPLE_PREFS);
+});
+
+test("persisted store survives a simulated cache miss (write then cold read)", async () => {
+	const cwd = await workspace();
+
+	// Simulate ensureSddPreflight writing to disk
+	writeSddPreflightToDisk(cwd, SAMPLE_PREFS);
+
+	// Simulate a fresh process where in-memory Map is empty — only disk store exists
+	const loaded = readSddPreflightFromDisk(cwd);
+	assert.ok(loaded !== undefined);
+	assert.equal(loaded.artifactStore, "engram");
+	assert.equal(loaded.executionMode, "auto");
+	assert.equal(loaded.prompted, true);
+});
+
+test("readSddPreflightFromDisk returns undefined for corrupt JSON", async () => {
+	const cwd = await workspace();
+	const path = sddPreflightDiskPath(cwd);
+	mkdirSync(join(cwd, ".pi", "gentle-ai"), { recursive: true });
+	writeFileSync(path, "not-json{{{");
+
+	assert.equal(readSddPreflightFromDisk(cwd), undefined);
+});
+
+test("readSddPreflightFromDisk returns undefined for JSON with invalid fields", async () => {
+	const cwd = await workspace();
+	const path = sddPreflightDiskPath(cwd);
+	mkdirSync(join(cwd, ".pi", "gentle-ai"), { recursive: true });
+	writeFileSync(path, JSON.stringify({ executionMode: "invalid", artifactStore: "openspec", chainedPrStrategy: "auto-forecast", reviewBudgetLines: 400, engramAvailable: false, prompted: false }));
+
+	// executionMode "invalid" is not "interactive" | "auto" → should reject
+	assert.equal(readSddPreflightFromDisk(cwd), undefined);
+});
+
+test("readSddPreflightFromDisk normalizes unknown chainedPrStrategy to auto-forecast", async () => {
+	const cwd = await workspace();
+	const path = sddPreflightDiskPath(cwd);
+	mkdirSync(join(cwd, ".pi", "gentle-ai"), { recursive: true });
+	writeFileSync(path, JSON.stringify({
+		executionMode: "interactive",
+		artifactStore: "openspec",
+		chainedPrStrategy: "unknown-strategy",
+		reviewBudgetLines: 400,
+		engramAvailable: false,
+		prompted: true,
+	}));
+
+	const loaded = readSddPreflightFromDisk(cwd);
+	assert.ok(loaded !== undefined);
+	assert.equal(loaded.chainedPrStrategy, "auto-forecast");
+});
+
+test("writeSddPreflightToDisk is non-fatal when directory is not writable (no throw)", async () => {
+	// Can only test the no-throw guarantee; the actual write failure is swallowed
+	// We verify that calling with a deeply nested path doesn't throw
+	assert.doesNotThrow(() => {
+		writeSddPreflightToDisk("/nonexistent/path/that/cannot/be/created/gently", SAMPLE_PREFS);
+	});
+});

package/tests/sdd-status.test.ts

@@ -5,9 +5,12 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
 import {
+	isNonAuthoritativeStatus,
 	listActiveOpenSpecChanges,
 	parseSddStatusCommandArgs,
+	renderNativeSddPhasePrompt,
 	renderPhaseInstructions,
+	renderSddDispatcherMarkdown,
 	renderSddStatusMarkdown,
 	resolveSddStatus,
 } from "../lib/sdd-status.ts";
@@ -279,6 +282,76 @@ test("renderSddStatusMarkdown includes structured JSON", async () => {
 	assert.match(markdown, /"schemaName": "gentle-pi.sdd-status"/);
 });
 
+test("resolveSddStatus with artifactStore engram returns non-authoritative status without disk scan", async () => {
+	const cwd = await workspace();
+	// No openspec directory — simulates an engram-only session
+
+	const status = resolveSddStatus({ cwd, artifactStore: "engram", changeName: "my-change" });
+
+	assert.equal(status.artifactStore, "engram");
+	assert.equal(status.changeName, "my-change");
+	assert.deepEqual(status.blockedReasons, []);
+	assert.equal(status.nextRecommended, "resolve-via-engram");
+	assert.equal(status.dependencies.apply, "not_applicable");
+	assert.equal(status.applyState, "not_applicable");
+});
+
+test("resolveSddStatus with artifactStore none returns non-authoritative status without disk scan", async () => {
+	const cwd = await workspace();
+	// No openspec directory
+
+	const status = resolveSddStatus({ cwd, artifactStore: "none", changeName: "my-change" });
+
+	assert.equal(status.artifactStore, "none");
+	assert.deepEqual(status.blockedReasons, []);
+	assert.equal(status.nextRecommended, "resolve-via-engram");
+});
+
+test("resolveSddStatus with artifactStore both uses disk scan and reflects store", async () => {
+	const cwd = await workspace();
+	seedChange(cwd);
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+
+	assert.equal(status.artifactStore, "both");
+	assert.equal(status.changeName, "add-auth");
+	assert.notEqual(status.nextRecommended, "resolve-via-engram");
+});
+
+test("resolveSddStatus with undefined store and existing openspec dir defaults to openspec and blocks", async () => {
+	const cwd = await workspace();
+	// Create openspec/ directory to signal an openspec workspace
+	mkdirSync(join(cwd, "openspec", "changes"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd });
+
+	// openspec workspace with no active changes → blocked (back-compat)
+	assert.equal(status.artifactStore, "openspec");
+	assert.match(status.blockedReasons[0] ?? "", /No active SDD changes/);
+});
+
+test("resolveSddStatus with undefined store and NO openspec dir returns non-authoritative status", async () => {
+	const cwd = await workspace();
+	// No openspec directory at all — unknown store, no disk evidence
+
+	const status = resolveSddStatus({ cwd });
+
+	// Safety net: should not emit the openspec false-block
+	assert.equal(status.artifactStore, "none");
+	assert.deepEqual(status.blockedReasons, []);
+	assert.equal(status.nextRecommended, "resolve-via-engram");
+	assert.equal(status.applyState, "not_applicable");
+});
+
+test("resolveSddStatus non-authoritative status has neutral planningHome (no misleading openspec path)", async () => {
+	const cwd = await workspace();
+
+	const status = resolveSddStatus({ cwd, artifactStore: "engram", changeName: "fix-auth" });
+
+	assert.equal(status.planningHome.changesDir, "");
+	assert.equal(status.planningHome.root, status.actionContext.workspaceRoot);
+});
+
 test("parseSddStatusCommandArgs extracts change and json flag", () => {
 	assert.deepEqual(parseSddStatusCommandArgs("add-auth --json"), {
 		changeName: "add-auth",
@@ -289,3 +362,250 @@ test("parseSddStatusCommandArgs extracts change and json flag", () => {
 		json: true,
 	});
 });
+
+test("resolveSddStatus with artifactStore both and NO openspec dir returns non-authoritative status", async () => {
+	const cwd = await workspace();
+	// No openspec directory — both store without disk backing is non-authoritative
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "my-change" });
+
+	assert.equal(status.artifactStore, "both");
+	assert.equal(status.changeName, "my-change");
+	assert.deepEqual(status.blockedReasons, []);
+	assert.equal(status.nextRecommended, "resolve-via-engram");
+	assert.equal(status.applyState, "not_applicable");
+	assert.equal(status.dependencies.apply, "not_applicable");
+	assert.equal(status.dependencies.archive, "not_applicable");
+});
+
+test("resolveSddStatus with artifactStore both and existing openspec dir runs authoritative disk scan", async () => {
+	const cwd = await workspace();
+	seedChange(cwd);
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+
+	assert.equal(status.artifactStore, "both");
+	assert.equal(status.changeName, "add-auth");
+	assert.notEqual(status.nextRecommended, "resolve-via-engram");
+	assert.equal(status.artifacts.proposal, "done");
+});
+
+// Renamed: previously "returns true only when nextRecommended is resolve-via-engram" — now
+// explicitly asserts BOTH the typed isNonAuthoritative field and the sentinel together.
+test("isNonAuthoritativeStatus reads typed isNonAuthoritative field and matches resolve-via-engram sentinel", async () => {
+	const cwd = await workspace();
+
+	const engram = resolveSddStatus({ cwd, artifactStore: "engram", changeName: "x" });
+	assert.equal(engram.isNonAuthoritative, true);
+	assert.equal(isNonAuthoritativeStatus(engram), true);
+	assert.equal(engram.nextRecommended, "resolve-via-engram");
+
+	const none = resolveSddStatus({ cwd, artifactStore: "none", changeName: "x" });
+	assert.equal(none.isNonAuthoritative, true);
+	assert.equal(isNonAuthoritativeStatus(none), true);
+	assert.equal(none.nextRecommended, "resolve-via-engram");
+
+	const bothWithoutOpenspec = resolveSddStatus({ cwd, artifactStore: "both", changeName: "x" });
+	assert.equal(bothWithoutOpenspec.isNonAuthoritative, true);
+	assert.equal(isNonAuthoritativeStatus(bothWithoutOpenspec), true);
+	assert.equal(bothWithoutOpenspec.nextRecommended, "resolve-via-engram");
+
+	seedChange(cwd);
+	const bothWithOpenspec = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+	assert.equal(bothWithOpenspec.isNonAuthoritative, false);
+	assert.equal(isNonAuthoritativeStatus(bothWithOpenspec), false);
+	assert.notEqual(bothWithOpenspec.nextRecommended, "resolve-via-engram");
+});
+
+// Fix 4 item 4 — isNonAuthoritative boolean is set correctly on the typed field
+test("isNonAuthoritative boolean field is set correctly across all store/disk combinations", async () => {
+	const cwd = await workspace();
+
+	// engram → non-authoritative
+	const engram = resolveSddStatus({ cwd, artifactStore: "engram", changeName: "x" });
+	assert.equal(engram.isNonAuthoritative, true);
+
+	// none → non-authoritative
+	const none = resolveSddStatus({ cwd, artifactStore: "none", changeName: "x" });
+	assert.equal(none.isNonAuthoritative, true);
+
+	// both without openspec/ → non-authoritative
+	const bothWithout = resolveSddStatus({ cwd, artifactStore: "both", changeName: "x" });
+	assert.equal(bothWithout.isNonAuthoritative, true);
+
+	// both WITH openspec/ and seeded change → authoritative
+	seedChange(cwd);
+	const bothWith = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+	assert.equal(bothWith.isNonAuthoritative, false);
+
+	// openspec (default disk scan, seeded) → authoritative
+	const openspec = resolveSddStatus({ cwd, artifactStore: "openspec", changeName: "add-auth" });
+	assert.equal(openspec.isNonAuthoritative, false);
+});
+
+// Fix 4 item 1 — both + openspec/ dir present + change NOT on disk → non-authoritative
+test("resolveSddStatus with artifactStore both, openspec dir present but change not on disk returns non-authoritative", async () => {
+	const cwd = await workspace();
+	// Create an openspec/changes dir with a different change — not the requested one
+	mkdirSync(join(cwd, "openspec", "changes", "other-change"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "missing-change" });
+
+	assert.equal(status.isNonAuthoritative, true);
+	assert.equal(status.nextRecommended, "resolve-via-engram");
+	assert.deepEqual(status.blockedReasons, []);
+	assert.equal(status.applyState, "not_applicable");
+	assert.equal(status.artifactStore, "both");
+	// Must NOT be treated as blocked
+	assert.notEqual(status.applyState, "blocked");
+});
+
+// Fix 4 item 2 — strengthen existing both-with-openspec-and-seeded-change test
+test("resolveSddStatus with artifactStore both, openspec dir present and change on disk is authoritative", async () => {
+	const cwd = await workspace();
+	seedChange(cwd);
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "add-auth" });
+
+	assert.equal(status.artifactStore, "both");
+	assert.equal(status.changeName, "add-auth");
+	// Must be authoritative
+	assert.equal(isNonAuthoritativeStatus(status), false);
+	assert.equal(status.isNonAuthoritative, false);
+	// Must not be not_applicable — real disk scan ran
+	assert.notEqual(status.applyState, "not_applicable");
+	assert.notEqual(status.nextRecommended, "resolve-via-engram");
+	assert.equal(status.artifacts.proposal, "done");
+});
+
+// Fix 4 item 3 — pure openspec store + change not found STILL blocks (guard against over-broadening Fix 2)
+test("resolveSddStatus with artifactStore openspec and change not found still blocks", async () => {
+	const cwd = await workspace();
+	// Create openspec dir with a different change — simulate openspec store with no matching change
+	mkdirSync(join(cwd, "openspec", "changes", "other-change"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, artifactStore: "openspec", changeName: "nonexistent" });
+
+	// Must block, not return non-authoritative
+	assert.equal(status.isNonAuthoritative, false);
+	assert.match(status.blockedReasons.join("\n"), /Active change not found/);
+	assert.equal(status.applyState, "blocked");
+	assert.notEqual(status.nextRecommended, "resolve-via-engram");
+});
+
+test("renderSddDispatcherMarkdown for both-without-openspec does NOT render Ready", async () => {
+	const cwd = await workspace();
+	// No openspec directory — both store is non-authoritative
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "fix-x" });
+	const markdown = renderSddDispatcherMarkdown(status);
+
+	assert.doesNotMatch(markdown, /### Ready/);
+	assert.match(markdown, /resolve via Engram/i);
+});
+
+test("renderNativeSddPhasePrompt for both-without-openspec emits non-authoritative line", async () => {
+	const cwd = await workspace();
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "fix-x" });
+	const prompt = renderNativeSddPhasePrompt(status, "apply");
+
+	assert.match(prompt, /non-authoritative/);
+	assert.doesNotMatch(prompt, /deterministically/);
+});
+
+test("renderPhaseInstructions for not_applicable applyState emits neutral line", async () => {
+	const cwd = await workspace();
+
+	const status = resolveSddStatus({ cwd, artifactStore: "engram", changeName: "fix-x" });
+	const instructions = renderPhaseInstructions(status);
+
+	assert.match(instructions.apply.join("\n"), /Readiness is resolved from Engram/);
+	assert.match(instructions.archive.join("\n"), /Readiness is resolved from Engram/);
+});
+
+// Fix 4 item 1 — both + openspec/ + ZERO changes + no changeName → non-authoritative
+test("resolveSddStatus both + openspec/ dir + zero active changes + no changeName returns non-authoritative", async () => {
+	const cwd = await workspace();
+	// openspec/ dir exists but holds no active changes (only the changes/ subdir)
+	mkdirSync(join(cwd, "openspec", "changes"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both" });
+
+	assert.equal(status.isNonAuthoritative, true);
+	assert.equal(status.nextRecommended, "resolve-via-engram");
+	assert.deepEqual(status.blockedReasons, []);
+	assert.equal(status.artifactStore, "both");
+	assert.equal(status.applyState, "not_applicable");
+	assert.equal(status.dependencies.apply, "not_applicable");
+	assert.equal(status.dependencies.archive, "not_applicable");
+	// Must NOT be treated as blocked
+	assert.notEqual(status.applyState, "blocked");
+});
+
+// Fix 4 item 2 — both + openspec/ + MULTIPLE changes + no changeName → authoritative select-change
+test("resolveSddStatus both + openspec/ dir + multiple active changes + no changeName stays authoritative", async () => {
+	const cwd = await workspace();
+	mkdirSync(join(cwd, "openspec", "changes", "alpha"), { recursive: true });
+	mkdirSync(join(cwd, "openspec", "changes", "beta"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both" });
+
+	// Authoritative ambiguous-selection behavior must be preserved
+	assert.equal(status.isNonAuthoritative, false);
+	assert.match(status.blockedReasons.join("\n"), /ambiguous/);
+	assert.notEqual(status.nextRecommended, "resolve-via-engram");
+});
+
+// Fix 4 item 3 — both + openspec/ + ONE resolvable change → authoritative
+test("resolveSddStatus both + openspec/ dir + exactly one active change is authoritative", async () => {
+	const cwd = await workspace();
+	seedChange(cwd);
+
+	// No changeName supplied — should auto-select the single change
+	const status = resolveSddStatus({ cwd, artifactStore: "both" });
+
+	assert.equal(status.isNonAuthoritative, false);
+	assert.equal(status.changeName, "add-auth");
+	assert.equal(status.artifactStore, "both");
+	assert.notEqual(status.applyState, "not_applicable");
+	assert.notEqual(status.nextRecommended, "resolve-via-engram");
+	assert.equal(status.artifacts.proposal, "done");
+});
+
+// Fix 4 item 4 — pure openspec + zero/missing change STILL blocks (guard against over-broadening)
+test("resolveSddStatus openspec + zero active changes still blocks", async () => {
+	const cwd = await workspace();
+	mkdirSync(join(cwd, "openspec", "changes"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, artifactStore: "openspec" });
+
+	assert.equal(status.isNonAuthoritative, false);
+	assert.match(status.blockedReasons.join("\n"), /No active SDD changes/);
+	assert.equal(status.applyState, "blocked");
+	assert.notEqual(status.nextRecommended, "resolve-via-engram");
+});
+
+test("resolveSddStatus openspec + named change missing still blocks", async () => {
+	const cwd = await workspace();
+	mkdirSync(join(cwd, "openspec", "changes", "other-change"), { recursive: true });
+
+	const status = resolveSddStatus({ cwd, artifactStore: "openspec", changeName: "nonexistent" });
+
+	assert.equal(status.isNonAuthoritative, false);
+	assert.match(status.blockedReasons.join("\n"), /Active change not found/);
+	assert.equal(status.applyState, "blocked");
+	assert.notEqual(status.nextRecommended, "resolve-via-engram");
+});
+
+// Fix 4 render test — non-authoritative both status → dispatcher shows "both" not "Engram or none"
+test("renderSddDispatcherMarkdown for non-authoritative both status shows artifact store 'both'", async () => {
+	const cwd = await workspace();
+
+	const status = resolveSddStatus({ cwd, artifactStore: "both", changeName: "fix-x" });
+	const markdown = renderSddDispatcherMarkdown(status);
+
+	assert.match(markdown, /artifact store: both/);
+	assert.doesNotMatch(markdown, /Engram or none/);
+	assert.match(markdown, /resolve via Engram/i);
+});