pi-goal-x 0.26.3 → 0.27.0

package/README.md

@@ -183,6 +183,12 @@ Run read-only storage/runtime health checks:
 /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
@@ -348,6 +354,8 @@ Each session can focus on one goal while the project keeps other goals open.
 /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/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

@@ -17,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,
@@ -157,6 +190,68 @@ 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);
@@ -547,6 +642,18 @@ export function registerGoalCommands(core: GoalCore): void {
 			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";
@@ -413,7 +413,7 @@ export function registerGoalEvents(core: GoalCore): void {
 				// Use deterministic compaction summary instead of generic reminder
 				try {
 					const ledger = getPromptLedger();
-				const compaction = buildCompactionSummary({ goalsById: core.goalsById, focusedGoalId: core.focusedGoalId, ledgerEvents: ledger.events });
+				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.`;

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;