gentle-pi 0.1.15 → 0.1.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,10 +1,60 @@
-# el Gentleman
+# gentle-pi
 
-`gentle-pi` installs **el Gentleman** into Pi: a controlled-development harness with a senior architect persona, SDD/OpenSpec phase discipline, strict TDD evidence, subagent orchestration, and review-workload protection.
+[![npm](https://img.shields.io/npm/v/gentle-pi?color=blue)](https://www.npmjs.com/package/gentle-pi)
+[![pi package](https://img.shields.io/badge/Pi-package-6f42c1)](https://pi.dev/packages/gentle-pi)
+[![license](https://img.shields.io/npm/l/gentle-pi?color=blue)](LICENSE)
+[![GitHub stars](https://img.shields.io/github/stars/Gentleman-Programming/gentle-pi?style=flat&color=yellow)](https://github.com/Gentleman-Programming/gentle-pi/stargazers)
+[![Gentle-AI](https://img.shields.io/badge/Gentle--AI-ecosystem-ff69b4)](https://github.com/Gentleman-Programming/gentle-ai)
+[![Gentleman Programming](https://img.shields.io/badge/by-Gentleman%20Programming-black)](https://github.com/Gentleman-Programming)
+[![YouTube](https://img.shields.io/badge/YouTube-Gentleman%20Programming-red?logo=youtube&logoColor=white)](https://www.youtube.com/c/GentlemanProgramming)
+[![Discord](https://img.shields.io/badge/Discord-community-5865F2?logo=discord&logoColor=white)](https://discord.com/invite/gentleman-programming-769863833996754944)
+[![SDD/OpenSpec](https://img.shields.io/badge/SDD-OpenSpec-00ADD8)](#sddopenspec-flow)
+[![Subagents](https://img.shields.io/badge/Pi-subagents-brightgreen)](#what-it-adds)
 
-Install it when you want Pi to stop behaving like a generic chatbot and start acting like a disciplined development harness.
+**Turn Pi from a powerful coding agent into a controlled development harness.**
 
-## Quick start
+`gentle-pi` installs **el Gentleman** in Pi: a senior-architect operating layer for Spec-Driven Development, focused subagents, strict TDD evidence, reviewable work units, safety guards, and project/user skill discovery.
+
+Pi already has strong tools. `gentle-pi` adds the discipline for using them well.
+
+`gentle-pi` is the Pi-native package from the [Gentle-AI ecosystem](https://github.com/Gentleman-Programming/gentle-ai), built by [Gentleman Programming](https://github.com/Gentleman-Programming): the broader open-source project for turning AI coding agents into disciplined engineering environments with SDD workflows, skills, memory integrations, model routing, and review guardrails across multiple agents.
+
+Follow the project and the community around it:
+
+- GitHub: [Gentleman-Programming](https://github.com/Gentleman-Programming)
+- YouTube: [Gentleman Programming](https://www.youtube.com/c/GentlemanProgramming)
+- Community Discord: [Gentleman Programming](https://discord.com/invite/gentleman-programming-769863833996754944)
+
+## The problem
+
+Most coding-agent sessions fail for operational reasons, not model reasons:
+
+- the agent jumps into code before requirements are clear;
+- architectural decisions disappear into chat history;
+- one request quietly becomes a huge multi-area diff;
+- tests run late, or not at all;
+- reviewers get handed a wall of changes;
+- subagents are available, but the parent session has no orchestration discipline;
+- project skills exist, but the model forgets to load them.
+
+`gentle-pi` fixes the workflow around the agent.
+
+## What it adds
+
+| Capability                     | What it does                                                                                                                         |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ |
+| **el Gentleman persona**       | Makes Pi behave like a senior architect and teacher, not a generic chatbot. Spanish responses use Rioplatense voseo by default.      |
+| **Work routing discipline**    | Small tasks stay inline. Context-heavy exploration can be delegated. Large or risky changes go through SDD/OpenSpec.                 |
+| **SDD/OpenSpec assets**        | Installs phase agents and chains for `init`, `explore`, `proposal`, `spec`, `design`, `tasks`, `apply`, `verify`, and `archive`.     |
+| **Subagent orchestration**     | Keeps one parent session responsible while child agents explore, implement, test, or review with focused context.                    |
+| **Strict TDD support**         | When project config declares a test command, apply/verify phases must record RED → GREEN → TRIANGULATE → REFACTOR evidence.          |
+| **Reviewer protection**        | Surfaces review workload risk before a task turns into an oversized PR.                                                              |
+| **Per-agent model assignment** | Pi-native modal for assigning stronger or cheaper models to specific SDD/custom agents.                                              |
+| **Skill discovery registry**   | Maintains `.atl/skill-registry.md` from project and user skills so review/comment/PR workflows do not silently miss the right skill. |
+| **Delivery skills**            | Includes issue-first PRs, chained PRs, work-unit commits, cognitive docs, comment writing, and Judgment Day review.                  |
+| **Shell safety**               | Blocks destructive shell commands and asks for confirmation for sensitive operations.                                                |
+
+## Install
 
 ```bash
 pi install npm:gentle-pi
@@ -15,214 +65,251 @@ Recommended companion packages:
 ```bash
 pi install npm:pi-subagents
 pi install npm:pi-intercom
+pi install npm:gentle-engram
+pi install npm:pi-web-access
+pi install npm:pi-lens
+pi install npm:@juicesharp/rpiv-todo
+pi install npm:@juicesharp/rpiv-ask-user-question
 ```
 
-Then start Pi in your project:
+Then start Pi in a project:
 
 ```bash
 pi
 ```
 
-On session start, `gentle-pi` automatically installs SDD assets into the project without overwriting local edits.
-
-## What you get
+On session start, `gentle-pi` installs local SDD assets without overwriting your edits.
 
-| Capability            | What it does                                                                                                                             |
-| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| el Gentleman identity | Answers as a Pi-specific harness, not a generic assistant. Defaults to the `gentleman` persona and can switch to `neutral`.              |
-| SDD/OpenSpec routing  | Small work stays inline, context-heavy work delegates, large/risky work uses SDD artifacts.                                              |
-| SDD phase agents      | Installs `sdd-init`, `sdd-explore`, `sdd-proposal`, `sdd-spec`, `sdd-design`, `sdd-tasks`, `sdd-apply`, `sdd-verify`, and `sdd-archive`. |
-| Strict TDD support    | Preserves RED → GREEN → TRIANGULATE → REFACTOR evidence and verify-time compliance checks.                                               |
-| Review workload guard | Forecasts large diffs and recommends chained PRs or explicit `size:exception`.                                                           |
-| Model assignment UI   | Opens a modal to assign Pi models to project, user, and built-in agents, with SDD agents shown first.                                    |
-| Foundation skills     | Adds PR, issue, chained-PR, comment, docs, work-unit, and Judgment Day skills.                                                           |
-| Safety policy         | Blocks destructive shell actions unless there is explicit user approval.                                                                 |
-
-## Core commands
+## Quick start
 
 ```text
-/gentle-ai:status          Show package, SDD asset, OpenSpec, and model config status.
-/gentle:models             Open the per-agent model assignment modal.
-/gentle-ai:models          Compatibility alias that points to /gentle:models.
-/gentleman:models          Compatibility alias that points to /gentle:models.
-/gentle:persona            Switch between gentleman and neutral personas.
-/gentle-ai:persona         Compatibility alias that points to /gentle:persona.
-/gentleman:persona         Compatibility alias that points to /gentle:persona.
-/sdd-init                  Bootstrap or refresh openspec/config.yaml.
-/gentle-ai:install-sdd     Reinstall SDD assets without overwriting local files.
-/gentle-ai:install-sdd --force
-                           Force-refresh installed SDD assets.
+/gentle-ai:status      Check package, SDD assets, OpenSpec, and model config.
+/sdd-init              Create or refresh openspec/config.yaml.
+/gentle:models         Assign models to SDD/custom agents.
+/gentle:persona        Switch between gentleman and neutral persona modes.
 ```
 
-## Switch persona
+Typical flow:
 
-Default persona: `gentleman`.
+1. Open Pi in your repo.
+2. Run `/gentle-ai:status`.
+3. Run `/sdd-init` once per project, or when test/project capabilities change.
+4. For a substantial change, ask Pi to use SDD.
+5. Review the phase artifacts instead of trusting floating chat context.
 
-Run:
+## How the harness decides what to do
 
-```text
-/gentle:persona
-```
+`gentle-pi` routes through the smallest safe workflow:
 
-Available modes:
+| Request shape                                                               | Harness                      |
+| --------------------------------------------------------------------------- | ---------------------------- |
+| Small, clear, local edit                                                    | Inline direct work.          |
+| Unknown codebase area or context-heavy investigation                        | Focused subagent delegation. |
+| Large, ambiguous, architectural, product-facing, or high-review-risk change | SDD/OpenSpec flow.           |
 
-| Persona     | Behavior                                                                                                                   |
-| ----------- | -------------------------------------------------------------------------------------------------------------------------- |
-| `gentleman` | Teaching-oriented senior architect persona with Rioplatense Spanish/voseo when the user writes Spanish.                    |
-| `neutral`   | Same senior architect discipline and teaching philosophy, but with warm professional language and no regional expressions. |
+The goal is not ceremony. The goal is to avoid accidental chaos.
 
-Saved config:
+## SDD/OpenSpec flow
 
 ```text
-.pi/gentle-ai/persona.json
+init → explore → proposal → spec → design → tasks → apply → verify → archive
 ```
 
-Run `/reload` or start a new Pi session after switching if the current session already injected the previous persona.
+For substantial work, the parent session coordinates the flow and each phase writes artifacts. That gives you:
+
+- explicit requirements and non-goals;
+- design decisions that survive compaction;
+- task plans reviewers can reason about;
+- implementation evidence;
+- verification reports;
+- archive notes for future agents.
 
-## Assign models to agents
+## Project files installed
 
-Run:
+On Pi `session_start`, `gentle-pi` copies these assets if they are missing:
 
 ```text
-/gentle:models
+.pi/agents/sdd-*.md
+.pi/chains/sdd-*.chain.md
+.pi/gentle-ai/support/strict-tdd.md
+.pi/gentle-ai/support/strict-tdd-verify.md
 ```
 
-This opens a modal similar to Gentle-AI's model picker. It discovers Pi subagents from project, user, and built-in sources, with SDD agents sorted first:
+It does **not** overwrite existing files unless you explicitly run:
 
 ```text
-Assign Models to Agents
-
-Current assignments:
+/gentle-ai:install-sdd --force
+```
 
-▸ Set all agents       mixed
-  sdd-init             inherit
-  sdd-explore          openai-codex/gpt-5.5
-  sdd-proposal         openai-codex/gpt-5.5
-  sdd-spec             anthropic/claude-sonnet-4
-  sdd-design           anthropic/claude-sonnet-4
-  sdd-tasks            anthropic/claude-sonnet-4
-  sdd-apply            anthropic/claude-sonnet-4
-  sdd-verify           google/gemini-3-pro
-  sdd-archive          inherit
-  delegate             inherit
-  my-custom-agent      anthropic/claude-sonnet-4
+## Skill registry
 
-Continue
-← Back
+`gentle-pi` keeps a local registry at:
 
-j/k: navigate • enter: change model / confirm • i: inherit • c: custom • ctrl+s: save • esc: back
+```text
+.atl/skill-registry.md
 ```
 
-Model choices come from Pi itself via the active model registry. The modal also supports custom model IDs for advanced setups.
+The registry scans project and user skill roots, not package-owned skills. It exists to catch workflow skills that are present on disk but not visible in Pi's injected skill list.
 
-The modal covers:
+It scans common roots such as:
 
-- project agents from `.pi/agents/` and `.agents/`;
-- user agents from `~/.pi/agent/agents/` and `~/.agents/`;
-- built-in `pi-subagents` agents.
+```text
+./skills
+.pi/skills
+.agent/skills
+.agents/skills
+.claude/skills
+.gemini/skills
+~/.config/opencode/skills
+~/.claude/skills
+~/.gemini/skills
+~/.cursor/skills
+~/.copilot/skills
+```
 
-Small recommendation in English:
+Behavior:
 
-| Agent kind                     | Recommended model shape                                                                |
-| ------------------------------ | -------------------------------------------------------------------------------------- |
-| Exploration, proposal, archive | Fast and cheap is usually enough.                                                      |
-| Spec, design, tasks            | Strong reasoning model, because these phases shape the implementation.                 |
-| Apply                          | Strong coding model with good tool-use reliability.                                    |
-| Verify / review agents         | Strongest fresh-context model you can afford; verification benefits from independence. |
-| Tiny utility agents            | Inherit the active/default model unless they become a bottleneck.                      |
+- `.atl/` is added to `.gitignore` when needed;
+- the registry refreshes on session start;
+- `/skill-registry:refresh` forces regeneration;
+- a best-effort watcher refreshes when skill files change;
+- skills without `## Compact Rules` are still listed with an instruction to load the full skill file.
 
-Saved config:
+Skill discovery is a guardrail, not a workflow router: it helps Pi load the right skill without forcing extra ceremony.
+
+## Persona modes
 
 ```text
-.pi/gentle-ai/models.json
+/gentle:persona
 ```
 
-Applied configuration:
+| Persona     | Behavior                                                                                                      |
+| ----------- | ------------------------------------------------------------------------------------------------------------- |
+| `gentleman` | Senior architect, teacher, direct technical feedback, Rioplatense Spanish/voseo when the user writes Spanish. |
+| `neutral`   | Same discipline, warmer professional language, no regional expression.                                        |
+
+Saved at:
 
 ```text
-.pi/agents/*.md                 # project/user markdown agents
-.pi/settings.json               # project overrides for built-in pi-subagents agents
+.pi/gentle-ai/persona.json
 ```
 
-Use `Inherit active/default model` to remove an agent override.
-
-## Installed project files
+Run `/reload` or start a new Pi session after switching persona.
 
-`gentle-pi` installs these project-local assets on session start:
+## Model assignment
 
 ```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
+/gentle:models
 ```
 
-Existing files are skipped. Your local edits remain unless you explicitly run:
+The modal discovers:
+
+- project agents in `.pi/agents/` and `.agents/`;
+- user agents in `~/.pi/agent/agents/` and `~/.agents/`;
+- built-in agents from `pi-subagents`.
+
+Recommended model shape:
+
+| Agent kind                 | Recommended model                                    |
+| -------------------------- | ---------------------------------------------------- |
+| Explore, proposal, archive | Fast and cheap is usually enough.                    |
+| Spec, design, tasks        | Strong reasoning model.                              |
+| Apply                      | Strong coding and tool-use model.                    |
+| Verify / review            | Strong fresh-context model.                          |
+| Tiny utilities             | Inherit active/default model unless they bottleneck. |
+
+Saved at:
 
 ```text
-/gentle-ai:install-sdd --force
+.pi/gentle-ai/models.json
 ```
 
-## Package contents
+## Commands
+
+| Command                          | What it does                                                 |
+| -------------------------------- | ------------------------------------------------------------ |
+| `/gentle-ai:status`              | Shows package, SDD asset, OpenSpec, and model config status. |
+| `/gentle:models`                 | Opens model 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.                        |
+| `/skill-registry:refresh`        | Regenerates `.atl/skill-registry.md`.                        |
 
-| Path                           | Purpose                                                                                                       |
-| ------------------------------ | ------------------------------------------------------------------------------------------------------------- |
-| `extensions/gentle-ai.ts`      | Injects el Gentleman, installs assets, provides commands, applies model config, blocks unsafe shell commands. |
-| `extensions/sdd-init.ts`       | Registers `/sdd-init` for OpenSpec project initialization.                                                    |
-| `extensions/skill-registry.ts` | Registers `/skill-registry:refresh` and maintains `.atl/skill-registry.md`.                                   |
-| `assets/orchestrator.md`       | Parent-session orchestration contract.                                                                        |
-| `assets/agents/`               | SDD phase agents copied into `.pi/agents/`.                                                                   |
-| `assets/chains/`               | SDD chains copied into `.pi/chains/`.                                                                         |
-| `assets/support/`              | Strict TDD apply/verify support docs.                                                                         |
-| `skills/`                      | el Gentleman and foundation skills.                                                                           |
-| `prompts/`                     | Gentle-prefixed prompt templates: `/gcl`, `/gis`, `/gpr`, `/gwr`.                                             |
+Compatibility aliases:
 
-## Foundation skills
+```text
+/gentle-ai:models
+/gentleman:models
+/gentle-ai:persona
+/gentleman:persona
+```
 
-Included skills:
+## Included skills
 
-- `gentle-ai` — el Gentleman harness discipline.
-- `branch-pr` — issue-first PR creation.
-- `chained-pr` — split oversized PRs into reviewable chains.
-- `work-unit-commits` — commit by deliverable work unit.
-- `judgment-day` — blind dual review and re-judgment flow.
-- `cognitive-doc-design` — documentation that reduces reviewer load.
-- `comment-writer` — concise collaboration comments.
-- `issue-creation` — issue-first GitHub workflow.
+- `gentle-ai` — harness discipline for controlled Pi work.
+- `branch-pr` — issue-first PR preparation.
+- `chained-pr` — split oversized changes into reviewable PR chains.
+- `work-unit-commits` — commits as reviewable work units.
+- `judgment-day` — blind dual review, fixes, and re-judgment.
+- `cognitive-doc-design` — documentation that reduces cognitive load.
+- `comment-writer` — concise, warm, postable collaboration comments.
+- `issue-creation` — issue workflow with checks before creation.
 
-## Memory is separate
+## Memory
 
-This package intentionally does **not** configure persistent memory.
+`gentle-pi` does **not** provide persistent memory by itself.
 
-Use a separate memory package, for example:
+For memory, install the companion package:
 
 ```bash
 pi install npm:gentle-engram
 ```
 
-el Gentleman may mention memory only when a memory package or callable memory tool is actually active.
+When memory tools are actually active, el Gentleman can save decisions, bug fixes, discoveries, user prompts, and session summaries across Pi sessions.
 
-## Local development
+## Package contents
+
+| Path                           | Purpose                                                                                                    |
+| ------------------------------ | ---------------------------------------------------------------------------------------------------------- |
+| `extensions/gentle-ai.ts`      | Injects identity, installs assets, registers commands, applies model config, and protects shell execution. |
+| `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/support/`              | Strict TDD support docs for apply/verify phases.                                                           |
+| `skills/`                      | Gentle AI delivery and collaboration skills.                                                               |
+| `prompts/`                     | Gentle-prefixed prompt templates.                                                                          |
 
-From this repo:
+## Development
+
+Install from this repo:
 
 ```bash
-pi install ./pi-packages/gentle-ai
+pi install .
 ```
 
 Validate before publishing:
 
 ```bash
-node --experimental-strip-types --check pi-packages/gentle-ai/extensions/gentle-ai.ts
-cd pi-packages/gentle-ai
+bun build extensions/skill-registry.ts --target=node --format=esm --outfile=/tmp/skill-registry.js
+node --experimental-strip-types --check extensions/gentle-ai.ts
 npm pack --dry-run
 ```
 
-## Design principles
+Publish:
+
+```bash
+npm publish
+```
+
+## Principles
 
+- Human control over agent momentum.
 - Concepts before code.
 - Artifacts over floating chat context.
-- Strict TDD evidence when tests exist.
+- SDD when risk justifies it.
+- Strict TDD when tests exist.
 - One parent orchestrator, focused subagents.
-- Review workload is a first-class constraint.
-- Human control beats agent momentum.
+- Reviewable changes over giant diffs.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gentle-pi",
-  "version": "0.1.15",
-  "description": "Opinionated el Gentleman harness package for Pi: SDD/OpenSpec workflow, strict TDD guidance, subagent assets, and safety defaults.",
+  "version": "0.1.16",
+  "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",
   "keywords": [
@@ -9,14 +9,18 @@
     "pi",
     "pi-coding-agent",
     "gentle-pi",
+    "gentle-ai",
     "sdd",
     "openspec",
-    "subagents"
+    "subagents",
+    "tdd",
+    "code-review",
+    "ai-coding-agent",
+    "agent-harness"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Gentleman-Programming/gentle-pi.git",
-    "directory": "pi-packages/gentle-ai"
+    "url": "git+https://github.com/Gentleman-Programming/gentle-pi.git"
   },
   "files": [
     "assets/",

package/assets/agents/sdd-apply.md

@@ -1,71 +0,0 @@
----
-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.
-
-## Before Writing Code
-
-Read proposal, specs, design, tasks, existing code, tests, `apply-progress.md` if present, and `openspec/config.yaml` when present.
-
-## Review Workload Gate
-
-Before implementing, inspect `tasks.md` for `Review Workload Forecast` and these guard lines:
-
-```text
-Decision needed before apply: Yes|No
-Chained PRs recommended: Yes|No
-Chain strategy: stacked-to-main|feature-branch-chain|size-exception|pending
-400-line budget risk: Low|Medium|High
-```
-
-If any of these are true:
-
-- `Decision needed before apply: Yes`
-- `Chained PRs recommended: Yes`
-- `400-line budget risk: High`
-
-then continue only when the parent prompt gives a resolved delivery path:
-
-- `auto-chain` or chosen chained/stacked PR mode: implement only the assigned work-unit slice and report the PR boundary.
-- `exception-ok` or `size:exception`: continue only if the prompt explicitly says the maintainer accepts the exception.
-- `single-pr` above budget: continue only after explicit `size:exception` approval.
-
-If no delivery decision is provided, STOP before writing code and return `blocked` with the exact decision needed.
-
-## Strict TDD Gate
-
-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.
-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.
-
-## Standard Mode
-
-If strict TDD is not active, implement assigned tasks against specs and design, update task checkboxes, and record verification evidence.
-
-## Apply Progress
-
-Update `openspec/changes/{change}/apply-progress.md` cumulatively. If previous progress exists, merge it with new progress; never overwrite completed work.
-
-Include:
-
-- completed tasks;
-- files changed;
-- test commands run;
-- TDD evidence when strict TDD is active;
-- deviations from design;
-- remaining tasks;
-- workload / PR boundary.
-
-Do NOT launch child subagents. Parent/orchestrator owns delegation. Never commit unless the user explicitly asks.
-
-Return the standard phase envelope with status, executive_summary, artifacts, next_recommended, risks, and skill_resolution.

package/assets/agents/sdd-archive.md

@@ -1,14 +0,0 @@
----
-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.
-
-- 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.

package/assets/agents/sdd-design.md

@@ -1,14 +0,0 @@
----
-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.
-
-- Read proposal, specs, and relevant code before designing.
-- Document decisions, data flow, file changes, contracts, tests, and rollout.
-- Keep design centered on `packages/coding-agent` unless scope explicitly expands.
-- Do NOT launch child subagents. Parent/orchestrator owns delegation.
-- Return the SDD result contract.

package/assets/agents/sdd-explore.md

@@ -1,14 +0,0 @@
----
-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.
-
-- Read OpenSpec/project context before conclusions.
-- Produce exploration notes only; do not implement.
-- Use OpenSpec artifacts and session context truthfully; persistent memory is optional and handled by separate packages.
-- Do NOT launch child subagents. Parent/orchestrator owns delegation.
-- Keep output concise and return the SDD result contract.

package/assets/agents/sdd-init.md

@@ -1,14 +0,0 @@
----
-name: sdd-init
-description: Initialize project SDD context, testing capabilities, and skill registry.
-tools: read, grep, glob, write, bash
-inheritProjectContext: true
----
-
-You are the SDD init executor for Gentle AI.
-
-- Inspect the project stack, test runner, conventions, and existing docs.
-- Create or update `openspec/config.yaml` with project context, `strict_tdd`, phase rules, and testing runner details.
-- Ensure `.atl/skill-registry.md` exists when skill registry data is available, or report that it is missing.
-- 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-onboard.md

@@ -1,15 +0,0 @@
----
-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.
-
-- 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.
-- Keep the walkthrough interactive and concise; explain why each phase exists before doing it.
-- Respect strict TDD when project testing capabilities are 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.