pi-goal-x 0.28.0 → 0.30.0

package/README.md

@@ -433,6 +433,23 @@ Configure the task shortcuts in the same file when the terminal captures the def
 
 The default task bindings are `ctrl+shift+t`, `ctrl+shift+up`, and `ctrl+shift+down`. Use pi key names such as `ctrl+shift+up`.
 
+### Blocker Oracle (opt-in)
+
+When an active goal reports blocked, a stronger read-only model can be consulted once per distinct blocker before the goal is allowed to stop. Off by default; configure under `/goal-settings → Blocker Oracle`:
+
+```json
+{
+  "oracle": {
+    "enabled": true,
+    "provider": "anthropic",
+    "model": "<a stronger model>",
+    "maxFailedAttemptsPerBlocker": 2
+  }
+}
+```
+
+Both `provider` and `model` must be set explicitly — the executor model is never used as a silent fallback. The Oracle session can only read files (`read`, `grep`, `find`, `ls`) and returns structured advice. Actionable advice keeps the goal running until you attempt it; advice that needs human input lets the goal block immediately.
+
 ## License
 
 MIT

package/extensions/goal-auditor.ts

@@ -15,6 +15,7 @@ import {
 import type { GoalRecord, GoalTask, GoalTaskList } from "./goal-record.ts";
 import { countTaskSubtree } from "./goal-task-count.ts";
 import { loadGoalSettings, type GoalSettings, type ThinkingLevel } from "./goal-settings.ts";
+import { statusLabel } from "./goal-core.ts";
 
 export interface AuditorProgress {
 	/** Current tool being executed by the auditor, if any */
@@ -108,6 +109,47 @@ function escapePromptPayload(value: string): string {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
+/** §60: human-readable labels for the auditor's read-only tool set. */
+export function labelForReadOnlyTool(toolName: string): string {
+	switch (toolName) {
+		case "read": return "Inspecting files...";
+		case "grep": return "Searching content...";
+		case "find": return "Locating files...";
+		case "ls": return "Listing directory...";
+		case "bash": return "Running verification commands...";
+		default: return `Inspecting (${toolName})...`;
+	}
+}
+
+/** §60: rough phase estimate by tool kind (display only). */
+export function estimateAuditProgress(toolName: string): number {
+	switch (toolName) {
+		case "read":
+		case "ls":
+		case "find":
+			return 25;
+		case "grep":
+			return 50;
+		case "bash":
+			return 75;
+		default:
+			return 25;
+	}
+}
+
+/**
+ * §61: goal metadata WITHOUT the objective or task tree — those appear exactly
+ * once each in their own blocks. Replaces detailedSummary in the auditor prompt.
+ */
+function minimalGoalMetadata(goal: GoalRecord): string {
+	return [
+		`Goal id: ${goal.id}`,
+		`Status: ${statusLabel(goal)}`,
+		`Mode: ${goal.sisyphus ? "sisyphus" : "regular"}`,
+		goal.tokenBudget ? `Budget: ${goal.tokenBudget} tokens (${goal.usage.tokensUsed} used)` : undefined,
+	].filter(Boolean).join("\n");
+}
+
 export function buildGoalAuditorPrompt(args: {
 	goal: GoalRecord;
 	detailedSummary: string;
@@ -140,11 +182,19 @@ export function buildGoalAuditorPrompt(args: {
 		"",
 		"The executor claim above is a claim, never evidence. It cannot make an otherwise incomplete goal complete; cross-check it against real artifacts where relevant.",
 		"",
-		"Current goal metadata:",
+		"Current goal metadata (objective and task tree appear in their own sections):",
 		"<goal_details>",
-		escapePromptPayload(args.detailedSummary),
-		...(!args.settings?.disableTasks && taskSummaryBlock(args.goal.taskList) ? ["", taskSummaryBlock(args.goal.taskList)] : []),
+		minimalGoalMetadata(args.goal),
 		"</goal_details>",
+		...(!args.settings?.disableTasks && args.goal.taskList ? [
+			"",
+			"Task tree:",
+			"<task_state>",
+			// Task titles are already escaped inside renderAuditorTaskTree; an
+			// extra pass would double-escape (&amp;lt;).
+			taskSummaryBlock(args.goal.taskList),
+			"</task_state>",
+		] : []),
 		...(!args.settings?.disableContracts && args.goal.verificationContract?.trim() ? [
 			"",
 			"Goal verification contract (what the executor was required to verify):",
@@ -170,28 +220,9 @@ export function buildGoalAuditorPrompt(args: {
 			"4. Explain missing or weak evidence, especially scaffold-vs-final quality gaps.",
 			"5. End with exactly <approved/> only if the objective is truly complete; otherwise end with exactly <disapproved/>.",
 		],
-		"",
-		"Progress reporting:",
-		"You have the report_auditor_progress tool available to report your progress to the user.",
-		"Please use it at natural phase boundaries:",
-		"  - When starting: report_auditor_progress(label='Starting audit...', percentage=0)",
-		"  - When beginning file inspection: report_auditor_progress(label='Inspecting files...', percentage=25)",
-		"  - When verifying success criteria: report_auditor_progress(label='Verifying success criteria...', percentage=50)",
-		"  - When evaluating evidence: report_auditor_progress(label='Evaluating evidence...', percentage=75)",
-		"  - When producing final report: report_auditor_progress(label='Producing report...', percentage=90)",
-		"This is purely for user visibility and does not affect the audit outcome.",
 	].join("\n");
 }
 
-/** Tool name for auditor progress reporting */
-export const REPORT_AUDITOR_PROGRESS_TOOL_NAME = "report_auditor_progress";
-
-/** Parameters for the report_auditor_progress tool */
-export const reportAuditorProgressParams = Type.Object({
-	label: Type.String({ description: "Current step label describing what the auditor is doing (e.g. 'Inspecting files...', 'Verifying success criteria...', 'Producing report...')" }),
-	percentage: Type.Number({ description: "Completion percentage from 0 to 100", minimum: 0, maximum: 100 }),
-});
-
 function makeAuditorResourceLoader(): ResourceLoader {
 	return {
 		getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
@@ -203,11 +234,6 @@ function makeAuditorResourceLoader(): ResourceLoader {
 			"You are a read-only completion auditor running in an isolated pi agent session.",
 			"Inspect the repository and decide whether the claimed goal completion is genuinely satisfied.",
 			"Never modify files. Never approve unless the actual user objective is complete.",
-			"",
-			"You have the report_auditor_progress tool available. Use it to report your audit progress",
-			"to the user at natural phase boundaries (starting, inspecting files, verifying criteria,",
-			"producing report). This helps the user understand what the auditor is doing and how far",
-			"along it is.",
 		].join("\n"),
 		getSystemPromptSource: () => undefined,
 		getAppendSystemPrompt: () => [],
@@ -312,37 +338,6 @@ export async function runGoalCompletionAuditor(args: {
 			args.onProgress?.({ ...progress });
 		}
 
-		// Build the report_auditor_progress tool, capturing the progress state
-		const reportProgressTool = defineTool({
-			name: REPORT_AUDITOR_PROGRESS_TOOL_NAME,
-			label: "Report Auditor Progress",
-			description: "Report current progress of the audit to the user. Call this at natural phase boundaries (starting, inspecting files, verifying criteria, producing report) to keep the user informed.",
-			promptSnippet: "Report current audit progress (step label and completion percentage) to the user.",
-			promptGuidelines: [
-				"Use report_auditor_progress at natural phase boundaries during the audit:",
-				"  - When starting the audit: label='Starting audit...' percentage=0",
-				"  - When beginning file inspection: label='Inspecting files...' percentage=25",
-				"  - When verifying success criteria: label='Verifying success criteria...' percentage=50",
-				"  - When evaluating evidence: label='Evaluating evidence...' percentage=75",
-				"  - When producing final report: label='Producing report...' percentage=90",
-				"This is purely for user visibility — it does not affect the audit outcome.",
-				"Do not call this tool more than once every few seconds to avoid flooding.",
-			],
-			parameters: reportAuditorProgressParams,
-			executionMode: "sequential",
-			async execute(_toolCallId, params) {
-				const { label, percentage } = params as Static<typeof reportAuditorProgressParams>;
-				progress.label = label;
-				progress.percentage = percentage;
-				progress.phase = "running";
-				emitProgress();
-				return {
-					content: [{ type: "text", text: `Progress reported: ${label} (${percentage}%)` }],
-					details: {},
-				};
-			},
-		});
-
 		const projectResources = args.settings?.auditorProjectResources === true;
 		const { session } = await createSession({
 			cwd: args.ctx.cwd,
@@ -357,10 +352,18 @@ export async function runGoalCompletionAuditor(args: {
 				: { resourceLoader: makeAuditorResourceLoader() }),
 			sessionManager: SessionManager.inMemory(args.ctx.cwd),
 			settingsManager: SettingsManager.inMemory({ compaction: { enabled: false } }),
-			tools: ["read", "grep", "find", "ls", "bash", REPORT_AUDITOR_PROGRESS_TOOL_NAME],
-			customTools: [reportProgressTool],
+			tools: ["read", "grep", "find", "ls", "bash"],
 		} as Parameters<typeof createAgentSession>[0]);
 		const unsubscribe = session.subscribe((event) => {
+			if (event.type === "agent_start") {
+				// PR E §60: progress is derived from session events — no model-facing
+				// report_auditor_progress tool exists anymore.
+				progress.label = "Starting audit...";
+				progress.percentage = 0;
+				progress.phase = "running";
+				emitProgress();
+				return;
+			}
 			if (event.type === "tool_execution_start") {
 				progress.currentTool = event.toolName;
 				progress.currentToolArgs = typeof event.args === "object" && event.args !== null
@@ -368,6 +371,9 @@ export async function runGoalCompletionAuditor(args: {
 					: String(event.args ?? "").slice(0, 120);
 				progress.currentToolStartedAt = Date.now();
 				progress.phase = "tool_executing";
+				// §60 derive the human label + estimate from the read-only tool.
+				progress.label = labelForReadOnlyTool(event.toolName);
+				progress.percentage = Math.max(progress.percentage ?? 0, estimateAuditProgress(event.toolName));
 				emitProgress();
 				return;
 			}
@@ -414,6 +420,12 @@ export async function runGoalCompletionAuditor(args: {
 			for (const part of message.content ?? []) {
 				if (part.type === "text" && typeof part.text === "string") outputParts.push(part.text);
 			}
+			// Final report production: derived label for the widget.
+			if (outputParts.some((t) => t.trim())) {
+				progress.label = "Producing report...";
+				progress.percentage = Math.max(progress.percentage ?? 0, 90);
+				progress.phase = "producing_report";
+			}
 			// Show the accumulated output in progress
 			const fullText = outputParts.join("\n\n");
 			const lines = fullText.split("\n").filter((l: string) => l.trim());

package/extensions/goal-commands.ts

@@ -380,10 +380,12 @@ export function registerGoalCommands(core: GoalCore): void {
 	 * eight persisted fields are present and operable.
 	 */
 	type SettingRow = {
-		key: keyof GoalSettings;
+		key: keyof GoalSettings | string;
 		label: string;
-		section: "Goal behavior" | "Task tracking" | "Completion auditor";
+		section: "Goal behavior" | "Task tracking" | "Completion auditor" | "Blocker Oracle";
 		kind: "boolean" | "modelSelector" | "thinking" | "positiveInteger";
+		/** Settings path for the mutation (defaults to [key]). */
+		path?: string[];
 	};
 
 	const SETTING_ROWS: readonly SettingRow[] = [
@@ -398,9 +400,16 @@ export function registerGoalCommands(core: GoalCore): void {
 		{ key: "provider", label: "provider", section: "Completion auditor", kind: "modelSelector" },
 		{ key: "model", label: "model", section: "Completion auditor", kind: "modelSelector" },
 		{ key: "thinkingLevel", label: "thinking_level", section: "Completion auditor", kind: "thinking" },
+		// Issue #26: opt-in blocker Oracle. Disabled by default; provider/model
+		// must BOTH be set explicitly — the executor model is never used silently.
+		{ key: "oracleEnabled", label: "oracle enabled", section: "Blocker Oracle", kind: "boolean", path: ["oracle", "enabled"] },
+		{ key: "oracleProviderModel", label: "oracle provider/model", section: "Blocker Oracle", kind: "modelSelector", path: ["oracle"] },
+		{ key: "oracleThinkingLevel", label: "oracle thinking_level", section: "Blocker Oracle", kind: "thinking", path: ["oracle", "thinkingLevel"] },
+		{ key: "oracleProjectResources", label: "oracle project resources", section: "Blocker Oracle", kind: "boolean", path: ["oracle", "projectResources"] },
+		{ key: "oracleMaxFailedAttemptsPerBlocker", label: "max failed attempts per blocker", section: "Blocker Oracle", kind: "positiveInteger", path: ["oracle", "maxFailedAttemptsPerBlocker"] },
 	];
 
-	function settingsValue(config: GoalSettings, key: keyof GoalSettings): string {
+	function settingsValue(config: GoalSettings, key: keyof GoalSettings | string): string {
 		if (key === "disabled" || key === "disableTasks" || key === "disableContracts" || key === "autoSelectSingleGoal" || key === "auditorProjectResources" || key === "hideUnfocusedBanner") {
 			return config[key] === true ? "true" : "false";
 		}
@@ -408,7 +417,7 @@ export function registerGoalCommands(core: GoalCore): void {
 		if (key === "stallTimeoutMinutes") return config.stallTimeoutMinutes !== undefined ? String(config.stallTimeoutMinutes) : "0";
 		if (key === "objectiveMaxChars") return config.objectiveMaxChars !== undefined ? String(config.objectiveMaxChars) : "0";
 		if (key === "keybindings") return config.keybindings ? `${config.keybindings.dashboard.toggleExpand}, ${config.keybindings.dashboard.scrollUp}, ${config.keybindings.dashboard.scrollDown}` : "(default)";
-		const value = config[key];
+		const value = (config as Record<string, unknown>)[key];
 		return typeof value === "string" ? value : "(default)";
 	}
 
@@ -465,24 +474,38 @@ export function registerGoalCommands(core: GoalCore): void {
 				const options: string[] = [];
 				options.push(`─── Editing: ${scope} (${scopePath(scope)}) ───`);
 				let lastSection: string | null = null;
+				const pathOf = (row: SettingRow): string[] => row.path ?? [String(row.key)];
+				const valueAtPath = (obj: unknown, path: string[]): unknown => {
+					let cursor: unknown = obj;
+					for (const segment of path) {
+						if (!cursor || typeof cursor !== "object") return undefined;
+						cursor = (cursor as Record<string, unknown>)[segment];
+					}
+					return cursor;
+				};
 				for (const row of SETTING_ROWS) {
 					if (row.section !== lastSection) {
 						options.push(`─── ${row.section} ───`);
 						lastSection = row.section;
 					}
-					const envVar = envOverrideFor(row.key);
+					const envVar = typeof row.key === "string" ? envOverrideFor(row.key as keyof GoalSettings) : null;
 					if (envVar) {
 						options.push(`  ${row.label}: ${settingsValue(snapshot.value, row.key)} (environment; read-only)`);
 						continue;
 					}
-					const provenance = snapshot.provenance.get(String(row.key));
+					const rowPath = pathOf(row);
+					const provenance = snapshot.provenance.get(rowPath.join("."));
 					let source: string;
 					if (provenance?.source === "global") source = scope === "project" ? "(inherited from global)" : "(global override)";
 					else if (provenance?.source === "project") source = scope === "project" ? "(project override)" : "(project; edit via project scope)";
 					else source = "(default)";
-					const hasLocalOverride = localLayer[row.key] !== undefined;
+					const hasLocalOverride = valueAtPath(localLayer, rowPath) !== undefined;
 					if (hasLocalOverride && provenance?.source === scope) source = `(${scope} override)`;
-					options.push(`  ${row.label}: ${settingsValue(snapshot.value, row.key)} ${source}`);
+					// Nested rows render their leaf value directly.
+					const displayValue = row.path
+						? String(valueAtPath(snapshot.value, rowPath) ?? "(default)")
+						: settingsValue(snapshot.value, row.key);
+					options.push(`  ${row.label}: ${displayValue} ${source}`);
 				}
 				options.push("Done");
 				const selected = await ctx.ui.select("Goal settings", options);
@@ -498,16 +521,29 @@ export function registerGoalCommands(core: GoalCore): void {
 				const label = trimmed.slice(0, colon).trim();
 				const row = SETTING_ROWS.find((r) => r.label === label);
 				if (!row) continue;
-				if (envOverrideFor(row.key)) {
-					ctx.ui.notify(`${row.label} is read-only: overridden by the ${envOverrideFor(row.key)} env var.`, "warning");
+				const envVarForRow2 = envOverrideFor(row.key as keyof GoalSettings);
+				if (envVarForRow2) {
+					ctx.ui.notify(`${row.label} is read-only: overridden by the ${envVarForRow2} env var.`, "warning");
 					continue;
 				}
+				// Per-row settings path (flat keys default to [key]; nested Blocker
+				// Oracle rows carry explicit paths).
+				const rowPath = row.path ?? [String(row.key)];
+				const pathKeyStr = rowPath.join(".");
+				const localValueAtPath = (() => {
+					let cursor: unknown = localLayer;
+					for (const segment of rowPath) {
+						if (!cursor || typeof cursor !== "object") return undefined;
+						cursor = (cursor as Record<string, unknown>)[segment];
+					}
+					return cursor;
+				})();
 
 				const inheritLabel = scope === "project" ? "Use inherited value" : "Use default (delete global override)";
-				const hasLocalOverride = localLayer[row.key] !== undefined;
+				const hasLocalOverride = localValueAtPath !== undefined;
 
 				if (row.kind === "boolean") {
-					const effective = snapshot.provenance.get(String(row.key))?.value === true;
+					const effective = snapshot.provenance.get(pathKeyStr)?.value === true;
 					const actions = [
 						`Set ${scope} override to true`,
 						`Set ${scope} override to false`,
@@ -517,28 +553,28 @@ export function registerGoalCommands(core: GoalCore): void {
 					const action = await ctx.ui.select(`${row.label} (${scope})`, actions);
 					if (!action || action === "Cancel") continue;
 					if (action === inheritLabel) {
-						applyMutation(scope, { op: "unset", path: [row.key] });
+						applyMutation(scope, { op: "unset", path: rowPath });
 						continue;
 					}
 					const value = action.endsWith("true");
 					if (value !== effective || !hasLocalOverride) {
-						applyMutation(scope, { op: "set", path: [row.key], value });
+						applyMutation(scope, { op: "set", path: rowPath, value });
 					}
 					continue;
 				}
 
 				if (row.kind === "positiveInteger") {
-					const min = (row.key === "stallTimeoutMinutes" || row.key === "objectiveMaxChars") ? 0 : 1;
+					const min = row.path ? 1 : ((row.key === "stallTimeoutMinutes" || row.key === "objectiveMaxChars") ? 0 : 1);
 					const actions = [`Set ${scope} override...`];
 					if (hasLocalOverride) actions.push(inheritLabel);
 					actions.push("Cancel");
 					const action = await ctx.ui.select(`${row.label} (${scope})`, actions);
 					if (!action || action === "Cancel") continue;
 					if (action === inheritLabel) {
-						applyMutation(scope, { op: "unset", path: [row.key] });
+						applyMutation(scope, { op: "unset", path: rowPath });
 						continue;
 					}
-					const input = await ctx.ui.input(`Set ${row.label}`, String(snapshot.provenance.get(String(row.key))?.value ?? min));
+					const input = await ctx.ui.input(`Set ${row.label}`, String(snapshot.provenance.get(pathKeyStr)?.value ?? min));
 					if (input === undefined) continue;
 					// Full-string decimal validation: rejects 1.5, 1x, negatives,
 					// infinity, and unsafe integers alike.
@@ -547,7 +583,12 @@ export function registerGoalCommands(core: GoalCore): void {
 						ctx.ui.notify(`${row.label} must be an integer >= ${min} (e.g. ${min}, ${min + 1}, ${min + 2})`, "warning");
 						continue;
 					}
-					applyMutation(scope, { op: "set", path: [row.key], value: Number(value) });
+					// Oracle attempt cap is bounded at 3 by the settings parser.
+					if (row.path?.[0] === "oracle" && Number(value) > 3) {
+						ctx.ui.notify(`${row.label} must be an integer between 1 and 3`, "warning");
+						continue;
+					}
+					applyMutation(scope, { op: "set", path: rowPath, value: Number(value) });
 					continue;
 				}
 
@@ -558,21 +599,26 @@ export function registerGoalCommands(core: GoalCore): void {
 					if (!picked) continue;
 					const choice = picked.trim().replace(/^\u2713\s+/, "");
 					if (choice === "(default)") {
-						if (hasLocalOverride) applyMutation(scope, { op: "unset", path: ["thinkingLevel"] });
+						if (hasLocalOverride) applyMutation(scope, { op: "unset", path: rowPath });
 						continue;
 					}
 					if (!(AUDITOR_THINKING_LEVELS as readonly string[]).includes(choice)) {
 						ctx.ui.notify(`thinking_level must be one of: ${AUDITOR_THINKING_LEVELS.join(", ")} (or "(default)")`, "warning");
 						continue;
 					}
-					applyMutation(scope, { op: "set", path: ["thinkingLevel"], value: choice });
+					applyMutation(scope, { op: "set", path: rowPath, value: choice });
 					continue;
 				}
 
-				// modelSelector rows (provider, model): searchable auditor model
-				// picker with explicit inherit/default handling. Either row applies
-				// the same provider+model pair.
-				const configured = configuredAuditorModelKey(snapshot.value as GoalSettings);
+				// modelSelector rows (provider, model): searchable model picker with
+				// explicit inherit/default handling. Auditor rows apply provider+model
+				// at the flat paths; the Oracle row writes oracle.provider/oracle.model.
+				const oraclePair = row.path?.[0] === "oracle";
+				const pairPrefix = oraclePair ? ["oracle"] : [];
+				const configuredBase = oraclePair
+					? [snapshot.value.oracle?.provider, snapshot.value.oracle?.model].filter(Boolean).join("/")
+					: configuredAuditorModelKey(snapshot.value as GoalSettings);
+				const configured = configuredBase || undefined;
 				const session = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
 				const choices = buildAuditorModelChoices(ctx.modelRegistry.getAvailable(), configured, session);
 				const filter = await ctx.ui.input("Filter auditor models (provider/id/name; blank = all)", "");
@@ -584,7 +630,7 @@ export function registerGoalCommands(core: GoalCore): void {
 				if (!choice) continue;
 				if (choice.kind === "default") {
 					for (const key of ["provider", "model"] as const) {
-						if (localLayer[key] !== undefined) applyMutation(scope, { op: "unset", path: [key] });
+						if (localLayer[key] !== undefined) applyMutation(scope, { op: "unset", path: [...pairPrefix, key] });
 					}
 					continue;
 				}
@@ -604,8 +650,8 @@ export function registerGoalCommands(core: GoalCore): void {
 					providerValue = choice.provider;
 					modelValue = choice.model;
 				}
-				if (applyMutation(scope, { op: "set", path: ["provider"], value: providerValue })) {
-					applyMutation(scope, { op: "set", path: ["model"], value: modelValue });
+				if (applyMutation(scope, { op: "set", path: [...pairPrefix, "provider"], value: providerValue })) {
+					applyMutation(scope, { op: "set", path: [...pairPrefix, "model"], value: modelValue });
 				}
 			}
 		} finally {

package/extensions/goal-compaction.ts

@@ -11,7 +11,7 @@ import {
   type GoalLedgerEvent,
   type LedgerStateReadResult,
 } from "./goal-ledger.ts";
-import { type GoalRecord } from "./goal-record.ts";
+import { type GoalRecord, type GoalTask } from "./goal-record.ts";
 
 export function buildGoalCompactSummary(
   goal: GoalRecord,
@@ -151,3 +151,51 @@ export function buildCompactionSummary(args: {
 
   return lines.join("\n");
 }
+
+/**
+ * PR E §62: post-compaction DELTA for the focused goal. The active system
+ * goal block already contains the objective, full policy, task gate, and
+ * verification contract — this delta adds only what compaction may have
+ * lost: the execution focus, a bounded recent-events tail, the latest
+ * unresolved auditor finding, and the other-open-goals count.
+ */
+export function buildPostCompactionGoalDelta(args: {
+  goal: GoalRecord;
+  ledgerEvents: GoalLedgerEvent[];
+  otherOpenCount: number;
+}): string {
+  const { goal, ledgerEvents, otherOpenCount } = args;
+  const lines: string[] = [];
+  lines.push(`[POST-COMPACTION RESYNC goalId=${goal.id}]`);
+  // Execution focus (with contract) — the one thing memory must not lose.
+  if (goal.currentTaskId && goal.taskList) {
+    const find = (tasks: GoalTask[]): GoalTask | undefined => {
+      for (const t of tasks) {
+        if (t.id === goal.currentTaskId) return t;
+        const nested = t.subtasks ? find(t.subtasks) : undefined;
+        if (nested) return nested;
+      }
+      return undefined;
+    };
+    const current = find(goal.taskList.tasks);
+    if (current) {
+      lines.push(`Current task: ${current.id} — ${current.title}${current.verificationContract ? ` (contract: ${current.verificationContract})` : ""}`);
+    }
+  }
+  // Bounded recent-event tail.
+  const recent = latestEventsForGoal(ledgerEvents, goal.id, 5);
+  if (recent.length > 0) {
+    lines.push("Recent events:");
+    for (const event of recent) {
+      lines.push(`  ${event.at.slice(11, 19)} ${event.type}`);
+    }
+  }
+  // Latest unresolved auditor finding.
+  const audit = latestAuditorResultForGoal(ledgerEvents, goal.id);
+  if (audit && audit.verdict === "disapproved") {
+    lines.push(`Latest unresolved auditor finding: ${audit.report.slice(0, 300)}`);
+  }
+  lines.push(`Other open goals: ${otherOpenCount}`);
+  lines.push("Continue from authoritative files and goal storage.");
+  return lines.join("\n");
+}

package/extensions/goal-completion.ts

@@ -195,7 +195,7 @@ if (settings.disabled === true) {
 		].filter((line): line is string => line !== undefined).join("\n"),
 		display: true,
 		details: { phase: "started", goalId: auditTarget.id, auditor: auditorLabel },
-	}, { triggerTurn: true });
+	}, { triggerTurn: false });
 	if (!core.isFocusedOperationCurrent(completionFocus)) {
 		return core.focusedOperationCancelledResult("Goal completion", completionFocus);
 	}