pi-goal-x 0.26.2 → 0.27.0

package/README.md

@@ -177,6 +177,18 @@ Show the focused goal:
 /goal-status
 ```
 
+Run read-only storage/runtime health checks:
+
+```text
+/goal-status health
+```
+
+Re-read goal storage caches (pool, ledger, settings) from disk and report what changed — picks up external edits to `.pi` files without file watchers:
+
+```text
+/goal-refresh
+```
+
 Select an open goal for the current session:
 
 ```text
@@ -341,6 +353,9 @@ Each session can focus on one goal while the project keeps other goals open.
 /goal-list                   List open goals
 /goal-status                 Show the focused goal (unified dashboard)
 /goal-status verbose         Show the focused goal with full diagnostic detail
+/goal-status health          Check goal storage/runtime health (read-only)
+/goal-refresh                Re-read storage caches and report external changes
+/goal-recovery               Read-only recovery report; `/goal-recovery repair` fixes stale locks + snapshot after confirmation
 /goal-focus                  Select an open goal
 /goal-unfocus                Remove the session’s focus
 /goal-tweak <change>         Revise the focused goal

package/docs/agent-flow-design.md

@@ -99,7 +99,7 @@ The curated fourteen-command palette:
 | `/goal-direct <objective>` | Direct regular-goal creation without drafting |
 | `/sisyphus-direct <objective>` | Direct Sisyphus creation without drafting |
 | `/goal-list` | List all open goals and the current focus |
-| `/goal-status` | Read-only focused-goal summary plus other-open-goal count |
+| `/goal-status` | Read-only focused-goal summary plus other-open-goal count; append `verbose` for diagnostics or `health` for storage/runtime checks |
 | `/goal-focus` | Choose this session's focused goal |
 | `/goal-unfocus` | Detach the session without modifying the shared goal |
 | `/goal-settings` | Fully operable settings editor for all eight persisted fields |

package/docs/architecture.md

@@ -182,6 +182,7 @@ user confirms.
 - `/sisyphus [seed]` starts a Sisyphus guided draft.
 - `/goal-direct <objective>` and `/sisyphus-direct <objective>` create directly without drafting.
 - `/goal-list` prints all open goals with id, status, mode, usage, objective title, path, and a focus marker.
+- `/goal-status health` performs a read-only coherence check for focus, lifecycle, goal-file presence, malformed ledger entries, task progress, and token-budget pressure; it never acts as a completion verdict.
 - `/goal-focus` uses `ctx.ui.select` when multiple goals are open and updates only session focus.
 - `/goal-unfocus` writes a null session focus entry, clears continuation/runtime state, aborts in-flight work and audits for that session, and leaves the shared active goal file and project-global focus ledger unchanged. Focus revision tokens prevent pending completion and task-list results from mutating a goal after detachment.
 - `/goal-resume` resumes the focused paused goal; when unfocused with multiple open goals, it asks the user to choose. Choosing an already active goal only focuses it.

package/extensions/goal-auditor.ts

@@ -217,6 +217,7 @@ function makeAuditorResourceLoader(): ResourceLoader {
 	};
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- pi SDK types Model<any> idiomatically (pi-coding-agent sdk.d.ts)
 export function resolveAuditorModel(ctx: ExtensionContext, config: GoalSettings): { model: Model<any> | undefined; error?: string } {
 	if (!config.model && !config.provider) return { model: ctx.model };
 	if (config.provider && config.model) {
@@ -268,6 +269,7 @@ export function resolveAuditorSessionModelOptions(ctx: ExtensionContext): {
 	return { modelRegistry: ctx.modelRegistry };
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- pi SDK types Model<any> idiomatically (pi-coding-agent sdk.d.ts)
 function modelLabel(model: Model<any> | undefined): string | undefined {
 	return model ? `${model.provider}/${model.id}` : undefined;
 }
@@ -379,7 +381,7 @@ export async function runGoalCompletionAuditor(args: {
 			}
 			if (event.type === "message_update") {
 				// Check for thinking events from the assistant stream
-				const streamEvent = (event as any).assistantMessageEvent;
+				const streamEvent = (event as { assistantMessageEvent?: { type?: string } }).assistantMessageEvent;
 				if (streamEvent?.type === "thinking_start") {
 					progress.phase = "thinking";
 					if (!progress.label) progress.label = "Analyzing goal...";
@@ -393,7 +395,7 @@ export async function runGoalCompletionAuditor(args: {
 				}
 				// For text content, show producing_report phase
 				progress.phase = "producing_report";
-				const message = event.message as any;
+				const message = event.message as { role?: string; content?: Array<{ type?: string; text?: string }> };
 				if (message?.role === "assistant") {
 					for (const part of message.content ?? []) {
 						if (part.type === "text" && typeof part.text === "string" && part.text.trim()) {
@@ -407,7 +409,7 @@ export async function runGoalCompletionAuditor(args: {
 				return;
 			}
 			if (event.type !== "message_end") return;
-			const message = event.message as any;
+			const message = event.message as { role?: string; content?: Array<{ type?: string; text?: string }> };
 			if (message.role !== "assistant") return;
 			for (const part of message.content ?? []) {
 				if (part.type === "text" && typeof part.text === "string") outputParts.push(part.text);

package/extensions/goal-commands.ts

@@ -1,3 +1,5 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { extractVerificationContract, sisyphusObjectiveSufficient } from "./goal-contract.ts";
 import { detailedSummary, oneLineSummary } from "./goal-format.ts";
@@ -15,12 +17,45 @@ import {
 	otherOpenGoalCount,
 } from "./goal-pool.ts";
 import { clearGoalCommandMessage, validateResumeGoal } from "./goal-policy.ts";
-import { readGoalLedger } from "./goal-ledger.ts";
+import { invalidateGoalLedgerCache, readGoalLedger } from "./goal-ledger.ts";
 import { buildGoalStatusText } from "./goal-status.ts";
-import { effectiveSettingsReport, envOverrideFor } from "./goal-settings.ts";
-import { mergeGoalPromptFromDisk } from "./storage/goal-files.ts";
+import { effectiveSettingsReport, envOverrideFor, invalidateGoalSettingsCache } from "./goal-settings.ts";
+import { invalidateGoalPoolCache, mergeGoalPromptFromDisk, readActiveGoalPool } from "./storage/goal-files.ts";
 import { nowIso, type GoalMode, type GoalRecord } from "./goal-record.ts";
 import { clearGoalDrafting, hasActiveDraft, startGoalDrafting } from "./goal-drafting.ts";
+import { formatRecoveryReport, runRecoveryReport, runRecoveryRepair } from "./goal-recovery.ts";
+
+export interface GoalRefreshState {
+	poolIds: Iterable<string>;
+	ledgerEvents: number;
+	ledgerMalformed: number;
+	/** Stable fingerprint of the effective settings (JSON of the parsed file). */
+	settings: string;
+}
+
+/**
+ * Pure diff of a goal-refresh cycle (before invalidation vs after re-read).
+ * Unit-testable without the command harness; the command renders the changes.
+ */
+export function diffGoalRefreshState(before: GoalRefreshState, after: GoalRefreshState): string[] {
+	const changes: string[] = [];
+	const beforeIds = new Set(before.poolIds);
+	const afterIds = new Set(after.poolIds);
+	const added = [...afterIds].filter((id) => !beforeIds.has(id)).sort();
+	const removed = [...beforeIds].filter((id) => !afterIds.has(id)).sort();
+	if (added.length > 0) changes.push(`pool: ${added.length} goal(s) added — ${added.join(", ")}`);
+	if (removed.length > 0) changes.push(`pool: ${removed.length} goal(s) removed — ${removed.join(", ")}`);
+	if (after.ledgerEvents !== before.ledgerEvents) {
+		changes.push(`ledger: ${before.ledgerEvents} -> ${after.ledgerEvents} events`);
+	}
+	if (after.ledgerMalformed !== before.ledgerMalformed) {
+		changes.push(`ledger: malformed entries ${before.ledgerMalformed} -> ${after.ledgerMalformed}`);
+	}
+	if (before.settings !== after.settings) {
+		changes.push("settings: effective settings changed (external edit)");
+	}
+	return changes;
+}
 import {
 	AUDITOR_THINKING_LEVELS,
 	buildAuditorModelChoices,
@@ -155,18 +190,87 @@ export function registerGoalCommands(core: GoalCore): void {
 		core.replaceGoal({ objective, autoContinue: true, sisyphus: mode === "sisyphus" }, ctx, true, verificationContract);
 	}
 
+	async function runGoalRecovery(rawArgs: string, ctx: ExtensionContext): Promise<void> {
+		const report = runRecoveryReport({ cwd: ctx.cwd });
+		if (/^repair$/i.test(rawArgs)) {
+			const result = await runRecoveryRepair({ cwd: ctx.cwd }, report, async () => {
+				const confirmed = await ctx.ui.confirm(`Remove ${report.staleLocks.length} stale lock(s) and refresh the pool snapshot?`, `Files are backed up to .pi/goals/.recovery-backup first.`);
+				return confirmed === true;
+			});
+			if (result.confirmed) {
+				ctx.ui.notify(result.applied.length > 0
+					? `goal-recovery repair: ${result.applied.length} operation(s) applied.\n${result.applied.map((a) => `  - ${a}`).join("\n")}\nBackup: ${result.backupDir}`
+					: "goal-recovery repair: nothing to repair.", "info");
+			} else {
+				ctx.ui.notify("goal-recovery repair: cancelled — nothing changed.", "info");
+			}
+			return;
+		}
+		ctx.ui.notify(formatRecoveryReport(report), report.healthy ? "info" : "warning");
+	}
+
+	async function runGoalRefresh(ctx: ExtensionContext): Promise<void> {
+		// Pre-state snapshots are cache-served (0 fs ops); the re-reads after
+		// invalidation go cold. This is the explicit user-owned path for picking
+		// up external edits — no watchers, no per-turn polling.
+		const beforePool = readActiveGoalPool(ctx);
+		const beforeLedger = readGoalLedger(ctx);
+		// Settings: the before fingerprint is cache-served; the after one is a
+		// cold re-read after invalidation — so an external settings edit shows
+		// up as a fingerprint difference.
+		const beforeSettings = settingsFingerprint(ctx);
+
+		invalidateGoalPoolCache();
+		invalidateGoalLedgerCache();
+		invalidateGoalSettingsCache();
+
+		const afterPool = readActiveGoalPool(ctx);
+		const afterLedger = readGoalLedger(ctx);
+		const afterSettings = settingsFingerprint(ctx);
+
+		const changes = diffGoalRefreshState({
+			poolIds: beforePool.keys(),
+			ledgerEvents: beforeLedger.events.length,
+			ledgerMalformed: beforeLedger.malformed,
+			settings: beforeSettings,
+		}, {
+			poolIds: afterPool.keys(),
+			ledgerEvents: afterLedger.events.length,
+			ledgerMalformed: afterLedger.malformed,
+			settings: afterSettings,
+		});
+
+		const text = changes.length > 0
+			? `goal-refresh: re-read caches from disk — ${changes.length} change(s):\n${changes.map((c) => `  - ${c}`).join("\n")}`
+			: "goal-refresh: no changes detected — caches were already current.";
+		ctx.ui.notify(text, "info");
+		core.updateUI(ctx);
+	}
+
+	/** Stable fingerprint of the effective settings (cache-served before invalidation). */
+	function settingsFingerprint(ctx: ExtensionContext): string {
+		return JSON.stringify(loadGoalSettingsFileConfig(ctx.cwd));
+	}
+
 	async function showGoalStatus(rawArgs: string, ctx: ExtensionContext): Promise<void> {
 		core.reconcileFocusedGoalFromDisk(ctx);
 		if (core.state.goal) core.syncGoalPromptFromDisk(ctx);
 		const view = core.goalForDisplay() ?? core.state.goal;
 		const otherCount = otherOpenGoalCount(core.goalsById, core.focusedGoalId);
 		const verbose = /^\s*verbose\b/i.test(rawArgs);
+		const health = /^\s*health\b/i.test(rawArgs);
+		const ledger = readGoalLedger(ctx);
 		const text = buildGoalStatusText({
 			goal: view,
 			focused: view !== null && core.focusedGoalId === view.id,
 			otherOpenGoals: otherCount,
-			ledgerEvents: readGoalLedger(ctx).events,
+			ledgerEvents: ledger.events,
+			ledgerMalformed: ledger.malformed,
 			verbose,
+			health,
+			activeFilePresent: health && view?.activePath
+				? existsSync(path.resolve(ctx.cwd, view.activePath))
+				: undefined,
 			// §13.2: effective settings with provenance appear only in verbose mode;
 			// the standard mode stays free of settings noise (§13.1).
 			settingsReport: verbose ? effectiveSettingsReport(ctx.cwd) : [],
@@ -481,8 +585,8 @@ export function registerGoalCommands(core: GoalCore): void {
 			ctx.ui.notify("Provide the replacement objective: /goal-tweak <new objective>", "info");
 			return;
 		}
-		if (trimmed.length > (loadGoalSettings(ctx.cwd).objectiveMaxChars ?? 0)) {
-			const max = loadGoalSettings(ctx.cwd).objectiveMaxChars;
+		const max = loadGoalSettings(ctx.cwd).objectiveMaxChars;
+		if (trimmed.length > (max ?? 0)) {
 			if (max !== undefined && max > 0) {
 				ctx.ui.notify(`Replacement objective exceeds ${max} characters (${trimmed.length}).`, "warning");
 				return;
@@ -533,11 +637,23 @@ export function registerGoalCommands(core: GoalCore): void {
 		},
 	});
 	pi.registerCommand("goal-status", {
-		description: "Show the unified goal dashboard for the focused goal (read-only). Append \"verbose\" for full diagnostic detail (goal id, revision, objective, task tree with evidence and contracts, ledger history, budget, pause/blocker, paths, audit report, effective settings).",
+		description: "Show the unified goal dashboard (read-only). Append \"verbose\" for full detail or \"health\" for storage/runtime checks.",
 		handler: async (rawArgs, ctx) => {
 			await showGoalStatus(rawArgs ?? "", ctx);
 		},
 	});
+	pi.registerCommand("goal-refresh", {
+		description: "Re-read goal storage caches (pool, ledger, settings) from disk and report what changed. Picks up external edits to .pi files — no file watchers needed.",
+		handler: async (_rawArgs, ctx) => {
+			await runGoalRefresh(ctx);
+		},
+	});
+	pi.registerCommand("goal-recovery", {
+		description: "Read-only storage/recovery report (malformed goal files, malformed ledger lines, stale locks, orphaned snapshot data). Append \"repair\" to remove stale locks and refresh the pool snapshot after confirmation (with backup).",
+		handler: async (rawArgs, ctx) => {
+			await runGoalRecovery((rawArgs ?? "").trim(), ctx);
+		},
+	});
 	pi.registerCommand("goal-focus", {
 		description: "Choose which open goal this session focuses on.",
 		handler: async (_rawArgs, ctx) => {

package/extensions/goal-compaction.ts

@@ -9,10 +9,15 @@ import {
   latestEventsForGoal,
   reconstructGoalLedger,
   type GoalLedgerEvent,
+  type LedgerStateReadResult,
 } from "./goal-ledger.ts";
 import { type GoalRecord } from "./goal-record.ts";
 
-export function buildGoalCompactSummary(goal: GoalRecord, events: GoalLedgerEvent[]): string {
+export function buildGoalCompactSummary(
+  goal: GoalRecord,
+  events: GoalLedgerEvent[],
+  auditorOverride?: { verdict: "approved" | "disapproved" | "error"; report: string; at: string },
+): string {
   const lines: string[] = [];
   lines.push(`Goal ${goal.id} — ${statusLabel(goal)}`);
   lines.push(`  Objective: ${truncateText(goal.objective, 200)}`);
@@ -70,7 +75,7 @@ export function buildGoalCompactSummary(goal: GoalRecord, events: GoalLedgerEven
     }
   }
 
-  const auditor = latestAuditorResultForGoal(events, goal.id);
+  const auditor = auditorOverride ?? latestAuditorResultForGoal(events, goal.id);
   if (auditor && auditor.verdict === "disapproved") {
     lines.push(`  Auditor rejection (latest): ${truncateText(auditor.report, 120)}`);
   }
@@ -88,20 +93,29 @@ export function buildGoalCompactSummary(goal: GoalRecord, events: GoalLedgerEven
 export function buildCompactionSummary(args: {
   goalsById: Map<string, GoalRecord>;
   focusedGoalId: string | null;
-  ledgerEvents: GoalLedgerEvent[];
+  ledgerEvents?: GoalLedgerEvent[];
+  /** Checkpoint-fed view: uses reconstructed state + per-goal recent tails instead of a full event list. */
+  ledgerState?: LedgerStateReadResult;
   capOpenGoals?: number;
   capEventsPerGoal?: number;
 }): string {
-  const { goalsById, focusedGoalId, ledgerEvents, capOpenGoals = 20, capEventsPerGoal = 5 } = args;
+  const { goalsById, focusedGoalId, ledgerEvents = [], ledgerState, capOpenGoals = 20, capEventsPerGoal = 5 } = args;
 
   const lines: string[] = [];
   const openGoals = Array.from(goalsById.values()).filter((g) => g.status !== "complete");
-  const reconstructed = reconstructGoalLedger(ledgerEvents);
+  const reconstructed = ledgerState?.state ?? reconstructGoalLedger(ledgerEvents);
+  const recentEventsFor = (goalId: string, cap: number): GoalLedgerEvent[] => {
+    if (ledgerState) return (ledgerState.recentEventsByGoal.get(goalId) ?? []).slice(0, cap);
+    return latestEventsForGoal(ledgerEvents, goalId, cap);
+  };
 
   if (focusedGoalId && goalsById.has(focusedGoalId)) {
     const focused = goalsById.get(focusedGoalId)!;
+    const auditor = ledgerState
+      ? reconstructed.goals.get(focusedGoalId)?.latestAuditorResult ?? reconstructed.terminalGoals.get(focusedGoalId)?.latestAuditorResult
+      : undefined;
     lines.push(`[FOCUSED GOAL]`);
-    lines.push(buildGoalCompactSummary(focused, latestEventsForGoal(ledgerEvents, focusedGoalId, capEventsPerGoal)));
+    lines.push(buildGoalCompactSummary(focused, recentEventsFor(focusedGoalId, capEventsPerGoal), auditor));
     lines.push("");
   }
 

package/extensions/goal-contract.ts

@@ -27,7 +27,7 @@ export function extractVerificationContract(objective: string): { objective: str
 		const trimmed = line.trim();
 		const m = VERIFICATION_CONTRACT_RE.exec(trimmed);
 		if (m) {
-			contract = m[1].trim();
+			contract = m[1]!.trim();
 			// Skip this line — don't add it to the cleaned objective
 		} else {
 			filtered.push(line);

package/extensions/goal-core.ts

@@ -71,7 +71,7 @@ export function statusLabel(goal: Pick<GoalDisplayRecordLike, "sisyphus" | "stat
 export function footerStatus(goal: GoalDisplayRecordLike): string {
 	const usageBits: string[] = [];
 	if (goal.usage.activeSeconds > 0) usageBits.push(formatDuration(goal.usage.activeSeconds));
-	if (goal.usage.tokensUsed > 0) usageBits.push(formatTokenValue(goal.usage.tokensUsed).split(" ")[0]);
+	if (goal.usage.tokensUsed > 0) usageBits.push(formatTokenValue(goal.usage.tokensUsed).split(" ")[0]!);
 	const usage = usageBits.length > 0 ? ` [${usageBits.join(" ")}]` : "";
 	const prefix = goal.sisyphus ? "goal✊" : "goal";
 	return `${prefix}: ${statusLabel(goal)}${usage} - ${truncateText(goal.objective, 60)}`;

package/extensions/goal-drafting.ts

@@ -276,7 +276,7 @@ export function registerDraftingTools(core: GoalCore): void {
 		}, { additionalProperties: false }),
 		async execute(_id, params, _signal, _update, ctx) {
 			if (!activeDraft(core)) return { content: [{ type: "text", text: "No guided goal draft is active." }], details: goalDetails(core.state.goal) };
-			const questions: GoalQuestionnaireQuestion[] = params.questions.map((q: any) => ({ ...q, allowCustom: q.allow_custom }));
+			const questions: GoalQuestionnaireQuestion[] = params.questions.map((q: GoalQuestionnaireQuestion & { allow_custom?: boolean }) => ({ ...q, allowCustom: q.allow_custom }));
 			core.enterGoalModal();
 			try {
 				const result = await runGoalQuestionnaire(ctx, questions);

package/extensions/goal-events.ts

@@ -12,7 +12,7 @@ import {
 	isToolUseAssistantMessage,
 } from "./goal-format.ts";
 import { buildCompactionSummary } from "./goal-compaction.ts";
-import { latestAuditorResultForGoal, readGoalLedger, invalidateGoalLedgerCache } from "./goal-ledger.ts";
+import { latestAuditorResultForGoal, loadLedgerState, readGoalLedger, invalidateGoalLedgerCache } from "./goal-ledger.ts";
 import { shouldArmPostCompactReminder, shouldInjectPostCompactReminder } from "./goal-policy.ts";
 import { formatTokenValue } from "./goal-core.ts";
 import { loadGoalSettings, invalidateGoalSettingsCache } from "./goal-settings.ts";
@@ -300,6 +300,11 @@ export function registerGoalEvents(core: GoalCore): void {
 		core.advanceTurnSeq();
 		const currentSystemPrompt = () => ctx.getSystemPrompt?.() || event.systemPrompt;
 		const incomingGoalId = extractGoalIdFromInjectedMessage(event.prompt ?? "");
+		// Several prompt enrichments may need the same ledger snapshot. Keep one
+		// local read for this hook instead of repeatedly traversing the cached
+		// ledger when rejection and post-compaction steering overlap.
+		let promptLedger: ReturnType<typeof readGoalLedger> | undefined;
+		const getPromptLedger = () => promptLedger ??= readGoalLedger(ctx);
 
 		// If this turn was triggered by a hidden goal checkpoint that no longer
 		// matches the active goal, abort the whole turn instead of letting the
@@ -353,10 +358,10 @@ export function registerGoalEvents(core: GoalCore): void {
 				pauseExtras.push(`Pause reason: ${current.pauseReason ?? "(unknown)"}`);
 				if (current.pauseSuggestedAction) pauseExtras.push(`Suggested action: ${current.pauseSuggestedAction}`);
 			}
-			// Inject durable auditor feedback if available
-			let auditorExtra = "";
-			try {
-				const ledger = readGoalLedger(ctx);
+				// Inject durable auditor feedback if available
+				let auditorExtra = "";
+				try {
+					const ledger = getPromptLedger();
 				const auditorResult = latestAuditorResultForGoal(ledger.events, current.id);
 				if (auditorResult && auditorResult.verdict === "disapproved") {
 					auditorExtra = `\n\n[AUDITOR REJECTION] An independent auditor previously rejected a completion request for this goal. Reason: ${auditorResult.report.slice(0, 300)}\nAddress the auditor's objections before requesting completion again.`;
@@ -395,7 +400,7 @@ export function registerGoalEvents(core: GoalCore): void {
 		if (stalledNote) prompt += stalledNote;
 		// Inject durable auditor feedback if the latest result was a rejection
 		try {
-			const ledger = readGoalLedger(ctx);
+			const ledger = getPromptLedger();
 			const auditorResult = latestAuditorResultForGoal(ledger.events, activeGoal.id);
 			if (auditorResult && auditorResult.verdict === "disapproved" && ledger.events.some((e) => e.type === "completion_requested" && e.goalId === activeGoal.id)) {
 				prompt = `${prompt}\n\n[AUDITOR REJECTION goalId=${activeGoal.id}]\nAn independent auditor previously rejected a completion request for this goal. Reason: ${auditorResult.report.slice(0, 300)}\nAddress the auditor's objections before requesting completion again.`;
@@ -405,10 +410,10 @@ export function registerGoalEvents(core: GoalCore): void {
 		}
 		if (core.runtime.isPostCompactReminderPending() && shouldInjectPostCompactReminder({ pending: true, goal: activeGoal })) {
 			core.runtime.clearPostCompactReminder();
-			// Use deterministic compaction summary instead of generic reminder
-			try {
-				const ledger = readGoalLedger(ctx);
-				const compaction = buildCompactionSummary({ goalsById: core.goalsById, focusedGoalId: core.focusedGoalId, ledgerEvents: ledger.events });
+				// Use deterministic compaction summary instead of generic reminder
+				try {
+					const ledger = getPromptLedger();
+				const compaction = buildCompactionSummary({ goalsById: core.goalsById, focusedGoalId: core.focusedGoalId, ledgerState: loadLedgerState(ctx) });
 				prompt = `${prompt}\n\n[POST-COMPACTION RESYNC goalId=${activeGoal.id}]\n${compaction}`;
 			} catch {
 				prompt = `${prompt}\n\n[POST-COMPACTION RESYNC goalId=${core.state.goal.id}]\nThe conversation was just compacted. Re-read the objective and continue from the actual artifacts/state; do not rely on memory of the prior chat.`;
@@ -473,4 +478,3 @@ export function registerGoalEvents(core: GoalCore): void {
 		if (core.state.goal) core.persist(ctx);
 	});
 }
-

package/extensions/goal-format.ts

@@ -181,7 +181,7 @@ export function extractGoalIdFromInjectedMessage(text: string): string | null {
 	// Borrowed from pi-codex-goal. More robust than bare bracket text because
 	// the angle brackets + attributes are nearly impossible for users to type
 	// by accident, and the structure is grep-able / parse-able by external tooling.
-	const xmlMatch = text.match(/^<pi_goal_continuation\s+goal_id=\"([^\"]+)\"/);
+	const xmlMatch = text.match(/^<pi_goal_continuation\s+goal_id="([^"]+)"/);
 	if (xmlMatch) return xmlMatch[1] ?? null;
 	const match = text.match(/^\[(?:GOAL CHECKPOINT|GOAL CONTINUATION|GOAL STALE) goalId=([^\]\s]+)\]/);
 	return match?.[1] ?? null;