guardian-framework 0.1.8 → 0.1.9

package/README.md

@@ -314,6 +314,11 @@ guardian update --regenerate   # Update and regenerate exports
 | `/architect status` | Current epic progress |
 | `/architect next-epic` | Find next logical slice |
 | `/architect abort` | Cancel epic |
+| `/architect --roadmap` | Show all roadmap phases with status |
+| `/architect --phase "Phase 1"` | Start a roadmap phase — creates epics for all modules |
+| `/architect --phase-status` | Show current/next pending phase |
+| `/architect --phase-done <N>` | Mark a phase complete |
+| `/architect --phase-module-done <N> "Module"` | Mark a module done within a phase |
 | `/domain --explore "..."` | Start domain exploration |
 | `/domain --validate <id>` | Validate against domain files |
 | `/domain --architect-scaffold <id>` | Generate module docs from exploration |
@@ -344,6 +349,7 @@ Tools callable programmatically by the agent during a session:
 | `guardian_goal_evaluate` | Evaluate goal progress (validator + LLM judge) |
 | `architect_status` | Show epic state |
 | `architect_discover` | Find modules + next slice |
+| `architect_roadmap` | Show roadmap phases and status |
 | `pipeline_status` | Pipeline progress |
 | `pipeline_advance` | Mark step passed |
 | `pipeline_fail` | Mark step failed |

package/dist/cli.js

@@ -1335,7 +1335,7 @@ __export(exports_package, {
   bin: () => bin,
   author: () => author
 });
-var name = "guardian-framework", version = "0.1.8", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
+var name = "guardian-framework", version = "0.1.9", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
 var init_package = __esm(() => {
   exports = {
     ".": {

package/dist/exports.js

@@ -995,7 +995,7 @@ __export(exports_package, {
   bin: () => bin,
   author: () => author
 });
-var name = "guardian-framework", version = "0.1.8", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
+var name = "guardian-framework", version = "0.1.9", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
 var init_package = __esm(() => {
   exports = {
     ".": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "guardian-framework",
-	"version": "0.1.8",
+	"version": "0.1.9",
 	"description": "Token-optimized agentic framework scaffolder with pi-first architecture",
 	"type": "module",
 	"main": "dist/exports.js",

package/templates/pi/agent/AGENTS.md

@@ -77,6 +77,7 @@ delegation:
 4. **DRY context** — Shared knowledge lives in `.pi/context/`, not scattered across agent files.
 5. **Shift-left validation** — Plans are validated before code is written.
 6. **Auto-advance pipeline** — After completing a step, immediately call `pipeline_advance` to move to the next step/item. Do NOT ask the user for permission — just advance and continue.
+7. **Auto-advance epics** — When you merge the last issue of an epic (architecture readiness), immediately start the next epic by running `/architect --epic "Next Module Name"`. Check the roadmap with `/architect --roadmap` to see which module is next. Do NOT ask the user — check the roadmap yourself and proceed.
 
 ## Commands
 

package/templates/pi/extensions/architect.ts

@@ -10,6 +10,7 @@
  * /architect --phase "Phase 1"                    Start a roadmap phase
  * /architect --phase-status                       Show current phase
  * /architect --phase-done <N>                     Mark phase complete
+ * /architect --phase-module-done <N> "Module"    Mark module done in phase
  * /architect status                                  Show current state
  * /architect next-epic                               Show next planned slice
  * /architect abort                                   Cancel current epic
@@ -107,6 +108,7 @@ type RoadmapPhase = {
 	goal: string;
 	days: string;
 	modules: RoadmapPhaseModule[];
+	completedModules: string[]; // names of completed modules within this phase
 	dependencies: string[];
 	migrations: string[];
 	criteria: string[];
@@ -587,6 +589,7 @@ function parseRoadmap(cwd: string): RoadmapPhase[] {
 			goal: currentPhase.goal || "",
 			days: currentPhase.days || "",
 			modules: currentPhase.modules || [],
+			completedModules: currentPhase.completedModules || [],
 			dependencies: currentPhase.dependencies || [],
 			migrations: currentPhase.migrations || [],
 			criteria: currentPhase.criteria || [],
@@ -599,7 +602,10 @@ function parseRoadmap(cwd: string): RoadmapPhase[] {
 	if (saved) {
 		for (const phase of phases) {
 			const savedPhase = saved.phases.find((p: RoadmapPhase) => p.index === phase.index);
-			if (savedPhase) phase.status = savedPhase.status;
+			if (savedPhase) {
+				phase.status = savedPhase.status;
+				phase.completedModules = savedPhase.completedModules || [];
+			}
 		}
 	}
 
@@ -633,13 +639,17 @@ function formatRoadmapStatus(phases: RoadmapPhase[]): string {
 		lines.push(`**Goal:** ${phase.goal}`);
 		lines.push(`**Days:** ${phase.days}`);
 		lines.push(`**Status:** ${phase.status}`);
-		lines.push(`**Modules (${phase.modules.length}):** ${phase.modules.map((m: RoadmapPhaseModule) => m.name).join(", ")}`);
+		lines.push("**Modules:**");
+		for (const mod of phase.modules) {
+			const modIcon = phase.completedModules?.includes(mod.name) ? "✅" : "⏳";
+			lines.push(`  ${modIcon} ${mod.name}`);
+		}
+		lines.push(`**Modules done:** ${phase.completedModules?.length || 0}/${phase.modules.length}`);
 		if (phase.migrations.length > 0) {
 			lines.push(`**Migrations:** ${phase.migrations.length}`);
 		}
 		if (phase.criteria.length > 0) {
-			const done = phase.criteria.filter(() => phase.status === "done").length;
-			lines.push(`**Criteria:** ${done}/${phase.criteria.length}`);
+			lines.push(`**Criteria:** ${phase.criteria.length}`);
 		}
 		if (phase.dependencies.length > 0) {
 			lines.push(`**Depends on:** ${phase.dependencies.join(", ")}`);
@@ -658,6 +668,8 @@ function getNextPendingPhase(phases: RoadmapPhase[]): RoadmapPhase | null {
 		if (phase.status !== "done") {
 			// Check dependencies
 			const depsMet = phase.dependencies.every((dep: string) => {
+				// "None" means no dependency
+				if (dep.toLowerCase() === "none") return true;
 				// Dependency format: "Phase N" or "Phase N: Name"
 				const depMatch = dep.match(/Phase\s+(\d+)/i);
 				if (depMatch) {
@@ -1284,16 +1296,23 @@ class EpicManager {
 				);
 			}
 		}
-		// Fallback: first module with planned components
+		// Fallback: if matched module has no planned components, error instead of silently switching
 		if (!slice) {
+			if (matchedModule) {
+				throw new Error(
+					`Module "${matchedModule}" matches epic "${name}" but all its components are already implemented. ` +
+					`No planned components found. Use a different epic or mark components as "planned" in the architecture doc.`,
+				);
+			}
+			// No match at all
+			slice = findNextLogicalSlice(this.cwd, moduleFiles);
+			if (!slice) {
+				throw new Error("All architecture components are implemented. No next slice found.");
+			}
 			ctx.ui.notify(
-				`No exact module match with planned components for "${name}". Using first available module instead.`,
+				`No module found matching "${name}". Using first module with planned components: "${slice.module}".`,
 				"warn",
 			);
-			slice = findNextLogicalSlice(this.cwd, moduleFiles);
-		}
-		if (!slice) {
-			throw new Error("All architecture components are implemented. No next slice found.");
 		}
 
 		ctx.ui.setStatus("architect", `Planning epic: ${name}`);
@@ -1487,7 +1506,7 @@ export default function (pi: ExtensionAPI) {
 			const tokens = raw ? raw.split(/\s+/).filter(Boolean) : [];
 			if (tokens.length === 0) {
 				ctx.ui.notify(
-					"Usage: /architect [--epic Name] [--tracking-issue N] | --roadmap | --phase \"Phase 1\" | --phase-status | --phase-done <N> | status | next-epic | abort",
+					"Usage: /architect [--epic Name] [--tracking-issue N] | --roadmap | --phase \"Phase 1\" | --phase-status | --phase-done <N> | --phase-module-done <N> \"Module\" | status | next-epic | abort",
 					"info",
 				);
 				return;
@@ -1540,7 +1559,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			if (tokens[0] === "--phase" || action === "phase") {
-				const phaseName = findFlag(tokens, "--phase") || tokens.slice(1).join(" ");
+				const phaseName = (tokens.slice(1).join(" ") || findFlag(tokens, "--phase")).replace(/["']/g, "").trim();
 				if (!phaseName) {
 					ctx.ui.notify('Usage: /architect --phase "Phase 1"', "error");
 					return;
@@ -1568,6 +1587,7 @@ export default function (pi: ExtensionAPI) {
 
 				// Check dependencies
 				const unmetDeps = targetPhase.dependencies.filter((dep) => {
+					if (dep.toLowerCase() === "none") return false;
 					const depMatch = dep.match(/Phase\s+(\d+)/i);
 					if (!depMatch) return false;
 					const depPhase = phases.find((p) => p.index === parseInt(depMatch[1], 10));
@@ -1601,30 +1621,100 @@ export default function (pi: ExtensionAPI) {
 				roadmapState.updatedAt = new Date().toISOString();
 				saveRoadmapState(ctx.cwd, roadmapState);
 
-				// Generate start message with module breakdown
-				const moduleList = targetPhase.modules
-					.map((m) => `- **${m.name}**: ${m.deliverables}`)
-					.join("\n");
-				const migrateList =
-					targetPhase.migrations.length > 0
-						? "\n\n### Database Migrations\n" +
-							targetPhase.migrations.map((m) => `- \`${m}\``).join("\n")
-						: "";
+				// Create standard epic for each module using the same pipeline as --epic
+				const results: string[] = [];
+				for (const mod of targetPhase.modules) {
+					if (targetPhase.completedModules?.includes(mod.name)) {
+						results.push(`✅ ${mod.name} — already completed, skipped`);
+						continue;
+					}
+					// Check if module has planned components BEFORE calling startEpic
+					// (startEpic silently falls back to wrong module if no planned components)
+					const matchedFile = findModuleByName(ctx.cwd, mod.name);
+					let hasPlanned = false;
+					if (matchedFile) {
+						const comps = parseModuleFile(join(ctx.cwd, ARCH_MODULES_DIR, matchedFile));
+						hasPlanned = comps.some((c) => c.status === "planned");
+					}
+					if (!hasPlanned) {
+						results.push(`✅ ${mod.name} — all components implemented, skipped`);
+						// Auto-mark as completed module
+						const rs = loadRoadmapState(ctx.cwd) || {
+							phases: [], currentPhaseIndex: 0, startedAt: "", updatedAt: "",
+						};
+						const comp = new Set((rs.phases.find((p) => p.index === targetPhase.index)?.completedModules || []));
+						comp.add(mod.name);
+						if (rs.phases.find((p) => p.index === targetPhase.index)) {
+							rs.phases.find((p) => p.index === targetPhase.index)!.completedModules = Array.from(comp);
+						}
+						rs.updatedAt = new Date().toISOString();
+						saveRoadmapState(ctx.cwd, rs);
+						continue;
+					}
+					try {
+						const state = await manager.startEpic(ctx, mod.name);
+						if (!state || !state.slices || state.slices.length === 0) {
+							results.push(`⚠️ ${mod.name} — no architecture components found`);
+							continue;
+						}
+						const items = (state.issues || []).map((i: { id: string }) => i.id);
+						// Create pipeline state for this epic
+						const pipelineId = `PL-${String(Math.floor(Math.random() * 10000)).padStart(4, "0")}`;
+						const pipelineState = {
+							id: pipelineId,
+							name: mod.name,
+							items,
+							steps: [
+								{ name: "implement", prompt: ".pi/prompts/issue-implementation-series.md", acceptance: { type: "validator", validators: ["ci"] } },
+								{ name: "validate", acceptance: { type: "validator", validators: ["ci", "tests", "security"] } },
+								{ name: "create-mr", prompt: ".pi/prompts/issue-closeout.md", acceptance: { type: "none" } },
+								{ name: "merge", prompt: ".pi/prompts/issue-merge.md", acceptance: { type: "validator", validators: ["ci", "canonical"] } },
+							],
+							currentItemIndex: 0,
+							currentStepIndex: 0,
+							status: "running",
+							retryCount: 0,
+							results: [],
+							mergeOnValid: true,
+							createdAt: new Date().toISOString(),
+							updatedAt: new Date().toISOString(),
+						};
+						// Write pipeline state only for the FIRST module (active pipeline)
+						// Other epics' pipelines are tracked in the phase state, not active
+						const pipelineFile = join(ctx.cwd, ".pi/.guardian-pipeline-state.json");
+						if (!existsSync(pipelineFile)) {
+							const pipelineDir = dirname(pipelineFile);
+							if (!existsSync(pipelineDir)) mkdirSync(pipelineDir, { recursive: true });
+							writeFileSync(pipelineFile, JSON.stringify(pipelineState, null, 2));
+						}
+						results.push(`📋 ${mod.name} — ${items.length} issues created (pipeline ${pipelineId})`);
+					} catch (e) {
+						results.push(`❌ ${mod.name} — error: ${e}`);
+					}
+				}
+
+				// Mark completed modules from roadmap state
+				const updatedRoadmap = loadRoadmapState(ctx.cwd) || roadmapState;
+				updatedRoadmap.updatedAt = new Date().toISOString();
+				saveRoadmapState(ctx.cwd, updatedRoadmap);
 
-				const instructions = [
-					`## Phase ${targetPhase.index}: ${targetPhase.title}`,
+				// Find the first module that got a pipeline (active epic)
+				const firstActive = results.find((r) => r.startsWith("📋"));
+				const activeEpic = firstActive ? firstActive.replace(/^📋\s*/, "").split(" —")[0] : null;
+
+				const summary = [
+					`## Phase ${targetPhase.index}: ${targetPhase.title} — Epics Created`,
 					`**Goal:** ${targetPhase.goal}`,
 					`**Days:** ${targetPhase.days}`,
 					"",
-					"### Modules",
-					moduleList,
-					migrateList,
+					"### Results",
+					...results.map((r) => `- ${r}`),
 					"",
-					"### How to proceed",
-					"Create epics for each module above using:",
-					`  \`/architect --epic "<module-name>"\``,
+					"### How to implement",
+					activeEpic ? `Active epic: **${activeEpic}** — use \`pipeline_next_task\` to start.` : "All modules already implemented.",
+					"When an epic is done, use /architect --epic \"<next-module>\" to start the next one.",
 					"",
-					"Complete all module epics, then mark phase done:",
+					"After completing all module epics, close the phase:",
 					`  \`/architect --phase-done ${targetPhase.index}\``,
 					"",
 					"### Acceptance Criteria",
@@ -1632,16 +1722,59 @@ export default function (pi: ExtensionAPI) {
 				].join("\n");
 
 				ctx.ui.notify(
-					`Phase ${targetPhase.index}: ${targetPhase.title} started (${targetPhase.modules.length} modules).`,
+					`Phase ${targetPhase.index}: ${targetPhase.title} — ${results.length} modules processed`,
 					"success",
 				);
 				pi.sendMessage(
-					{ content: instructions, display: true },
+					{ content: summary, display: true },
 					{ deliverAs: "followUp", triggerTurn: true },
 				);
 				return;
 			}
 
+			if (tokens[0] === "--phase-module-done" || action === "phase-module-done") {
+				const phaseIdx = parseInt(tokens[1] || "", 10);
+				if (isNaN(phaseIdx) || !tokens[2]) {
+					ctx.ui.notify('Usage: /architect --phase-module-done <phase-number> "<module-name>"', "error");
+					return;
+				}
+				const rawName = tokens.slice(2).join(" ").replace(/["']/g, "").trim();
+				const phases = parseRoadmap(ctx.cwd);
+				const phase = phases.find((p) => p.index === phaseIdx);
+				if (!phase) {
+					ctx.ui.notify(`Phase ${phaseIdx} not found.`, "error");
+					return;
+				}
+				const matchedModule = phase.modules.find(
+					(m) => m.name.toLowerCase() === rawName.toLowerCase(),
+				);
+				if (!matchedModule) {
+					ctx.ui.notify(
+						`Module "${rawName}" not found in Phase ${phaseIdx}. Available: ${phase.modules.map((m) => m.name).join(", ")}`,
+						"error",
+					);
+					return;
+				}
+				const roadmapState = loadRoadmapState(ctx.cwd) || {
+					phases: [],
+					currentPhaseIndex: 0,
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				};
+				const completed = new Set(phase.completedModules || []);
+				completed.add(matchedModule.name);
+				roadmapState.phases = phases.map((p) => ({
+					...p,
+					completedModules: p.index === phaseIdx ? Array.from(completed) : p.completedModules,
+				}));
+				roadmapState.updatedAt = new Date().toISOString();
+				saveRoadmapState(ctx.cwd, roadmapState);
+				const done = completed.size;
+				const total = phase.modules.length;
+				ctx.ui.notify(`Phase ${phaseIdx}: "${matchedModule.name}" marked done (${done}/${total} modules)`, "success");
+				return;
+			}
+
 			if (tokens[0] === "--phase-done" || action === "phase-done") {
 				const phaseIdx = parseInt(tokens[1] || "", 10);
 				if (isNaN(phaseIdx)) {
@@ -1723,16 +1856,6 @@ export default function (pi: ExtensionAPI) {
 					return;
 				}
 
-				// Initialize git if needed
-				try {
-					const gitCheck = runScript(ctx.cwd, "git rev-parse --git-dir 2>/dev/null");
-					if (gitCheck.exitCode !== 0) {
-						runScript(ctx.cwd, "git init");
-						runScript(ctx.cwd, "git add .");
-						runScript(ctx.cwd, 'git commit -m "Initial Guardian scaffold"');
-					}
-				} catch { /* ignore */ }
-
 				// Remove stale pipeline state so the new one takes effect
 				try {
 					const oldPipelinePath = join(ctx.cwd, ".pi/.guardian-pipeline-state.json");

package/templates/pi/extensions/coordinator.ts

@@ -20,7 +20,13 @@ type ExtensionContext = {
 type ToolCallEvent = { toolName: string; toolCallId: string; input: { command: string } };
 
 type ExtensionAPI = {
-	on(event: string, handler: (event: unknown, ctx: ExtensionContext) => void | Promise<void>): void;
+	on(
+		event: string,
+		handler: (
+			event: unknown,
+			ctx: ExtensionContext,
+		) => void | { block: boolean; reason: string } | Promise<void | { block: boolean; reason: string }>,
+	): void;
 	registerTool(options: {
 		name: string;
 		label: string;
@@ -30,7 +36,7 @@ type ExtensionAPI = {
 			toolCallId: string,
 			params: Record<string, unknown>,
 			signal: AbortSignal,
-			onUpdate: (update: { type: string; message: string }) => void,
+			onUpdate: (update: { content: Array<{ type: string; text: string }> }) => void,
 			ctx: ExtensionContext,
 		): unknown | Promise<unknown>;
 	}): void;
@@ -213,15 +219,33 @@ export default function (pi: ExtensionAPI) {
 			validators: Type.Optional(Type.Array(Type.String())),
 		}),
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
-			// 1. Classify scope
+			// 1. Classify scope (inlined from guardian_scope to avoid nested tool calls)
 			let scope = typeof params.scope === "string" ? params.scope : undefined;
 			if (!scope) {
-				const scopeResult = await ctx.tools.execute("guardian_scope", {});
-				// Parse the text result to extract scope
-				const text =
-					(scopeResult as { content?: Array<{ text?: string }> })?.content?.[0]?.text ?? "";
-				const match = text.match(/Scope:\s+\*\*(\w+)\*\*/);
-				scope = match?.[1] ?? "moderate";
+				let diff;
+				try {
+					diff = await ctx.shell.execute("git diff --numstat HEAD", { signal });
+				} catch {
+					try {
+						diff = await ctx.shell.execute("git diff --numstat", { signal });
+					} catch {
+						scope = "moderate";
+					}
+				}
+				if (diff) {
+					const rows = diff.stdout.split("\n").filter((line: string) => line.trim());
+					const fileCount = rows.length;
+					const lineChanges = rows.reduce((sum: number, row: string) => {
+						const [added, removed] = row.split(/\s+/);
+						const a = Number.parseInt(added, 10);
+						const r = Number.parseInt(removed, 10);
+						return sum + (Number.isFinite(a) ? a : 0) + (Number.isFinite(r) ? r : 0);
+					}, 0);
+					if (fileCount >= 16 || lineChanges >= 500) scope = "critical";
+					else if (fileCount >= 6 || lineChanges >= 200) scope = "complex";
+					else if (fileCount >= 3 || lineChanges >= 50) scope = "moderate";
+					else scope = "simple";
+				}
 			}
 
 			onUpdate({ content: [{ type: "text", text: `Scope: ${scope}` }] });
@@ -244,14 +268,30 @@ export default function (pi: ExtensionAPI) {
 
 			const validators = Array.isArray(params.validators)
 				? params.validators.filter((v): v is string => typeof v === "string")
-				: (validatorMap[scope] ?? validatorMap.moderate);
+				: (validatorMap[scope ?? "moderate"] ?? validatorMap.moderate);
 
 			onUpdate({ content: [{ type: "text", text: `Validators: ${validators.join(", ")}` }] });
 
-			// 3. Run validators
-			const validationResults = await ctx.tools.execute("guardian_validate", { validators, scope });
+			// 3. Run validators (inlined from guardian_validate to avoid nested tool calls)
+			const valResults: Record<string, { passed: boolean; output: string }> = {};
+			for (const validator of validators) {
+				if (signal?.aborted) break;
+				if (!isValidatorName(validator)) {
+					valResults[validator] = { passed: false, output: `Unsupported validator: ${validator}` };
+					continue;
+				}
+				onUpdate({ content: [{ type: "text", text: `Running ${validator} validation...` }] });
+				const scriptPath = VALIDATORS[validator];
+				try {
+					const result = await ctx.shell.execute(`bash ${scriptPath}`, { signal });
+					valResults[validator] = { passed: result.exitCode === 0, output: result.stdout };
+				} catch (error) {
+					valResults[validator] = { passed: false, output: `Error: ${error}` };
+				}
+			}
 
 			// 4. Build coordination result
+			const allPassed = Object.values(valResults).every((r) => r.passed);
 			const lines: string[] = [
 				"## Coordination Report",
 				"",
@@ -259,17 +299,27 @@ export default function (pi: ExtensionAPI) {
 				`**Scope:** ${scope}`,
 				`**Validators:** ${validators.join(", ")}`,
 				"",
-				"### Next Steps",
-				scope === "critical"
-					? "- Request human approval before proceeding"
-					: "- Proceed with implementation",
+				`**Result:** ${allPassed ? "✅ All Passed" : "❌ Some Failed"}`,
+				"",
+				"### Validation Details",
 			];
 
-			// Append validation results
-			const valText =
-				(validationResults as { content?: Array<{ text?: string }> })?.content?.[0]?.text ?? "";
-			if (valText) {
-				lines.push("", "### Validation", valText);
+			for (const [name, vr] of Object.entries(valResults)) {
+				lines.push(`**${name}:** ${vr.passed ? "✅ PASS" : "❌ FAIL"}`);
+				const output = vr.output.trim();
+				if (output) {
+					const tail = output.split("\n").slice(-10).join("\n");
+					lines.push(`\`\`\`\n${tail}\n\`\`\``);
+				}
+			}
+
+			lines.push("", "### Next Steps");
+			if (scope === "critical") {
+				lines.push("- Request human approval before proceeding");
+			} else if (allPassed) {
+				lines.push("- ✅ All validators passed — proceed with implementation");
+			} else {
+				lines.push("- ❌ Some validators failed — fix issues before proceeding");
 			}
 
 			return toolResult(lines.join("\n"));
@@ -279,7 +329,7 @@ export default function (pi: ExtensionAPI) {
 	// ── Block catastrophic commands only (lightweight safety net) ──
 	// Git commit/push are allowed — agents need them for autonomous workflows.
 	// Destructive operations are blocked to prevent irreversible damage.
-	pi.on("tool_call", async (event) => {
+	pi.on("tool_call", async (event, _ctx) => {
 		if (!isToolCallEventType("bash", event)) return;
 
 		const cmd = event.input.command;

package/templates/pi/extensions/domain-explorer.ts

@@ -75,7 +75,7 @@ type ExtensionAPI = {
 			toolCallId: string,
 			params: Record<string, unknown>,
 			signal: AbortSignal,
-			onUpdate: (update: { type: string; message: string }) => void,
+			onUpdate: (update: { content: Array<{ type: string; text: string }> }) => void,
 			ctx: ExtensionContext,
 		): unknown | Promise<unknown>;
 	}): void;

package/templates/pi/extensions/goal-loop.ts

@@ -230,16 +230,15 @@ async function runLLMJudge(
 
 	const prompt = `Goal:\n${truncatedGoal}\n${subgoalsBlock}\n\nAgent's most recent response:\n${truncatedResponse}\n\nIs the goal satisfied?`;
 
-	// Use guardian_coordinate to run an LLM-based judgment
+	// Check if git diff is accessible (for heuristic judgment)
 	try {
-		const result = await ctx.tools.execute("guardian_scope", {});
-		// We can't directly call LLM from extension — instead return a heuristic judgment
-		// The LLM judge runs via the agent itself being prompted to self-assess
-		// For now, return continue to let the agent decide
-		return { done: false, reason: "LLM judge requires agent self-assessment turn" };
+		await ctx.shell.execute("git rev-parse --git-dir 2>/dev/null", {});
 	} catch {
-		return { done: false, reason: "judge unavailable, continuing" };
+		// Not a git repo — continue anyway
 	}
+	// The LLM judge runs via the agent itself being prompted to self-assess
+	// For now, return continue to let the agent decide
+	return { done: false, reason: "LLM judge requires agent self-assessment turn" };
 }
 
 function truncate(text: string, limit: number): string {

package/templates/pi/preflight_report.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-07-02T20:32:22Z",
+  "timestamp": "2026-07-03T03:41:18Z",
   "mode": "all",
   "stages_run": [],
   "summary": {