gentle-pi 0.2.6 → 0.2.7

package/README.md

@@ -213,6 +213,7 @@ 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;
 - `## 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.
@@ -285,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

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

@@ -21,6 +21,8 @@ const EXCLUDE_PREFIXES = ["sdd-"];
 const ATL_IGNORE_ENTRY = ".atl/";
 const WATCH_DEBOUNCE_MS = 500;
 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";
@@ -410,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);
@@ -444,10 +466,18 @@ export const __testing = {
 	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.6",
+  "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",
@@ -32,7 +32,8 @@
     "README.md"
   ],
   "scripts": {
-    "test": "node --experimental-strip-types --test tests/*.test.ts",
+    "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"
   },

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

@@ -112,3 +112,17 @@ test("uniqueExistingDirs normalizes duplicates and ignores missing roots", () =>
 
 	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);
+});