gentle-pi 0.3.3 → 0.3.5

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
 
@@ -137,7 +137,18 @@ Fresh reviewers are intentionally not token-saving devices; they buy independent
 ## SDD/OpenSpec flow
 
 ```text
-init → explore → proposal → spec → design → tasks → apply → verify → archive
+init
+  ↓
+explore → proposal → spec ─┬→ design ─┐
+                            └─────────┴→ tasks → apply → verify → sync → archive
+```
+
+The main loop is intentionally file-backed when you choose `openspec` or `both`:
+
+```text
+planning artifacts                implementation evidence        canonical update
+──────────────────                ───────────────────────        ────────────────
+proposal/spec/design/tasks   →    apply-progress/verify-report → sync-report → archive-report
 ```
 
 For substantial work, the parent session coordinates the flow and each phase writes artifacts. That gives you:
@@ -147,17 +158,67 @@ For substantial work, the parent session coordinates the flow and each phase wri
 - task plans reviewers can reason about;
 - implementation evidence;
 - verification reports;
+- sync reports that update canonical specs while keeping the change active;
 - archive notes for future agents.
 
+### OpenSpec artifact model
+
+`gentle-pi` treats OpenSpec-compatible behavior as part of the harness. You do not need to install the external OpenSpec CLI/package for SDD.
+
+In file-backed modes, canonical accepted behavior lives in `openspec/specs/`, while active changes carry deltas under `openspec/changes/`:
+
+```text
+openspec/
+├── specs/                                      # accepted source of truth
+│   └── {domain}/spec.md
+└── changes/
+    ├── {change}/                              # active work
+    │   ├── proposal.md
+    │   ├── specs/{domain}/spec.md             # full spec or delta spec
+    │   ├── design.md
+    │   ├── tasks.md
+    │   ├── apply-progress.md
+    │   ├── verify-report.md
+    │   └── sync-report.md
+    └── archive/YYYY-MM-DD-{change}/           # immutable audit trail
+```
+
+Delta flow:
+
+```text
+openspec/changes/{change}/specs/{domain}/spec.md
+        │
+        │  sdd-sync applies ADDED / MODIFIED / REMOVED
+        ▼
+openspec/specs/{domain}/spec.md
+        │
+        │  sdd-archive moves the completed change folder
+        ▼
+openspec/changes/archive/YYYY-MM-DD-{change}/
+```
+
+When a canonical spec already exists, change specs use requirement operation sections:
+
+```markdown
+## ADDED Requirements
+
+## MODIFIED Requirements
+
+## REMOVED Requirements
+```
+
+`MODIFIED` requirements must include the full requirement block, including still-valid scenarios, because sync replaces the canonical block by requirement name. `sdd-sync` syncs file-backed deltas into `openspec/specs/{domain}/spec.md` while keeping the change active; `sdd-archive` then moves the synced change to `openspec/changes/archive/YYYY-MM-DD-{change}/`.
+
+Engram-only mode is different by design: Engram is working memory and does not maintain a canonical spec merge layer. Use `openspec` or `both` (hybrid file + memory persistence) when you need canonical spec evolution.
+
 ## 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:
@@ -167,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
@@ -232,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
@@ -316,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:
@@ -371,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,25 +2,143 @@
 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.
 
-- Read verify report before archiving.
-- Merge accepted deltas into `openspec/specs/` and move the change to archive.
-- Preserve audit trail; never delete active artifacts silently.
-- Do NOT launch child subagents. Parent/orchestrator owns delegation.
-- Return archived paths and any migration risks.
 ## Memory Contract
 
 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.
+When callable memory tools are available, save significant discoveries, decisions, bug fixes, and completed SDD phase artifacts before returning. In memory-backed modes (`engram` or `both` / `hybrid`), use stable topic keys such as `sdd/<change>/proposal`, `sdd/<change>/spec`, `sdd/<change>/design`, `sdd/<change>/tasks`, `sdd/<change>/apply-progress`, `sdd/<change>/verify-report`, or `sdd/<change>/archive-report`. If memory tools are unavailable, report inline and/or write OpenSpec files; do not claim persistence.
+
+## Purpose
+
+Archive a completed SDD change. In file-backed modes, this requires canonical spec sync to be complete (normally via `sdd-sync`), then moves the active change folder to the dated archive. In Engram-only mode, this records traceability without creating a canonical merge layer.
+
+## Archive Preconditions
+
+Before archiving, read:
+
+- `openspec/changes/{change}/proposal.md`
+- `openspec/changes/{change}/specs/` or memory artifact `sdd/{change}/spec`
+- `openspec/changes/{change}/design.md`
+- `openspec/changes/{change}/tasks.md`
+- `openspec/changes/{change}/verify-report.md`
+- `openspec/changes/{change}/sync-report.md` when file-backed sync was run
+- `openspec/config.yaml` when present
+
+Stop with `blocked` if:
+
+- the verification report is missing;
+- the verification report is not clearly passing, or contains unresolved `FAIL`, `BLOCKED`, `CRITICAL`, or verification blockers;
+- required artifacts are missing;
+- tasks are incomplete and no explicit archive exception is recorded;
+- file-backed mode has no successful `sync-report.md` and the parent prompt does not explicitly approve archive-time sync fallback;
+- a legacy flat `openspec/changes/{change}/spec.md` is the only spec artifact in file-backed mode;
+- the merge would be destructive and the parent prompt does not include explicit confirmation.
+
+## Artifact Store Modes
+
+- `openspec`: require completed filesystem sync, then perform archive move.
+- `both` / `hybrid`: require completed filesystem sync, move the archive, and save the archive report to memory when tools are available.
+- `engram`: skip filesystem sync/archive. Engram is working memory; do not create or require `sdd/canonical/<domain>/spec` topics. Record proposal/spec/design/tasks/verify observation IDs in the archive report.
+- `none`: return a closure summary only.
+
+## Archive-Time Sync Fallback
+
+Prefer `sdd-sync` before `sdd-archive`. If no successful `sync-report.md` exists, archive may perform the same file-backed sync only when the parent prompt explicitly approves archive-time sync fallback.
+
+For each domain spec in:
+
+```text
+openspec/changes/{change}/specs/{domain}/spec.md
+```
+
+sync into:
+
+```text
+openspec/specs/{domain}/spec.md
+```
+
+### New canonical spec
+
+If `openspec/specs/{domain}/spec.md` does not exist, treat the change spec as a full domain spec and copy it to the canonical path.
+
+### Existing canonical spec
+
+If the canonical spec exists, apply operation sections by requirement name:
+
+```text
+## ADDED Requirements     -> append each requirement to the canonical Requirements section
+## MODIFIED Requirements  -> replace the full matching canonical requirement block
+## REMOVED Requirements   -> delete the full matching canonical requirement block
+```
+
+Merge rules:
+
+- Match requirements by exact `### Requirement: {Name}` heading.
+- Preserve every canonical requirement not mentioned by the delta.
+- Preserve heading hierarchy and Markdown formatting.
+- Fail or block if a MODIFIED or REMOVED requirement does not exist in the canonical spec.
+- Warn if another active change under `openspec/changes/*/specs/{domain}/spec.md` touches the same domain.
+- Report all ADDED/MODIFIED/REMOVED requirement names in the archive report.
+
+## Destructive Merge Guard
+
+Before applying REMOVED requirements or large MODIFIED blocks:
+
+- list affected requirement names;
+- summarize the approximate removed/replaced line count;
+- warn the parent/orchestrator;
+- continue only if the parent prompt records explicit approval for the destructive sync.
+
+Verification alone is not approval for destructive canonical spec changes.
+
+Never silently drop scenarios from a MODIFIED requirement. If a MODIFIED delta appears partial, block and ask for a corrected full requirement block.
+
+## Move to Archive
+
+After successful file-backed sync, move:
+
+```text
+openspec/changes/{change}/
+  -> openspec/changes/archive/YYYY-MM-DD-{change}/
+```
+
+Use today's ISO date. Create `openspec/changes/archive/` if missing. The archive is an audit trail; never delete or modify archived changes silently.
+
+## Archive Report
+
+Archive report handling depends on mode:
+
+- `openspec`: write `openspec/changes/{change}/archive-report.md` before moving the change.
+- `both` / `hybrid`: write the file report before moving the change and save `sdd/{change}/archive-report` to memory when tools are available.
+- `engram`: save or return the archive report with observation-ID traceability only; do not perform filesystem sync/archive.
+
+Include:
+
+- pass/fail archive status;
+- artifacts read;
+- domains synced;
+- ADDED/MODIFIED/REMOVED requirement names;
+- active same-domain change warnings;
+- destructive merge approvals or blockers;
+- archived path;
+- memory observation IDs when using Engram or `both` / `hybrid` mode.
+
+## Rules
+
+- Read verify report before archiving.
+- Require file-backed specs to be synced before moving the change to archive; use archive-time sync fallback only with explicit parent approval.
+- Preserve audit trail; never delete active artifacts silently.
+- Apply `rules.archive` from `openspec/config.yaml` when present.
+- Do NOT launch child subagents. Parent/orchestrator owns delegation.
 
+Return the standard phase envelope with status, executive_summary, artifacts, next_recommended, risks, and skill_resolution.

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.
-