gentle-pi 0.3.4 → 0.3.6

package/skills/skill-registry/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: skill-registry
+description: "Trigger: update skills, skill registry, actualizar skills, after skill changes. Index available skills by trigger and path."
+license: MIT
+metadata:
+  author: gentleman-programming
+  version: "1.0"
+---
+
+## Activation Contract
+
+Use this skill after installing, removing, creating, moving, or renaming skills, or when a delegator needs a fresh skill index.
+
+## Hard Rules
+
+- The registry is an index, not a compiler or summary. `SKILL.md` remains the source of truth.
+- Do not generate or inject compact rules by default; preserve author intent by passing exact skill paths to subagents.
+- Always write `.atl/skill-registry.md` regardless of SDD persistence mode.
+- Save the registry to Engram as `topic_key: skill-registry` when available, with `capture_prompt: false`.
+- Skip `sdd-*`, `_shared`, and `skill-registry`; deduplicate by skill name, preferring project-level skills over user-level skills.
+- Add `.atl/` to `.gitignore` when possible unless explicitly disabled.
+
+## Decision Gates
+
+| Situation | Action |
+| --- | --- |
+| Same skill exists globally and in project | Keep the project-level skill |
+| Same skill exists in multiple global locations | Keep the first source in scan order |
+| No skills found | Write an empty registry so agents stop searching blindly |
+| Agent will delegate work | Select matching registry rows and pass their `SKILL.md` paths |
+
+## Execution Steps
+
+1. Scan all known user and project skill directories for `*/SKILL.md`.
+2. Read frontmatter only as needed to extract `name` and `description` trigger text.
+3. Render `.atl/skill-registry.md` with scanned sources, registry contract, skill name, trigger/description, scope, and exact path.
+4. Persist to Engram when available using `title: skill-registry`, `topic_key: skill-registry`, `type: config`, and `capture_prompt: false`.
+5. Return the registry path, skill count, cache status, and whether Engram was updated.
+
+## Output Contract
+
+Return:
+- Project name and `.atl/skill-registry.md` path.
+- Number of indexed skills.
+- Whether the cache was hit or regenerated.
+- Any skipped or duplicate skills when relevant.
+
+## References
+
+- `docs/skill-style-guide.md` — how skills should be authored before indexing.
+- `skills/_shared/skill-resolver.md` — how delegators use the index.

package/tests/runtime-harness.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import assert from "node:assert/strict";
 import { existsSync } from "node:fs";
-import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { discoverAndLoadExtensions } from "@earendil-works/pi-coding-agent";
@@ -138,7 +138,9 @@ async function loadExtensions(pi) {
 
 async function run() {
 	const globalConfigHome = await tempWorkspace();
+	const globalAgentHome = await tempWorkspace();
 	process.env.GENTLE_PI_CONFIG_HOME = globalConfigHome;
+	process.env.GENTLE_PI_AGENT_HOME = globalAgentHome;
 	const globalModelsPath = join(globalConfigHome, "models.json");
 	const { pi, hooks, commands, flags } = createPi();
 	await loadExtensions(pi);
@@ -152,6 +154,16 @@ async function run() {
 	assert.ok(hooks.has("before_agent_start"), "missing before_agent_start hook");
 	assert.ok(hooks.has("tool_call"), "missing tool_call hook");
 
+	for (const entry of await readdir(join(ROOT, "assets", "agents"))) {
+		if (!entry.endsWith(".md")) continue;
+		const agentPrompt = await readFile(join(ROOT, "assets", "agents", entry), "utf8");
+		assert.doesNotMatch(
+			agentPrompt,
+			/inheritProjectContext:\s*true/,
+			`${entry} must not inherit parent project context by default`,
+		);
+	}
+
 	const discovered = await discoverAndLoadExtensions(["./extensions"], ROOT);
 	assert.deepEqual(
 		discovered.errors,
@@ -165,6 +177,13 @@ async function run() {
 		const promptResult = await promptHook({ systemPrompt: "base" }, createCtx(promptCwd));
 		assert.match(promptResult.systemPrompt, /base/);
 		assert.match(promptResult.systemPrompt, /el Gentleman/);
+		assert.match(promptResult.systemPrompt, /openspec\/config\.yaml.*not session preflight/s);
+		assert.match(promptResult.systemPrompt, /Do not mark SDD preflight complete/);
+		const subagentPromptResult = await promptHook(
+			{ agentName: "worker", systemPrompt: "worker base" },
+			createCtx(promptCwd),
+		);
+		assert.equal(subagentPromptResult.systemPrompt, "worker base");
 		assert.equal(
 			existsSync(join(promptCwd, ".pi", "agents", "sdd-apply.md")),
 			false,
@@ -196,13 +215,15 @@ async function run() {
 		assert.equal(
 			existsSync(join(noUiCwd, ".pi", "agents", "sdd-apply.md")),
 			false,
-			"session_start must not install SDD agents before first SDD intent",
+			"session_start must not install project-local SDD agents",
 		);
 		assert.equal(
 			existsSync(join(noUiCwd, ".pi", "chains", "sdd-full.chain.md")),
 			false,
-			"session_start must not install SDD chains before first SDD intent",
+			"session_start must not install project-local SDD chains",
 		);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
 	} finally {
 		await rm(noUiCwd, { recursive: true, force: true });
 	}
@@ -265,10 +286,26 @@ async function run() {
 		);
 		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
 
+		assert.deepEqual(
+			await inputHook({ text: "vamos con sdd", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "chains", "sdd-full.chain.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
+		assert.equal(ctx.ui.selections.length, 3);
+		assert.equal(ctx.ui.selections[0].label, "SDD execution mode");
+		assert.equal(ctx.ui.selections[1].label, "SDD artifact store");
+		assert.deepEqual(ctx.ui.selections[1].options, ["openspec"]);
+		assert.equal(ctx.ui.selections[2].label, "SDD PR chaining");
+		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: user prompt/);
 		assert.deepEqual(
 			await inputHook({ text: "please use sdd for this change", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
+		assert.equal(ctx.ui.selections.length, 3, "natural SDD trigger should reuse session choices");
 		assert.deepEqual(
 			await inputHook({ text: "/sdd", source: "interactive" }, ctx),
 			{ action: "continue" },
@@ -281,21 +318,20 @@ async function run() {
 			await inputHook({ text: "/sdd:plan", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
-		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(ctx.ui.selections.length, 3);
 
 		assert.deepEqual(
 			await inputHook({ text: "/sdd-plan this change", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
-		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), true);
-		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-sync.md")), true);
-		assert.equal(existsSync(join(lazySddCwd, ".pi", "chains", "sdd-full.chain.md")), true);
-		const lazyAppliedAgent = await readFile(
-			join(lazySddCwd, ".pi", "agents", "sdd-apply.md"),
-			"utf8",
-		);
-		assert.match(lazyAppliedAgent, /model: openai\/gpt-5/);
-		assert.match(lazyAppliedAgent, /thinking: high/);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "chains", "sdd-full.chain.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
+		const lazySettings = JSON.parse(await readFile(join(lazySddCwd, ".pi", "settings.json"), "utf8"));
+		assert.equal(lazySettings.subagents.agentOverrides["sdd-apply"].model, "openai/gpt-5");
+		assert.equal(lazySettings.subagents.agentOverrides["sdd-apply"].thinking, "high");
 		assert.equal(ctx.ui.selections.length, 3);
 		assert.deepEqual(ctx.ui.selections[1].options, ["openspec"]);
 		assert.match(ctx.ui.notifications.at(-1).message, /SDD preflight complete/);
@@ -306,16 +342,42 @@ async function run() {
 		const promptResult = await promptHook({ systemPrompt: "base" }, ctx);
 		assert.match(promptResult.systemPrompt, /SDD Session Preflight/);
 		assert.match(promptResult.systemPrompt, /Execution mode: interactive/);
+		const workerPromptResult = await promptHook(
+			{ agentName: "worker", systemPrompt: "worker base" },
+			ctx,
+		);
+		assert.equal(
+			workerPromptResult.systemPrompt,
+			"worker base",
+			"non-SDD subagents must not receive parent harness or SDD preflight prompts",
+		);
 	} finally {
 		await rm(lazySddCwd, { recursive: true, force: true });
 		await rm(globalModelsPath, { force: true });
 	}
 
+	for (const [index, text] of ["/sdd", "/sdd plan", "/sdd:plan", "/sdd-plan this change"].entries()) {
+		const slashSddCwd = await tempWorkspace();
+		try {
+			const ctx = createCtx(slashSddCwd, true, `slash-sdd-session-${index}`);
+			const inputHook = hooks.get("input")[0];
+			assert.deepEqual(await inputHook({ text, source: "interactive" }, ctx), {
+				action: "continue",
+			});
+			assert.equal(existsSync(join(slashSddCwd, ".pi", "agents", "sdd-apply.md")), false);
+			assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+			assert.equal(ctx.ui.selections.length, 3, `${text} should run canonical preflight`);
+		} finally {
+			await rm(slashSddCwd, { recursive: true, force: true });
+		}
+	}
+
 	const commandSddCwd = await tempWorkspace();
 	try {
 		const ctx = createCtx(commandSddCwd, true, "command-session");
 		await commands.get("gentle-ai:sdd-preflight").handler("", ctx);
-		assert.equal(existsSync(join(commandSddCwd, ".pi", "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(commandSddCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
 		assert.equal(ctx.ui.selections.length, 3);
 		await commands.get("gentle:sdd-preflight").handler("", ctx);
 		assert.equal(ctx.ui.selections.length, 3, "manual preflight command should reuse session choices");
@@ -333,13 +395,25 @@ async function run() {
 			},
 			ctx,
 		);
-		assert.equal(existsSync(join(sddAgentGuardCwd, ".pi", "agents", "sdd-apply.md")), true);
-		assert.equal(existsSync(join(sddAgentGuardCwd, ".pi", "chains", "sdd-full.chain.md")), true);
+		assert.equal(existsSync(join(sddAgentGuardCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(sddAgentGuardCwd, ".pi", "chains", "sdd-full.chain.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
 		assert.equal(ctx.ui.selections.length, 3);
 		assert.match(promptResult.systemPrompt, /SDD Session Preflight/);
+		assert.doesNotMatch(
+			promptResult.systemPrompt,
+			/el Gentleman Identity and Harness/,
+			"SDD executor startup must not receive the parent orchestrator prompt",
+		);
+		assert.doesNotMatch(
+			promptResult.systemPrompt,
+			/Work Routing Ladder/,
+			"SDD executor startup must not receive parent routing instructions",
+		);
 		assert.match(ctx.ui.notifications.at(-1).message, /SDD preflight complete/);
 
-		await promptHook(
+		const reusedPromptResult = await promptHook(
 			{
 				agentName: "sdd-tasks",
 				systemPrompt: "You are the SDD tasks executor for Gentle AI.",
@@ -347,10 +421,35 @@ async function run() {
 			ctx,
 		);
 		assert.equal(ctx.ui.selections.length, 3, "SDD agent guard should reuse session choices");
+		assert.doesNotMatch(
+			reusedPromptResult.systemPrompt,
+			/el Gentleman Identity and Harness/,
+			"named SDD executor startup must not receive the parent orchestrator prompt",
+		);
 	} finally {
 		await rm(sddAgentGuardCwd, { recursive: true, force: true });
 	}
 
+	const noUiSddAgentCwd = await tempWorkspace();
+	try {
+		const ctx = createCtx(noUiSddAgentCwd, false, "no-ui-sdd-agent-session");
+		const promptHook = hooks.get("before_agent_start")[0];
+		const promptResult = await promptHook(
+			{
+				agentName: "sdd-proposal",
+				systemPrompt: "You are the SDD proposal executor for Gentle AI.",
+			},
+			ctx,
+		);
+		assert.match(promptResult.systemPrompt, /SDD Session Preflight/);
+		assert.match(promptResult.systemPrompt, /No interactive UI was available/);
+		assert.equal(ctx.ui.selections.length, 0);
+		assert.equal(existsSync(join(noUiSddAgentCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+	} finally {
+		await rm(noUiSddAgentCwd, { recursive: true, force: true });
+	}
+
 	const invalidPreflightCwd = await tempWorkspace();
 	try {
 		await writeFile(globalModelsPath, "{ invalid json");
@@ -379,7 +478,9 @@ async function run() {
 	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/);
+		assert.match(ctx.ui.notifications.at(-1).message, /Global Gentle AI SDD assets installed/);
+		assert.equal(existsSync(join(installCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
 	} finally {
 		await rm(installCwd, { recursive: true, force: true });
 	}
@@ -393,7 +494,7 @@ async function run() {
 		await writeFile(join(staleAssetsCwd, ".pi", "chains", "sdd-full.chain.md"), "stale chain\n");
 		const ctx = createCtx(staleAssetsCwd, true);
 		await commands.get("gentle-ai:status").handler("", ctx);
-		assert.match(ctx.ui.notifications.at(-1).message, /SDD assets stale: \d+ file\(s\)/);
+		assert.match(ctx.ui.notifications.at(-1).message, /Project-local SDD override drift: \d+ file\(s\)/);
 		assert.match(ctx.ui.notifications.at(-1).message, /gentle-ai:install-sdd --force/);
 	} finally {
 		await rm(staleAssetsCwd, { recursive: true, force: true });
@@ -403,9 +504,11 @@ async function run() {
 	try {
 		const ctx = createCtx(sddCwd, true);
 		await commands.get("sdd-init").handler("", ctx);
-		assert.equal(existsSync(join(sddCwd, ".pi", "agents", "sdd-apply.md")), true);
-		assert.equal(existsSync(join(sddCwd, ".pi", "agents", "sdd-sync.md")), true);
-		assert.equal(existsSync(join(sddCwd, ".pi", "chains", "sdd-full.chain.md")), true);
+		assert.equal(existsSync(join(sddCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(sddCwd, ".pi", "chains", "sdd-full.chain.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
 		assert.equal(ctx.ui.selections.length, 3);
 		assert.match(ctx.ui.notifications[0].message, /SDD preflight complete/);
 		assert.match(ctx.ui.notifications.at(-1).message, /Wrote openspec\/config\.yaml/);

package/tests/skill-registry.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import test from "node:test";
 import { __testing } from "../extensions/skill-registry.ts";
 
@@ -28,68 +28,53 @@ test("project skill dirs include supported workspace roots", () => {
 	}
 });
 
-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.
-`);
+test("registry renders indexed skill paths instead of compact rules", () => {
+	const cwd = join(tmpdir(), `gentle-pi-render-${Date.now()}`);
+	const skillPath = join(cwd, "skills", "go-testing", "SKILL.md");
+	const registry = __testing.renderRegistry(cwd, ["skills"], [
+		{
+			name: "go-testing",
+			path: skillPath,
+			description: "Trigger: Go tests. Apply focused testing patterns.",
+		},
+	]);
 
-	assert.deepEqual(rules, ["Explicit compact rule."]);
+	assert.match(registry, /## Skills/);
+	assert.match(registry, /\| Skill \| Trigger \/ description \| Scope \| Path \|/);
+	assert.match(registry, /## Loading protocol/);
+	assert.match(registry, /\| `go-testing` \| Trigger: Go tests\. Apply focused testing patterns\. \| project \|/);
+	assert.match(registry, new RegExp(skillPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+	assert.doesNotMatch(registry, /Selected skills and compact rules/);
+	assert.doesNotMatch(registry, /Project Standards \(auto-resolved\)/);
+	assert.doesNotMatch(registry, /Rules:/);
 });
 
-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.
+test("frontmatter parser keeps full multiline descriptions", () => {
+	const parsed = __testing.parseFrontmatter(`---
+name: ai-sdk-5
+description: >
+  Trigger: AI chat features, Vercel AI SDK 5, streaming UI.
+  Use AI SDK 5 patterns and avoid v4 APIs.
+license: Apache-2.0
+---
 
-## Voice Rules
-
-| Rule | Requirement |
-|------|-------------|
-| Be warm | Sound like a teammate. |
-
-## Decision Gates
+## Hard Rules
 
-| Target | Test pattern |
-|---|---|
-| File operations | Use t.TempDir(). |
+- Do not copy this rule.
 `);
 
-	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(parsed.name, "ai-sdk-5");
 	assert.equal(
-		__testing.extractTriggerDescription("Write comments. Trigger: PR feedback, issue replies."),
-		"PR feedback, issue replies.",
+		parsed.description,
+		"Trigger: AI chat features, Vercel AI SDK 5, streaming UI. Use AI SDK 5 patterns and avoid v4 APIs.",
 	);
-	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("description normalization preserves trigger and collapses whitespace", () => {
+	assert.equal(
+		__testing.normalizeSkillDescription("Trigger: PR feedback, issue replies.\nUse maintainer voice."),
+		"Trigger: PR feedback, issue replies. Use maintainer voice.",
+	);
 });
 
 test("project-scoped duplicate wins over user duplicate", () => {
@@ -97,8 +82,8 @@ test("project-scoped duplicate wins over user duplicate", () => {
 	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."] },
+		{ name: "dup", path: userPath, description: "user" },
+		{ name: "dup", path: projectPath, description: "project" },
 	];
 
 	const [chosen] = __testing.dedupeBySkillName(entries, cwd);
@@ -129,3 +114,56 @@ test("startup skip honors no skill registry controls", () => {
 	);
 	assert.equal(__testing.shouldSkipSkillRegistryStartup(disabled, [], {}), false);
 });
+
+test("scope and markdown cells are represented in registry", () => {
+	const cwd = join(tmpdir(), `gentle-pi-scope-${Date.now()}`);
+	const projectPath = join(cwd, "skills", "docs", "SKILL.md");
+	const userPath = join(tmpdir(), `gentle-pi-home-${Date.now()}`, ".claude", "skills", "docs", "SKILL.md");
+	const registry = __testing.renderRegistry(cwd, ["skills"], [
+		{ name: "project-docs", path: projectPath, description: "Docs | guides" },
+		{ name: "user-docs", path: userPath, description: "" },
+	]);
+
+	assert.match(registry, /\| `project-docs` \| Docs \\\| guides \| project \|/);
+	assert.match(registry, /\| `user-docs` \| — \| user \|/);
+});
+
+test("generated registry file indexes skill path and omits body rules", async () => {
+	const cwd = join(tmpdir(), `gentle-pi-regenerate-${Date.now()}`);
+	const skillPath = join(cwd, "skills", "go-testing", "SKILL.md");
+	mkdirSync(dirname(skillPath), { recursive: true });
+	writeFileSync(
+		skillPath,
+		`---
+name: go-testing
+description: "Trigger: Go tests. Apply focused Go testing patterns."
+---
+
+## Hard Rules
+
+- Run focused tests before broad tests.
+`,
+	);
+
+	const dirs = await __testing.uniqueExistingDirs(__testing.projectSkillDirs(cwd));
+	assert.ok(dirs.includes(join(cwd, "skills")));
+
+	const registry = __testing.renderRegistry(cwd, ["skills"], [
+		{
+			name: "go-testing",
+			path: skillPath,
+			description: "Trigger: Go tests. Apply focused Go testing patterns.",
+		},
+	]);
+	assert.match(registry, /go-testing/);
+	assert.match(registry, /Trigger: Go tests\. Apply focused Go testing patterns\./);
+	assert.match(registry, new RegExp(skillPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+	assert.doesNotMatch(registry, /Run focused tests before broad tests/);
+});
+
+test("orchestrator documents path injection protocol", () => {
+	const source = readFileSync(join(import.meta.dirname, "..", "assets", "orchestrator.md"), "utf8");
+	assert.match(source, /## Skills to load before work/);
+	assert.match(source, /paths-injected/);
+	assert.doesNotMatch(source, /Use matching compact rules based on code context and task intent/);
+});