gentle-pi 0.2.5 → 0.2.7

package/README.md

@@ -178,25 +178,45 @@ 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:
 
 - `.atl/` is added to `.gitignore` when needed;
 - the registry refreshes on session start;
+- startup refresh is skipped when Pi starts with `--no-skills` / `-ns`, `--no-skill-registry`, or `GENTLE_PI_NO_SKILL_REGISTRY=1`;
 - `/skill-registry:refresh` forces regeneration;
 - a best-effort watcher refreshes when skill files change;
-- 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.
 
@@ -266,6 +286,14 @@ Saved at:
 | `/gentle-ai:install-sdd --force` | Force-refreshes installed SDD assets.                        |
 | `/skill-registry:refresh`        | Regenerates `.atl/skill-registry.md`.                        |
 
+Startup flag:
+
+```text
+pi --no-skill-registry
+```
+
+Use it when you want skills available normally but do not want Gentle AI to refresh/watch `.atl/skill-registry.md` on startup. `pi -ns` / `pi --no-skills` also skip the registry startup work because Pi is already disabling skill loading.
+
 Compatibility aliases:
 
 ```text
@@ -331,6 +359,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/assets/orchestrator.md

@@ -31,6 +31,8 @@ User-facing conversation should stay in the user's language and follow the curre
 
 Subagent-facing prompts should be written in English by default, even when the user speaks Spanish. Translate the user's request into concise English before delegation. This keeps token usage lower and gives built-in/project subagents a consistent operating language without changing the user-facing persona.
 
+Generated artifacts — whether by the parent inline or by subagents — (code, UI copy, comments, identifiers, commit messages, filenames, PR descriptions) default to English, regardless of the user's conversation language. Override only when the user explicitly requests another language for that artifact, or when extending a project whose existing convention is non-English.
+
 Exceptions:
 
 - Preserve exact user quotes, UI copy, error messages, filenames, commands, and domain terms in their original language when they are evidence.

package/extensions/gentle-ai.ts

@@ -471,15 +471,19 @@ class SddModelPanel implements OverlayComponent {
 	private query = "";
 	private readonly draft: AgentModelConfig;
 	private readonly rows: string[];
+	private readonly modelOptions: string[];
+	private readonly done: (result: ModelPanelResult) => void;
 
 	constructor(
 		initialConfig: AgentModelConfig,
-		private readonly modelOptions: string[],
+		modelOptions: string[],
 		agents: string[],
-		private readonly done: (result: ModelPanelResult) => void,
+		done: (result: ModelPanelResult) => void,
 	) {
 		this.draft = { ...initialConfig };
 		this.rows = [SET_ALL_AGENTS, ...agents];
+		this.modelOptions = modelOptions;
+		this.done = done;
 	}
 
 	invalidate(): void {}

package/extensions/skill-registry.ts

@@ -10,7 +10,7 @@ import {
 	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";
@@ -20,7 +20,9 @@ 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 = 3;
+const REGISTRY_SCHEMA_VERSION = 4;
+const NO_SKILL_REGISTRY_FLAG = "no-skill-registry";
+const NO_SKILL_REGISTRY_ENV = "GENTLE_PI_NO_SKILL_REGISTRY";
 const LEGACY_PROJECT_REGISTRY_REL_PATH = ".pi/extensions/skill-registry.ts";
 const LEGACY_PROJECT_REGISTRY_DISABLED_REL_PATH =
 	".pi/extensions/skill-registry.ts.disabled";
@@ -36,23 +38,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"),
 	];
 }
@@ -78,7 +96,7 @@ function findSkillFiles(root: string): string[] {
 			}
 		}
 	}
-	return out;
+	return out.sort();
 }
 
 function parseFrontmatter(source: string): { name?: string; description?: string; body: string } {
@@ -102,24 +120,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, ".."));
@@ -130,13 +200,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;
 }
@@ -155,7 +231,7 @@ function loadSkill(file: string): SkillEntry | undefined {
 	return {
 		name,
 		path: file,
-		description: fm.description ?? "",
+		description: extractTriggerDescription(fm.description ?? ""),
 		rules:
 			rules.length > 0
 				? rules
@@ -163,8 +239,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) ?? [];
@@ -173,7 +255,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));
@@ -298,7 +380,7 @@ function quarantineLegacyProjectRegistry(cwd: string): boolean {
 
 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);
@@ -330,6 +412,26 @@ function regenerateRegistry(cwd: string, force: boolean): RegenResult {
 
 const watchedCwds = new Set<string>();
 
+function isTruthyEnv(value: string | undefined): boolean {
+	return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+
+function hasCliArg(args: string[], ...names: string[]): boolean {
+	return args.some((arg) => names.includes(arg));
+}
+
+function shouldSkipSkillRegistryStartup(
+	pi: Pick<ExtensionAPI, "getFlag">,
+	argv = process.argv.slice(2),
+	env = process.env,
+): boolean {
+	return (
+		pi.getFlag(NO_SKILL_REGISTRY_FLAG) === true ||
+		isTruthyEnv(env[NO_SKILL_REGISTRY_ENV]) ||
+		hasCliArg(argv, "--no-skills", "-ns")
+	);
+}
+
 function startSkillRegistryWatcher(cwd: string, notify: (message: string) => void): void {
 	if (watchedCwds.has(cwd)) return;
 	watchedCwds.add(cwd);
@@ -357,8 +459,25 @@ function startSkillRegistryWatcher(cwd: string, notify: (message: string) => voi
 	}
 }
 
+export const __testing = {
+	projectSkillDirs,
+	userSkillDirs,
+	extractCompactRulesSection,
+	extractTriggerDescription,
+	uniqueExistingDirs,
+	dedupeBySkillName,
+	shouldSkipSkillRegistryStartup,
+};
+
 export default function (pi: ExtensionAPI) {
+	pi.registerFlag(NO_SKILL_REGISTRY_FLAG, {
+		description: "Skip the Gentle AI skill registry refresh and watcher on startup.",
+		type: "boolean",
+		default: false,
+	});
+
 	pi.on("session_start", async (_event, ctx) => {
+		if (shouldSkipSkillRegistryStartup(pi)) return;
 		try {
 			ensureAtlIgnored(ctx.cwd);
 			const quarantinedLegacy = quarantineLegacyProjectRegistry(ctx.cwd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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,14 @@
     "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 && pnpm run test:harness",
+    "test:harness": "node --experimental-strip-types tests/runtime-harness.mjs",
+    "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/runtime-harness.mjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const EXTENSIONS = [
+	"extensions/gentle-ai.ts",
+	"extensions/skill-registry.ts",
+	"extensions/sdd-init.ts",
+	"extensions/startup-banner.ts",
+];
+
+const EXPECTED_COMMANDS = [
+	"gentle-ai:install-sdd",
+	"gentle:models",
+	"gentle-ai:models",
+	"gentleman:models",
+	"gentle:persona",
+	"gentle-ai:persona",
+	"gentleman:persona",
+	"gentle-ai:status",
+	"sdd-init",
+	"skill-registry:refresh",
+];
+
+function createPi() {
+	const hooks = new Map();
+	const commands = new Map();
+	const flags = new Map();
+	const flagValues = new Map([["no-skill-registry", true]]);
+
+	const pi = {
+		on(name, handler) {
+			const list = hooks.get(name) ?? [];
+			list.push(handler);
+			hooks.set(name, list);
+		},
+		registerCommand(name, definition) {
+			commands.set(name, definition);
+		},
+		registerFlag(name, definition) {
+			flags.set(name, definition);
+		},
+		getFlag(name) {
+			return flagValues.get(name) ?? false;
+		},
+		setFlag(name, value) {
+			flagValues.set(name, value);
+		},
+		getCommands() {
+			return Array.from(commands, ([name, definition]) => ({ name, ...definition }));
+		},
+		getAllTools() {
+			return [
+				{ name: "read" },
+				{ name: "bash" },
+				{ name: "edit" },
+				{ name: "write" },
+			];
+		},
+	};
+
+	return { pi, hooks, commands, flags };
+}
+
+function createUi() {
+	const notifications = [];
+	return {
+		notifications,
+		notify(message, level = "info") {
+			notifications.push({ message, level });
+		},
+		async confirm() {
+			return false;
+		},
+		async select(_label, options) {
+			return options[0];
+		},
+		async input(_label, placeholder) {
+			return placeholder;
+		},
+		custom() {
+			return Promise.resolve({ type: "cancel" });
+		},
+	};
+}
+
+function createCtx(cwd, hasUI = false) {
+	return {
+		cwd,
+		hasUI,
+		ui: createUi(),
+		modelRegistry: {
+			async getAvailable() {
+				return [];
+			},
+		},
+	};
+}
+
+async function tempWorkspace() {
+	return mkdtemp(join(tmpdir(), "gentle-pi-runtime-"));
+}
+
+async function loadExtensions(pi) {
+	for (const [index, rel] of EXTENSIONS.entries()) {
+		const mod = await import(`${pathToFileURL(join(ROOT, rel)).href}?runtime-harness=${index}`);
+		assert.equal(typeof mod.default, "function", `${rel} must export a default function`);
+		mod.default(pi);
+	}
+}
+
+async function run() {
+	const { pi, hooks, commands, flags } = createPi();
+	await loadExtensions(pi);
+
+	for (const name of EXPECTED_COMMANDS) {
+		assert.ok(commands.has(name), `missing command ${name}`);
+	}
+	assert.ok(flags.has("no-skill-registry"), "missing no-skill-registry flag");
+	assert.ok(hooks.has("session_start"), "missing session_start hook");
+	assert.ok(hooks.has("before_agent_start"), "missing before_agent_start hook");
+	assert.ok(hooks.has("tool_call"), "missing tool_call hook");
+
+	const promptCwd = await tempWorkspace();
+	try {
+		const promptHook = hooks.get("before_agent_start")[0];
+		const promptResult = promptHook({ systemPrompt: "base" }, createCtx(promptCwd));
+		assert.match(promptResult.systemPrompt, /base/);
+		assert.match(promptResult.systemPrompt, /el Gentleman/);
+	} finally {
+		await rm(promptCwd, { recursive: true, force: true });
+	}
+
+	const toolCwd = await tempWorkspace();
+	try {
+		const toolHook = hooks.get("tool_call")[0];
+		assert.equal(await toolHook({ toolName: "bash", input: { command: "git status" } }, createCtx(toolCwd)), undefined);
+		const denied = await toolHook({ toolName: "bash", input: { command: "rm -rf /" } }, createCtx(toolCwd));
+		assert.equal(denied.block, true);
+		assert.match(denied.reason, /destructive/);
+		const needsConfirm = await toolHook({ toolName: "bash", input: { command: "git push" } }, createCtx(toolCwd));
+		assert.equal(needsConfirm.block, true);
+		assert.match(needsConfirm.reason, /confirmation/);
+	} finally {
+		await rm(toolCwd, { recursive: true, force: true });
+	}
+
+	const noUiCwd = await tempWorkspace();
+	try {
+		for (const handler of hooks.get("session_start")) {
+			await handler({ reason: "startup" }, createCtx(noUiCwd, false));
+		}
+	} finally {
+		await rm(noUiCwd, { recursive: true, force: true });
+	}
+
+	const installCwd = await tempWorkspace();
+	try {
+		const ctx = createCtx(installCwd, true);
+		await commands.get("gentle-ai:install-sdd").handler("", ctx);
+		assert.match(ctx.ui.notifications.at(-1).message, /SDD assets installed/);
+	} finally {
+		await rm(installCwd, { recursive: true, force: true });
+	}
+
+	const sddCwd = await tempWorkspace();
+	try {
+		const ctx = createCtx(sddCwd, true);
+		await commands.get("sdd-init").handler("", ctx);
+		assert.match(ctx.ui.notifications.at(-1).message, /Wrote openspec\/config\.yaml/);
+	} finally {
+		await rm(sddCwd, { recursive: true, force: true });
+	}
+
+	const registryCwd = await tempWorkspace();
+	try {
+		const ctx = createCtx(registryCwd, true);
+		await commands.get("skill-registry:refresh").handler("", ctx);
+		assert.match(ctx.ui.notifications.at(-1).message, /Skill registry:/);
+	} finally {
+		await rm(registryCwd, { recursive: true, force: true });
+	}
+}
+
+run().catch((error) => {
+	console.error(error);
+	process.exitCode = 1;
+});

package/tests/skill-registry.test.ts

@@ -0,0 +1,128 @@
+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]);
+});
+
+test("startup skip honors no skill registry controls", () => {
+	const enabled = { getFlag: () => true };
+	const disabled = { getFlag: () => false };
+
+	assert.equal(__testing.shouldSkipSkillRegistryStartup(enabled, [], {}), true);
+	assert.equal(__testing.shouldSkipSkillRegistryStartup(disabled, ["--no-skills"], {}), true);
+	assert.equal(__testing.shouldSkipSkillRegistryStartup(disabled, ["-ns"], {}), true);
+	assert.equal(
+		__testing.shouldSkipSkillRegistryStartup(disabled, [], { GENTLE_PI_NO_SKILL_REGISTRY: "1" }),
+		true,
+	);
+	assert.equal(__testing.shouldSkipSkillRegistryStartup(disabled, [], {}), false);
+});