gentle-pi 0.3.5 → 0.3.7

package/assets/orchestrator.md

@@ -6,16 +6,16 @@ Bind this to the parent Pi session only. Do not apply it to SDD executor phase a
 
 You are el Gentleman: a Pi-specific coding-agent harness for controlled development work.
 
-When the user asks who or what you are, answer in this shape:
+When the user asks who or what you are, answer with this meaning, translated into the user's language:
 
 ```text
-Soy el Gentleman: un harness específico de Pi para desarrollo controlado, con persona de arquitecto senior. Trabajo con SDD/OpenSpec cuando la tarea lo justifica, coordino subagentes, uso artifacts de fase, corro comandos y edito archivos. No soy un chatbot genérico.
+I am el Gentleman: a Pi-specific coding-agent harness for controlled development, with a senior architect persona. I work with SDD/OpenSpec when the task justifies it, coordinate subagents, use phase artifacts, run commands, and edit files. I am not a generic chatbot.
 ```
 
 Rules:
 
 - Never introduce yourself as only "your assistant" or "the default assistant".
-- Keep the response in the user's language; in Spanish, use natural Rioplatense voseo.
+- Keep the response in the user's language and follow the currently selected persona mode.
 - Mention persistent memory only when a memory package or callable memory tools are actually active.
 - Do not claim portability outside the Pi runtime.
 
@@ -45,7 +45,7 @@ el Gentleman is an ecosystem configurator and harness layer. After installation,
 
 - Small request: do it directly.
 - Substantial feature: suggest SDD organically.
-- User says "use sdd" / "hacelo con sdd": run the SDD flow.
+- User explicitly asks to use SDD: run the SDD flow.
 - Parent session orchestrates; phase agents execute.
 
 Delegation is not optional once complexity appears. If a task crosses the triggers below, use the smallest useful subagent workflow instead of continuing as a monolithic executor.
@@ -101,7 +101,7 @@ Triggers:
 - cross-cutting behavior changes;
 - expected large diff or reviewer burden;
 - need for specs/design/tasks before safe implementation;
-- user explicitly says `use sdd`, `hacelo con sdd`, `/sdd-new`, `/sdd-ff`, or `/sdd-continue`.
+- user explicitly asks to use SDD, or invokes `/sdd-new`, `/sdd-ff`, or `/sdd-continue`.
 
 If the request is large enough for SDD, do not jump directly to implementation. Calibrate context, create artifacts, and ask for approval at the appropriate gates.
 
@@ -181,6 +181,13 @@ proposal → design ┘
 
 Do not ask SDD setup questions on session start. The first time the user initiates an SDD process in a Pi session, run the SDD preflight once and keep those choices for the rest of that session. Runtime trigger detection is intentionally deterministic: slash SDD flows and `/sdd-init` run preflight automatically; for natural-language requests, the parent/orchestrator decides semantically whether SDD is needed and must run/reuse `/gentle-ai:sdd-preflight` before continuing.
 
+**Hard gate:** `openspec/config.yaml`, existing SDD changes, installed `.pi`/global SDD assets, or a todo named "preflight" are not session preflight. They are project context only. Do not mark SDD preflight complete, start `sdd-init`, launch SDD subagents/chains, or move to explore/proposal/spec/design/tasks until this session has either:
+
+1. an injected `## SDD Session Preflight` block, or
+2. an explicit user answer in the current conversation covering all four preflight choices below.
+
+If neither exists and `/gentle-ai:sdd-preflight` cannot be invoked from the current context, ask the four choices manually with `ask_user_question` before any SDD phase work. Treat missing Engram availability as a reason to ask/confirm artifact store, not as permission to assume defaults.
+
 The preflight captures:
 
 - execution mode: `interactive` or `auto`;
@@ -207,7 +214,7 @@ In this Pi package, the default local artifact is:
 openspec/config.yaml
 ```
 
-If it is missing, ask the user for the minimal information needed or run `/sdd-init` if available. Do not proceed with a substantial SDD flow while pretending project context and testing capability are known.
+If it is missing, ask the user for the minimal information needed or run `/sdd-init` if available. This init guard runs after the session preflight gate above; project config presence or absence never substitutes for session preflight choices. Do not proceed with a substantial SDD flow while pretending project context, testing capability, or session preflight choices are known.
 
 ## Artifact Store Policy
 

package/lib/sdd-preflight.ts

@@ -25,6 +25,7 @@ export interface SddPreflightPreferences {
 	chainedPrStrategy: SddChainedPrStrategy;
 	reviewBudgetLines: number;
 	engramAvailable: boolean;
+	prompted: boolean;
 }
 
 interface SddPreflightCallbacks {
@@ -55,6 +56,7 @@ const DEFAULT_SDD_PREFLIGHT: SddPreflightPreferences = {
 	chainedPrStrategy: "auto-forecast",
 	reviewBudgetLines: 400,
 	engramAvailable: false,
+	prompted: false,
 };
 
 const sddPreflightBySession = new Map<string, SddPreflightPreferences>();
@@ -122,7 +124,23 @@ export function installSddAssets(
 }
 
 export function isSddPreflightTrigger(text: string): boolean {
-	return /^\/sdd-[^\s]*(?:\s|$)/i.test(text.trim());
+	const trimmed = text.trim();
+	if (/^\/sdd(?:[-:][^\s]*)?(?:\s|$)/i.test(trimmed)) return true;
+	if (/[?？]\s*$/.test(trimmed)) return false;
+	if (
+		/\b(?:don't|do\s+not|not\s+use|never\s+use|without\s+using|sin\s+usar|no\s+(?:quiero|queremos|vamos\s+a)?\s*usar)\s+sdd\b/i.test(
+			trimmed,
+		)
+	) {
+		return false;
+	}
+	return [
+		/^(?:please\s+)?(?:use|run|start)\s+(?:the\s+|an?\s+)?sdd(?:\s+(?:flow|process|workflow|plan))?\b/i,
+		/^(?:please\s+)?(?:do|handle|implement)\b.+\b(?:with|using)\s+(?:the\s+|an?\s+)?sdd\b/i,
+		/^(?:por\s+favor[\s,]+)?(?:vamos|vayamos)\s+con\s+(?:el\s+)?sdd\b/i,
+		/^(?:por\s+favor[\s,]+)?(?:usa|usá|usemos|corre|corré|arranca|arrancá|inicia|iniciá|empeza|empezá)\s+(?:el\s+)?sdd\b/i,
+		/^(?:por\s+favor[\s,]+)?(?:hacelo|hazlo|hacerlo)\s+(?:con|usando)\s+(?:el\s+)?sdd\b/i,
+	].some((pattern) => pattern.test(trimmed));
 }
 
 export function sddPreflightSessionKey(ctx: ExtensionContext): string {
@@ -209,13 +227,17 @@ async function collectSddPreflightPreferences(
 				: DEFAULT_SDD_PREFLIGHT.chainedPrStrategy,
 		reviewBudgetLines,
 		engramAvailable,
+		prompted: true,
 	};
 }
 
 export function renderSddPreflightPrompt(prefs: SddPreflightPreferences): string {
+	const sourceLine = prefs.prompted
+		? "The user already chose these SDD preferences for this Pi session. Reuse them unless the user explicitly changes them."
+		: "No interactive UI was available for SDD preflight, so these default preferences were applied for this Pi session. Ask the user before making delivery decisions that depend on them.";
 	return [
 		"## SDD Session Preflight",
-		"The user already chose these SDD preferences for this Pi session. Reuse them unless the user explicitly changes them.",
+		sourceLine,
 		`- Execution mode: ${prefs.executionMode}`,
 		`- Artifact store: ${prefs.artifactStore}${prefs.engramAvailable ? "" : " (Engram unavailable in this session)"}`,
 		`- Chained PR strategy: ${prefs.chainedPrStrategy}`,
@@ -254,6 +276,7 @@ export async function ensureSddPreflight(
 					`Artifacts: ${prefs.artifactStore}`,
 					`PR chaining: ${prefs.chainedPrStrategy}`,
 					`Review budget: ${prefs.reviewBudgetLines} changed lines`,
+					`Preference source: ${prefs.prompted ? "user prompt" : "defaults (no interactive UI available)"}`,
 					`Global SDD assets ready: ${result.agents} agent(s), ${result.chains} chain(s), ${result.support} support file(s), ${result.skipped} already present.`,
 					modelRoutingLine,
 				].join("\n"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.3.5",
+  "version": "0.3.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",

package/tests/artifact-language.test.ts

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, extname, join, relative } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import {
+	renderSddPreflightPrompt,
+	type SddPreflightPreferences,
+} from "../lib/sdd-preflight.ts";
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const TEXT_EXTENSIONS = new Set([".md", ".ts", ".mjs", ".json"]);
+
+async function collectTextFiles(dir: string): Promise<string[]> {
+	const entries = await readdir(dir, { withFileTypes: true });
+	const files: string[] = [];
+	for (const entry of entries) {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...(await collectTextFiles(path)));
+			continue;
+		}
+		if (entry.isFile() && TEXT_EXTENSIONS.has(extname(entry.name))) {
+			files.push(path);
+		}
+	}
+	return files;
+}
+
+const SPANISH_PREFLIGHT_COPY = [
+	/Antes de continuar con SDD/i,
+	/Antes de seguir con SDD/i,
+	/una opci[oó]n por grupo/i,
+	/usar recomendad[oa]/i,
+	/\bRitmo\b/i,
+	/\bArtefactos\b/i,
+	/\bPreguntarme\b/i,
+	/l[ií]neas cambiadas/i,
+	/\bhacelo\b/i,
+	/\bSoy el Gentleman\b/i,
+];
+
+test("orchestrator keeps conversation language separate from generated artifact language", async () => {
+	const orchestrator = await readFile(join(ROOT, "assets/orchestrator.md"), "utf8");
+
+	assert.match(
+		orchestrator,
+		/User-facing conversation should stay in the user's language/,
+	);
+	assert.match(
+		orchestrator,
+		/Generated artifacts[\s\S]*default to English, regardless of the user's conversation language/,
+	);
+});
+
+test("rendered SDD preflight prompt is English artifact copy", () => {
+	const prefs: SddPreflightPreferences = {
+		executionMode: "interactive",
+		artifactStore: "openspec",
+		chainedPrStrategy: "ask-always",
+		reviewBudgetLines: 400,
+		engramAvailable: false,
+		prompted: true,
+	};
+	const prompt = renderSddPreflightPrompt(prefs);
+
+	assert.match(prompt, /The user already chose these SDD preferences/);
+	assert.match(prompt, /Review budget: 400 changed lines/);
+	for (const pattern of SPANISH_PREFLIGHT_COPY) {
+		assert.doesNotMatch(prompt, pattern);
+	}
+});
+
+test("persistent harness prompt assets do not hardcode Spanish SDD artifact copy", async () => {
+	const files = [
+		...(await collectTextFiles(join(ROOT, "assets"))),
+		...(await collectTextFiles(join(ROOT, "prompts"))),
+	];
+	const failures: string[] = [];
+
+	for (const file of files) {
+		const text = await readFile(file, "utf8");
+		for (const pattern of SPANISH_PREFLIGHT_COPY) {
+			if (pattern.test(text)) {
+				failures.push(`${relative(ROOT, file)} matched ${pattern}`);
+			}
+		}
+	}
+
+	assert.deepEqual(failures, []);
+});

package/tests/runtime-harness.mjs

@@ -177,6 +177,20 @@ 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/);
+		await mkdir(join(promptCwd, ".pi", "gentle-ai"), { recursive: true });
+		await writeFile(
+			join(promptCwd, ".pi", "gentle-ai", "persona.json"),
+			'{"mode":"neutral"}\n',
+		);
+		const neutralPromptResult = await promptHook({ systemPrompt: "base" }, createCtx(promptCwd));
+		assert.match(neutralPromptResult.systemPrompt, /Do not use slang or regional expressions/);
+		assert.doesNotMatch(
+			neutralPromptResult.systemPrompt,
+			/When the user writes Spanish, answer in natural Rioplatense Spanish with voseo/,
+			"neutral persona prompt must not include unconditional voseo instructions after reload",
+		);
 		const subagentPromptResult = await promptHook(
 			{ agentName: "worker", systemPrompt: "worker base" },
 			createCtx(promptCwd),
@@ -284,10 +298,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" },
@@ -300,7 +330,7 @@ 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),
@@ -338,6 +368,22 @@ async function run() {
 		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");
@@ -396,6 +442,26 @@ async function run() {
 		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");