pi-goal-x 0.6.0

package/extensions/goal-ledger.ts

@@ -0,0 +1,319 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { normalizeRelPath, nowIso, safeIdPart, type GoalRecord } from "./goal-record.ts";
+
+export const GOAL_LEDGER_FILE = ".pi/goals/goal_events.jsonl";
+
+export type GoalLedgerEvent =
+  | { type: "goal_created"; goalId: string; objective: string; sisyphus: boolean; autoContinue: boolean; at: string }
+  | { type: "goal_focused"; goalId: string; reason: string; at: string }
+  | { type: "goal_unfocused"; reason: string; at: string }
+  | { type: "goal_paused"; goalId: string; reason: string; suggestedAction?: string; status?: "paused"; at: string }
+  | { type: "goal_resumed"; goalId: string; reason: string; at: string }
+  | { type: "goal_tweaked"; goalId: string; changeSummary: string; at: string }
+  | { type: "completion_requested"; goalId: string; summary?: string; at: string }
+  | { type: "audit_started"; goalId: string; provider?: string; model?: string; thinkingLevel?: string; at: string }
+  | { type: "audit_result"; goalId: string; verdict: "approved" | "disapproved" | "error"; report: string; at: string }
+  | { type: "audit_skipped"; goalId: string; reason: "disabled" | "user_aborted"; provider?: string; model?: string; thinkingLevel?: string; at: string }
+  | { type: "goal_completed"; goalId: string; archivePath?: string; at: string }
+  | { type: "goal_aborted"; goalId: string; reason: string; archivePath?: string; at: string };
+
+export interface GoalLedgerContext {
+  cwd: string;
+}
+
+export interface GoalLedgerReadResult {
+  events: GoalLedgerEvent[];
+  malformed: number;
+}
+
+export interface ReconstructedGoalState {
+  goalId: string;
+  latestStatus: "active" | "paused" | "complete" | "aborted" | "unknown";
+  latestFocus: boolean;
+  latestPauseReason?: string;
+  latestPauseSuggestedAction?: string;
+  latestAuditorResult?: { verdict: "approved" | "disapproved" | "error"; report: string; at: string };
+  createdAt?: string;
+  completedAt?: string;
+  abortedAt?: string;
+  tweakedAt?: string;
+  resumedAt?: string;
+}
+
+export interface ReconstructedLedgerState {
+  focusedGoalId: string | null;
+  goals: Map<string, ReconstructedGoalState>;
+  terminalGoals: Map<string, ReconstructedGoalState>;
+}
+
+function safeGoalId(value: string): string {
+  return safeIdPart(value);
+}
+
+export function goalLedgerPath(ctx: GoalLedgerContext): string {
+  return path.resolve(ctx.cwd, normalizeRelPath(GOAL_LEDGER_FILE));
+}
+
+export function appendGoalEvent(ctx: GoalLedgerContext, event: GoalLedgerEvent): void {
+  const filePath = goalLedgerPath(ctx);
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const line = JSON.stringify(event) + "\n";
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  let appended = false;
+  try {
+    fs.writeFileSync(tempPath, line, { flag: "wx", encoding: "utf8" });
+    fs.appendFileSync(filePath, fs.readFileSync(tempPath, "utf8"), "utf8");
+    appended = true;
+  } catch {
+    // If temp write fails, try direct append as fallback.
+    // Skip fallback only if the primary append already succeeded.
+    if (!appended) {
+      try {
+        fs.appendFileSync(filePath, line, "utf8");
+        appended = true;
+      } catch {
+        // Ledger append failure should not crash the transaction.
+        // Callers that need strict durability can check the return.
+      }
+    }
+  } finally {
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+      // Temp file may not exist; ignore cleanup failure.
+    }
+  }
+}
+
+export function readGoalLedger(ctx: GoalLedgerContext): GoalLedgerReadResult {
+  const filePath = goalLedgerPath(ctx);
+  let content: string;
+  try {
+    content = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return { events: [], malformed: 0 };
+  }
+
+  const events: GoalLedgerEvent[] = [];
+  let malformed = 0;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      if (isValidLedgerEvent(parsed)) {
+        events.push(sanitizeEvent(parsed));
+      } else {
+        malformed++;
+      }
+    } catch {
+      malformed++;
+    }
+  }
+  return { events, malformed };
+}
+
+function isValidLedgerEvent(value: unknown): value is GoalLedgerEvent {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const obj = value as Record<string, unknown>;
+  if (typeof obj.type !== "string") return false;
+  if (typeof obj.at !== "string") return false;
+  const type = obj.type as GoalLedgerEvent["type"];
+  switch (type) {
+    case "goal_created":
+      return typeof obj.goalId === "string" && typeof obj.objective === "string" && typeof obj.sisyphus === "boolean" && typeof obj.autoContinue === "boolean";
+    case "goal_focused":
+      return typeof obj.goalId === "string" && typeof obj.reason === "string";
+    case "goal_unfocused":
+      return typeof obj.reason === "string";
+    case "goal_paused":
+      return typeof obj.goalId === "string" && typeof obj.reason === "string" && (obj.suggestedAction === undefined || typeof obj.suggestedAction === "string") && (obj.status === undefined || obj.status === "paused");
+    case "goal_resumed":
+      return typeof obj.goalId === "string" && typeof obj.reason === "string";
+    case "goal_tweaked":
+      return typeof obj.goalId === "string" && typeof obj.changeSummary === "string";
+    case "completion_requested":
+      return typeof obj.goalId === "string" && (obj.summary === undefined || typeof obj.summary === "string");
+    case "audit_started":
+      return typeof obj.goalId === "string" && (obj.provider === undefined || typeof obj.provider === "string") && (obj.model === undefined || typeof obj.model === "string") && (obj.thinkingLevel === undefined || typeof obj.thinkingLevel === "string");
+    case "audit_result":
+      return typeof obj.goalId === "string" && (obj.verdict === "approved" || obj.verdict === "disapproved" || obj.verdict === "error") && typeof obj.report === "string";
+    case "audit_skipped":
+      return typeof obj.goalId === "string" && (obj.reason === "disabled" || obj.reason === "user_aborted") && (obj.provider === undefined || typeof obj.provider === "string") && (obj.model === undefined || typeof obj.model === "string") && (obj.thinkingLevel === undefined || typeof obj.thinkingLevel === "string");
+    case "goal_completed":
+      return typeof obj.goalId === "string" && (obj.archivePath === undefined || typeof obj.archivePath === "string");
+    case "goal_aborted":
+      return typeof obj.goalId === "string" && typeof obj.reason === "string" && (obj.archivePath === undefined || typeof obj.archivePath === "string");
+    default:
+      return false;
+  }
+}
+
+function sanitizeEvent(event: GoalLedgerEvent): GoalLedgerEvent {
+  switch (event.type) {
+    case "goal_created":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "goal_focused":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "goal_paused":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "goal_resumed":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "goal_tweaked":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "completion_requested":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "audit_started":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "audit_result":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "audit_skipped":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "goal_completed":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "goal_aborted":
+      return { ...event, goalId: safeGoalId(event.goalId) };
+    case "goal_unfocused":
+      return event;
+  }
+}
+
+export function reconstructGoalLedger(events: GoalLedgerEvent[]): ReconstructedLedgerState {
+  const goals = new Map<string, ReconstructedGoalState>();
+  const terminalGoals = new Map<string, ReconstructedGoalState>();
+  let focusedGoalId: string | null = null;
+
+  for (const event of events) {
+    switch (event.type) {
+      case "goal_created": {
+        const state: ReconstructedGoalState = {
+          goalId: event.goalId,
+          latestStatus: "active",
+          latestFocus: false,
+          createdAt: event.at,
+        };
+        goals.set(event.goalId, state);
+        break;
+      }
+      case "goal_focused": {
+        focusedGoalId = event.goalId;
+        for (const g of goals.values()) g.latestFocus = false;
+        for (const g of terminalGoals.values()) g.latestFocus = false;
+        const state = goals.get(event.goalId) ?? terminalGoals.get(event.goalId);
+        if (state) state.latestFocus = true;
+        break;
+      }
+      case "goal_unfocused": {
+        focusedGoalId = null;
+        for (const g of goals.values()) g.latestFocus = false;
+        for (const g of terminalGoals.values()) g.latestFocus = false;
+        break;
+      }
+      case "goal_paused": {
+        const state = goals.get(event.goalId);
+        if (state) {
+          state.latestStatus = event.status ?? "paused";
+          state.latestPauseReason = event.reason;
+          state.latestPauseSuggestedAction = event.suggestedAction;
+        }
+        break;
+      }
+      case "goal_resumed": {
+        const state = goals.get(event.goalId);
+        if (state) {
+          state.latestStatus = "active";
+          state.resumedAt = event.at;
+          delete state.latestPauseReason;
+          delete state.latestPauseSuggestedAction;
+        }
+        break;
+      }
+      case "goal_tweaked": {
+        const state = goals.get(event.goalId);
+        if (state) state.tweakedAt = event.at;
+        break;
+      }
+      case "completion_requested": {
+        // No status change until audit_result or goal_completed
+        break;
+      }
+      case "audit_started": {
+        // No state change
+        break;
+      }
+      case "audit_skipped": {
+        // audit was skipped; goal continues as-is
+        break;
+      }
+      case "audit_result": {
+        const state = goals.get(event.goalId) ?? terminalGoals.get(event.goalId);
+        if (state) {
+          state.latestAuditorResult = { verdict: event.verdict, report: event.report, at: event.at };
+        }
+        break;
+      }
+      case "goal_completed": {
+        let state = goals.get(event.goalId);
+        if (!state) {
+          state = { goalId: event.goalId, latestStatus: "complete", latestFocus: false };        }
+        state.latestStatus = "complete";
+        state.completedAt = event.at;
+        terminalGoals.set(event.goalId, state);
+        goals.delete(event.goalId);
+        break;
+      }
+      case "goal_aborted": {
+        let state = goals.get(event.goalId);
+        if (!state) {
+          state = { goalId: event.goalId, latestStatus: "aborted", latestFocus: false };        }
+        state.latestStatus = "aborted";
+        state.abortedAt = event.at;
+        terminalGoals.set(event.goalId, state);
+        goals.delete(event.goalId);
+        break;
+      }
+    }
+  }
+
+  // If the focused goal was moved to terminal (e.g., aborted/completed), clear focus.
+  if (focusedGoalId && !goals.has(focusedGoalId)) {
+    focusedGoalId = null;
+  }
+
+  return { focusedGoalId, goals, terminalGoals };
+}
+
+export function latestAuditorResultForGoal(events: GoalLedgerEvent[], goalId: string): { verdict: "approved" | "disapproved" | "error"; report: string; at: string } | undefined {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type === "audit_result" && event.goalId === goalId) {
+      return { verdict: event.verdict, report: event.report, at: event.at };
+    }
+  }
+  return undefined;
+}
+
+export function latestEventsForGoal(events: GoalLedgerEvent[], goalId: string, limit = 10): GoalLedgerEvent[] {
+  const result: GoalLedgerEvent[] = [];
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if ("goalId" in event && event.goalId === goalId) {
+      result.unshift(event);
+      if (result.length >= limit) break;
+    }
+  }
+  return result;
+}
+
+export function latestGoalLifecycleEvent(events: GoalLedgerEvent[], goalId: string): GoalLedgerEvent | undefined {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if ("goalId" in event && event.goalId === goalId) {
+      return event;
+    }
+  }
+  return undefined;
+}

package/extensions/goal-policy.ts

@@ -0,0 +1,152 @@
+import { statusLabel, type GoalDisplayRecordLike } from "./goal-core.ts";
+
+export type GoalStatusLike = "active" | "paused" | "complete";
+export type StopReasonLike = "user" | "agent";
+
+export interface GoalPolicyRecordLike extends GoalDisplayRecordLike {
+	id: string;
+	status: GoalStatusLike;
+	updatedAt?: string;
+	pauseReason?: string;
+	pauseSuggestedAction?: string;
+}
+
+export type PolicyValidation =
+	| { ok: true }
+	| { ok: false; message: string };
+
+export function isGoalUnfinished(goal: Pick<GoalPolicyRecordLike, "status"> | null | undefined): boolean {
+	return !!goal && goal.status !== "complete";
+}
+
+export function isRunnableStatus(status: GoalStatusLike): boolean {
+	return status === "active";
+}
+
+export function isCompletableStatus(status: GoalStatusLike): boolean {
+	return status === "active" || status === "paused";
+}
+
+export function validateGoalCreationSlot(goal: Pick<GoalPolicyRecordLike, "status"> | null): PolicyValidation {
+	void goal;
+	return { ok: true };
+}
+
+export function validateGoalCompletion(args: {
+	goal: GoalPolicyRecordLike | null;
+	runningGoalId?: string | null;
+}): PolicyValidation {
+	const { goal, runningGoalId } = args;
+	if (!goal) return { ok: false, message: "No goal is set." };
+	if (runningGoalId && goal.id !== runningGoalId) return { ok: false, message: "The active goal changed during this run; not marking it complete." };
+	if (!isCompletableStatus(goal.status)) return { ok: false, message: `Goal is ${statusLabel(goal)}; update_goal does not apply.` };
+	return { ok: true };
+}
+
+export function validateGoalAbort(args: {
+	goal: GoalPolicyRecordLike | null;
+	runningGoalId?: string | null;
+	reason: string;
+}): PolicyValidation {
+	const { goal, runningGoalId } = args;
+	if (!goal) return { ok: false, message: "No goal is set; abort_goal is a no-op." };
+	if (runningGoalId && goal.id !== runningGoalId) return { ok: false, message: "The active goal changed during this run; not aborting." };
+	if (goal.status === "complete") return { ok: false, message: "Goal is complete; abort_goal does not apply." };
+	if (!args.reason.trim()) return { ok: false, message: "abort_goal requires a non-empty reason." };
+	return { ok: true };
+}
+
+export function validatePauseGoal(args: {
+	goal: GoalPolicyRecordLike | null;
+	runningGoalId?: string | null;
+	reason: string;
+}): PolicyValidation {
+	const { goal, runningGoalId } = args;
+	if (!goal) return { ok: false, message: "No goal is set; pause_goal is a no-op." };
+	if (runningGoalId && goal.id !== runningGoalId) return { ok: false, message: "The active goal changed during this run; not pausing." };
+	if (!isRunnableStatus(goal.status)) return { ok: false, message: `Goal is ${statusLabel(goal)}; pause_goal does not apply.` };
+	if (!args.reason.trim()) return { ok: false, message: "pause_goal requires a non-empty reason." };
+	return { ok: true };
+}
+
+export function buildPausedByAgentGoal<T extends GoalPolicyRecordLike>(goal: T, args: {
+	reason: string;
+	suggestedAction?: string;
+	updatedAt: string;
+}): T {
+	const suggested = args.suggestedAction?.trim() || undefined;
+	return {
+		...goal,
+		status: "paused",
+		autoContinue: false,
+		stopReason: "agent",
+		pauseReason: args.reason.trim(),
+		pauseSuggestedAction: suggested,
+		updatedAt: args.updatedAt,
+	};
+}
+
+export function buildAbortedByAgentGoal<T extends GoalPolicyRecordLike>(goal: T, args: {
+	reason: string;
+	updatedAt: string;
+}): T {
+	return {
+		...goal,
+		status: "paused",
+		autoContinue: false,
+		stopReason: "agent",
+		pauseReason: `Aborted: ${args.reason.trim()}`,
+		pauseSuggestedAction: undefined,
+		updatedAt: args.updatedAt,
+	};
+}
+
+export function validateResumeGoal(goal: GoalPolicyRecordLike | null): PolicyValidation {
+	if (!goal) return { ok: false, message: "No goal is set. Use /goals or /sisyphus to discuss, or /goals-set / /sisyphus-set to start immediately." };
+	if (goal.status === "complete") return { ok: false, message: "Goal is complete. Use /goals to discuss a new one or /goals-set to start immediately." };
+	if (goal.status === "active" && goal.autoContinue) return { ok: false, message: "Goal is already running." };
+	return { ok: true };
+}
+
+export function clearGoalCommandMessage(args: { archived: boolean; wasDrafting: boolean }): string {
+	return args.archived ? "Goal cleared and archived." : args.wasDrafting ? "Drafting cancelled." : "No goal is set.";
+}
+
+export function abortGoalCommandMessage(args: { archived: boolean; wasDrafting: boolean }): string {
+	return args.archived ? "Goal aborted and archived." : args.wasDrafting ? "Drafting cancelled." : "No goal is set.";
+}
+
+export function buildCompletionReport(args: { detailedSummary: string; completionSummary?: string | null; auditorReport?: string | null }): string {
+	const auditorReport = args.auditorReport?.trim();
+	const lines = auditorReport
+		? ["Goal audit approved.", "", "Auditor approval:", auditorReport, "", "Goal complete."]
+		: ["Goal complete."];
+	const summary = args.completionSummary?.trim();
+	if (summary) {
+		lines.push("", "Completion summary:", summary);
+	}
+	lines.push("", args.detailedSummary);
+	return lines.join("\n");
+}
+
+export function buildGoalCreatedReport(args: { objective: string; detailedSummary?: string | null }): string {
+	const lines = ["Goal confirmed and created.", "", "Finalized goal:", "", args.objective.trim()];
+	const summary = args.detailedSummary?.trim();
+	if (summary) {
+		lines.push("", "Goal details:", summary);
+	}
+	return lines.join("\n");
+}
+
+export function shouldQueueContinuation(goal: Pick<GoalPolicyRecordLike, "status" | "autoContinue"> | null): boolean {
+	return !!goal && goal.status === "active" && goal.autoContinue;
+}
+
+
+export function shouldArmPostCompactReminder(goal: Pick<GoalPolicyRecordLike, "sisyphus" | "status"> | null): boolean {
+	return !!goal && isRunnableStatus(goal.status);
+}
+
+export function shouldInjectPostCompactReminder(args: { pending: boolean; goal: Pick<GoalPolicyRecordLike, "sisyphus"> | null }): boolean {
+	return args.pending && !!args.goal;
+}

package/extensions/goal-pool.ts

@@ -0,0 +1,94 @@
+import {
+	displayObjectiveTitle,
+	formatDuration,
+	formatTokenValue,
+	statusLabel,
+	truncateText,
+} from "./goal-core.ts";
+import { cloneGoal, type GoalFocusEntry, type GoalRecord } from "./goal-record.ts";
+
+export function goalPoolFromGoals(goals: Iterable<GoalRecord>): Map<string, GoalRecord> {
+	const pool = new Map<string, GoalRecord>();
+	for (const goal of goals) {
+		if (goal.status !== "complete") pool.set(goal.id, cloneGoal(goal));
+	}
+	return pool;
+}
+
+export function openGoalsFromPool(pool: Map<string, GoalRecord>): GoalRecord[] {
+	return Array.from(pool.values())
+		.filter((goal) => goal.status !== "complete")
+		.sort((a, b) => {
+			const byCreated = a.createdAt.localeCompare(b.createdAt);
+			return byCreated !== 0 ? byCreated : a.id.localeCompare(b.id);
+		});
+}
+
+export function focusedGoalFromPool(pool: Map<string, GoalRecord>, focusedGoalId: string | null): GoalRecord | null {
+	if (!focusedGoalId) return null;
+	const goal = pool.get(focusedGoalId) ?? null;
+	return goal;
+}
+
+export function otherOpenGoalCount(pool: Map<string, GoalRecord>, focusedGoalId: string | null): number {
+	return openGoalsFromPool(pool).filter((goal) => goal.id !== focusedGoalId).length;
+}
+
+export function resolveSessionFocus(args: {
+	pool: Map<string, GoalRecord>;
+	focusEntry?: GoalFocusEntry | null;
+	legacyGoal?: GoalRecord | null;
+}): string | null {
+	const focusedGoalId = args.focusEntry?.focusedGoalId ?? null;
+	const focused = focusedGoalId ? focusedGoalFromPool(args.pool, focusedGoalId) : null;
+	if (focused && focused.status !== "complete") {
+		return focusedGoalId;
+	}
+	if (args.focusEntry) {
+		return null;
+	}
+	if (args.legacyGoal && args.legacyGoal.status !== "complete") {
+		if (args.pool.has(args.legacyGoal.id)) return args.legacyGoal.id;
+		args.pool.set(args.legacyGoal.id, cloneGoal(args.legacyGoal));
+		return args.legacyGoal.id;
+	}
+	const open = openGoalsFromPool(args.pool);
+	return open.length === 1 ? open[0]?.id ?? null : null;
+}
+
+export function goalSelectorLabel(goal: GoalRecord, focusedGoalId: string | null): string {
+	const marker = goal.id === focusedGoalId ? "*" : " ";
+	const mode = goal.sisyphus ? "sisyphus" : "goal";
+	const path = goal.activePath ? ` ${goal.activePath}` : "";
+	return `${marker} ${goal.id} | ${statusLabel(goal)} | ${mode} | ${truncateText(displayObjectiveTitle(goal.objective), 72)}${path}`;
+}
+
+export function buildGoalListText(pool: Map<string, GoalRecord>, focusedGoalId: string | null): string {
+	const open = openGoalsFromPool(pool);
+	if (open.length === 0) return "No open goals. Use /goals <topic> or /sisyphus <topic> to discuss, or /goals-set <objective> / /sisyphus-set <objective> to start immediately.";
+	const lines = [`Open goals: ${open.length}`, ""];
+	for (const goal of open) {
+		const focused = goal.id === focusedGoalId ? "*" : " ";
+		const mode = goal.sisyphus ? "sisyphus" : "goal";
+		const usage = goal.usage.tokensUsed > 0 || goal.usage.activeSeconds > 0
+			? ` · ${formatDuration(goal.usage.activeSeconds)} · ${formatTokenValue(goal.usage.tokensUsed).split(" ")[0]}`
+			: "";
+		lines.push(`${focused} ${goal.id} — ${statusLabel(goal)} · ${mode}${usage}`);
+		lines.push(`  ${displayObjectiveTitle(goal.objective)}`);
+		if (goal.activePath) lines.push(`  ${goal.activePath}`);
+	}
+	return lines.join("\n");
+}
+
+export function buildUnfocusedOpenGoalsSummary(openGoalCount: number): string {
+	return `No goal is focused in this session. ${openGoalCount} open goal${openGoalCount === 1 ? "" : "s"} exist in .pi/goals. Use /goal-focus to choose the session focus before doing goal work.`;
+}
+
+export function mergeFocusedGoalWithDisk(args: { memoryGoal: GoalRecord; diskGoal: GoalRecord }): GoalRecord {
+	const tokensUsed = Math.max(args.memoryGoal.usage.tokensUsed, args.diskGoal.usage.tokensUsed);
+	const activeSeconds = Math.max(args.memoryGoal.usage.activeSeconds, args.diskGoal.usage.activeSeconds);
+	return {
+		...args.diskGoal,
+		usage: { tokensUsed, activeSeconds },
+	};
+}