gentle-pi 0.3.4 → 0.3.6

package/README.md

@@ -82,7 +82,7 @@ Then start Pi in a project:
 pi
 ```
 
-`gentle-pi` waits until the first SDD flow in a session, then runs a one-time SDD preflight and installs local SDD assets without overwriting your edits. Slash SDD commands trigger this automatically; for natural-language requests, el Gentleman decides when SDD is needed and runs the explicit preflight first.
+`gentle-pi` provides SDD agents as global Pi runtime assets, not per-project setup. The first SDD flow in a session still runs a one-time SDD preflight for preferences; for natural-language requests, el Gentleman decides when SDD is needed and runs the explicit preflight first.
 
 ## Quick start
 
@@ -213,13 +213,12 @@ Engram-only mode is different by design: Engram is working memory and does not m
 
 ## SDD preflight and project files
 
-`gentle-pi` does not interrupt every new session. Slash SDD flows such as `/sdd-*`, `/sdd-init`, and the explicit `/gentle-ai:sdd-preflight` command run a lazy preflight, ask for session-scoped SDD preferences, and then copy these assets if they are missing. For natural-language requests, the parent agent decides whether the work should use SDD and must run/reuse `/gentle-ai:sdd-preflight` before continuing.
+`gentle-pi` does not require SDD agents to be copied into every project. The package ensures global Pi SDD assets exist under the Pi agent home and treats project-local files only as overrides/debug copies. Slash SDD flows such as `/sdd-*`, `/sdd-init`, and the explicit `/gentle-ai:sdd-preflight` command run a lazy preflight and ask for session-scoped SDD preferences. For natural-language requests, the parent agent decides whether the work should use SDD and must run/reuse `/gentle-ai:sdd-preflight` before continuing.
 
 ```text
-.pi/agents/sdd-*.md
-.pi/chains/sdd-*.chain.md
-.pi/gentle-ai/support/strict-tdd.md
-.pi/gentle-ai/support/strict-tdd-verify.md
+~/.pi/agent/agents/sdd-*.md
+~/.pi/agent/chains/sdd-*.chain.md
+~/.pi/agent/gentle-ai/support/strict-tdd*.md
 ```
 
 The preflight choices are reused for later SDD flows in the same session:
@@ -229,7 +228,7 @@ The preflight choices are reused for later SDD flows in the same session:
 - PR chaining strategy: `auto-forecast`, `ask-always`, `single-pr-default`, or `force-chained`;
 - review budget line threshold.
 
-It does **not** overwrite existing files unless you explicitly run:
+It does **not** overwrite existing global assets unless you explicitly run:
 
 ```text
 /gentle-ai:install-sdd --force
@@ -294,15 +293,15 @@ Behavior:
 - startup refresh is skipped when Pi starts with `--no-skills` / `-ns`, `--no-skill-registry`, or `GENTLE_PI_NO_SKILL_REGISTRY=1`;
 - `/skill-registry:refresh` forces regeneration;
 - a best-effort watcher refreshes when skill files change;
-- `## Compact Rules` wins when present; otherwise the registry extracts compact rules from `## Hard Rules`, `## Critical Rules`, `## Critical Patterns`, `## Voice Rules`, and `## Decision Gates` using bullets, numbered lists, or simple tables.
+- the registry indexes skill names, full descriptions, scope, and exact `SKILL.md` paths without copying skill body rules.
 
 Skill discovery is a guardrail, not a workflow router: it helps Pi load the right skill without forcing extra ceremony.
 
 Delegation contract:
 
-- parent/orchestrator resolves project/user skills from the registry and injects compact rule text under `## Project Standards (auto-resolved)`;
+- parent/orchestrator resolves project/user skills from the registry and passes matching paths under `## Skills to load before work`;
 - SDD subagents still use their assigned executor/phase skill;
-- during normal runtime, subagents should not independently discover or load additional project/user `SKILL.md` files or the registry;
+- during normal runtime, subagents should not independently discover additional project/user `SKILL.md` files or the registry;
 - fallback loading is degraded self-healing and must be reported via `skill_resolution` as `fallback-registry`, `fallback-path`, or `none`.
 
 ## Persona modes
@@ -378,8 +377,8 @@ Legacy string entries are still accepted and treated as `model`-only config.
 | `/gentle:models`                 | Opens global model + effort assignment UI.                          |
 | `/gentle:persona`                | Switches persona mode.                                              |
 | `/sdd-init`                      | Initializes or refreshes `openspec/config.yaml`.                    |
-| `/gentle-ai:install-sdd`         | Reinstalls SDD assets without overwriting local files.              |
-| `/gentle-ai:install-sdd --force` | Force-refreshes installed SDD assets.                               |
+| `/gentle-ai:install-sdd`         | Repairs missing global SDD runtime assets without overwriting files. |
+| `/gentle-ai:install-sdd --force` | Force-refreshes installed global SDD assets.                         |
 | `/skill-registry:refresh`        | Regenerates `.atl/skill-registry.md`.                               |
 
 Startup flag:
@@ -433,13 +432,13 @@ Memory contract for SDD delegation:
 
 | Path                           | Purpose                                                                                                    |
 | ------------------------------ | ---------------------------------------------------------------------------------------------------------- |
-| `extensions/gentle-ai.ts`      | Injects identity, installs assets, registers commands, applies model config, and protects shell execution. |
+| `extensions/gentle-ai.ts`      | Injects identity, ensures global SDD assets, registers commands, applies model config, and protects shell execution. |
 | `extensions/startup-banner.ts` | Shows the rose startup intro, compact runtime panel, and collaboration credit.                             |
 | `extensions/sdd-init.ts`       | Registers `/sdd-init` for OpenSpec initialization.                                                         |
 | `extensions/skill-registry.ts` | Maintains `.atl/skill-registry.md` from project/user skills.                                               |
 | `assets/orchestrator.md`       | Parent-session orchestration contract.                                                                     |
-| `assets/agents/`               | SDD agents copied into `.pi/agents/`.                                                                      |
-| `assets/chains/`               | SDD chains copied into `.pi/chains/`.                                                                      |
+| `assets/agents/`               | SDD agents installed as global Pi runtime assets.                                                          |
+| `assets/chains/`               | SDD chains installed as global Pi runtime assets.                                                          |
 | `assets/support/`              | Strict TDD support docs for apply/verify phases.                                                           |
 | `skills/`                      | Gentle AI delivery and collaboration skills.                                                               |
 | `prompts/`                     | Gentle-prefixed prompt templates.                                                                          |

package/assets/agents/sdd-apply.md

@@ -2,16 +2,15 @@
 name: sdd-apply
 description: Implement SDD tasks with strict TDD evidence and review workload guard.
 tools: read, grep, glob, edit, write, bash
-inheritProjectContext: true
 ---
 
 You are the SDD apply executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 ## Memory Contract
 
@@ -53,13 +52,13 @@ If no delivery decision is provided, STOP before writing code and return `blocke
 
 If `openspec/config.yaml` declares strict TDD and a test runner, or the parent prompt says strict TDD is active:
 
-1. Read `.pi/gentle-ai/support/strict-tdd.md` if present.
+1. Read the global Gentle AI strict-TDD support guidance when available. If a project-local `.pi/gentle-ai/support/strict-tdd.md` exists, treat it as an override.
 2. Follow RED → GREEN → TRIANGULATE → REFACTOR for every assigned task.
 3. Do not write production code before a failing test or equivalent RED test is written.
 4. Run relevant focused tests during GREEN and after refactors.
 5. Write a `TDD Cycle Evidence` table in `apply-progress.md`.
 
-If strict TDD is active and `.pi/gentle-ai/support/strict-tdd.md` is missing, follow the RED/GREEN/TRIANGULATE/REFACTOR contract from this prompt and report the missing support file as a risk. Do not silently fall back to standard mode.
+If strict TDD is active and no external support file is available, follow the RED/GREEN/TRIANGULATE/REFACTOR contract from this prompt. Do not silently fall back to standard mode.
 
 ## Standard Mode
 

package/assets/agents/sdd-archive.md

@@ -2,16 +2,15 @@
 name: sdd-archive
 description: Archive a verified SDD change into OpenSpec source specs.
 tools: read, grep, glob, write, edit, bash
-inheritProjectContext: true
 ---
 
 You are the SDD archive executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 ## Memory Contract
 

package/assets/agents/sdd-design.md

@@ -2,16 +2,15 @@
 name: sdd-design
 description: Design the technical approach for an SDD change.
 tools: read, grep, glob, write, edit
-inheritProjectContext: true
 ---
 
 You are the SDD design executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 - Read proposal, specs, and relevant code before designing.
 - Document decisions, data flow, file changes, contracts, tests, and rollout.
@@ -23,4 +22,3 @@ If Project Standards are missing, explicit fallback loading is allowed only as d
 The parent/orchestrator owns memory retrieval: use memory context passed in the prompt and do not independently search Engram/memory during normal runtime unless explicitly instructed to retrieve a specific artifact or observation.
 
 When callable memory tools are available, save significant discoveries, decisions, bug fixes, and completed SDD phase artifacts before returning. In memory/hybrid mode, use stable topic keys such as `sdd/<change>/proposal`, `sdd/<change>/spec`, `sdd/<change>/design`, `sdd/<change>/tasks`, `sdd/<change>/apply-progress`, or `sdd/<change>/verify-report`. If memory tools are unavailable, report inline and/or write OpenSpec files; do not claim persistence.
-

package/assets/agents/sdd-explore.md

@@ -2,16 +2,15 @@
 name: sdd-explore
 description: Explore an SDD change idea before proposal.
 tools: read, grep, glob, webfetch
-inheritProjectContext: true
 ---
 
 You are the SDD explore executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 - Read OpenSpec/project context before conclusions.
 - Produce exploration notes only; do not implement.
@@ -23,4 +22,3 @@ If Project Standards are missing, explicit fallback loading is allowed only as d
 The parent/orchestrator owns memory retrieval: use memory context passed in the prompt and do not independently search Engram/memory during normal runtime unless explicitly instructed to retrieve a specific artifact or observation.
 
 When callable memory tools are available, save significant discoveries, decisions, bug fixes, and completed SDD phase artifacts before returning. In memory/hybrid mode, use stable topic keys such as `sdd/<change>/proposal`, `sdd/<change>/spec`, `sdd/<change>/design`, `sdd/<change>/tasks`, `sdd/<change>/apply-progress`, or `sdd/<change>/verify-report`. If memory tools are unavailable, report inline and/or write OpenSpec files; do not claim persistence.
-

package/assets/agents/sdd-init.md

@@ -3,16 +3,15 @@ name: sdd-init
 description: Initialize project SDD context, testing capabilities, and skill registry.
 model: openai-codex/gpt-5.3-codex
 tools: read, grep, glob, write, bash
-inheritProjectContext: true
 ---
 
 You are the SDD init executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 - Inspect the project stack, test runner, conventions, and existing docs.
 - If `openspec/config.yaml` is missing, create it automatically with project context, `strict_tdd`, phase rules, and testing runner details.
@@ -25,4 +24,3 @@ If Project Standards are missing, explicit fallback loading is allowed only as d
 The parent/orchestrator owns memory retrieval: use memory context passed in the prompt and do not independently search Engram/memory during normal runtime unless explicitly instructed to retrieve a specific artifact or observation.
 
 When callable memory tools are available, save significant discoveries, decisions, bug fixes, and completed SDD phase artifacts before returning. In memory/hybrid mode, use stable topic keys such as `sdd/<change>/proposal`, `sdd/<change>/spec`, `sdd/<change>/design`, `sdd/<change>/tasks`, `sdd/<change>/apply-progress`, or `sdd/<change>/verify-report`. If memory tools are unavailable, report inline and/or write OpenSpec files; do not claim persistence.
-

package/assets/agents/sdd-onboard.md

@@ -2,16 +2,15 @@
 name: sdd-onboard
 description: Guide a user through a complete SDD cycle on a small real project change.
 tools: read, grep, glob, write, edit, bash
-inheritProjectContext: true
 ---
 
 You are the SDD onboard executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 - Pick or ask for a small, real, low-risk improvement that can demonstrate the full SDD lifecycle.
 - Teach by doing: create real artifacts for explore, proposal, spec, design, tasks, apply, verify, and archive where appropriate.
@@ -24,4 +23,3 @@ If Project Standards are missing, explicit fallback loading is allowed only as d
 The parent/orchestrator owns memory retrieval: use memory context passed in the prompt and do not independently search Engram/memory during normal runtime unless explicitly instructed to retrieve a specific artifact or observation.
 
 When callable memory tools are available, save significant discoveries, decisions, bug fixes, and completed SDD phase artifacts before returning. In memory/hybrid mode, use stable topic keys such as `sdd/<change>/proposal`, `sdd/<change>/spec`, `sdd/<change>/design`, `sdd/<change>/tasks`, `sdd/<change>/apply-progress`, or `sdd/<change>/verify-report`. If memory tools are unavailable, report inline and/or write OpenSpec files; do not claim persistence.
-

package/assets/agents/sdd-proposal.md

@@ -2,16 +2,15 @@
 name: sdd-proposal
 description: Write an SDD proposal for an approved change idea.
 tools: read, grep, glob, write, edit
-inheritProjectContext: true
 ---
 
 You are the SDD proposal executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 - Read exploration and project standards before writing.
 - Write `openspec/changes/{change}/proposal.md`.
@@ -23,4 +22,3 @@ If Project Standards are missing, explicit fallback loading is allowed only as d
 The parent/orchestrator owns memory retrieval: use memory context passed in the prompt and do not independently search Engram/memory during normal runtime unless explicitly instructed to retrieve a specific artifact or observation.
 
 When callable memory tools are available, save significant discoveries, decisions, bug fixes, and completed SDD phase artifacts before returning. In memory/hybrid mode, use stable topic keys such as `sdd/<change>/proposal`, `sdd/<change>/spec`, `sdd/<change>/design`, `sdd/<change>/tasks`, `sdd/<change>/apply-progress`, or `sdd/<change>/verify-report`. If memory tools are unavailable, report inline and/or write OpenSpec files; do not claim persistence.
-

package/assets/agents/sdd-spec.md

@@ -2,16 +2,15 @@
 name: sdd-spec
 description: Write SDD delta specs with requirements and scenarios.
 tools: read, grep, glob, write, edit
-inheritProjectContext: true
 ---
 
 You are the SDD spec executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 ## Memory Contract
 

package/assets/agents/sdd-sync.md

@@ -2,16 +2,15 @@
 name: sdd-sync
 description: Sync verified SDD delta specs into OpenSpec canonical specs without archiving the change.
 tools: read, grep, glob, write, edit, bash
-inheritProjectContext: true
 ---
 
 You are the SDD sync executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 ## Memory Contract
 

package/assets/agents/sdd-tasks.md

@@ -2,16 +2,15 @@
 name: sdd-tasks
 description: Break SDD design/specs into implementation tasks with review workload forecast.
 tools: read, grep, glob, write, edit
-inheritProjectContext: true
 ---
 
 You are the SDD tasks executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 ## Memory Contract
 

package/assets/agents/sdd-verify.md

@@ -2,16 +2,15 @@
 name: sdd-verify
 description: Verify implementation against SDD specs, tasks, strict TDD evidence, and review workload boundaries.
 tools: read, grep, glob, bash, write, edit
-inheritProjectContext: true
 ---
 
 You are the SDD verify executor for Gentle AI.
 
 ## Skill Resolution Contract
 
-Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer the parent-injected `## Project Standards (auto-resolved)` block; do not independently discover or load additional project/user `SKILL.md` files or the registry during normal runtime.
+Use your assigned executor/phase skill for this SDD phase. For project/user skills, prefer parent-injected `## Skills to load before work` paths; read those exact `SKILL.md` files before work. Do not independently discover additional project/user skills or the registry during normal runtime.
 
-If Project Standards are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should inject compact rules next time.
+If skill paths are missing, explicit fallback loading is allowed only as degraded self-healing. Report `skill_resolution` as `paths-injected`, `fallback-registry`, `fallback-path`, or `none`; fallbacks mean the parent should pass indexed paths next time.
 
 ## Memory Contract
 
@@ -32,14 +31,14 @@ Run required focused and full verification commands when available. Report comma
 
 If strict TDD is active in `openspec/config.yaml`, parent prompt, or `apply-progress.md`:
 
-1. Read `.pi/gentle-ai/support/strict-tdd-verify.md` if present.
+1. Read the global Gentle AI strict-TDD verification support guidance when available. If a project-local `.pi/gentle-ai/support/strict-tdd-verify.md` exists, treat it as an override.
 2. Verify `apply-progress.md` contains a `TDD Cycle Evidence` table.
 3. Cross-reference reported test files against the actual codebase.
 4. Run the relevant tests and confirm GREEN is still true.
 5. Audit assertion quality in changed/created tests: no tautologies, ghost loops, type-only assertions alone, smoke-only tests, or implementation-detail CSS assertions.
 6. Flag missing or incomplete TDD evidence as CRITICAL.
 
-If strict TDD is active and `.pi/gentle-ai/support/strict-tdd-verify.md` is missing, perform the checks above and report the missing support file as a risk. Do not skip TDD compliance.
+If strict TDD is active and no external support file is available, perform the checks above. Do not skip TDD compliance.
 
 ## Review Workload Verification
 

package/assets/orchestrator.md

@@ -181,6 +181,13 @@ proposal → design ┘
 
 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`;
@@ -188,11 +195,11 @@ The preflight captures:
 - chained PR strategy: `auto-forecast`, `ask-always`, `single-pr-default`, or `force-chained`;
 - review budget in changed lines.
 
-During that lazy preflight, the package should ensure SDD assets are present for `pi-subagents` without the user needing to remember setup commands. If assets are missing, install them non-destructively into:
+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/agents/sdd-*.md
-.pi/chains/sdd-*.chain.md
+~/.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.
@@ -207,7 +214,7 @@ In this Pi package, the default local artifact is:
 openspec/config.yaml
 ```
 
-If it is missing, ask the user for the minimal information needed or run `/sdd-init` if available. Do not proceed with a substantial SDD flow while pretending project context and testing capability are known.
+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
 
@@ -260,22 +267,23 @@ The parent should synthesize these envelopes, not paste long raw reports unless
 The parent resolves skills once per session or before first delegation:
 
 1. Read `.atl/skill-registry.md` if present.
-2. Use matching compact rules based on code context and task intent.
-3. Inject matching rule text into subagent prompts under `## Project Standards (auto-resolved)`.
-4. If the registry is absent, continue but mention that project-specific skill rules were unavailable.
+2. Match task context and target files against the `Trigger / description` column.
+3. Pass only matching `Path` values to subagents under `## Skills to load before work`.
+4. Tell subagents to read those exact `SKILL.md` files before reading, writing, reviewing, testing, or creating artifacts.
+5. If the registry is absent, continue but mention that project-specific skill paths were unavailable.
 
-Subagents should receive pre-digested project/user rules. They should not have to rediscover the registry.
+Subagents should receive exact indexed paths. They should not have to rediscover the registry.
 
-Important distinction: SDD subagents still use their assigned executor/phase skill (for example `sdd-apply`, `sdd-design`, or `sdd-verify`). What they should not do during normal runtime is independently discover or load additional project/user `SKILL.md` files or the registry. Those project/user rules arrive pre-digested from the parent under `## Project Standards (auto-resolved)`.
+Important distinction: SDD subagents still use their assigned executor/phase skill (for example `sdd-apply`, `sdd-design`, or `sdd-verify`). What they should not do during normal runtime is independently discover additional project/user `SKILL.md` files or the registry. The parent passes selected project/user skill paths explicitly.
 
 If a subagent reports `skill_resolution`, interpret it as project/user skill resolution:
 
-- `injected`: parent supplied `## Project Standards (auto-resolved)`.
-- `fallback-registry`: subagent self-loaded compact rules from a registry because Project Standards were missing; degraded but auditable.
-- `fallback-path`: subagent loaded explicit `SKILL: Load` paths because Project Standards were missing; degraded but auditable.
+- `paths-injected`: parent supplied `## Skills to load before work` with exact `SKILL.md` paths.
+- `fallback-registry`: subagent self-loaded skill paths from the registry because parent paths were missing; degraded but auditable.
+- `fallback-path`: subagent loaded explicit skill paths because parent paths were missing; degraded but auditable.
 - `none`: no project/user skills were loaded.
 
-If any subagent reports a fallback instead of `injected`, treat it as an orchestration gap and correct future delegations by injecting the compact rules directly.
+If any subagent reports a fallback instead of `paths-injected`, treat it as an orchestration gap and correct future delegations by passing exact indexed paths directly.
 
 ## Intent-Driven Skill Discovery
 
@@ -284,7 +292,7 @@ For skill-shaped requests, do not treat injected `<available_skills>` as complet
 Discovery order:
 
 1. Read `.atl/skill-registry.md` when present.
-2. If the registry suggests a specific skill, load that skill before acting.
+2. If the registry suggests a specific skill, load the indexed `SKILL.md` path before acting.
 3. If the expected skill is absent from the registry but the request clearly names a known workflow, search common project/user skill dirs such as `./skills`, `.pi/skills`, `.agents/skills`, `~/.config/opencode/skills`, `~/.claude/skills`, and other configured skill roots.
 4. Prefer the most specific project skill over a global skill with the same intent.
 5. If no matching skill exists, continue with the smallest safe fallback and say which expected skill was unavailable.