pi-monofold 0.10.0 → 0.11.0

package/README.md

@@ -86,7 +86,7 @@ pi -e npm:pi-monofold
 1. Install the extension (see [Install](#install)).
 2. In your control repository, create `.pi/monofold.yaml` with at least one workspace entry (or run `/monofold:init`).
 3. Start Pi in the control repository and run `/monofold:explore show the project workspaces`.
-4. Use `/monofold:focus`, `ctrl+shift+m`, or `shift+ctrl+f` to switch focus presets when `focusPresets` are configured.
+4. Use `/monofold:focus`, `ctrl+shift+m`, or `shift+ctrl+f` to switch focus presets when `focusPresets` are configured. Active Focus is restored automatically on the next Pi session in the same control repository.
 5. Use `/monofold:write` for routed Markdown outputs and `/monofold:git` for guarded git workflows.
 
 Example command flows: [docs/examples.md](./docs/examples.md).

package/focus-preset.ts

@@ -1,3 +1,4 @@
+import { type FocusSessionLoadResult } from "./focus-session-state.js";
 import { type MonofoldRouteType, parseDefaultRouteOverride } from "./focus-route-override.js";
 import {
   parseDecisionNoteDestination,
@@ -213,14 +214,59 @@ export function warnZeroTargetMatchesForPreset(
   }
 }
 
+export type ActiveFocusInitSource = "restored" | "default" | "stale" | "cleared" | "malformed";
+
 let activeFocusPresetId: string | null = null;
 let activeFocusInitialized = false;
+let activeFocusInitSource: ActiveFocusInitSource | null = null;
 
-/** Initializes the active focus preset once per process/session. */
-export function ensureActiveFocusInitialized(focusPresets: FocusPreset[] | undefined): void {
+/** Returns how the current session initialized Active Focus, when applicable. */
+export function getActiveFocusInitSource(): ActiveFocusInitSource | null {
+  return activeFocusInitSource;
+}
+
+/** Returns true after Active Focus has been initialized for this Pi session. */
+export function isActiveFocusSessionInitialized(): boolean {
+  return activeFocusInitialized;
+}
+
+function clearActiveFocusInitSource(): void {
+  activeFocusInitSource = null;
+}
+
+/** Applies persisted or default Active Focus once per Pi session. */
+export function applyActiveFocusSession(
+  focusPresets: FocusPreset[] | undefined,
+  persisted: FocusSessionLoadResult = { kind: "missing" },
+): void {
   if (activeFocusInitialized) return;
   activeFocusInitialized = true;
-  activeFocusPresetId = pickDefaultFocusPresetId(focusPresets);
+  const presets = focusPresets ?? [];
+
+  if (persisted.kind === "loaded") {
+    const savedId = persisted.activeFocusPresetId;
+    if (savedId === null) {
+      activeFocusPresetId = null;
+      activeFocusInitSource = "cleared";
+      return;
+    }
+    if (findFocusPresetById(presets, savedId)) {
+      activeFocusPresetId = savedId;
+      activeFocusInitSource = "restored";
+      return;
+    }
+    activeFocusPresetId = pickDefaultFocusPresetId(presets);
+    activeFocusInitSource = "stale";
+    return;
+  }
+
+  activeFocusPresetId = pickDefaultFocusPresetId(presets);
+  activeFocusInitSource = persisted.kind === "malformed" ? "malformed" : "default";
+}
+
+/** Initializes the active focus preset once per process/session. */
+export function ensureActiveFocusInitialized(focusPresets: FocusPreset[] | undefined): void {
+  applyActiveFocusSession(focusPresets, { kind: "missing" });
 }
 
 /** Returns the current active focus preset id, if any. */
@@ -235,6 +281,7 @@ export function setActiveFocusPresetId(id: string, focusPresets: FocusPreset[] |
   }
   activeFocusPresetId = id;
   activeFocusInitialized = true;
+  clearActiveFocusInitSource();
   resetFocusSkillsWarningState();
   resetDecisionNoteWarningState();
 }
@@ -315,6 +362,7 @@ export function cycleActiveFocusPresetBackward(focusPresets: FocusPreset[] | und
 export function clearActiveFocusPresetId(): void {
   activeFocusPresetId = null;
   activeFocusInitialized = true;
+  clearActiveFocusInitSource();
   resetFocusSkillsWarningState();
   resetDecisionNoteWarningState();
 }
@@ -323,6 +371,7 @@ export function clearActiveFocusPresetId(): void {
 export function resetActiveFocusSessionState(): void {
   activeFocusPresetId = null;
   activeFocusInitialized = false;
+  activeFocusInitSource = null;
   resetFocusSkillsWarningState();
   resetDecisionNoteWarningState();
 }

package/focus-session-state.ts

@@ -0,0 +1,58 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { normalizeGuardPath } from "./path-normalize.js";
+
+export const FOCUS_SESSION_STATE_RELATIVE_PATH = path.join(".pi", "monofold-focus-session.json");
+
+export type FocusSessionStateFile = {
+  version: 1;
+  activeFocusPresetId: string | null;
+};
+
+export type FocusSessionLoadResult =
+  | { kind: "missing" }
+  | { kind: "malformed"; error: string }
+  | { kind: "loaded"; activeFocusPresetId: string | null };
+
+function assertFocusSessionStateFile(value: unknown): asserts value is FocusSessionStateFile {
+  if (typeof value !== "object" || value === null) throw new Error("focus session state file must be an object");
+  if (!("version" in value) || (value as { version?: unknown }).version !== 1) {
+    throw new Error("focus session state file requires version: 1");
+  }
+  const activeFocusPresetId = (value as { activeFocusPresetId?: unknown }).activeFocusPresetId;
+  if (activeFocusPresetId !== null && typeof activeFocusPresetId !== "string") {
+    throw new Error("focus session state file requires string|null activeFocusPresetId");
+  }
+  if (typeof activeFocusPresetId === "string" && activeFocusPresetId.trim() === "") {
+    throw new Error("focus session state file activeFocusPresetId must be non-empty when set");
+  }
+}
+
+export function resolveFocusSessionStatePath(root: string): string {
+  return path.join(normalizeGuardPath(root), FOCUS_SESSION_STATE_RELATIVE_PATH);
+}
+
+export async function loadFocusSessionState(root: string): Promise<FocusSessionLoadResult> {
+  const filePath = resolveFocusSessionStatePath(root);
+  try {
+    const text = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(text) as unknown;
+    assertFocusSessionStateFile(parsed);
+    return { kind: "loaded", activeFocusPresetId: parsed.activeFocusPresetId };
+  } catch (error) {
+    const code = typeof error === "object" && error && "code" in error ? (error as { code?: string }).code : undefined;
+    if (code === "ENOENT") return { kind: "missing" };
+    const message = error instanceof Error ? error.message : String(error);
+    return { kind: "malformed", error: message };
+  }
+}
+
+export async function saveFocusSessionState(root: string, activeFocusPresetId: string | null): Promise<void> {
+  const filePath = resolveFocusSessionStatePath(root);
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const payload: FocusSessionStateFile = {
+    version: 1,
+    activeFocusPresetId,
+  };
+  await writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}

package/index.ts

@@ -6,13 +6,15 @@ import path from "node:path";
 import YAML from "yaml";
 import {
   type ActiveFocusPresetPosition,
+  applyActiveFocusSession,
   cycleActiveFocusPresetBackward,
   cycleActiveFocusPresetForward,
   type FocusPreset,
-  ensureActiveFocusInitialized,
   findFocusPresetById,
+  getActiveFocusInitSource,
   getActiveFocusPresetId,
   getActiveFocusPresetPosition,
+  isActiveFocusSessionInitialized,
   biasMatchesTowardActiveFocus,
   isTagBasedTargetInference,
   matchesFocusTarget,
@@ -42,6 +44,11 @@ import {
   readMonofoldFile,
   runMonofoldSearch,
 } from "./monofold-read-ops.js";
+import {
+  FOCUS_SESSION_STATE_RELATIVE_PATH,
+  loadFocusSessionState,
+  saveFocusSessionState,
+} from "./focus-session-state.js";
 import {
   clearUnknownPathAllows,
   loadUnknownPathAllows,
@@ -919,8 +926,16 @@ function sendCommandError(pi: ExtensionAPI, command: string, error: unknown, usa
   sendCommandOutput(pi, command, `Error: ${message}\n\nUsage:\n${usage}`, { error: message });
 }
 
+function formatActiveFocusInitSourceSuffix(): string {
+  const source = getActiveFocusInitSource();
+  if (source === "restored") return " [restored]";
+  if (source === "stale") return " [stale save, using default]";
+  if (source === "malformed") return " [using default]";
+  return "";
+}
+
 function formatFocusStatus(position: ActiveFocusPresetPosition): string {
-  const base = `focus: ${position.preset.label} (${position.index + 1}/${position.total}) ${FOCUS_CYCLE_SHORTCUT} / ${FOCUS_CYCLE_BACKWARD_SHORTCUT}`;
+  const base = `focus: ${position.preset.label} (${position.index + 1}/${position.total})${formatActiveFocusInitSourceSuffix()} ${FOCUS_CYCLE_SHORTCUT} / ${FOCUS_CYCLE_BACKWARD_SHORTCUT}`;
   const route = position.preset.defaultRouteOverride ? ` route:${position.preset.defaultRouteOverride}` : "";
   const note = position.preset.decisionNoteDestination
     ? ` note:${position.preset.decisionNoteDestination.path}`
@@ -928,6 +943,38 @@ function formatFocusStatus(position: ActiveFocusPresetPosition): string {
   return `${base}${route}${note}`;
 }
 
+function notifyActiveFocusInitSource(ctx: ExtensionContext | ExtensionCommandContext, loaded: LoadedConfig): void {
+  if (!ctx.hasUI) return;
+  const source = getActiveFocusInitSource();
+  if (source === "malformed") {
+    ctx.ui.notify(
+      `Ignored malformed focus session state at ${FOCUS_SESSION_STATE_RELATIVE_PATH}; using default Active Focus.`,
+      "warning",
+    );
+    return;
+  }
+  if (source === "stale") {
+    ctx.ui.notify("Saved Active Focus preset is no longer valid; using default.", "warning");
+    return;
+  }
+  if (source === "restored") {
+    const position = getActiveFocusPresetPosition(loaded.raw.focusPresets);
+    if (position) {
+      ctx.ui.notify(`Restored Active Focus: ${position.preset.label} (${position.index + 1}/${position.total})`, "info");
+    }
+  }
+}
+
+async function ensureActiveFocusReady(loaded: LoadedConfig): Promise<void> {
+  if (isActiveFocusSessionInitialized()) return;
+  const persisted = await loadFocusSessionState(loaded.root);
+  applyActiveFocusSession(loaded.raw.focusPresets, persisted);
+}
+
+async function persistActiveFocusSession(root: string): Promise<void> {
+  await saveFocusSessionState(root, getActiveFocusPresetId());
+}
+
 function updateFocusStatus(ctx: ExtensionContext | ExtensionCommandContext, loaded: LoadedConfig): void {
   if (!ctx.hasUI) return;
   const position = getActiveFocusPresetPosition(loaded.raw.focusPresets);
@@ -969,7 +1016,7 @@ function biasWorkspaceMatchesWithActiveFocus(loaded: LoadedConfig, matches: Reso
 }
 
 async function resolveWorkspace(ctx: ExtensionContext | ExtensionCommandContext, loaded: LoadedConfig, target: TargetInput): Promise<ResolvedWorkspace> {
-  ensureActiveFocusInitialized(loaded.raw.focusPresets);
+  await ensureActiveFocusReady(loaded);
   let matches = loaded.workspaces.filter((workspace) => matchesTarget(workspace, target));
   if (matches.length === 0) throw new Error(`No workspace matches target: ${JSON.stringify(target)}`);
   if (matches.length > 1 && isTagBasedTargetInference(target)) {
@@ -1137,12 +1184,14 @@ async function buildManifest(
   loaded: LoadedConfig,
   options?: { skills?: import("@earendil-works/pi-coding-agent").Skill[] },
 ): Promise<string> {
-  ensureActiveFocusInitialized(loaded.raw.focusPresets);
+  await ensureActiveFocusReady(loaded);
   const lines = ["Pi Monofold Manifest:"];
   const activePreset = getActiveFocusPreset(loaded);
   const position = getActiveFocusPresetPosition(loaded.raw.focusPresets);
   if (activePreset && position) {
-    lines.push(`Active Focus: ${activePreset.label} (${activePreset.id}, ${position.index + 1}/${position.total})`);
+    lines.push(
+      `Active Focus: ${activePreset.label} (${activePreset.id}, ${position.index + 1}/${position.total})${formatActiveFocusInitSourceSuffix()}`,
+    );
     if (activePreset.defaultRouteOverride) {
       lines.push(`Default write route override: ${activePreset.defaultRouteOverride} (explicit routeType/--route still wins)`);
     }
@@ -1443,8 +1492,9 @@ export default function piMultiWorkspace(pi: ExtensionAPI) {
   pi.on("session_start", async (_event, ctx) => {
     try {
       const loaded = await loadConfig(ctx.cwd);
-      ensureActiveFocusInitialized(loaded.raw.focusPresets);
+      await ensureActiveFocusReady(loaded);
       updateFocusStatus(ctx, loaded);
+      notifyActiveFocusInitSource(ctx, loaded);
       const activeId = getActiveFocusPresetId();
       if (!activeId) return;
       const preset = findFocusPresetById(loaded.raw.focusPresets, activeId);
@@ -1459,7 +1509,7 @@ export default function piMultiWorkspace(pi: ExtensionAPI) {
   pi.on("before_agent_start", async (_event, ctx) => {
     try {
       const loaded = await loadConfig(ctx.cwd);
-      ensureActiveFocusInitialized(loaded.raw.focusPresets);
+      await ensureActiveFocusReady(loaded);
       const manifest = await buildManifest(loaded, { skills: _event.systemPromptOptions?.skills });
       const activePreset = getActiveFocusPreset(loaded);
       const focusInjection = activePreset ? await buildFocusContextInjection(loaded, activePreset) : undefined;
@@ -2067,7 +2117,7 @@ ${focusInjection.text}` : ""}
     try {
       const loaded = await loadConfig(ctx.cwd);
       const focusPresets = loaded.raw.focusPresets ?? [];
-      ensureActiveFocusInitialized(focusPresets);
+      await ensureActiveFocusReady(loaded);
       updateFocusStatus(ctx, loaded);
 
       if (focusPresets.length === 0) {
@@ -2085,6 +2135,7 @@ ${focusInjection.text}` : ""}
       if (focusPresets.length === 1) {
         const preset = focusPresets[0]!;
         setActiveFocusPresetId(preset.id, focusPresets);
+        await persistActiveFocusSession(ctx.cwd);
         await notifyFocusApplied(ctx, loaded, { preset, index: 0, total: 1 }, "command");
         return;
       }
@@ -2095,6 +2146,7 @@ ${focusInjection.text}` : ""}
         return;
       }
       const position = setActiveFocusPresetByLabel(choice, focusPresets);
+      await persistActiveFocusSession(ctx.cwd);
       await notifyFocusApplied(ctx, loaded, position, "command");
     } catch (error) {
       sendCommandError(pi, "monofold:focus", error, "/monofold:focus");
@@ -2109,8 +2161,10 @@ ${focusInjection.text}` : ""}
         notifyNoFocusPresets(ctx);
         return;
       }
+      await ensureActiveFocusReady(loaded);
       const result = cycleActiveFocusPresetForward(focusPresets);
       if (!result) return;
+      await persistActiveFocusSession(ctx.cwd);
       updateFocusStatus(ctx, loaded);
       await warnActiveFocusPresetIssues(result.preset, loaded, loaded.workspaces, (message) => ctx.ui.notify(message, "warning"));
       if (focusPresets.length === 1) {
@@ -2132,8 +2186,10 @@ ${focusInjection.text}` : ""}
         notifyNoFocusPresets(ctx);
         return;
       }
+      await ensureActiveFocusReady(loaded);
       const result = cycleActiveFocusPresetBackward(focusPresets);
       if (!result) return;
+      await persistActiveFocusSession(ctx.cwd);
       updateFocusStatus(ctx, loaded);
       await warnActiveFocusPresetIssues(result.preset, loaded, loaded.workspaces, (message) => ctx.ui.notify(message, "warning"));
       if (focusPresets.length === 1) {

package/package.json

@@ -12,7 +12,7 @@
   },
   "description": "Pi extension that folds multiple repositories and folders into a guarded virtual monorepo for AI agents.",
   "type": "module",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "pi": {
     "extensions": [
       "./index.ts"
@@ -29,6 +29,7 @@
     "focus-route-override.ts",
     "focus-skills.ts",
     "focus-decision-note.ts",
+    "focus-session-state.ts",
     "monofold-read-ops.ts",
     "read-caps.ts",
     "validation.ts"