gentle-pi 0.3.3 → 0.3.5

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,11 @@ async function run() {
 		const promptResult = await promptHook({ systemPrompt: "base" }, createCtx(promptCwd));
 		assert.match(promptResult.systemPrompt, /base/);
 		assert.match(promptResult.systemPrompt, /el Gentleman/);
+		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 +213,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 });
 	}
@@ -287,14 +306,14 @@ async function run() {
 			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", "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/);
@@ -305,6 +324,15 @@ 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 });
@@ -314,7 +342,8 @@ async function run() {
 	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");
@@ -332,13 +361,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.",
@@ -346,6 +387,11 @@ 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 });
 	}
@@ -378,17 +424,37 @@ 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 });
 	}
 
+	const staleAssetsCwd = await tempWorkspace();
+	try {
+		await mkdir(join(staleAssetsCwd, ".pi", "agents"), { recursive: true });
+		await mkdir(join(staleAssetsCwd, ".pi", "chains"), { recursive: true });
+		await writeFile(join(staleAssetsCwd, ".pi", "agents", "sdd-apply.md"), "stale apply\n");
+		await writeFile(join(staleAssetsCwd, ".pi", "agents", "sdd-spec.md"), "stale spec\n");
+		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, /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 });
+	}
+
 	const sddCwd = await tempWorkspace();
 	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", "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/);
+});