gentle-pi 0.10.8 → 0.11.0

package/assets/agents/sdd-apply.md

@@ -26,15 +26,15 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read your own input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
 - Tasks (required): `sdd/{change}/tasks`
 - Spec (required): `sdd/{change}/spec`
 - Design (required): `sdd/{change}/design`
 - Previous apply-progress (if it exists): `sdd/{change}/apply-progress` — read and MERGE with your new progress; do NOT overwrite.
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/apply-progress"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
-- Also update the tasks artifact checkboxes via `mem_update` (`engram`/`both`) or file edit (`openspec`).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/apply-progress"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- Also update the tasks artifact checkboxes via the injected Engram update tool (`engram`/`both`) or file edit (`openspec`).
 - `openspec`: write/update the apply-progress and tasks files under `openspec/changes/{change}/`.
 - `none`: return progress inline.
 
@@ -45,7 +45,7 @@ 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.
+- `engram` (or `both` without openspec/): search Engram for `sdd/{change}/tasks`, `sdd/{change}/spec`, and `sdd/{change}/design` using the Engram memory tools injected by the memory provider. 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:

package/assets/agents/sdd-archive.md

@@ -25,11 +25,11 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read your own input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the files under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the files under `openspec/changes/{change}/`):
 - All change artifacts: `sdd/{change}/proposal`, `sdd/{change}/spec`, `sdd/{change}/design`, `sdd/{change}/tasks`, `sdd/{change}/apply-progress`, `sdd/{change}/verify-report`, and `sdd/{change}/sync-report` if present.
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/archive-report"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/archive-report"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write the archive report and perform the file moves described in the sections below.
 - `none`: return the archive report inline.
 
@@ -44,7 +44,7 @@ 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.
+- `engram` (or `both` without openspec/): refer to the Artifact Store Modes section — resolve readiness by checking Engram for `sdd/{change}/verify-report` using the Engram memory tools injected by the memory provider, 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:

package/assets/agents/sdd-design.md

@@ -29,11 +29,11 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read your own input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
 - Proposal (required): `sdd/{change}/proposal`
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/design"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/design"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write/update `openspec/changes/{change}/design.md`.
 - `none`: return the design inline.
 

package/assets/agents/sdd-explore.md

@@ -26,11 +26,11 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read any input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
 - None — exploration has no upstream artifacts. If iterating on a prior exploration, read `sdd/{change}/explore`.
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/explore"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/explore"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write the exploration file under `openspec/changes/{change}/`.
 - `none`: return the exploration inline.
 

package/assets/agents/sdd-init.md

@@ -32,11 +32,11 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read any existing project context directly from the active backend before bootstrapping; do not wait for the parent to inline it. The parent may pass references and context, but retrieving them is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/`):
 - Existing project context (if re-initializing): `sdd-init/{project}`
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd-init/{project}"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd-init/{project}"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write the project context file under `openspec/`.
 - `none`: return the project context inline.
 

package/assets/agents/sdd-onboard.md

@@ -32,11 +32,11 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 This is a guided walkthrough. For each phase you demonstrate, read that phase's input artifacts directly from the active backend (do not wait for the parent to inline them) and persist the artifact you produce, using the same topic-key scheme as the real phases.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
 - Whichever upstream artifacts the demonstrated step requires, named `sdd/{change}/<phase>` (e.g. `sdd/{change}/proposal`, `sdd/{change}/spec`).
 
 Persist each demonstrated artifact to the active backend before moving on (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/<phase>"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/<phase>"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write/update the corresponding file under `openspec/changes/{change}/`.
 - `none`: walk through the artifacts inline.
 

package/assets/agents/sdd-proposal.md

@@ -42,11 +42,11 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read your own input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
 - Exploration (optional): `sdd/{change}/explore`
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/proposal"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/proposal"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write/update `openspec/changes/{change}/proposal.md`.
 - `none`: return the proposal inline.
 

package/assets/agents/sdd-spec.md

@@ -24,11 +24,11 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read your own input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
 - Proposal (required): `sdd/{change}/proposal`
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/spec"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/spec"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write/update the spec files under `openspec/changes/{change}/`.
 - `none`: return the spec inline.
 

package/assets/agents/sdd-status.md

@@ -22,9 +22,10 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 ## Memory Contract
 
-This phase is READ-ONLY. Read the change artifacts directly from the active backend to compute status; do not wait for the parent to inline them, and do NOT write or `mem_save` anything.
+This phase is READ-ONLY. Read the change artifacts directly from the active backend to compute status; do not wait for the parent to inline them, and do NOT write files or call the injected Engram save tool.
+
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the files under `openspec/changes/{change}/`):
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the files under `openspec/changes/{change}/`):
 - Whichever change artifacts are needed to compute status, named `sdd/{change}/<phase>` (proposal, spec, design, tasks, apply-progress, verify-report, sync-report).
 
 Do not persist anything — status is a read-only report. Never claim persistence.
@@ -104,7 +105,7 @@ 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.
+**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 the Engram memory tools injected by the memory provider 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
 

package/assets/agents/sdd-sync.md

@@ -26,11 +26,11 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read the change artifacts directly from the active backend before syncing; do not wait for the parent to inline them. The parent may pass references and context, but retrieving them is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the files under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the files under `openspec/changes/{change}/`):
 - Core change artifacts: `sdd/{change}/proposal`, `sdd/{change}/spec`, `sdd/{change}/design`, `sdd/{change}/tasks`, and `sdd/{change}/verify-report`.
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/sync-report"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/sync-report"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write/update the canonical specs and sync report under `openspec/`.
 - `none`: return the sync report inline.
 

package/assets/agents/sdd-tasks.md

@@ -24,12 +24,12 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read your own input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
 - Spec (required): `sdd/{change}/spec`
 - Design (required): `sdd/{change}/design`
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/tasks"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/tasks"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write/update `openspec/changes/{change}/tasks.md`.
 - `none`: return the tasks inline.
 

package/assets/agents/sdd-verify.md

@@ -25,13 +25,13 @@ If skill paths are missing, explicit fallback loading is allowed only as degrade
 
 Read your own input artifacts directly from the active backend before doing the phase work; do not wait for the parent to inline them. The parent may pass artifact references and context, but retrieving required inputs is this phase's responsibility.
 
-Inputs to read (`engram`/`both`: `mem_search("<topic-key>")` then `mem_get_observation`; `openspec`: read the file under `openspec/changes/{change}/`):
+Inputs to read (`engram`/`both`: use the injected Engram memory read tools for the topic key, then fetch the full observation; `openspec`: read the file under `openspec/changes/{change}/`):
 - Spec (required): `sdd/{change}/spec`
 - Tasks (required): `sdd/{change}/tasks`
 - Apply-progress (required): `sdd/{change}/apply-progress`
 
 Persist this phase's artifact to the active backend before returning (mandatory):
-- `engram`/`both`: call `mem_save` with title and `topic_key` `"sdd/{change}/verify-report"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
+- `engram`/`both`: call the injected Engram save tool with title and `topic_key` `"sdd/{change}/verify-report"`, `type: "architecture"`, `project` from context, and `capture_prompt: false` when the tool schema supports it (omit the field if an older schema rejects it).
 - `openspec`: write/update `openspec/changes/{change}/verify-report.md`.
 - `none`: return the verify report inline.
 
@@ -42,7 +42,7 @@ 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.
+- `engram` (or `both` without openspec/): check Engram for `sdd/{change}/tasks` and `sdd/{change}/apply-progress` using the Engram memory tools injected by the memory provider. 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:

package/assets/orchestrator.md

@@ -188,103 +188,15 @@ stop writes → parent captures git status → selected review lens audits affec
 
 If multiple rows match, run the narrow set that covers the risk. Example: shell integration that mutates live state should use `review-reliability` plus `review-resilience`, not `review-readability` by default.
 
-## SDD Workflow
+## SDD Workflow (lazy-loaded)
 
-SDD phases:
+The detailed SDD workflow is intentionally not embedded in this always-on parent prompt. Before handling any `/sdd-*` command, natural-language SDD request, SDD continuation/routing, apply/verify/sync/archive work, or SDD/Judgment-Day phase delegation, read this package asset first:
 
-```text
-init → explore → proposal → spec → design → tasks → apply → verify → sync → archive
-```
-
-Dependency graph:
-
-```text
-proposal → spec ─┬→ tasks → apply → verify → sync → archive
-proposal → design ┘
-```
-
-`/sdd-status [change]` is the read-only status action for resolving the active change, artifact paths, task progress, dependency readiness, and action context before apply/verify/sync/archive.
-
-## Native SDD Dispatcher
-
-The user expresses intent; they should not have to administer phases manually. For natural-language SDD requests and `/sdd-continue`, the parent/orchestrator must use the native status engine as the state authority, decide the next phase, and delegate only the phase that status marks ready.
-
-Flow:
-
-```text
-user intent → preflight/init guard → native status engine → phase decision → subagent gets status JSON + generated instructions → artifact/progress write → status recalculation → continue or stop
-```
-
-Rules:
-
-- `/sdd-status` is a debug/status command, not the main UX.
-- `/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 `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
-
-Before `/sdd-continue`, `sdd-apply`, `sdd-verify`, `sdd-sync`, or `sdd-archive`, resolve and carry structured status. Lookup order: parent-provided status, then 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 `sdd-status` prompt contract. Do not use `assets/support/...` as a runtime path; that is only the package source path before installation.
-
-Status must include:
-
-- active change selection and how it was resolved;
-- artifact store and paths/topics for proposal, specs, design, tasks, apply-progress, verify-report, and sync-report;
-- task progress with exact unchecked `- [ ]` implementation task lines;
-- dependency states for apply, verify, sync, and archive;
-- `actionContext` with mode, workspace root, allowed edit roots, and warnings;
-- next recommended action.
-
-Do not guess the active change. If change selection is ambiguous, ask the user and stop. If `actionContext.mode: workspace-planning` and no allowed edit roots are provided, stop before apply/verify/sync/archive and ask for an explicit implementation/edit scope.
-
-## Lazy SDD Preflight
-
-Do not ask SDD setup questions on session start. The first time the user initiates an SDD process in a Pi session, run the SDD preflight once and keep those choices for the rest of that session. Runtime trigger detection is intentionally deterministic: slash SDD flows and `/sdd-init` run preflight automatically; for natural-language requests, the parent/orchestrator decides semantically whether SDD is needed and must run/reuse `/gentle-ai:sdd-preflight` before continuing.
-
-**Hard gate:** `openspec/config.yaml`, existing SDD changes, installed `.pi`/global SDD assets, or a todo named "preflight" are not session preflight. They are project context only. Do not mark SDD preflight complete, start `sdd-init`, launch SDD subagents/chains, or move to explore/proposal/spec/design/tasks until this session has either:
-
-1. an injected `## SDD Session Preflight` block, or
-2. an explicit user answer in the current conversation covering all four preflight choices below.
-
-If neither exists and `/gentle-ai:sdd-preflight` cannot be invoked from the current context, ask the four choices manually with `ask_user_question` before any SDD phase work. Treat missing Engram availability as a reason to ask/confirm artifact store, not as permission to assume defaults.
-
-The preflight captures:
-
-- execution mode: `interactive` or `auto`;
-- artifact store: `openspec`, `engram`, or `both` when callable memory tools are available;
-- chained PR strategy: `auto-forecast`, `ask-always`, `single-pr-default`, or `force-chained`;
-- review budget in changed lines.
-
-The package should ensure SDD assets are present as global Pi runtime assets without the user needing to remember per-project setup commands. If assets are missing, install them non-destructively into:
-
-```text
-~/.pi/agent/agents/sdd-*.md
-~/.pi/agent/chains/sdd-*.chain.md
-```
-
-Manual install commands are recovery/debug paths, not the happy path. `/gentle-ai:sdd-preflight` and `/gentle:sdd-preflight` are the explicit preflight commands for agent/orchestrator use. If the user explicitly changes SDD preferences later in the same session, follow the new instruction.
+`{{GENTLE_PI_SDD_WORKFLOW_PATH}}`
 
-## Init Guard
+That lazy surface contains the SDD phases, native dispatcher rules, status contract, preflight/init guards, artifact-store policy, execution mode, Strict TDD forwarding, phase result contract, and review workload guard.
 
-Before any SDD flow, make sure project context exists.
-
-In this Pi package, the default local artifact is:
-
-```text
-openspec/config.yaml
-```
-
-If it is missing, ask the user for the minimal information needed or run `/sdd-init` if available. This init guard runs after the session preflight gate above; project config presence or absence never substitutes for session preflight choices. Do not proceed with a substantial SDD flow while pretending project context, testing capability, or session preflight choices are known.
-
-## Artifact Store Policy
-
-This package does not provide persistent memory by itself.
-
-- Default: `openspec` artifacts in the repo.
-- If a separate memory package is installed and callable, memory/hybrid flows may be used.
-- Never claim memory exists because Gentle AI is installed.
+Hard preflight invariant: `openspec/config.yaml`, existing SDD changes, installed `.pi`/global SDD assets, or a todo named "preflight" are not session preflight. Do not mark SDD preflight complete, start `sdd-init`, launch SDD subagents/chains, or move to explore/proposal/spec/design/tasks until this session has either an injected `## SDD Session Preflight` block or an explicit user answer covering the preflight choices.
 
 ## Memory Contract
 
@@ -292,8 +204,8 @@ When Engram or another callable memory package is available, the parent owns con
 
 ### Non-SDD delegation
 
-- Read context: the parent/orchestrator searches memory (`mem_search`), selects relevant observations, and passes them into the subagent prompt. The subagent does NOT search memory itself.
-- Write context: the subagent MUST save significant discoveries, decisions, or bug fixes via `mem_save` before returning when memory tools are available.
+- Read context: the parent/orchestrator searches memory (the injected Engram search tool), selects relevant observations, and passes them into the subagent prompt. The subagent does NOT search memory itself.
+- Write context: the subagent MUST save significant discoveries, decisions, or bug fixes via the injected Engram save tool before returning when memory tools are available.
 - Prompt forwarding: when delegating, add a concrete instruction such as: `If you make important discoveries, decisions, or fix bugs, save them to Engram via the available memory save tool with project: '<project>' before returning.`
 
 ### SDD phases
@@ -318,44 +230,12 @@ Each SDD phase subagent reads its own required inputs directly from the active b
 
 Memory lifecycle rule (when Engram exposes lifecycle metadata/tooling):
 
-- At session start or before architecture-sensitive work, call `mem_review` with action `list` for the current project when the tool is available.
-- If `mem_review` is unavailable, do not fail the task. Continue with normal `mem_context`/`mem_search`, and still apply lifecycle metadata from any returned observations when present.
+- At session start or before architecture-sensitive work, call the injected Engram review tool with action `list` for the current project when the tool is available.
+- If the injected Engram review tool is unavailable, do not fail the task. Continue with the injected Engram context/search tools, and still apply lifecycle metadata from any returned observations when present.
 - `active` memories may be used normally.
 - `needs_review` memories are stale context, not trusted facts.
 - When a retrieved memory is marked `needs_review`, surface that stale context to the user and verify it against current evidence before relying on it.
-- Do NOT call `mem_review` with action `mark_reviewed` automatically. Only call `mark_reviewed` after explicit user confirmation or through a dedicated memory maintenance command.
-
-## Execution Mode
-
-Use the session's SDD preflight choice:
-
-- `interactive`: default, pause between major phases and ask whether to continue.
-- `auto`: run phases back-to-back when the user explicitly wants speed and trusts the flow.
-
-In interactive mode, between phases:
-
-1. show concise phase result;
-2. state next phase;
-3. ask whether to continue or adjust.
-
-Interactive approval is phase-scoped. A user response such as "continue", "dale", or "go on" approves only the immediate next phase, not the rest of the SDD pipeline. Do not treat a generated artifact as approved until the user has had a chance to review or explicitly delegate that review.
-
-Before `sdd-proposal` in interactive mode, offer the user a proposal question round instead of silently deciding whether the proposal is clear enough. Explain that the questions are meant to improve the PRD/proposal by uncovering business understanding, business rules, implications, impact, edge cases, and product tradeoffs. Prefer 3–5 concrete product questions per round, then summarize the resulting assumptions and ask whether the user wants to correct anything or run a second question round. Cover business/product/PRD decisions: business problem, target users and situations, business rules, product outcome, current-state gap, implications and impact, edge cases, decision gaps, first-slice scope boundaries, non-goals, product constraints, and business tradeoffs. Do not ask about test commands, PR shape, changed-line budget, or other harness mechanics at proposal time unless the user explicitly asks to discuss delivery.
-
-## Result Contract
-
-Every phase result should include:
-
-```text
-status
-executive_summary
-artifacts
-next_recommended
-risks
-skill_resolution
-```
-
-The parent should synthesize these envelopes, not paste long raw reports unless needed.
+- Do NOT call the injected Engram review tool with action `mark_reviewed` automatically. Only call `mark_reviewed` after explicit user confirmation or through a dedicated memory maintenance command.
 
 ## Skill Registry Protocol
 
@@ -403,26 +283,6 @@ Common intent hints, not hard routing:
 
 Keep this lightweight: loading a skill should improve the immediate task, not force extra ceremony.
 
-## Strict TDD Forwarding
-
-For `sdd-apply` and `sdd-verify`, read `openspec/config.yaml` when present.
-
-If it declares strict TDD and a test command, include a non-negotiable instruction in the phase prompt:
-
-```text
-STRICT TDD MODE IS ACTIVE. Test runner: <command>. Follow RED, GREEN, TRIANGULATE, REFACTOR. Record evidence.
-```
-
-Do not rely on the child agent to discover this independently.
-
-## Review Workload Guard
-
-After `sdd-tasks` and before `sdd-apply`, inspect the task output for review workload risk.
-
-If estimated changed lines exceed 400, chained PRs are recommended, or a decision is needed, pause and ask unless the user already approved a delivery strategy.
-
-Automatic mode does not override reviewer burnout protection.
-
 ## Safety
 
 - Never commit unless the user explicitly asks.

package/assets/sdd-orchestrator-workflow.md

@@ -0,0 +1,153 @@
+# SDD Orchestrator Workflow
+
+This is the lazy-loaded SDD workflow surface for el Gentleman on Pi. Read this file before handling `/sdd-*`, natural-language SDD requests, SDD continuation/routing, apply/verify/sync/archive work, or SDD/Judgment-Day phase delegation.
+
+## SDD Workflow
+
+SDD phases:
+
+```text
+init → explore → proposal → spec → design → tasks → apply → verify → sync → archive
+```
+
+Dependency graph:
+
+```text
+proposal → spec ─┬→ tasks → apply → verify → sync → archive
+proposal → design ┘
+```
+
+`/sdd-status [change]` is the read-only status action for resolving the active change, artifact paths, task progress, dependency readiness, and action context before apply/verify/sync/archive.
+
+## Native SDD Dispatcher
+
+The user expresses intent; they should not have to administer phases manually. For natural-language SDD requests and `/sdd-continue`, the parent/orchestrator must use the native status engine as the state authority, decide the next phase, and delegate only the phase that status marks ready.
+
+Flow:
+
+```text
+user intent → preflight/init guard → native status engine → phase decision → subagent gets status JSON + generated instructions → artifact/progress write → status recalculation → continue or stop
+```
+
+Rules:
+
+- `/sdd-status` is a debug/status command, not the main UX.
+- `/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 `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 the Engram memory tools injected by the memory provider 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
+
+Before `/sdd-continue`, `sdd-apply`, `sdd-verify`, `sdd-sync`, or `sdd-archive`, resolve and carry structured status. Lookup order: parent-provided status, then 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 `sdd-status` prompt contract. Do not use `assets/support/...` as a runtime path; that is only the package source path before installation.
+
+Status must include:
+
+- active change selection and how it was resolved;
+- artifact store and paths/topics for proposal, specs, design, tasks, apply-progress, verify-report, and sync-report;
+- task progress with exact unchecked `- [ ]` implementation task lines;
+- dependency states for apply, verify, sync, and archive;
+- `actionContext` with mode, workspace root, allowed edit roots, and warnings;
+- next recommended action.
+
+Do not guess the active change. If change selection is ambiguous, ask the user and stop. If `actionContext.mode: workspace-planning` and no allowed edit roots are provided, stop before apply/verify/sync/archive and ask for an explicit implementation/edit scope.
+
+## Lazy SDD Preflight
+
+Do not ask SDD setup questions on session start. The first time the user initiates an SDD process in a Pi session, run the SDD preflight once and keep those choices for the rest of that session. Runtime trigger detection is intentionally deterministic: slash SDD flows and `/sdd-init` run preflight automatically; for natural-language requests, the parent/orchestrator decides semantically whether SDD is needed and must run/reuse `/gentle-ai:sdd-preflight` before continuing.
+
+**Hard gate:** `openspec/config.yaml`, existing SDD changes, installed `.pi`/global SDD assets, or a todo named "preflight" are not session preflight. They are project context only. Do not mark SDD preflight complete, start `sdd-init`, launch SDD subagents/chains, or move to explore/proposal/spec/design/tasks until this session has either:
+
+1. an injected `## SDD Session Preflight` block, or
+2. an explicit user answer in the current conversation covering all four preflight choices below.
+
+If neither exists and `/gentle-ai:sdd-preflight` cannot be invoked from the current context, ask the four choices manually with `ask_user_question` before any SDD phase work. Treat missing Engram availability as a reason to ask/confirm artifact store, not as permission to assume defaults.
+
+The preflight captures:
+
+- execution mode: `interactive` or `auto`;
+- artifact store: `openspec`, `engram`, or `both` when callable memory tools are available;
+- chained PR strategy: `auto-forecast`, `ask-always`, `single-pr-default`, or `force-chained`;
+- review budget in changed lines.
+
+The package should ensure SDD assets are present as global Pi runtime assets without the user needing to remember per-project setup commands. If assets are missing, install them non-destructively into:
+
+```text
+~/.pi/agent/agents/sdd-*.md
+~/.pi/agent/chains/sdd-*.chain.md
+```
+
+Manual install commands are recovery/debug paths, not the happy path. `/gentle-ai:sdd-preflight` and `/gentle:sdd-preflight` are the explicit preflight commands for agent/orchestrator use. If the user explicitly changes SDD preferences later in the same session, follow the new instruction.
+
+## Init Guard
+
+Before any SDD flow, make sure project context exists.
+
+In this Pi package, the default local artifact is:
+
+```text
+openspec/config.yaml
+```
+
+If it is missing, ask the user for the minimal information needed or run `/sdd-init` if available. This init guard runs after the session preflight gate above; project config presence or absence never substitutes for session preflight choices. Do not proceed with a substantial SDD flow while pretending project context, testing capability, or session preflight choices are known.
+
+## Artifact Store Policy
+
+This package does not provide persistent memory by itself.
+
+- Default: `openspec` artifacts in the repo.
+- If a separate memory package is installed and callable, memory/hybrid flows may be used.
+- Never claim memory exists because Gentle AI is installed.
+
+## Execution Mode
+
+Use the session's SDD preflight choice:
+
+- `interactive`: default, pause between major phases and ask whether to continue.
+- `auto`: run phases back-to-back when the user explicitly wants speed and trusts the flow.
+
+In interactive mode, between phases:
+
+1. show concise phase result;
+2. state next phase;
+3. ask whether to continue or adjust.
+
+Interactive approval is phase-scoped. A user response such as "continue", "dale", or "go on" approves only the immediate next phase, not the rest of the SDD pipeline. Do not treat a generated artifact as approved until the user has had a chance to review or explicitly delegate that review.
+
+Before `sdd-proposal` in interactive mode, offer the user a proposal question round instead of silently deciding whether the proposal is clear enough. Explain that the questions are meant to improve the PRD/proposal by uncovering business understanding, business rules, implications, impact, edge cases, and product tradeoffs. Prefer 3–5 concrete product questions per round, then summarize the resulting assumptions and ask whether the user wants to correct anything or run a second question round. Cover business/product/PRD decisions: business problem, target users and situations, business rules, product outcome, current-state gap, implications and impact, edge cases, decision gaps, first-slice scope boundaries, non-goals, product constraints, and business tradeoffs. Do not ask about test commands, PR shape, changed-line budget, or other harness mechanics at proposal time unless the user explicitly asks to discuss delivery.
+
+## Result Contract
+
+Every phase result should include:
+
+```text
+status
+executive_summary
+artifacts
+next_recommended
+risks
+skill_resolution
+```
+
+The parent should synthesize these envelopes, not paste long raw reports unless needed.
+
+## Strict TDD Forwarding
+
+For `sdd-apply` and `sdd-verify`, read `openspec/config.yaml` when present.
+
+If it declares strict TDD and a test command, include a non-negotiable instruction in the phase prompt:
+
+```text
+STRICT TDD MODE IS ACTIVE. Test runner: <command>. Follow RED, GREEN, TRIANGULATE, REFACTOR. Record evidence.
+```
+
+Do not rely on the child agent to discover this independently.
+
+## Review Workload Guard
+
+After `sdd-tasks` and before `sdd-apply`, inspect the task output for review workload risk.
+
+If estimated changed lines exceed 400, chained PRs are recommended, or a decision is needed, pause and ask unless the user already approved a delivery strategy.
+
+Automatic mode does not override reviewer burnout protection.

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

@@ -95,7 +95,7 @@ The orchestrator MUST carry `actionContext` into any phase launch.
 ## 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.
+- `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 the Engram memory tools injected by the memory provider 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
 

package/extensions/gentle-ai.ts

@@ -43,7 +43,6 @@ import {
 } from "../lib/sdd-status.ts";
 import {
 	evaluateEvent,
-	matchPathGlobs,
 	type ChangedDiff,
 	type TriggerEvent,
 } from "../lib/review-triggers.ts";
@@ -124,12 +123,18 @@ function sddLocalOverrideDriftCount(cwd: string): number {
 }
 
 let orchestratorPromptCache: string | null = null;
+function getSddWorkflowPath(): string {
+	return join(ASSETS_DIR, "sdd-orchestrator-workflow.md");
+}
+
 function getOrchestratorPrompt(): string {
 	if (orchestratorPromptCache === null) {
 		orchestratorPromptCache = readFileSync(
 			join(ASSETS_DIR, "orchestrator.md"),
 			"utf8",
-		).trim();
+		)
+			.replaceAll("{{GENTLE_PI_SDD_WORKFLOW_PATH}}", getSddWorkflowPath())
+			.trim();
 	}
 	return orchestratorPromptCache;
 }
@@ -219,14 +224,6 @@ const DENIED_BASH_PATTERNS: RegExp[] = [
 	/\bchown\s+-R\b/,
 ];
 
-const CONFIRM_BASH_PATTERNS: RegExp[] = [
-	/\bgit\s+push\b/,
-	/\bgit\s+rebase\b/,
-	/\bgit\s+branch\s+(?:-[a-zA-Z]*D[a-zA-Z]*|-[a-zA-Z]*d[a-zA-Z]*f[a-zA-Z]*|-[a-zA-Z]*f[a-zA-Z]*d[a-zA-Z]*|--delete\b[^\n]*--force\b|--force\b[^\n]*--delete\b)/,
-	/\bnpm\s+publish\b/,
-	/\bpi\s+remove\b/,
-];
-
 // ---------------------------------------------------------------------------
 // Autonomous guard — runtime guardrails config
 // ---------------------------------------------------------------------------
@@ -577,12 +574,7 @@ function hasWritableEngramTool(pi: ExtensionAPI): boolean {
 					: isRecord(tool) && typeof tool.name === "string"
 						? tool.name
 						: "";
-			return (
-				name === "mem_save" ||
-				name === "engram_mem_save" ||
-				name.endsWith(".mem_save") ||
-				name.endsWith(".engram_mem_save")
-			);
+			return name === "mem_save" || name.endsWith(".mem_save");
 		});
 	} catch {
 		return false;
@@ -1992,7 +1984,7 @@ function computeDiffForEvent(event: TriggerEvent, cwd: string): ChangedDiff | nu
 	const gitOpts = {
 		cwd,
 		encoding: "utf8" as const,
-		stdio: ["pipe", "pipe", "pipe"] as const,
+		stdio: "pipe" as const,
 		// Bound synchronous git calls so a slow/large repo cannot freeze the extension process.
 		// The existing outer try/catch returns null (fail-open) when this throws.
 		timeout: 2000,

package/extensions/skill-registry.ts

@@ -21,7 +21,7 @@ const EXCLUDE_NAMES = new Set(["_shared", "skill-registry"]);
 const EXCLUDE_PREFIXES = ["sdd-"];
 const ATL_IGNORE_ENTRY = ".atl/";
 const WATCH_DEBOUNCE_MS = 500;
-const REGISTRY_SCHEMA_VERSION = 5;
+const REGISTRY_SCHEMA_VERSION = 6;
 const NO_SKILL_REGISTRY_FLAG = "no-skill-registry";
 const NO_SKILL_REGISTRY_ENV = "GENTLE_PI_NO_SKILL_REGISTRY";
 const LEGACY_PROJECT_REGISTRY_REL_PATH = ".pi/extensions/skill-registry.ts";
@@ -96,23 +96,30 @@ function projectSkillDirs(cwd: string): string[] {
 
 async function findSkillFiles(root: string): Promise<string[]> {
 	if (!(await pathExists(root))) return [];
+	let entries;
+	try {
+		entries = await readdir(root, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+
 	const out: string[] = [];
-	const stack: string[] = [root];
-	while (stack.length > 0) {
-		const dir = stack.pop()!;
-		let entries;
+	for (const entry of entries) {
+		const skillDir = join(root, entry.name);
+		let dirInfo;
 		try {
-			entries = await readdir(dir, { withFileTypes: true });
+			dirInfo = await stat(skillDir);
 		} catch {
 			continue;
 		}
-		for (const entry of entries) {
-			const full = join(dir, entry.name);
-			if (entry.isDirectory()) {
-				stack.push(full);
-			} else if (entry.isFile() && entry.name === "SKILL.md") {
-				out.push(full);
-			}
+		if (!dirInfo.isDirectory()) continue;
+
+		const candidate = join(skillDir, "SKILL.md");
+		try {
+			const skillInfo = await stat(candidate);
+			if (skillInfo.isFile()) out.push(candidate);
+		} catch {
+			// Missing or unreadable skill files are ignored; the registry is best-effort.
 		}
 	}
 	return out.sort();
@@ -512,6 +519,7 @@ async function startSkillRegistryWatcher(
 export const __testing = {
 	projectSkillDirs,
 	userSkillDirs,
+	findSkillFiles,
 	uniqueExistingDirs,
 	dedupeBySkillName,
 	scopeForPath,

package/lib/sdd-preflight.ts

@@ -229,12 +229,7 @@ function hasWritableEngramTool(pi: ExtensionAPI): boolean {
 					: isRecord(tool) && typeof tool.name === "string"
 						? tool.name
 						: "";
-			return (
-				name === "mem_save" ||
-				name === "engram_mem_save" ||
-				name.endsWith(".mem_save") ||
-				name.endsWith(".engram_mem_save")
-			);
+			return name === "mem_save" || name.endsWith(".mem_save");
 		});
 	} catch {
 		return false;

package/lib/sdd-status.ts

@@ -545,7 +545,7 @@ export function renderNativeSddPhasePrompt(status: SddStatus, phase?: SddPhase):
 		? `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 block phase work based on this status — resolve readiness from Engram using the injected Engram memory read tools 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",
@@ -567,7 +567,7 @@ export function renderSddDispatcherMarkdown(status: SddStatus): string {
 		? [
 				"### 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:",
+				"Resolve readiness directly from Engram using the injected Engram memory read tools on the change topic keys:",
 				`- sdd/${status.changeName ?? "<change>"}/proposal`,
 				`- sdd/${status.changeName ?? "<change>"}/spec`,
 				`- sdd/${status.changeName ?? "<change>"}/design`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.10.8",
+  "version": "0.11.0",
   "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/artifact-language.test.ts

@@ -89,19 +89,20 @@ test("orchestrator Memory Contract carries the Engram memory lifecycle rule", as
 
 	// Mirrors gentle-ai's engram-protocol/engram-convention lifecycle rule (PRs #842 + #844),
 	// in its final availability-gated form: agents must treat needs_review memories as stale,
-	// prefer mem_review when present, fall back safely when it is not, and never auto-mark reviewed.
+	// use the memory-provider-injected lifecycle tool when present, fall back safely when it is not,
+	// and never auto-mark reviewed.
 	for (const required of [
 		"when Engram exposes lifecycle metadata/tooling",
 		"At session start or before architecture-sensitive work",
-		"call `mem_review` with action `list`",
+		"call the injected Engram review tool with action `list`",
 		"for the current project when the tool is available",
-		"If `mem_review` is unavailable, do not fail the task",
-		"Continue with normal `mem_context`/`mem_search`",
+		"If the injected Engram review tool is unavailable, do not fail the task",
+		"Continue with the injected Engram context/search tools",
 		"still apply lifecycle metadata from any returned observations when present",
 		"`active` memories may be used normally",
 		"`needs_review` memories are stale context, not trusted facts",
 		"verify it against current evidence before relying on it",
-		"Do NOT call `mem_review` with action `mark_reviewed` automatically",
+		"Do NOT call the injected Engram review tool with action `mark_reviewed` automatically",
 		"Only call `mark_reviewed` after explicit user confirmation or through a dedicated memory maintenance command",
 	]) {
 		assert.ok(
@@ -145,6 +146,21 @@ test("SDD chain assets distinguish interactive gates from auto execution", async
 	assert.match(fullChain, /must stop at each phase boundary/i);
 });
 
+test("orchestrator lazy-loads detailed SDD workflow", async () => {
+	const orchestrator = await readFile(join(ROOT, "assets/orchestrator.md"), "utf8");
+	const workflow = await readFile(join(ROOT, "assets/sdd-orchestrator-workflow.md"), "utf8");
+
+	assert.match(orchestrator, /## SDD Workflow \(lazy-loaded\)/);
+	assert.match(orchestrator, /\{\{GENTLE_PI_SDD_WORKFLOW_PATH\}\}/);
+	assert.doesNotMatch(orchestrator, /## Native SDD Dispatcher/);
+	assert.match(workflow, /## Native SDD Dispatcher/);
+	assert.match(workflow, /## SDD Status Contract/);
+	assert.match(workflow, /## Execution Mode/);
+	assert.match(workflow, /## Strict TDD Forwarding/);
+	assert.match(workflow, /## Review Workload Guard/);
+	assert.match(workflow, /## Result Contract/);
+});
+
 test("persistent harness prompt assets do not hardcode Spanish SDD artifact copy", async () => {
 	const files = [
 		...(await collectTextFiles(join(ROOT, "assets"))),

package/tests/runtime-harness.mjs

@@ -203,6 +203,11 @@ async function run() {
 		assert.doesNotMatch(promptResult.systemPrompt, /default\s*\|\s*sonnet\s*\|\s*Non-SDD general delegation/);
 		assert.match(promptResult.systemPrompt, /openspec\/config\.yaml.*not session preflight/s);
 		assert.match(promptResult.systemPrompt, /Do not mark SDD preflight complete/);
+		assert.match(
+			promptResult.systemPrompt,
+			new RegExp(`${ROOT.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}.*assets.*sdd-orchestrator-workflow\\.md`),
+		);
+		assert.doesNotMatch(promptResult.systemPrompt, /\{\{GENTLE_PI_SDD_WORKFLOW_PATH\}\}/);
 		await writeFile(
 			join(globalConfigHome, "persona.json"),
 			'{"mode":"neutral"}\n',
@@ -637,6 +642,17 @@ async function run() {
 		await rm(engramSddCwd, { recursive: true, force: true });
 	}
 
+	const directEngramToolCwd = await tempWorkspace();
+	try {
+		pi.setActiveTools(["read", "bash", "edit", "write", "engram_mem_save"]);
+		const ctx = createCtx(directEngramToolCwd, true, "direct-engram-session");
+		await commands.get("gentle-ai:sdd-preflight").handler("", ctx);
+		assert.deepEqual(ctx.ui.selections[1].options, ["openspec"]);
+	} finally {
+		pi.setActiveTools(["read", "bash", "edit", "write"]);
+		await rm(directEngramToolCwd, { recursive: true, force: true });
+	}
+
 	const installCwd = await tempWorkspace();
 	try {
 		const ctx = createCtx(installCwd, true);
@@ -669,6 +685,9 @@ async function run() {
 		pi.setActiveTools([{ name: "engram.mem_save" }]);
 		await commands.get("gentle-ai:doctor").handler("", ctx);
 		assert.match(ctx.ui.notifications.at(-1).message, /Engram memory tools active/);
+		pi.setActiveTools([{ name: "engram_mem_save" }]);
+		await commands.get("gentle-ai:doctor").handler("", ctx);
+		assert.match(ctx.ui.notifications.at(-1).message, /Engram memory tools not active in this session/);
 		pi.setActiveTools(["read", "bash", "edit", "write"]);
 	} finally {
 		await rm(staleAssetsCwd, { recursive: true, force: true });

package/tests/skill-registry.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
@@ -114,6 +114,36 @@ test("uniqueExistingDirs normalizes duplicates and ignores missing roots", async
 	);
 });
 
+test("findSkillFiles scans one skill directory level only", async () => {
+	const root = join(tmpdir(), `gentle-pi-shallow-${Date.now()}`);
+	const skillPath = join(root, "docs", "SKILL.md");
+	const nestedSkillPath = join(root, "fixtures", "nested", "SKILL.md");
+	mkdirSync(dirname(skillPath), { recursive: true });
+	mkdirSync(dirname(nestedSkillPath), { recursive: true });
+	writeFileSync(skillPath, "---\nname: docs\ndescription: Docs.\n---\n");
+	writeFileSync(nestedSkillPath, "---\nname: nested\ndescription: Nested fixture.\n---\n");
+
+	assert.deepEqual(await __testing.findSkillFiles(root), [skillPath]);
+});
+
+test("findSkillFiles follows symlinked skill directories", async (t) => {
+	const root = join(tmpdir(), `gentle-pi-symlink-root-${Date.now()}`);
+	const realSkillDir = join(tmpdir(), `gentle-pi-symlink-target-${Date.now()}`);
+	const linkedSkillDir = join(root, "linked");
+	const skillPath = join(linkedSkillDir, "SKILL.md");
+	mkdirSync(root, { recursive: true });
+	mkdirSync(realSkillDir, { recursive: true });
+	writeFileSync(join(realSkillDir, "SKILL.md"), "---\nname: linked\ndescription: Linked skill.\n---\n");
+	try {
+		symlinkSync(realSkillDir, linkedSkillDir, "dir");
+	} catch (error) {
+		t.skip(`symlink creation unavailable: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+
+	assert.deepEqual(await __testing.findSkillFiles(root), [skillPath]);
+});
+
 test("skill registry watchers close on shutdown", async () => {
 	const root = join(tmpdir(), `gentle-pi-watchers-${Date.now()}`);
 	const skillPath = join(root, "skills", "docs", "SKILL.md");