gentle-pi 0.1.22 → 0.2.0

package/README.md

@@ -25,6 +25,8 @@ Follow the project and the community around it:
 - YouTube: [Gentleman Programming](https://www.youtube.com/c/GentlemanProgramming)
 - Community Discord: [Gentleman Programming](https://discord.com/invite/gentleman-programming-769863833996754944)
 
+Startup intro collaboration: thanks to [@aporcelli](https://github.com/aporcelli) for [`pi-gentle-startup`](https://github.com/aporcelli/pi-gentle-startup), which inspired the clean-screen startup animation, compact runtime panel, and pink visual treatment.
+
 ## The problem
 
 Most coding-agent sessions fail for operational reasons, not model reasons:
@@ -44,6 +46,7 @@ Most coding-agent sessions fail for operational reasons, not model reasons:
 | 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.      |
+| **Rose startup intro**         | Adds a pink rose fade-in, compact project/runtime panel, and visible startup collaboration credit for @aporcelli's `pi-gentle-startup` ideas. |
 | **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.                    |
@@ -173,10 +176,17 @@ Behavior:
 - 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.
+- skills without `## Compact Rules` are still listed, but delegators should inject project/user compact rules into subagents whenever possible.
 
 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)`;
+- 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;
+- fallback loading is degraded self-healing and must be reported via `skill_resolution` as `fallback-registry`, `fallback-path`, or `none`.
+
 ## Persona modes
 
 ```text
@@ -268,6 +278,13 @@ pi install npm:gentle-engram
 
 When memory tools are actually active, el Gentleman can save decisions, bug fixes, discoveries, user prompts, and session summaries across Pi sessions.
 
+Memory contract for SDD delegation:
+
+- parent/orchestrator owns memory retrieval and passes selected context into subagent prompts;
+- subagents should not independently search memory during normal runtime unless explicitly instructed to retrieve a specific artifact or observation;
+- subagents should save significant discoveries, decisions, bug fixes, and completed SDD phase artifacts before returning when memory tools are available;
+- in memory/hybrid mode, SDD artifacts use stable topic keys such as `sdd/<change>/proposal`, `sdd/<change>/spec`, `sdd/<change>/design`, `sdd/<change>/tasks`, `sdd/<change>/apply-progress`, and `sdd/<change>/verify-report`.
+
 ## Package contents
 
 | Path                           | Purpose                                                                                                    |

package/assets/agents/sdd-apply.md

@@ -7,6 +7,19 @@ 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.
+
+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.
+
+## 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.
+
+
 ## Before Writing Code
 
 Read proposal, specs, design, tasks, existing code, tests, `apply-progress.md` if present, and `openspec/config.yaml` when present.

package/assets/agents/sdd-archive.md

@@ -7,8 +7,20 @@ 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.
+
+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.
+
 - 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.
+

package/assets/agents/sdd-design.md

@@ -7,8 +7,20 @@ 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.
+
+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.
+
 - 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.
+## 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.
+

package/assets/agents/sdd-explore.md

@@ -7,8 +7,20 @@ 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.
+
+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.
+
 - 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.
+## 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.
+

package/assets/agents/sdd-init.md

@@ -8,9 +8,21 @@ 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.
+
+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.
+
 - 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.
 - If `openspec/config.yaml` already exists, read it, summarize the current SDD/testing configuration, and do not block the caller. Update only safe derived context when explicitly necessary; never destructively rewrite user-maintained SDD configuration.
 - 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.
+## 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.
+

package/assets/agents/sdd-onboard.md

@@ -7,9 +7,21 @@ 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.
+
+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.
+
 - 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.
+## 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.
+

package/assets/agents/sdd-proposal.md

@@ -7,8 +7,20 @@ 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.
+
+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.
+
 - Read exploration and project standards before writing.
 - Write `openspec/changes/{change}/proposal.md`.
 - Include intent, scope, affected areas, risks, rollback, and success criteria.
 - Do NOT launch child subagents. Parent/orchestrator owns delegation.
 - Persist planning output to OpenSpec artifacts; persistent memory is optional and handled by separate packages.
+## 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.
+

package/assets/agents/sdd-spec.md

@@ -7,8 +7,20 @@ 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.
+
+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.
+
 - Read proposal and existing specs first.
 - Write RFC 2119 requirements and Given/When/Then scenarios.
 - Store deltas under `openspec/changes/{change}/specs/`.
 - Do NOT launch child subagents. Parent/orchestrator owns delegation.
 - Return exact artifact paths and 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.
+

package/assets/agents/sdd-tasks.md

@@ -7,6 +7,19 @@ 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.
+
+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.
+
+## 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.
+
+
 ## Inputs
 
 Read proposal, specs, design, project testing capabilities, and `openspec/config.yaml` when present.

package/assets/agents/sdd-verify.md

@@ -7,6 +7,19 @@ 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.
+
+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.
+
+## 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.
+
+
 ## Inputs
 
 Read specs, design, tasks, apply-progress, changed code, tests, and `openspec/config.yaml` when present.

package/assets/orchestrator.md

@@ -141,6 +141,16 @@ This package does not provide persistent memory by itself.
 - If a separate memory package is installed and callable, memory/hybrid flows may be used.
 - Never claim memory exists because Gentle AI is installed.
 
+## Memory Contract
+
+When Engram or another callable memory package is available, the parent owns memory retrieval and subagents own write-back for significant findings.
+
+- Read context: parent/orchestrator searches memory, selects relevant observations, and passes them into subagent prompts. Subagents should not independently search memory during normal runtime unless the parent explicitly instructs them to retrieve a specific artifact or observation.
+- Write context: subagents MUST save significant discoveries, decisions, bug fixes, and completed SDD phase artifacts to memory before returning when memory tools are available.
+- Prompt forwarding: when delegating, add a concrete instruction such as: `If you make important discoveries, decisions, or fix bugs, save them to Engram via the available memory save tool with project: '<project>' before returning.`
+- SDD artifact keys: in memory/hybrid mode, phase artifacts should use stable topic keys such as `sdd/<change>/proposal`, `sdd/<change>/spec`, `sdd/<change>/design`, `sdd/<change>/tasks`, `sdd/<change>/apply-progress`, and `sdd/<change>/verify-report`.
+- If memory tools are unavailable, do not pretend persistence exists; return artifacts inline and/or write OpenSpec files.
+
 ## Execution Mode
 
 For substantial SDD flows, choose or ask once per change:
@@ -178,7 +188,18 @@ The parent resolves skills once per session or before first delegation:
 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.
 
-Subagents should receive pre-digested rules. They should not have to rediscover the registry.
+Subagents should receive pre-digested project/user rules. 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)`.
+
+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.
+- `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.
 
 ## Intent-Driven Skill Discovery
 

package/extensions/gentle-ai.ts

@@ -8,18 +8,12 @@ import {
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { VERSION } from "@earendil-works/pi-coding-agent";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
-	Theme,
 	ToolCallEventResult,
 } from "@earendil-works/pi-coding-agent";
-import {
-	matchesKey,
-	truncateToWidth,
-	visibleWidth,
-} from "@earendil-works/pi-tui";
+import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
 
 const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const ASSETS_DIR = join(PACKAGE_ROOT, "assets");
@@ -49,139 +43,6 @@ const NEUTRAL_PERSONA_PROMPT = `Persona:
 - Push back when the user asks for code without enough context or understanding.
 - Correct errors directly, explain why, and show the better path.`;
 
-const ROSE_LOGO_LINES = [
-	"             ⣠⣾⣷⣶⣦⣤⣤⣄⣠⣄⣀  ⢀⣀⣀",
-	"          ⢀⣴⣿⣿⠿⣋⣭⣭⣯⣭⣍⣭⣿⣟⠛⠛⠿⠿⣿⣷⣄",
-	"      ⢀⣴⣾⡟⢻⣿⡟⠁⣼⣿⠏⣵⢻⣿⣻⣿⣿⢿⡻⣿⣿⣶⡌⢿⣿⣷⣦⣤⡄",
-	"   ⣤⣶⣾⣿⣿⠏ ⠈⢿⣄ ⢹⣏⠠⠟⣾⣿⣿⣿⣿⣿⠷⣏⣼⠟⢡⣿⡟⠋⢻⣿⣿⡄",
-	"   ⠈⣿⣿⣿⣿⡆   ⣽⢧⡘⠈⠳⣦⣍⠛⠛⢦⣉⣴⣛⣫⣭⣴⡟⠋  ⣾⣿⣿⡿",
-	"   ⢀⠹⣿⣿⣿⣷⣤⡄ ⠋ ⠙⢆ ⣠⠴⠟⠛⣛⣛⣛⠟⠋⠁⠺⡇ ⣀⣴⣿⣿⡟⠁",
-	"   ⠈⣀⠈⠛⠷⠿⣿⣿⣷⣤⣀ ⢠⠋   ⠈⠉⠉    ⣠⣴⣥⠾⠛⠉⣰⣿⣷",
-	"          ⠹⣯⣝⠛⠛⠷⢶⣤⣤⣀   ⢀⡠⠖⠋⠉⢉⣀⣀⣴⣾⣿⠿⠟⠃ ⠠⠦",
-	"⠁       ⠖  ⠘⠻⢿⣦⣄⡀  ⠉⠛⢦⠠⢊⠤⠴⢒⣛⣛⣩⣽⡿⠟⠁⢀⡀",
-	"⠲⠶⣦⠴⠶⠶⠶⠶⡶⠶⢶⣤⣄⡀⠨⠭⠽⠟⣓⢦⣀⠈⢇⡥⠖⠛⠋⠉⠉⠉    ⠈  ⢠⡤",
-	"  ⠈⢷ ⠐⠂⢤⣽⣄ ⠰⡎⠙⠳⣄⡀ ⠈⢣⠘⢦⠋⣀⡬⠟⠛⠛⠉⢀⣀⣀⣠⡤⠄⠃",
-	"   ⠈⢳⣀⡒⠉⠉⣉⠙⡲⣽⣄ ⣏⠳⡄ ⠘⡇ ⡾⠁ ⢀⡤⠖⣻⣿⡏⢡⡎ ⠰⠄",
-	"     ⠛⠻⢦⣄⣉⡁⣀⣀⣈⣙⣺⣌⡇⢠⢀⡇⡾  ⣴⣿⡷⠊ ⢲⣠⠟",
-	"          ⠈⠉    ⠈⠳⡄⣸⢱⠇⢀⣰⣯⣭⣥⠭⠾⠛⠃",
-	"                  ⡷⠡⡯⢖⠉   ⢠⠤",
-	"                ⡠⢊⡴⠤⠂⠃ ⠒",
-	"             ⢀⡴⢪⠔⣉⠔⠋",
-	"               ⠐⠈",
-];
-
-const ROSE_FADE_STEPS = 12;
-const ROSE_FADE_INTERVAL_MS = 45;
-const ROSE_INTRO_HOLD_MS = 180;
-
-function rgb(r: number, g: number, b: number, text: string): string {
-	return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
-}
-
-function italic(text: string): string {
-	return `\x1b[3m${text}\x1b[23m`;
-}
-
-function bold(text: string): string {
-	return `\x1b[1m${text}\x1b[22m`;
-}
-
-function centerLine(line: string, width: number): string {
-	const clipped = truncateToWidth(line, width, "");
-	const padding = Math.max(0, width - visibleWidth(clipped));
-	return `${" ".repeat(Math.floor(padding / 2))}${clipped}`;
-}
-
-function pinkFade(text: string, frame: number): string {
-	const progress = Math.max(0, Math.min(1, frame / ROSE_FADE_STEPS));
-	const eased = 1 - (1 - progress) ** 3;
-	const r = Math.round(72 + (255 - 72) * eased);
-	const g = Math.round(38 + (122 - 38) * eased);
-	const b = Math.round(58 + (198 - 58) * eased);
-	return rgb(r, g, b, text);
-}
-
-function buildGentlemanTitle(width: number, frame: number): string[] {
-	const title = "✧  𝓮𝓵 𝓖𝓮𝓷𝓽𝓵𝓮𝓶𝓪𝓷  ✧";
-	const version = `━━  v${VERSION}  ━━`;
-	return [
-		pinkFade(bold(italic(centerLine(title, width))), frame),
-		pinkFade(italic(centerLine(version, width)), frame),
-	];
-}
-
-function buildRoseHeader(
-	_theme: Theme,
-	width: number,
-	frame: number,
-): string[] {
-	return [
-		"",
-		...ROSE_LOGO_LINES.map((line) => pinkFade(centerLine(line, width), frame)),
-		...buildGentlemanTitle(width, frame),
-		"",
-	];
-}
-
-function installRoseHeader(ctx: ExtensionContext): void {
-	if (!ctx.hasUI) return;
-
-	process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
-
-	let closeIntro: (() => void) | undefined;
-	const closeIntroSafely = () => {
-		const close = closeIntro;
-		closeIntro = undefined;
-		try {
-			close?.();
-		} catch {
-			// Ignore shutdown races during startup/reload.
-		}
-	};
-
-	void ctx.ui
-		.custom((_tui, _theme, _keybindings, done) => {
-			closeIntro = () => done(undefined);
-			return {
-				render: () => [""],
-				invalidate: () => {},
-				handleInput: () => {},
-			};
-		})
-		.catch(() => {
-			closeIntro = undefined;
-		});
-
-	const state: { frame: number; timer?: NodeJS.Timeout } = { frame: 0 };
-	ctx.ui.setHeader((tui, theme) => {
-		if (state.timer) clearInterval(state.timer);
-		state.timer = setInterval(() => {
-			state.frame += 1;
-			tui.requestRender();
-			if (
-				state.frame <
-				ROSE_FADE_STEPS + Math.ceil(ROSE_INTRO_HOLD_MS / ROSE_FADE_INTERVAL_MS)
-			) {
-				return;
-			}
-			if (state.timer) clearInterval(state.timer);
-			state.timer = undefined;
-			closeIntroSafely();
-		}, ROSE_FADE_INTERVAL_MS);
-
-		return {
-			render(width: number): string[] {
-				return buildRoseHeader(theme, width, state.frame);
-			},
-			invalidate() {
-				if (state.timer) clearInterval(state.timer);
-				state.timer = undefined;
-				closeIntroSafely();
-			},
-		};
-	});
-}
-
 function buildGentlePrompt(persona: PersonaMode): string {
 	const personaPrompt =
 		persona === "neutral" ? NEUTRAL_PERSONA_PROMPT : GENTLEMAN_PERSONA_PROMPT;
@@ -911,7 +772,6 @@ async function handlePersonaCommand(ctx: ExtensionContext): Promise<void> {
 
 export default function gentleAi(pi: ExtensionAPI): void {
 	pi.on("session_start", (_event, ctx) => {
-		installRoseHeader(ctx);
 		const result = installSddAssets(ctx.cwd, false);
 		const modelResult = applyModelConfig(ctx.cwd, readModelConfig(ctx.cwd));
 		if (

package/extensions/skill-registry.ts

@@ -147,7 +147,7 @@ function loadSkill(file: string): SkillEntry | undefined {
 		rules:
 			rules.length > 0
 				? rules
-				: ["No compact rules declared; load the full skill file before doing work that matches this trigger."],
+				: ["No compact rules declared; delegators should load the full skill file before direct work, or pass an explicit fallback path only when Project Standards cannot be injected."],
 	};
 }
 
@@ -198,6 +198,12 @@ function renderRegistry(cwd: string, sources: string[], entries: SkillEntry[]):
 		lines.push(`- ${src}`);
 	}
 	lines.push("");
+	lines.push("## Contract");
+	lines.push("");
+	lines.push("**Delegator use only.** Any agent that launches subagents reads this registry to resolve compact rules, then injects matching rule text into subagent prompts under `## Project Standards (auto-resolved)`.");
+	lines.push("");
+	lines.push("Subagents still read their assigned executor/phase skill. During normal runtime, they do **not** independently discover or load additional project/user `SKILL.md` files or this registry; project/user rules arrive pre-digested. Explicit fallback loading is degraded self-healing and must be reported in `skill_resolution` as `fallback-registry` or `fallback-path`.");
+	lines.push("");
 	lines.push(SECTION_MARKER);
 	lines.push("");
 	for (const entry of entries) {

package/extensions/startup-banner.ts

@@ -0,0 +1,463 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { VERSION } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import * as os from "node:os";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const execAsync = promisify(exec);
+
+const TEXT_LOGO = [
+  "                  ▄▄▄▀▀▀▀▀██                                ▄▄▀▄▄           ▄▄█▀▀▀██   ▀▀█▄    ▄▄▄",
+  "              ▄▄█▀▀▒▒▒▒▒▄▄█▀▒                   ▄██     ▄▄█▀█▄█▀▒▒      ▄█▀▀ ▒▒▒▄█▀▀▒   ▄██▒ ▄█▀▒▒▒",
+  "          ▄▄██▀▒▒▒▒▒▄▄▄▀▀▒▒▒▒        ▄▄▄  ▀▀▀▀██▀▀▀▀▀███▀█▄▀▀▒▒▒▒      ██▒▒▒▒▄▄█▀▒▒▒▒▄▄█▀▀▄██▀▒▒▒",
+  "        ▄██▀▒▒▒▒     ▒▒▄▄█ ▄▄▄▀██ ▄▄▄▀▀▀▄  ▄██▀▒▒▒▒▄██▀▀▀▒▄▄███         ▒▒ ▄███▄▄▄█▀▀▀▒▒▄██▀▒▒▒",
+  "       ██▀▒▒▒     ▄▄▄███▀▄██▀▀▀▄▄██▀▀▄█▀▄▄██▀▒▒▒▄▄██▀▒▒▄██▀▀▀▄▄▀▀▀▀▀▀▀▀▀ ▄█▀▀▒▒▒▒▒▒▒▒▒▄██▒▒▒▒",
+  "       ▀█▄▄▄▄▄▀▀▀█▄▄███▄▒▀▀▀▀▀▀▒▀▀▒▒▀▀▀▀▒██▄▄▀▀▀ ▀█▄▀▀▀ ▀▀▀▀▀▒▒▒▒▒▒▒▒▒▒▄██▀▒▒▒       ███▒▒",
+  "        ▒▄▄▄█▀▀▀█▄█▀▀▒▒▒▒ ▒▒▒▒▒▒ ▒▒  ▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒        ▀▀▀▒▒▒          ▒▒▒",
+  "     ▄▄▀▀ ▒▒▒▒▄██▀▒▒▒▒                                                 ▒▒▒",
+  "   ▄█ ▒▒▒▄▄██▀▀▒▒▒▒",
+  "    ▀▀▀▀▀▀▒▒▒▒▒▒",
+  "     ▒▒▒▒▒▒",
+];
+
+const ROSE_LARGE_RAW = [
+  "             ⣠⣾⣷⣶⣦⣤⣤⣄⣠⣄⣀  ⢀⣀⣀",
+  "          ⢀⣴⣿⣿⠿⣋⣭⣭⣯⣭⣍⣭⣿⣟⠛⠛⠿⣿⣷⣄",
+  "      ⢀⣴⣾⡟⢻⣿⡟⠁⣼⣿⠏⣵⢻⣿⣻⣿⣿⢿⡻⣿⣿⣶⡌⢿⣿⣷⣦⣤⡄",
+  "   ⣤⣶⣾⣿⣿⠏ ⠈⢿⣄ ⢹⣏⠠⠟⣾⣿⣿⣿⣿⣿⠷⣏⣼⠟⢡⣿⡟⠋⢻⣿⣿⡄",
+  "   ⠈⣿⣿⣿⣿⡆   ⣽⢧⡘⠈⠳⣦⣍⠛⠛⢦⣉⣴⣛⣫⣭⣴⡟⠋  ⣾⣿⣿⡿",
+  "   ⢀⠹⣿⣿⣿⣷⣤⡄ ⠋ ⠙⢆ ⣠⠴⠟⠛⣛⣛⣛⠟⠋⠁⠺⡇ ⣀⣴⣿⣿⡟⠁",
+  "   ⠈⣀⠈⠛⠷⠿⣿⣿⣷⣤⣀ ⢠⠋   ⠈⠉⠉    ⣠⣴⣥⠾⠛⠉⣰⣿⣷",
+  "          ⠹⣯⣝⠛⠛⠷⢶⣤⣤⣀   ⢀⡠⠖⠋⠉⢉⣀⣀⣴⣾⣿⠿⠟⠃",
+  "             ⠘⠻⢿⣦⣄⡀  ⠉⠛⢦⠠⢊⠤⠴⢒⣛⣛⣩⣽⡿⠟⠁",
+  "        ⠶⢶⣤⣄⡀⠨⠭⠽⠟⣓⢦⣀⠈⢇⡥⠖⠛⠋⠉⠉",
+  "           ⠈⢷ ⠐⠂⢤⣽⣄ ⠰⡎⠙⠳⣄⡀ ⠈⢣⠘⢦⠋",
+  "            ⠈⢳⣀⡒⠉⠉⣉⠙⡲⣽⣄ ⣏⠳⡄ ⠘⡇ ⡾⠁",
+  "              ⠛⠻⢦⣄⣉⡁⣀⣀⣈⣙⣺⣌⡇⢠⢀⡇⡾",
+  "                   ⠈⠉    ⠈⠳⡄⣸⢱⠇",
+  "                           ⡷⠡⡯⢖⠉",
+  "                        ⢀⡴⢪⠔⣉⠔⠋",
+  "                           ⠐⠈",
+];
+
+function rgb(r: number, g: number, b: number, text: string): string {
+  return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+}
+
+function normalizeAscii(lines: string[]): string[] {
+  const trimmed = lines.map((l) => l.replace(/\s+$/g, ""));
+  const nonEmpty = trimmed.filter((l) => l.trim().length > 0);
+  const minLead = nonEmpty.length
+    ? Math.min(...nonEmpty.map((l) => (l.match(/^\s*/) || [""])[0].length))
+    : 0;
+  return trimmed.map((l) => (l.length >= minLead ? l.slice(minLead) : l));
+}
+
+function padLines(lines: string[]): { lines: string[]; width: number } {
+  const width = Math.max(...lines.map((l) => l.length), 0);
+  return { lines: lines.map((l) => l.padEnd(width)), width };
+}
+
+type CellType =
+  | "banner"
+  | "rose"
+  | "label"
+  | "value"
+  | "dim"
+  | "accent"
+  | "none";
+type LayoutCell = { char: string; type: CellType };
+
+class LayoutBuilder {
+  lines: LayoutCell[][] = [];
+
+  addRow() {
+    this.lines.push([]);
+  }
+
+  add(type: CellType, text: string) {
+    const row = this.lines[this.lines.length - 1];
+    for (const char of text) row.push({ char, type });
+  }
+
+  center(width: number) {
+    const row = this.lines[this.lines.length - 1];
+    const pad = Math.max(0, Math.floor((width - row.length) / 2));
+    const prefix = Array.from({ length: pad }, () => ({
+      char: " ",
+      type: "none" as const,
+    }));
+    this.lines[this.lines.length - 1] = prefix.concat(row);
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+
+    // Si se está ejecutando un comando de CLI como "pi update" o "pi install", no mostramos la intro animada.
+    const isCLICommand =
+      process.argv.length > 2 &&
+      !process.argv.every((arg) => arg.startsWith("-") || arg.endsWith(".ts"));
+    if (isCLICommand) return;
+
+    process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+
+    let closeIntro: (() => void) | null = null;
+    const closeIntroSafely = () => {
+      if (!closeIntro) return;
+      const fn = closeIntro;
+      closeIntro = null;
+      try {
+        fn();
+      } catch {}
+    };
+
+    void ctx.ui
+      .custom((_tui, _theme, _keybindings, done) => {
+        closeIntro = () => done(undefined);
+        return {
+          render: () => [""],
+          invalidate: () => {},
+          handleInput: () => {},
+        };
+      })
+      .catch(() => {
+        closeIntro = null;
+      });
+
+    const roseBase = padLines(normalizeAscii(ROSE_LARGE_RAW));
+    const logoBase = padLines(TEXT_LOGO);
+
+    let gitBranch = "Not a git repo";
+    let mcpServersCount = 0;
+    let extensionsCount = 0;
+    let packagesCount = 0;
+
+    const allCommands = pi.getCommands();
+    const skills = allCommands.filter((c) => c.source === "skill");
+    const allTools = pi.getAllTools();
+    const customTools = allTools.filter(
+      (t) => !["builtin", "sdk"].includes(t.sourceInfo.source),
+    );
+
+    setTimeout(() => {
+      execAsync(`git -C "${ctx.cwd}" branch --show-current`)
+        .then(({ stdout }) => {
+          const b = stdout.trim();
+          gitBranch = b ? `On branch ${b}` : "Detached HEAD";
+        })
+        .catch(() => {});
+    }, 100);
+
+    setTimeout(() => {
+      (async () => {
+        try {
+          const raw = await readFile(
+            join(os.homedir(), ".pi", "agent", "mcp.json"),
+            "utf8",
+          );
+          const cfg = JSON.parse(raw);
+          mcpServersCount = Object.keys(cfg.mcpServers || {}).length;
+        } catch {
+          mcpServersCount = 0;
+        }
+      })();
+    }, 150);
+
+    setTimeout(() => {
+      (async () => {
+        try {
+          const raw = await readFile(
+            join(os.homedir(), ".pi", "agent", "settings.json"),
+            "utf8",
+          );
+          const cfg = JSON.parse(raw);
+          extensionsCount = Array.isArray(cfg.extensions)
+            ? cfg.extensions.length
+            : 0;
+          packagesCount = Array.isArray(cfg.packages) ? cfg.packages.length : 0;
+        } catch {
+          extensionsCount = 0;
+          packagesCount = 0;
+        }
+      })();
+    }, 200);
+
+    let tick = 0;
+    const state = { timer: null as NodeJS.Timeout | null };
+
+    setTimeout(() => {
+      ctx.ui.setHeader((tui, theme) => {
+        if (state.timer) clearInterval(state.timer);
+
+        state.timer = setInterval(() => {
+          tick++;
+          if (tick > 90) {
+            if (state.timer) {
+              clearInterval(state.timer);
+              state.timer = null;
+            }
+            closeIntroSafely();
+            return;
+          }
+          try {
+            tui.requestRender();
+          } catch {
+            if (state.timer) {
+              clearInterval(state.timer);
+              state.timer = null;
+            }
+          }
+        }, 50);
+
+        return {
+          render(width: number): string[] {
+            const flashStartTick = 16;
+            const roseOpacity = Math.min(1, tick / 16);
+            const flashPhase =
+              tick >= flashStartTick
+                ? Math.max(0, 1 - (tick - flashStartTick) / 20)
+                : 0;
+            const frame = Math.floor(tick / 2);
+
+            const sideBySideMinWidth = roseBase.width + 3 + logoBase.width + 4;
+            const wideStatsMinWidth = 122;
+            const horizontal = width >= sideBySideMinWidth;
+            const wideStats = width >= wideStatsMinWidth;
+
+            const b = new LayoutBuilder();
+            b.addRow();
+            b.center(width);
+
+            if (horizontal) {
+              const rowCount = Math.max(
+                roseBase.lines.length,
+                logoBase.lines.length,
+              );
+              const roseOffset = Math.max(
+                0,
+                Math.floor((rowCount - roseBase.lines.length) / 2),
+              );
+              const logoOffset = Math.max(
+                0,
+                Math.floor((rowCount - logoBase.lines.length) / 2),
+              );
+
+              for (let i = 0; i < rowCount; i++) {
+                const roseI = i - roseOffset;
+                const logoI = i - logoOffset;
+                const roseLine =
+                  roseI >= 0 && roseI < roseBase.lines.length
+                    ? roseBase.lines[roseI]
+                    : " ".repeat(roseBase.width);
+                const logoLine =
+                  logoI >= 0 && logoI < logoBase.lines.length
+                    ? logoBase.lines[logoI]
+                    : " ".repeat(logoBase.width);
+
+                b.addRow();
+                b.add("rose", roseLine);
+                b.add("none", "   ");
+                b.add("banner", logoLine);
+                b.center(width);
+              }
+            } else {
+              const showBanner = width >= logoBase.width + 2;
+              const showRose = width >= roseBase.width + 2;
+              if (showBanner) {
+                for (const logoLine of logoBase.lines) {
+                  b.addRow();
+                  b.add("banner", logoLine);
+                  b.center(width);
+                }
+                if (showRose) {
+                  b.addRow();
+                  b.center(width);
+                }
+              }
+              if (showRose) {
+                for (const roseLine of roseBase.lines) {
+                  b.addRow();
+                  b.add("rose", roseLine);
+                  b.center(width);
+                }
+              }
+            }
+
+            b.addRow();
+            b.center(width);
+
+            const fit = (v: unknown, w: number) =>
+              String(v ?? "")
+                .replace(/\s+/g, " ")
+                .trim()
+                .slice(0, w)
+                .padEnd(w);
+            const addWideRow = (
+              l1: string,
+              v1: string,
+              l2: string,
+              v2: string,
+            ) => {
+              b.addRow();
+              b.add("label", fit(l1, 10));
+              b.add("none", " ");
+              b.add("value", fit(v1, 48));
+              b.add("none", "   ");
+              b.add("label", fit(l2, 12));
+              b.add("none", " ");
+              b.add("value", fit(v2, 46));
+              b.center(width);
+            };
+            const narrowRows: Array<[string, string]> = [
+              ["GIT:", gitBranch],
+              ["PATH:", ctx.cwd],
+              ["MCP:", `${mcpServersCount} server(s)`],
+              ["PLUGINS:", `${packagesCount} package(s)`],
+              ["AGENTS:", `${skills.length} loaded`],
+              ["EXTENSIONS:", `${extensionsCount} active`],
+              ["VER:", `v${VERSION}`],
+              ["TOOLS:", `${customTools.length} custom`],
+            ];
+            const narrowLabelW = Math.max(...narrowRows.map(([l]) => l.length));
+            const narrowValueW = Math.max(
+              0,
+              Math.min(
+                Math.max(...narrowRows.map(([, v]) => v.length)),
+                Math.max(8, width - narrowLabelW - 4),
+              ),
+            );
+            const addNarrowRow = (label: string, value: string) => {
+              b.addRow();
+              b.add("label", label.padEnd(narrowLabelW));
+              b.add("none", "  ");
+              b.add("value", fit(value, narrowValueW));
+              b.center(width);
+            };
+
+            if (wideStats) {
+              addWideRow("GIT:", gitBranch, "PATH:", ctx.cwd);
+              addWideRow(
+                "MCP:",
+                `${mcpServersCount} server(s)`,
+                "PLUGINS:",
+                `${packagesCount} package(s)`,
+              );
+              addWideRow(
+                "AGENTS:",
+                `${skills.length} loaded`,
+                "EXTENSIONS:",
+                `${extensionsCount} active`,
+              );
+              addWideRow(
+                "VER:",
+                `v${VERSION}`,
+                "TOOLS:",
+                `${customTools.length} custom`,
+              );
+            } else {
+              addNarrowRow("GIT:", gitBranch);
+              addNarrowRow("PATH:", ctx.cwd);
+              addNarrowRow("MCP:", `${mcpServersCount} server(s)`);
+              addNarrowRow("PLUGINS:", `${packagesCount} package(s)`);
+              addNarrowRow("AGENTS:", `${skills.length} loaded`);
+              addNarrowRow("EXTENSIONS:", `${extensionsCount} active`);
+              addNarrowRow("VER:", `v${VERSION}`);
+              addNarrowRow("TOOLS:", `${customTools.length} custom`);
+            }
+
+            b.addRow();
+            b.center(width);
+
+            const out: string[] = [];
+            const layout = b.lines;
+
+            for (let y = 0; y < layout.length; y++) {
+              const row = layout[y] || [];
+              const firstBannerX = row.findIndex((c) => c.type === "banner");
+              let line = "";
+
+              for (let x = 0; x < row.length; x++) {
+                const cell = row[x] || { char: " ", type: "none" as const };
+                if (cell.char === " ") {
+                  line += " ";
+                  continue;
+                }
+
+                if (cell.type === "rose") {
+                  const pulse = 0.9 + Math.sin((x + y + frame) * 0.08) * 0.1;
+                  const k = Math.max(0.01, roseOpacity * pulse);
+                  const f = Math.pow(flashPhase, 0.4);
+
+                  const rBase = Math.floor(255 * k);
+                  const gBase = Math.floor(118 * k);
+                  const bBase = Math.floor(195 * k);
+
+                  if (f > 0.85) {
+                    line += `\x1b[1m\x1b[38;2;255;255;255m${cell.char}\x1b[0m`;
+                  } else {
+                    const r = Math.floor(rBase + (255 - rBase) * f);
+                    const g = Math.floor(gBase + (255 - gBase) * f);
+                    const bColor = Math.floor(bBase + (255 - bBase) * f);
+                    line += rgb(r, g, bColor, cell.char);
+                  }
+                  continue;
+                }
+
+                if (cell.type === "banner") {
+                  if (cell.char === "▒") {
+                    line += rgb(95, 30, 60, cell.char);
+                    continue;
+                  }
+                  const localX = firstBannerX >= 0 ? x - firstBannerX : x;
+                  const sweep = Math.floor((tick - 16) * 2.2);
+                  const isFlashing =
+                    tick >= 16 && localX >= sweep - 4 && localX <= sweep + 2;
+
+                  if (isFlashing) {
+                    line += `\x1b[1m\x1b[38;2;255;255;255m${cell.char}\x1b[0m`;
+                  } else {
+                    line += rgb(255, 120, 198, cell.char);
+                  }
+                  continue;
+                }
+
+                switch (cell.type) {
+                  case "label":
+                    line += rgb(200, 100, 160, cell.char);
+                    break;
+                  case "value":
+                    line += rgb(255, 140, 210, cell.char);
+                    break;
+                  case "dim":
+                    line += theme.fg("dim", cell.char);
+                    break;
+                  case "accent":
+                    line += theme.fg("accent", cell.char);
+                    break;
+                  default:
+                    line += cell.char;
+                }
+              }
+
+              out.push(truncateToWidth(line, Math.max(1, width), ""));
+            }
+
+            return out;
+          },
+          invalidate() {
+            if (state.timer) {
+              clearInterval(state.timer);
+              state.timer = null;
+            }
+            closeIntroSafely();
+          },
+        };
+      });
+    }, 50);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.1.22",
+  "version": "0.2.0",
   "description": "Turn Pi into el Gentleman: a senior-architect development harness with SDD/OpenSpec, subagents, strict TDD evidence, review guardrails, and skill discovery.",
   "license": "MIT",
   "type": "module",
@@ -56,5 +56,8 @@
     "@earendil-works/pi-coding-agent": {
       "optional": true
     }
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
   }
 }