gentle-pi 0.2.4 → 0.2.6

package/README.md

@@ -178,16 +178,35 @@ It scans common roots such as:
 
 ```text
 ./skills
+.opencode/skills
+.claude/skills
+.gemini/skills
+.cursor/skills
+.github/skills
+.codex/skills
+.qwen/skills
+.kiro/skills
+.openclaw/skills
 .pi/skills
 .agent/skills
 .agents/skills
-.claude/skills
-.gemini/skills
+.atl/skills
+~/.pi/agent/skills
+~/.config/agents/skills
+~/.agents/skills
+~/.kimi/skills
 ~/.config/opencode/skills
+~/.config/kilo/skills
 ~/.claude/skills
 ~/.gemini/skills
+~/.gemini/antigravity/skills
 ~/.cursor/skills
 ~/.copilot/skills
+~/.codex/skills
+~/.codeium/windsurf/skills
+~/.qwen/skills
+~/.kiro/skills
+~/.openclaw/skills
 ```
 
 Behavior:
@@ -196,7 +215,7 @@ 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, but delegators should inject project/user compact rules into subagents whenever possible.
+- `## 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.
 
 Skill discovery is a guardrail, not a workflow router: it helps Pi load the right skill without forcing extra ceremony.
 
@@ -331,6 +350,7 @@ pi install .
 Validate before publishing:
 
 ```bash
+pnpm test
 bun build extensions/skill-registry.ts --target=node --format=esm --outfile=/tmp/skill-registry.js
 node --experimental-strip-types --check extensions/gentle-ai.ts
 node --experimental-strip-types --check extensions/sdd-init.ts

package/extensions/skill-registry.ts

@@ -1,7 +1,16 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, watch, writeFileSync } from "node:fs";
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	renameSync,
+	statSync,
+	watch,
+	writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
-import { basename, join, relative } from "node:path";
+import { basename, join, normalize, relative, sep } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 const REGISTRY_REL_PATH = ".atl/skill-registry.md";
@@ -11,7 +20,10 @@ const EXCLUDE_NAMES = new Set(["_shared", "skill-registry"]);
 const EXCLUDE_PREFIXES = ["sdd-"];
 const ATL_IGNORE_ENTRY = ".atl/";
 const WATCH_DEBOUNCE_MS = 500;
-const REGISTRY_SCHEMA_VERSION = 2;
+const REGISTRY_SCHEMA_VERSION = 4;
+const LEGACY_PROJECT_REGISTRY_REL_PATH = ".pi/extensions/skill-registry.ts";
+const LEGACY_PROJECT_REGISTRY_DISABLED_REL_PATH =
+	".pi/extensions/skill-registry.ts.disabled";
 
 interface SkillEntry {
 	name: string;
@@ -24,23 +36,39 @@ function userSkillDirs(): string[] {
 	const home = homedir();
 	return [
 		join(home, ".pi/agent/skills"),
+		join(home, ".config/agents/skills"),
 		join(home, ".agents/skills"),
+		join(home, ".kimi/skills"),
 		join(home, ".config/opencode/skills"),
+		join(home, ".config/kilo/skills"),
 		join(home, ".claude/skills"),
 		join(home, ".gemini/skills"),
+		join(home, ".gemini/antigravity/skills"),
 		join(home, ".cursor/skills"),
 		join(home, ".copilot/skills"),
+		join(home, ".codex/skills"),
+		join(home, ".codeium/windsurf/skills"),
+		join(home, ".qwen/skills"),
+		join(home, ".kiro/skills"),
+		join(home, ".openclaw/skills"),
 	];
 }
 
 function projectSkillDirs(cwd: string): string[] {
 	return [
 		join(cwd, "skills"),
+		join(cwd, ".opencode/skills"),
+		join(cwd, ".claude/skills"),
+		join(cwd, ".gemini/skills"),
+		join(cwd, ".cursor/skills"),
+		join(cwd, ".github/skills"),
+		join(cwd, ".codex/skills"),
+		join(cwd, ".qwen/skills"),
+		join(cwd, ".kiro/skills"),
+		join(cwd, ".openclaw/skills"),
 		join(cwd, ".pi/skills"),
 		join(cwd, ".agent/skills"),
 		join(cwd, ".agents/skills"),
-		join(cwd, ".claude/skills"),
-		join(cwd, ".gemini/skills"),
 		join(cwd, ".atl/skills"),
 	];
 }
@@ -66,7 +94,7 @@ function findSkillFiles(root: string): string[] {
 			}
 		}
 	}
-	return out;
+	return out.sort();
 }
 
 function parseFrontmatter(source: string): { name?: string; description?: string; body: string } {
@@ -90,24 +118,76 @@ function parseFrontmatter(source: string): { name?: string; description?: string
 	return { ...out, body };
 }
 
+const FALLBACK_RULE_HEADINGS = ["Hard Rules", "Critical Rules", "Critical Patterns", "Voice Rules", "Decision Gates"];
+const MAX_EXTRACTED_RULE_COUNT = 15;
+
 function extractCompactRulesSection(body: string): string[] {
-	const lines = body.split("\n");
+	const compactRules = extractRulesFromHeadings(body, ["Compact Rules"]);
+	if (compactRules.length > 0) return compactRules;
+	return extractRulesFromHeadings(body, FALLBACK_RULE_HEADINGS);
+}
+
+function extractRulesFromHeadings(body: string, headings: string[]): string[] {
+	const wanted = new Set(headings.map(normalizeHeading));
 	let inSection = false;
 	const rules: string[] = [];
-	for (const raw of lines) {
+	for (const raw of body.split("\n")) {
 		const line = raw.trimEnd();
-		if (/^##\s+Compact Rules\s*$/i.test(line)) {
-			inSection = true;
+		const heading = line.match(/^##\s+(.+?)\s*$/);
+		if (heading) {
+			inSection = wanted.has(normalizeHeading(heading[1]));
 			continue;
 		}
 		if (!inSection) continue;
-		if (/^##\s+/.test(line)) break;
-		const m = line.match(/^-\s+(.+)$/);
-		if (m) rules.push(m[1].trim());
+		if (/^##\s+/.test(line)) {
+			inSection = false;
+			continue;
+		}
+		const rule = extractRuleLine(line);
+		if (rule) {
+			rules.push(rule);
+			if (rules.length >= MAX_EXTRACTED_RULE_COUNT) return rules;
+		}
 	}
 	return rules;
 }
 
+function extractRuleLine(line: string): string | undefined {
+	const trimmed = line.trim();
+	if (!trimmed) return undefined;
+	const bullet = trimmed.match(/^-\s+(.+)$/);
+	if (bullet) return bullet[1].trim();
+	const ordered = trimmed.match(/^\d+[.)]\s+(.+)$/);
+	if (ordered) return ordered[1].trim();
+	if (trimmed.startsWith("|") && trimmed.endsWith("|")) return extractRuleTableRow(trimmed);
+	return undefined;
+}
+
+function extractRuleTableRow(line: string): string | undefined {
+	const cells = line
+		.slice(1, -1)
+		.split("|")
+		.map((cell) => cell.trim());
+	if (cells.length < 2) return undefined;
+	if (isTableSeparator(cells) || isTableHeader(cells) || !cells[0] || !cells[1]) return undefined;
+	return `${cells[0]}: ${cells[1]}`;
+}
+
+function isTableSeparator(cells: string[]): boolean {
+	return cells.every((cell) => cell.replace(/[\s:-]/g, "") === "");
+}
+
+function isTableHeader(cells: string[]): boolean {
+	if (cells.length < 2) return false;
+	const first = normalizeHeading(cells[0]);
+	const second = normalizeHeading(cells[1]);
+	return (first === "rule" && second === "requirement") || (first === "target" && second === "test pattern");
+}
+
+function normalizeHeading(heading: string): string {
+	return heading.trim().toLowerCase();
+}
+
 function deriveSkillName(file: string, frontmatterName: string | undefined): string {
 	if (frontmatterName) return frontmatterName;
 	return basename(join(file, ".."));
@@ -118,13 +198,19 @@ function isExcluded(name: string): boolean {
 	return EXCLUDE_PREFIXES.some((p) => name.startsWith(p));
 }
 
+function comparablePath(path: string): string {
+	const clean = normalize(path);
+	return clean.length > 1 ? clean.replace(/[\\/]+$/, "") : clean;
+}
+
 function uniqueExistingDirs(dirs: string[]): string[] {
 	const seen = new Set<string>();
 	const out: string[] = [];
 	for (const dir of dirs) {
-		if (seen.has(dir) || !existsSync(dir)) continue;
-		seen.add(dir);
-		out.push(dir);
+		const clean = comparablePath(dir);
+		if (seen.has(clean) || !existsSync(clean)) continue;
+		seen.add(clean);
+		out.push(clean);
 	}
 	return out;
 }
@@ -143,7 +229,7 @@ function loadSkill(file: string): SkillEntry | undefined {
 	return {
 		name,
 		path: file,
-		description: fm.description ?? "",
+		description: extractTriggerDescription(fm.description ?? ""),
 		rules:
 			rules.length > 0
 				? rules
@@ -151,8 +237,14 @@ function loadSkill(file: string): SkillEntry | undefined {
 	};
 }
 
+function extractTriggerDescription(description: string): string {
+	const match = description.match(/\bTrigger:\s*(.+)$/i);
+	return match ? match[1].trim() : description;
+}
+
 function dedupeBySkillName(entries: SkillEntry[], cwd: string): SkillEntry[] {
-	const projectPrefix = cwd.endsWith("/") ? cwd : `${cwd}/`;
+	const cleanCwd = comparablePath(cwd);
+	const projectPrefix = cleanCwd.endsWith(sep) ? cleanCwd : `${cleanCwd}${sep}`;
 	const buckets = new Map<string, SkillEntry[]>();
 	for (const entry of entries) {
 		const list = buckets.get(entry.name) ?? [];
@@ -161,7 +253,7 @@ function dedupeBySkillName(entries: SkillEntry[], cwd: string): SkillEntry[] {
 	}
 	const out: SkillEntry[] = [];
 	for (const [, list] of buckets) {
-		const projectScoped = list.find((e) => e.path.startsWith(projectPrefix));
+		const projectScoped = list.find((e) => comparablePath(e.path).startsWith(projectPrefix));
 		out.push(projectScoped ?? list[0]);
 	}
 	return out.sort((a, b) => a.name.localeCompare(b.name));
@@ -188,7 +280,7 @@ function renderRegistry(cwd: string, sources: string[], entries: SkillEntry[]):
 	const lines: string[] = [];
 	lines.push(`# Skill Registry — ${projectName}`);
 	lines.push("");
-	lines.push("<!-- Auto-generated by .pi/extensions/skill-registry.ts. Run /skill-registry:refresh to regenerate. -->");
+	lines.push("<!-- Auto-generated by gentle-pi extensions/skill-registry.ts. Run /skill-registry:refresh to regenerate. -->");
 	lines.push("");
 	lines.push(`Last updated: ${today}`);
 	lines.push("");
@@ -243,9 +335,50 @@ function ensureAtlIgnored(cwd: string): void {
 	writeFileSync(gitignorePath, `${existing}${prefix}${header}${ATL_IGNORE_ENTRY}\n`);
 }
 
+function isGeneratedLegacyProjectRegistry(source: string): boolean {
+	return (
+		source.includes("Auto-generated by .pi/extensions/skill-registry.ts") &&
+		source.includes("const REGISTRY_REL_PATH = \".atl/skill-registry.md\"") &&
+		source.includes("function projectSkillDirs(cwd: string): string[]") &&
+		source.includes("function regenerateRegistry(cwd: string, force: boolean)") &&
+		(!source.includes('join(cwd, "skills")') ||
+			source.includes("const dirs = [...userSkillDirs(), ...projectSkillDirs(cwd)]") ||
+			source.includes("if (rules.length === 0) return undefined"))
+	);
+}
+
+function nextLegacyDisabledPath(cwd: string): string {
+	const base = join(cwd, LEGACY_PROJECT_REGISTRY_DISABLED_REL_PATH);
+	if (!existsSync(base)) return base;
+	for (let i = 1; i < 100; i++) {
+		const candidate = `${base}.${i}`;
+		if (!existsSync(candidate)) return candidate;
+	}
+	return `${base}.${Date.now()}`;
+}
+
+function quarantineLegacyProjectRegistry(cwd: string): boolean {
+	const legacyPath = join(cwd, LEGACY_PROJECT_REGISTRY_REL_PATH);
+	if (!existsSync(legacyPath)) return false;
+	let source = "";
+	try {
+		source = readFileSync(legacyPath, "utf8");
+	} catch {
+		return false;
+	}
+	if (!isGeneratedLegacyProjectRegistry(source)) return false;
+	const disabledPath = nextLegacyDisabledPath(cwd);
+	try {
+		renameSync(legacyPath, disabledPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 function regenerateRegistry(cwd: string, force: boolean): RegenResult {
 	const existingDirs = uniqueExistingDirs([...projectSkillDirs(cwd), ...userSkillDirs()]);
-	const files = existingDirs.flatMap(findSkillFiles).sort();
+	const files = existingDirs.flatMap(findSkillFiles);
 	const cachePath = join(cwd, CACHE_REL_PATH);
 	const registryPath = join(cwd, REGISTRY_REL_PATH);
 	const fp = fingerprint(files);
@@ -304,17 +437,42 @@ function startSkillRegistryWatcher(cwd: string, notify: (message: string) => voi
 	}
 }
 
+export const __testing = {
+	projectSkillDirs,
+	userSkillDirs,
+	extractCompactRulesSection,
+	extractTriggerDescription,
+	uniqueExistingDirs,
+	dedupeBySkillName,
+};
+
 export default function (pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		try {
 			ensureAtlIgnored(ctx.cwd);
-			const result = regenerateRegistry(ctx.cwd, false);
+			const quarantinedLegacy = quarantineLegacyProjectRegistry(ctx.cwd);
+			const result = regenerateRegistry(ctx.cwd, quarantinedLegacy);
 			if (result.regenerated && ctx.hasUI) {
 				ctx.ui.notify(`Skill registry refreshed (${result.skillCount} skills)`, "info");
 			}
+			if (quarantinedLegacy && ctx.hasUI) {
+				ctx.ui.notify(
+					"Disabled stale project-local skill registry extension; using package registry with project skills first.",
+					"warning",
+				);
+			}
 			startSkillRegistryWatcher(ctx.cwd, (message) => {
 				if (ctx.hasUI) ctx.ui.notify(message, "info");
 			});
+			if (quarantinedLegacy) {
+				setTimeout(() => {
+					try {
+						regenerateRegistry(ctx.cwd, true);
+					} catch {
+						// Best-effort same-session self-heal in case the stale extension already ran.
+					}
+				}, WATCH_DEBOUNCE_MS);
+			}
 		} catch (error) {
 			if (ctx.hasUI) {
 				const message = error instanceof Error ? error.message : String(error);

package/extensions/startup-banner.ts

@@ -63,6 +63,9 @@ function padLines(lines: string[]): { lines: string[]; width: number } {
 
 type CellType =
   | "banner"
+  | "logo-tip"
+  | "logo-fresh"
+  | "logo-ink"
   | "rose"
   | "label"
   | "value"
@@ -70,6 +73,280 @@ type CellType =
   | "accent"
   | "none";
 type LayoutCell = { char: string; type: CellType };
+type LogoCellType = Extract<
+  CellType,
+  "banner" | "logo-tip" | "logo-fresh" | "logo-ink"
+>;
+
+const LOGO_CELL_TYPES: ReadonlySet<CellType> = new Set<CellType>([
+  "banner",
+  "logo-tip",
+  "logo-fresh",
+  "logo-ink",
+]);
+
+function isLogoCellType(type: CellType): type is LogoCellType {
+  return LOGO_CELL_TYPES.has(type);
+}
+
+type Span = { start: number; end: number };
+
+function computeLogoBounds(lines: string[]): Span {
+  let start = Number.POSITIVE_INFINITY;
+  let end = Number.NEGATIVE_INFINITY;
+  for (const line of lines) {
+    for (let i = 0; i < line.length; i++) {
+      if (line[i] !== " ") {
+        if (i < start) start = i;
+        if (i > end) end = i;
+      }
+    }
+  }
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    return { start: 0, end: 0 };
+  }
+  return { start, end };
+}
+
+function buildLetterSpans(bounds: Span, weights: number[]): Span[] {
+  const spanWidth = Math.max(1, bounds.end - bounds.start + 1);
+  const total = weights.reduce((a, b) => a + b, 0);
+  let cursor = bounds.start;
+  return weights.map((w, i) => {
+    const remaining = bounds.end - cursor + 1;
+    const raw = Math.max(1, Math.round((w / total) * spanWidth));
+    const width =
+      i === weights.length - 1
+        ? remaining
+        : Math.min(raw, remaining - (weights.length - i - 1));
+    const s = cursor;
+    const e = s + width - 1;
+    cursor = e + 1;
+    return { start: s, end: e };
+  });
+}
+
+const LOGO_BOUNDS = computeLogoBounds(TEXT_LOGO);
+const LETTER_WEIGHTS = [14, 10, 11, 10, 9, 11, 6, 13, 12]; // G E N T L E - P I
+const LETTER_SPANS = buildLetterSpans(LOGO_BOUNDS, LETTER_WEIGHTS);
+
+function letterIndexAtX(x: number): number {
+  for (let i = 0; i < LETTER_SPANS.length; i++) {
+    const s = LETTER_SPANS[i];
+    if (x >= s.start && x <= s.end) return i;
+  }
+  if (x < LETTER_SPANS[0].start) return 0;
+  return LETTER_SPANS.length - 1;
+}
+
+type Point = { x: number; y: number };
+
+function pointKey(x: number, y: number): string {
+  return `${x}:${y}`;
+}
+
+function buildLetterStrokeMap(letterIdx: number): { orderMap: Map<string, number>; maxOrder: number } {
+  const span = LETTER_SPANS[letterIdx];
+  const points: Point[] = [];
+  const pointSet = new Set<string>();
+
+  for (let y = 0; y < TEXT_LOGO.length; y++) {
+    const line = TEXT_LOGO[y] ?? "";
+    for (let x = span.start; x <= Math.min(span.end, line.length - 1); x++) {
+      if (line[x] !== " ") {
+        points.push({ x, y });
+        pointSet.add(pointKey(x, y));
+      }
+    }
+  }
+
+  const neighbors8 = [
+    [-1, -1], [0, -1], [1, -1],
+    [-1, 0],           [1, 0],
+    [-1, 1],  [0, 1],  [1, 1],
+  ] as const;
+
+  const visited = new Set<string>();
+  const components: Point[][] = [];
+
+  for (const p of points) {
+    const k = pointKey(p.x, p.y);
+    if (visited.has(k)) continue;
+
+    const stack = [p];
+    const comp: Point[] = [];
+    visited.add(k);
+
+    while (stack.length > 0) {
+      const cur = stack.pop()!;
+      comp.push(cur);
+      for (const [dx, dy] of neighbors8) {
+        const nk = pointKey(cur.x + dx, cur.y + dy);
+        if (!visited.has(nk) && pointSet.has(nk)) {
+          visited.add(nk);
+          stack.push({ x: cur.x + dx, y: cur.y + dy });
+        }
+      }
+    }
+
+    components.push(comp);
+  }
+
+  components.sort((a, b) => {
+    const ax = Math.min(...a.map((p) => p.x));
+    const bx = Math.min(...b.map((p) => p.x));
+    if (ax !== bx) return ax - bx;
+    const ay = Math.min(...a.map((p) => p.y));
+    const by = Math.min(...b.map((p) => p.y));
+    return ay - by;
+  });
+
+  const orderMap = new Map<string, number>();
+  let order = 0;
+
+  for (const comp of components) {
+    const compSet = new Set(comp.map((p) => pointKey(p.x, p.y)));
+    const compMap = new Map(comp.map((p) => [pointKey(p.x, p.y), p]));
+
+    let current = comp.reduce((best, p) =>
+      p.x < best.x || (p.x === best.x && p.y < best.y) ? p : best,
+    );
+
+    let dirX = 1;
+    let dirY = 0;
+
+    while (compSet.size > 0) {
+      const ck = pointKey(current.x, current.y);
+      if (compSet.has(ck)) {
+        compSet.delete(ck);
+        orderMap.set(ck, order++);
+      }
+      if (compSet.size === 0) break;
+
+      const candidates: Point[] = [];
+      for (let dy = -2; dy <= 2; dy++) {
+        for (let dx = -2; dx <= 2; dx++) {
+          if (dx === 0 && dy === 0) continue;
+          const nk = pointKey(current.x + dx, current.y + dy);
+          if (compSet.has(nk)) {
+            const point = compMap.get(nk);
+            if (point) candidates.push(point);
+          }
+        }
+      }
+
+      let next: Point | null = null;
+      if (candidates.length > 0) {
+        candidates.sort((a, b) => {
+          const adx = a.x - current.x;
+          const ady = a.y - current.y;
+          const bdx = b.x - current.x;
+          const bdy = b.y - current.y;
+
+          const aDist = Math.hypot(adx, ady);
+          const bDist = Math.hypot(bdx, bdy);
+          const aTurn = Math.abs(adx * dirY - ady * dirX);
+          const bTurn = Math.abs(bdx * dirY - bdy * dirX);
+
+          const aScore = aDist * 3.8 + aTurn * 1.3 + Math.abs(ady) * 0.12;
+          const bScore = bDist * 3.8 + bTurn * 1.3 + Math.abs(bdy) * 0.12;
+          return aScore - bScore;
+        });
+        next = candidates[0];
+      } else {
+        let best: Point | null = null;
+        let bestScore = Number.POSITIVE_INFINITY;
+        for (const k of compSet) {
+          const p = compMap.get(k);
+          if (!p) continue;
+          const dx = p.x - current.x;
+          const dy = p.y - current.y;
+          const score = Math.hypot(dx, dy) + Math.abs(dy) * 0.16;
+          if (score < bestScore) {
+            bestScore = score;
+            best = p;
+          }
+        }
+        next = best;
+      }
+
+      if (!next) break;
+      dirX = next.x - current.x;
+      dirY = next.y - current.y;
+      current = next;
+    }
+  }
+
+  return { orderMap, maxOrder: Math.max(1, order - 1) };
+}
+
+const LETTER_STROKES = LETTER_SPANS.map((_, i) => buildLetterStrokeMap(i));
+const WRITING_START_TICK = 6;
+const LETTER_TICKS = LETTER_STROKES.map((s) =>
+  Math.max(5, Math.ceil(((s.maxOrder + 8) / 11) * 0.48)),
+);
+const LETTER_START_TICKS = LETTER_TICKS.map((_, i) =>
+  WRITING_START_TICK + LETTER_TICKS.slice(0, i).reduce((a, b) => a + b, 0),
+);
+const WRITING_END_TICK = WRITING_START_TICK + LETTER_TICKS.reduce((a, b) => a + b, 0);
+
+function buildPenLogoLine(
+  line: string,
+  rowIdx: number,
+  _totalRows: number,
+  tick: number,
+): LayoutCell[] {
+  const out: LayoutCell[] = [];
+
+  for (let x = 0; x < line.length; x++) {
+    const ch = line[x] ?? " ";
+    if (ch === " ") {
+      out.push({ char: " ", type: "none" });
+      continue;
+    }
+
+    const letterIdx = letterIndexAtX(x);
+    const stroke = LETTER_STROKES[letterIdx];
+    const startTick = LETTER_START_TICKS[letterIdx];
+    const duration = LETTER_TICKS[letterIdx];
+    const progress = (tick - startTick) / Math.max(1, duration);
+
+    if (progress < 0) {
+      out.push({ char: " ", type: "none" });
+      continue;
+    }
+
+    const head = progress * (stroke.maxOrder + 7);
+    const rawOrder = stroke.orderMap.get(pointKey(x, rowIdx));
+    if (rawOrder === undefined) {
+      out.push({ char: " ", type: "none" });
+      continue;
+    }
+
+    let order = rawOrder;
+    // v1: ajuste SOLO para la primera letra (G), con más curvatura caligráfica.
+    if (letterIdx === 0) {
+      const s = LETTER_SPANS[0];
+      const w = Math.max(1, s.end - s.start + 1);
+      const localX = x - s.start;
+      const curveBias =
+        Math.sin((localX / w) * Math.PI * 1.35 + rowIdx * 0.26) * 2.2 +
+        Math.cos((localX / w) * Math.PI * 0.72 - rowIdx * 0.20) * 1.3;
+      order = rawOrder + curveBias;
+    }
+
+    if (head < order) {
+      out.push({ char: " ", type: "none" });
+      continue;
+    }
+
+    const age = head - order;
+    if (age < 1.2) out.push({ char: ch, type: "logo-tip" });
+    else if (age < 4.9) out.push({ char: ch, type: "logo-fresh" });
+    else out.push({ char: ch, type: "logo-ink" });
+  }
+  return out;
+}
 
 class LayoutBuilder {
   lines: LayoutCell[][] = [];
@@ -106,10 +383,6 @@ export default function (pi: ExtensionAPI) {
 
     process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
 
-    const finishIntro = () => {
-      ctx.ui.setHeader(undefined);
-    };
-
     const roseBase = padLines(normalizeAscii(ROSE_LARGE_RAW));
     const logoBase = padLines(TEXT_LOGO);
 
@@ -177,12 +450,11 @@ export default function (pi: ExtensionAPI) {
 
         state.timer = setInterval(() => {
           tick++;
-          if (tick > 90) {
+          if (tick > WRITING_END_TICK + 22) {
             if (state.timer) {
               clearInterval(state.timer);
               state.timer = null;
             }
-            finishIntro();
             return;
           }
           try {
@@ -193,15 +465,15 @@ export default function (pi: ExtensionAPI) {
               state.timer = null;
             }
           }
-        }, 50);
+        }, 25);
 
         return {
           render(width: number): string[] {
-            const flashStartTick = 16;
-            const roseOpacity = Math.min(1, tick / 16);
+            const flashStartTick = 10;
+            const roseOpacity = Math.min(1, tick / 10);
             const flashPhase =
               tick >= flashStartTick
-                ? Math.max(0, 1 - (tick - flashStartTick) / 20)
+                ? Math.max(0, 1 - (tick - flashStartTick) / 12)
                 : 0;
             const frame = Math.floor(tick / 2);
 
@@ -243,16 +515,35 @@ export default function (pi: ExtensionAPI) {
                 b.addRow();
                 b.add("rose", roseLine);
                 b.add("none", "   ");
-                b.add("banner", logoLine);
+                if (logoI >= 0 && logoI < logoBase.lines.length) {
+                  b.lines[b.lines.length - 1].push(
+                    ...buildPenLogoLine(
+                      logoLine,
+                      logoI,
+                      logoBase.lines.length,
+                      tick,
+                    ),
+                  );
+                } else {
+                  b.add("none", " ".repeat(logoBase.width));
+                }
                 b.center(width);
               }
             } else {
               const showBanner = width >= logoBase.width + 2;
               const showRose = width >= roseBase.width + 2;
               if (showBanner) {
-                for (const logoLine of logoBase.lines) {
+                for (let logoI = 0; logoI < logoBase.lines.length; logoI++) {
+                  const logoLine = logoBase.lines[logoI];
                   b.addRow();
-                  b.add("banner", logoLine);
+                  b.lines[b.lines.length - 1].push(
+                    ...buildPenLogoLine(
+                      logoLine,
+                      logoI,
+                      logoBase.lines.length,
+                      tick,
+                    ),
+                  );
                   b.center(width);
                 }
                 if (showRose) {
@@ -357,9 +648,46 @@ export default function (pi: ExtensionAPI) {
             const out: string[] = [];
             const layout = b.lines;
 
+            const logoRows = layout
+              .map((row, idx) => ({
+                idx,
+                hasLogo: (row || []).some((c) => isLogoCellType(c.type)),
+              }))
+              .filter((r) => r.hasLogo)
+              .map((r) => r.idx);
+            const sparkleY =
+              logoRows.length > 0
+                ? logoRows[Math.floor(logoRows.length / 2)]
+                : -1;
+            const logoLastX = Math.max(
+              -1,
+              ...layout.map((row) => {
+                let last = -1;
+                for (let i = 0; i < (row || []).length; i++) {
+                  const cell = row?.[i];
+                  if (cell && isLogoCellType(cell.type) && cell.char !== " ") {
+                    last = i;
+                  }
+                }
+                return last;
+              }),
+            );
+
+            const glintStartTick = WRITING_END_TICK + 3;
+            const glintEndTick = WRITING_END_TICK + 12;
+            const glintActive = tick >= glintStartTick && tick <= glintEndTick;
+            const glintHead =
+              ((tick - glintStartTick) /
+                Math.max(1, glintEndTick - glintStartTick)) *
+              (LOGO_BOUNDS.end - LOGO_BOUNDS.start + 1);
+            const sparkleActive =
+              tick >= WRITING_END_TICK + 13 && tick <= WRITING_END_TICK + 20;
+
             for (let y = 0; y < layout.length; y++) {
               const row = layout[y] || [];
-              const firstBannerX = row.findIndex((c) => c.type === "banner");
+              const firstLogoX = row.findIndex(
+                (c) => isLogoCellType(c.type) && c.char !== " ",
+              );
               let line = "";
 
               for (let x = 0; x < row.length; x++) {
@@ -389,20 +717,37 @@ export default function (pi: ExtensionAPI) {
                   continue;
                 }
 
-                if (cell.type === "banner") {
-                  if (cell.char === "▒") {
-                    line += rgb(95, 30, 60, cell.char);
+                if (isLogoCellType(cell.type)) {
+                  const localLogoX = firstLogoX >= 0 ? x - firstLogoX : x;
+                  const glintOnCell =
+                    glintActive &&
+                    localLogoX >= glintHead - 2 &&
+                    localLogoX <= glintHead + 1;
+                  const sparkleOnCell =
+                    sparkleActive &&
+                    y === sparkleY &&
+                    (x === logoLastX || x === logoLastX - 1);
+
+                  if (sparkleOnCell) {
+                    line += `\x1b[1m` + rgb(255, 255, 255, "✦") + `\x1b[22m`;
                     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`;
+                  if (glintOnCell) {
+                    line += `\x1b[1m` + rgb(255, 245, 252, cell.char) + `\x1b[22m`;
+                    continue;
+                  }
+
+                  if (cell.type === "logo-tip") {
+                    line += `\x1b[1m` + rgb(255, 205, 238, cell.char) + `\x1b[22m`;
+                  } else if (cell.type === "logo-fresh") {
+                    line += cell.char === "▒"
+                      ? rgb(110, 36, 70, cell.char)
+                      : rgb(255, 138, 206, cell.char);
                   } else {
-                    line += rgb(255, 120, 198, cell.char);
+                    line += cell.char === "▒"
+                      ? rgb(95, 30, 60, cell.char)
+                      : rgb(255, 120, 198, cell.char);
                   }
                   continue;
                 }
@@ -435,7 +780,6 @@ export default function (pi: ExtensionAPI) {
               clearInterval(state.timer);
               state.timer = null;
             }
-            finishIntro();
           },
         };
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "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",
@@ -28,11 +28,13 @@
     "prompts/",
     "skills/",
     "scripts/",
+    "tests/",
     "README.md"
   ],
   "scripts": {
-    "prepack": "node scripts/verify-package-files.mjs",
-    "prepublishOnly": "node scripts/verify-package-files.mjs"
+    "test": "node --experimental-strip-types --test tests/*.test.ts",
+    "prepack": "pnpm test && node scripts/verify-package-files.mjs",
+    "prepublishOnly": "pnpm test && node scripts/verify-package-files.mjs"
   },
   "pi": {
     "image": "https://cdn.jsdelivr.net/npm/gentle-pi/assets/gentle-logo-only.png",

package/tests/skill-registry.test.ts

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { __testing } from "../extensions/skill-registry.ts";
+
+test("project skill dirs include supported workspace roots", () => {
+	const cwd = "/repo";
+	const dirs = __testing.projectSkillDirs(cwd);
+	for (const want of [
+		"skills",
+		".opencode/skills",
+		".claude/skills",
+		".gemini/skills",
+		".cursor/skills",
+		".github/skills",
+		".codex/skills",
+		".qwen/skills",
+		".kiro/skills",
+		".openclaw/skills",
+		".pi/skills",
+		".agent/skills",
+		".agents/skills",
+		".atl/skills",
+	]) {
+		assert.ok(dirs.includes(join(cwd, want)), `missing ${want}`);
+	}
+});
+
+test("Compact Rules are preferred over fallback sections", () => {
+	const rules = __testing.extractCompactRulesSection(`## Compact Rules
+
+- Explicit compact rule.
+
+## Hard Rules
+
+- Hard rule should not be copied.
+`);
+
+	assert.deepEqual(rules, ["Explicit compact rule."]);
+});
+
+test("LLM-first and legacy sections extract bullets, ordered lists, and tables", () => {
+	const rules = __testing.extractCompactRulesSection(`## Hard Rules
+
+- Prefer focused tests.
+
+## Critical Rules
+
+1. Link an approved issue.
+2. Keep PRs within review budget.
+
+## Voice Rules
+
+| Rule | Requirement |
+|------|-------------|
+| Be warm | Sound like a teammate. |
+
+## Decision Gates
+
+| Target | Test pattern |
+|---|---|
+| File operations | Use t.TempDir(). |
+`);
+
+	assert.deepEqual(rules, [
+		"Prefer focused tests.",
+		"Link an approved issue.",
+		"Keep PRs within review budget.",
+		"Be warm: Sound like a teammate.",
+		"File operations: Use t.TempDir().",
+	]);
+});
+
+test("description trigger text is extracted when present", () => {
+	assert.equal(
+		__testing.extractTriggerDescription("Write comments. Trigger: PR feedback, issue replies."),
+		"PR feedback, issue replies.",
+	);
+	assert.equal(__testing.extractTriggerDescription("No explicit trigger."), "No explicit trigger.");
+});
+
+test("fallback extraction is capped at 15 rules", () => {
+	const body = `## Hard Rules
+
+${Array.from({ length: 16 }, (_, i) => `- Rule ${String(i + 1).padStart(2, "0")}.`).join("\n")}
+`;
+	const rules = __testing.extractCompactRulesSection(body);
+
+	assert.equal(rules.length, 15);
+	assert.equal(rules.at(-1), "Rule 15.");
+});
+
+test("project-scoped duplicate wins over user duplicate", () => {
+	const cwd = join(tmpdir(), `gentle-pi-registry-${Date.now()}`);
+	const projectPath = join(cwd, ".opencode/skills/dup/SKILL.md");
+	const userPath = join(cwd + "-home", ".config/opencode/skills/dup/SKILL.md");
+	const entries = [
+		{ name: "dup", path: userPath, description: "user", rules: ["User rule."] },
+		{ name: "dup", path: projectPath, description: "project", rules: ["Project rule."] },
+	];
+
+	const [chosen] = __testing.dedupeBySkillName(entries, cwd);
+	assert.equal(chosen.path, projectPath);
+});
+
+test("uniqueExistingDirs normalizes duplicates and ignores missing roots", () => {
+	const root = join(tmpdir(), `gentle-pi-existing-${Date.now()}`);
+	const existing = join(root, "skills");
+	mkdirSync(existing, { recursive: true });
+
+	assert.deepEqual(__testing.uniqueExistingDirs([existing, join(root, "skills/"), join(root, "missing")]), [existing]);
+});