gentle-pi 0.3.5 → 0.3.6

package/assets/orchestrator.md

@@ -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.6",
   "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/runtime-harness.mjs

@@ -177,6 +177,8 @@ 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),
@@ -284,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" },
@@ -300,7 +318,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 +356,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 +430,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");