@openlines/opl-pi-sht 0.2.12 → 0.3.1

package/extensions/opl-modes/index.ts

@@ -41,6 +41,7 @@ import {
   PLAN_DIR,
   buildExecutePrompt,
   buildRefinePrompt,
+  capPlan,
   USER_CONFIG,
   MODE_REGISTRY,
   getModeDefinition,
@@ -57,6 +58,7 @@ import {
   extractPlanText,
   isPlanLike,
   ensurePlanDir,
+  planFilePath,
   titleFromFilename,
   listPlanFiles,
   sanitizePlanName,
@@ -78,6 +80,10 @@ import {
   resetState,
   getRefineCount,
   incrementRefineCount,
+  publishModeGlobals,
+  clearModeGlobals,
+  getSessionCwd,
+  setSessionCwd,
 } from "./state.js";
 import { showSelectMenu } from "./menus.js";
 
@@ -105,7 +111,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
       async execute(_toolCallId, params) {
         const mode = getMode();
         const modeDef = getModeDefinition(mode);
-        const modeAllowed = modeDef?.tools ?? null; // null = mode inherits all tools
+        const modeAllowed = modeDef?.tools ?? getModeDefinition("off")?.tools ?? null; // Unlisted modes inherit the pinned baseline, if any.
         const current = pi.getActiveTools();
         const enable = lazyToolsToEnable(params.tools as string[] | undefined, current, modeAllowed);
         if (enable.length > 0) pi.setActiveTools([...current, ...enable]);
@@ -123,6 +129,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
   // ─── Saved model for restoring ─────────────────────────────────────────────
   let savedModel: Model<any> | null = null;
   const queueModelChange = createLatestModelQueue();
+  let pendingPlanModel: Promise<void> | null = null;
   // Consecutive restore failures for the same model, so an un-authable restore point is
   // retried once and then released instead of blocking future captures forever.
   let restoreAttempts = 0;
@@ -260,7 +267,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
   function getPlanFilePath(): string | null {
     const file = getActivePlanFile();
     if (!file) return null;
-    return join(process.cwd(), PLAN_DIR, file);
+    return planFilePath(getSessionCwd(), file);
   }
 
   function getPlanDisplayTitle(): string | null {
@@ -269,7 +276,8 @@ export default function modeSwitcher(pi: ExtensionAPI) {
     const filePath = getPlanFilePath();
     if (filePath && existsSync(filePath)) {
       const heading = readFileSync(filePath, "utf-8").match(/^# Plan:\s*(.+)$/m);
-      if (heading) return heading[1].trim();
+      const captured = heading?.[1];
+      if (captured) return captured.trim();
     }
     return titleFromFilename(file);
   }
@@ -356,7 +364,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
     transition("plan", pi);
     const modeDef = getModeDefinition("plan");
     saveAndSetActiveTools(planModeTools());
-    applyModeModel(ctx, modeDef);
+    pendingPlanModel = applyModeModel(ctx, modeDef);
     updateStatus(ctx);
     if (ctx.hasUI && !USER_CONFIG.ui.hideNotify) {
       const notify = modeDef?.labels?.notify ?? USER_CONFIG.labels.plan.notify;
@@ -367,10 +375,15 @@ export default function modeSwitcher(pi: ExtensionAPI) {
 
   async function enterExecuteMode(ctx: ExtensionContext): Promise<void> {
     transition("execute", pi);
-    const baseNames = savedToolNames ?? pi.getActiveTools();
-    pi.setActiveTools(applyLazyPolicy([...toolsWithoutPlanComplete(baseNames), "plan_complete"]));
-    savedToolNames = null;
     const modeDef = getModeDefinition("execute");
+    if (modeDef?.tools) {
+      saveAndSetActiveTools(withPlanComplete("execute", toolsWithoutPlanComplete(modeDef.tools)));
+    } else {
+      const baseNames = savedToolNames ?? pi.getActiveTools();
+      pi.setActiveTools(applyLazyPolicy(withPlanComplete("execute", toolsWithoutPlanComplete(baseNames))));
+      savedToolNames = null;
+    }
+    await pendingPlanModel;
     await applyModeModel(ctx, modeDef);
     updateStatus(ctx);
     const title = getPlanDisplayTitle();
@@ -390,6 +403,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
    */
   function enterOffMode(ctx: ExtensionContext, message?: string, silent = false): void {
     transition("off", pi);
+    pendingPlanModel = null;
     const offModeDef = getModeDefinition("off");
     // OFF gates tools only when the user declares modes.off.tools; otherwise it restores
     // whatever was active before the mode.
@@ -444,7 +458,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
   /** Open the mode picker. Handles all mode transitions including cross-mode switches. */
   async function openModePicker(ctx: ExtensionContext): Promise<void> {
     const current = getMode();
-    const planFiles = listPlanFiles();
+    const planFiles = listPlanFiles(getSessionCwd());
 
     // Build mode list dynamically from registry (skip invisible/disabled modes)
     const registryModes = Array.from(MODE_REGISTRY.entries())
@@ -504,7 +518,9 @@ export default function modeSwitcher(pi: ExtensionAPI) {
 
     if (!restored) {
       resetState();
-      restoreAllTools();
+      const offTools = getModeDefinition("off")?.tools;
+      if (offTools) saveAndSetActiveTools(withPlanComplete("off", offTools), true);
+      else restoreAllTools();
       applyOffModel(ctx);
       updateStatus(ctx);
       return;
@@ -521,13 +537,21 @@ export default function modeSwitcher(pi: ExtensionAPI) {
     const mode = getMode();
     const modeDef = getModeDefinition(mode);
 
+    // A restored plan or execution needs the pinned resting set as its inherited baseline,
+    // not the host tools active before this branch was restored.
+    const offTools = getModeDefinition("off")?.tools;
+    if ((mode === "plan" || mode === "execute") && offTools) {
+      saveAndSetActiveTools(withPlanComplete("off", offTools), true);
+    }
+
     if (modeDef?.tools) {
       // Honor allowPlanComplete here too, otherwise a resume drops the tool a mode was given.
       // OFF's declared list is the resting baseline, so it must not keep a stale snapshot.
-      saveAndSetActiveTools(withPlanComplete(mode, modeDef.tools), mode === "off");
+      const tools = mode === "execute" ? toolsWithoutPlanComplete(modeDef.tools) : modeDef.tools;
+      saveAndSetActiveTools(withPlanComplete(mode, tools), mode === "off");
     } else if (mode === "execute") {
       const allNames = pi.getActiveTools();
-      pi.setActiveTools(applyLazyPolicy([...toolsWithoutPlanComplete(allNames), "plan_complete"]));
+      pi.setActiveTools(applyLazyPolicy(withPlanComplete(mode, toolsWithoutPlanComplete(allNames))));
     } else {
       // Default: the active set minus plan_complete, re-added when the mode allows it.
       const allNames = pi.getActiveTools();
@@ -551,7 +575,14 @@ export default function modeSwitcher(pi: ExtensionAPI) {
   // ─── Event: session_start ──────────────────────────────────────────────────────
 
   pi.on("session_start", async (event, ctx) => {
+    setSessionCwd(ctx.cwd);
+    // Re-publish the footer seam: a previous session in this process cleared it on shutdown.
+    publishModeGlobals();
     if (event.reason === "startup") {
+      if (getMode() === "off" && (pi.getFlag("chat") === true || pi.getFlag("plan") === true)) {
+        const offTools = getModeDefinition("off")?.tools;
+        if (offTools) saveAndSetActiveTools(withPlanComplete("off", offTools), true);
+      }
       if (pi.getFlag("chat") === true && getMode() === "off") {
         enterChatMode(ctx);
         return;
@@ -565,6 +596,12 @@ export default function modeSwitcher(pi: ExtensionAPI) {
     await syncStateFromBranch(ctx, event.reason === "resume" || event.reason === "fork");
   });
 
+  pi.on("session_shutdown", async () => {
+    // Hand the seam back: an orphaned mode global would keep rendering a mode that no
+    // longer belongs to any live session.
+    clearModeGlobals();
+  });
+
   // ─── Event: before_agent_start ──────────────────────────────────────────
 
   pi.on("before_agent_start", (event: BeforeAgentStartEvent): BeforeAgentStartEventResult => {
@@ -578,7 +615,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
       const filePath = getPlanFilePath();
       if (filePath && existsSync(filePath)) {
         const planContent = readFileSync(filePath, "utf-8");
-        return { systemPrompt: event.systemPrompt + "\n\n" + buildRefinePrompt(planContent) };
+        return { systemPrompt: event.systemPrompt + "\n\n" + buildRefinePrompt(planContent, filePath) };
       }
     }
     
@@ -590,12 +627,14 @@ export default function modeSwitcher(pi: ExtensionAPI) {
       const customTemplate = modeDef.prompt;
       if (typeof customTemplate === "string" && customTemplate.trim().length > 0) {
         // User-configured template via modes.execute.prompt — {plan} is replaced with the plan file content.
+        // Capped here too: a custom template must not become a way around the injection budget.
+        const capped = capPlan(planContent, USER_CONFIG.plan.maxInjectBytes, filePath).text;
         const filled = customTemplate.includes("{plan}")
-          ? customTemplate.replace("{plan}", planContent)
-          : `${customTemplate}\n\nPlan:\n${planContent}`;
+          ? customTemplate.replace("{plan}", capped)
+          : `${customTemplate}\n\nPlan:\n${capped}`;
         return { systemPrompt: event.systemPrompt + "\n\n" + filled };
       }
-      return { systemPrompt: event.systemPrompt + "\n\n" + buildExecutePrompt(planContent) };
+      return { systemPrompt: event.systemPrompt + "\n\n" + buildExecutePrompt(planContent, filePath) };
     }
     
     // Generic mode prompt from registry
@@ -628,7 +667,13 @@ export default function modeSwitcher(pi: ExtensionAPI) {
     if (event.toolName !== "bash") return {};
     if (!modeDef?.safePatterns && !modeDef?.destructivePatterns) return {};
 
-    const command = event.input.command as string;
+    if (typeof event.input.command !== "string") {
+      // Uninspectable commands are refused rather than coerced: String(["rm","-rf"]) would
+      // reach the pattern matchers as "rm,-rf" and slip past a segment-based safe list.
+      return { block: true, reason: `[mode-switcher] Blocked a bash tool call whose command was not a string [${mode} mode].` };
+    }
+
+    const command = event.input.command;
     const reason = bashBlockReason(command, modeDef.safePatterns, modeDef.destructivePatterns);
     if (reason) {
       return { block: true, reason: `[mode-switcher] Command blocked — ${reason} [${mode} mode]` };
@@ -699,7 +744,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
     setRefining(false);
 
     if (planText) {
-      const planDir = ensurePlanDir();
+      const planDir = ensurePlanDir(getSessionCwd());
       const activeFile = getActivePlanFile();
       let filename = activeFile;
       if (!filename) {
@@ -776,6 +821,8 @@ export default function modeSwitcher(pi: ExtensionAPI) {
       const filename = `${PLAN_FILE_PREFIX}${sanitized}.md`;
       enterPlanWithFile(filename, pi);
       saveAndSetActiveTools(planModeTools());
+      pendingPlanModel = applyModeModel(ctx, getModeDefinition("plan"));
+      await pendingPlanModel;
       updateStatus(ctx);
       const createTitle = titleFromFilename(filename);
       if (ctx.hasUI && !USER_CONFIG.ui.hideNotify) {
@@ -842,25 +889,30 @@ export default function modeSwitcher(pi: ExtensionAPI) {
   }
 
   /** Load an existing plan file and show the action menu. */
-  function loadPlanAndShowMenu(ctx: ExtensionContext, filename: string, displayName: string): void {
+  async function loadPlanAndShowMenu(ctx: ExtensionContext, filename: string, displayName: string): Promise<void> {
     enterPlanWithFile(filename, pi);
     saveAndSetActiveTools(planModeTools());
+    pendingPlanModel = applyModeModel(ctx, getModeDefinition("plan"));
+    await pendingPlanModel;
     updateStatus(ctx);
     if (ctx.hasUI && !USER_CONFIG.ui.hideNotify) {
       ctx.ui.notify(USER_CONFIG.labels.plan.notifyLoaded.replace("{title}", displayName), "info");
     }
 
-    const filePath = join(process.cwd(), PLAN_DIR, filename);
+    const filePath = planFilePath(getSessionCwd(), filename);
     if (existsSync(filePath)) {
       const planContent = readFileSync(filePath, "utf-8");
-      pi.appendEntry("plan-mode", { title: displayName, plan: planContent });
+      // The entry copy is display/session only (plain custom entries never reach the
+      // model), but it is written to the session file forever, so it gets its own budget.
+      const entry = capPlan(planContent, USER_CONFIG.plan.maxEntryBytes, filePath);
+      pi.appendEntry("plan-mode", { title: displayName, plan: entry.text, truncated: entry.truncated, file: filePath });
     }
   }
 
   // ─── Entry renderer for TUI-only plan cards (never sent to the model) ──────
 
   pi.registerEntryRenderer("plan-mode", (entry, _options, theme) => {
-    const data = (entry.data ?? {}) as { title?: string; plan?: string };
+    const data = (entry.data ?? {}) as { title?: string; plan?: string; truncated?: boolean; file?: string };
     const border = new DynamicBorder((s: string) => theme.fg("border", s));
     const container = new Container();
     container.addChild(border);
@@ -870,6 +922,9 @@ export default function modeSwitcher(pi: ExtensionAPI) {
       container.addChild(new Spacer());
       container.addChild(new Text(body));
     }
+    if (data.truncated) {
+      container.addChild(new Text(theme.fg("muted", `✂ truncated copy — full plan: ${data.file ?? PLAN_DIR}`)));
+    }
     container.addChild(border);
     return container;
   });
@@ -982,7 +1037,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
       if (!input) {
         const current = getMode();
         if (current === "off") {
-          const files = listPlanFiles();
+          const files = listPlanFiles(getSessionCwd());
           if (files.length === 0) {
             await promptNameAndEnterPlanMode(ctx);
           } else {
@@ -995,7 +1050,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
             if (choice === "__new__") {
               await promptNameAndEnterPlanMode(ctx);
             } else {
-              loadPlanAndShowMenu(ctx, choice, titleFromFilename(choice));
+              await loadPlanAndShowMenu(ctx, choice, titleFromFilename(choice));
               await showPlanMenu(ctx);
             }
           }
@@ -1025,11 +1080,11 @@ export default function modeSwitcher(pi: ExtensionAPI) {
         return;
       }
       const filename = `${PLAN_FILE_PREFIX}${sanitized}.md`;
-      const filePath = join(process.cwd(), PLAN_DIR, filename);
+      const filePath = planFilePath(getSessionCwd(), filename);
 
       if (existsSync(filePath)) {
         if (getMode() !== "off") enterOffMode(ctx, undefined, true);
-        loadPlanAndShowMenu(ctx, filename, titleFromFilename(filename));
+        await loadPlanAndShowMenu(ctx, filename, titleFromFilename(filename));
         await showPlanMenu(ctx);
       } else {
         if (getMode() === "plan" || getMode() === "execute") {
@@ -1039,6 +1094,8 @@ export default function modeSwitcher(pi: ExtensionAPI) {
         if (getMode() !== "off") enterOffMode(ctx, undefined, true);
         enterPlanWithFile(filename, pi);
         saveAndSetActiveTools(planModeTools());
+        pendingPlanModel = applyModeModel(ctx, getModeDefinition("plan"));
+        await pendingPlanModel;
         updateStatus(ctx);
         if (ctx.hasUI && !USER_CONFIG.ui.hideNotify) {
           ctx.ui.notify(USER_CONFIG.labels.plan.notifyWithTitle.replace("{title}", titleFromFilename(filename)), USER_CONFIG.labels.plan.notifyType as "info" | "warning" | "error");
@@ -1078,13 +1135,14 @@ export default function modeSwitcher(pi: ExtensionAPI) {
           pi.sendUserMessage("Execute the plan steps now.", { deliverAs: "followUp" });
           return;
         }
-        const files = listPlanFiles();
+        const files = listPlanFiles(getSessionCwd());
         if (files.length === 0) {
           if (ctx.hasUI) ctx.ui.notify("No plan files found. Run /plan first.", "warning");
           return;
         }
         if (files.length === 1) {
-          await startExecute(files[0].name);
+          const only = files[0];
+          if (only) await startExecute(only.name);
           return;
         }
         const items: SelectItem[] = files.map(f => ({ value: f.name, label: f.title }));
@@ -1100,7 +1158,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
         return;
       }
       const filename = `${PLAN_FILE_PREFIX}${sanitized}.md`;
-      const filePath = join(process.cwd(), PLAN_DIR, filename);
+      const filePath = planFilePath(getSessionCwd(), filename);
       if (!existsSync(filePath)) {
         if (ctx.hasUI) ctx.ui.notify(`Plan "${input}" not found. Check /plan for available plans.`, "warning");
         return;
@@ -1124,6 +1182,7 @@ export default function modeSwitcher(pi: ExtensionAPI) {
 
     const idx = order.indexOf(current);
     const next = idx === -1 ? order[0] : order[(idx + 1) % order.length];
+    if (!next) return; // order is non-empty above; this is what lets the branches below take a string
     if (next === current) return;
 
     if (next === "off") {

package/extensions/opl-modes/state.ts

@@ -7,12 +7,17 @@ import type { AgentMode, AgentModeBlob, ModeAppearanceConfig, ModeModelConfig }
 const state: {
   mode: AgentMode;
   activePlanFile: string | null;
+  sessionCwd: string;
   restoringModel: ModeModelConfig | null;
   refining: boolean;
   refineCount: number;
 } = {
   mode: "off",
   activePlanFile: null,
+  // Until the first `session_start` hands us the real one, the directory the harness was started
+  // in is the only candidate. Plans and the footer path must never be resolved from
+  // `process.cwd()` at the call site: a session opened elsewhere would write its plans there.
+  sessionCwd: process.cwd(),
   restoringModel: null,
   refining: false,
   refineCount: 0,
@@ -23,6 +28,23 @@ const state: {
 (globalThis as Record<string, unknown>).__planMode = { mode: "off" };
 (globalThis as Record<string, unknown>).__chatMode = { mode: "off" };
 
+/**
+ * Cross-extension seam. `opl-footer` publishes `__footerRequestRender` while a footer is
+ * mounted; `__agentMode`, `__planMode` and `__chatMode` are read by the footer's mode
+ * segment and by `opl-input`. Extensions install one directory at a time and load in any
+ * combination, so nothing here may assume the other side exists or is healthy: the value can
+ * be missing, be something else entirely, or close over a TUI that was already torn down.
+ */
+function requestFooterRender(): void {
+  const requestRender = (globalThis as Record<string, unknown>).__footerRequestRender;
+  if (typeof requestRender !== "function") return;
+  try {
+    (requestRender as () => void)();
+  } catch {
+    // A dead footer must not fail a mode transition.
+  }
+}
+
 /** Derive and sync all globalThis snapshots from unified state. */
 function syncGlobalThis(): void {
   const m = state.mode;
@@ -35,8 +57,23 @@ function syncGlobalThis(): void {
   // plan-family modes light up __planMode, so a custom mode cannot read as "Plan mode ON".
   (globalThis as Record<string, unknown>).__planMode = { mode: m === "plan" || m === "execute" ? m : "off" };
   (globalThis as Record<string, unknown>).__chatMode = { mode: m === "chat" ? "chat" : "off" };
-  const requestRender = (globalThis as Record<string, unknown>).__footerRequestRender;
-  if (typeof requestRender === "function") requestRender();
+  requestFooterRender();
+}
+
+/** Re-publish the seam after a fresh session starts in this process. */
+export function publishModeGlobals(): void {
+  syncGlobalThis();
+}
+
+/**
+ * Drop the seam when the session ends. A leftover value would let a footer in a later
+ * session render a mode that belongs to nobody, and the footer's own render trigger is
+ * removed with it (see `opl-footer`).
+ */
+export function clearModeGlobals(): void {
+  delete (globalThis as Record<string, unknown>).__agentMode;
+  delete (globalThis as Record<string, unknown>).__planMode;
+  delete (globalThis as Record<string, unknown>).__chatMode;
 }
 
 export function getMode(): AgentMode { return state.mode; }
@@ -126,6 +163,7 @@ export function restore(
 ): boolean {
   for (let i = entries.length - 1; i >= 0; i--) {
     const entry = entries[i];
+    if (!entry) continue; // a hole in the persisted array is not a restore candidate
     if (entry.type !== "custom" || entry.customType !== ENTRY_TYPE) continue;
 
     const data = entry.data as AgentModeBlob | undefined;
@@ -145,6 +183,7 @@ export function restore(
   // Backward compat: restore from legacy entries written by the old extensions.
   for (let i = entries.length - 1; i >= 0; i--) {
     const entry = entries[i];
+    if (!entry) continue; // a hole in the persisted array is not a restore candidate
     if (entry.type !== "custom") continue;
 
     if (entry.customType === "plan-mode") {
@@ -181,3 +220,12 @@ export function resetState(): void {
   state.refineCount = 0;
   syncGlobalThis();
 }
+
+/** The directory the current session lives in (`.pi/plans/` is resolved against this). */
+export function getSessionCwd(): string {
+  return state.sessionCwd;
+}
+
+export function setSessionCwd(cwd: string): void {
+  if (cwd) state.sessionCwd = cwd;
+}

package/extensions/opl-modes/types.ts

@@ -154,6 +154,12 @@ export interface ModeSwitcherUserConfig {
   shortcuts?: ShortcutsUserConfig;
   /** @deprecated Use `modes` registry instead. Kept for backward compat. */
   labels?: LabelsUserConfig;
+  plan?: {
+    /** Ceiling for a plan body injected into a system prompt, in bytes (default 24000). Larger plans truncate with a marker pointing at the file. */
+    maxInjectBytes?: number;
+    /** Ceiling for the plan copy kept in the `plan-mode` session entry, in bytes (default 4096). */
+    maxEntryBytes?: number;
+  };
   bashPatterns?: BashPatternsUserConfig;
   /** Replace-only: provide a list of tool names to replace the default CHAT mode tool set. Omit to keep defaults. */
   chatAllowedTools?: string[];

package/extensions/opl-modes/utils.ts

@@ -52,6 +52,7 @@ function commandSegments(command: string): string[] {
   for (let i = 0; i < command.length; i++) {
     const ch = command[i];
     const top = stack[stack.length - 1];
+    if (!top) break; // stack drained: the rest of the command is literal text
     // Single quotes are literal: nothing expands, only the closing ' matters.
     if (top.quote === "'") {
       if (ch === "'") top.quote = "";
@@ -165,9 +166,9 @@ export function extractPlanText(message: string): string | null {
 
 // ─── Plan File I/O ────────────────────────────────────────────────────────────
 
-/** Ensure .pi/plans/ exists, return its absolute path. */
-export function ensurePlanDir(): string {
-  const dir = join(process.cwd(), PLAN_DIR);
+/** Ensure <sessionCwd>/.pi/plans/ exists, return its absolute path. */
+export function ensurePlanDir(cwd: string): string {
+  const dir = join(cwd, PLAN_DIR);
   mkdirSync(dir, { recursive: true });
   return dir;
 }
@@ -181,7 +182,12 @@ export function titleFromFilename(filename: string): string {
   // Detect timestamp pattern: YYYY-MM-DD-HH-MM
   const tsMatch = stem.match(/^(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})$/);
   if (tsMatch) {
-    const [, y, m, d, h, min] = tsMatch;
+    // Five digit groups by the shape test above; the explicit checks are what let the compiler see
+    // that, rather than a cast.
+    const [y, m, d, h, min] = tsMatch.slice(1);
+    if (y === undefined || m === undefined || d === undefined || h === undefined || min === undefined) {
+      return stem.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    }
     const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
     const month = months[parseInt(m, 10) - 1] ?? m;
     return `${month} ${parseInt(d, 10)}, ${y} ${h}:${min}`;
@@ -203,8 +209,8 @@ export function sanitizePlanName(name: string): string | null {
 }
 
 /** List available plan files in .pi/plans/ with titles from # Plan: heading. */
-export function listPlanFiles(): PlanFileSummary[] {
-  const dir = join(process.cwd(), PLAN_DIR);
+export function listPlanFiles(cwd: string): PlanFileSummary[] {
+  const dir = join(cwd, PLAN_DIR);
   if (!existsSync(dir)) return [];
 
   const files = readdirSync(dir)
@@ -214,7 +220,7 @@ export function listPlanFiles(): PlanFileSummary[] {
   return files.map((filename) => {
     const content = readFileSync(join(dir, filename), "utf-8");
     const titleMatch = content.match(/^# Plan:\s*(.+)$/m);
-    const title = titleMatch ? titleMatch[1].trim() : titleFromFilename(filename);
+    const title = titleMatch?.[1] ? titleMatch[1].trim() : titleFromFilename(filename);
     return { name: filename, title };
   });
 }
@@ -265,4 +271,8 @@ export function applyLabelColor(theme: Theme, color: string, text: string): stri
   } catch {
     return text;
   }
-}
+}
+/** Absolute path of a plan file inside the session directory. */
+export function planFilePath(cwd: string, filename: string): string {
+  return join(cwd, PLAN_DIR, filename);
+}

package/extensions/opl-questionnaire/index.ts

@@ -22,6 +22,7 @@ import {
 import {
 	type Answer,
 	type Question,
+	type QuestionCheck,
 	QuestionnaireParams,
 	type QuestionnaireResult,
 	type RenderOption,
@@ -42,7 +43,7 @@ export function errorResult(
 /** Validate the question list. Returns the first error message, or null when valid.
  *  Blank ids are rejected (answers are keyed by id and "" would produce an empty key),
  *  as are duplicate ids and questions with nothing selectable. */
-export function validateQuestions(questions: Question[]): string | null {
+export function validateQuestions(questions: readonly QuestionCheck[]): string | null {
 	const seenIds = new Set<string>();
 	for (const q of questions) {
 		if (q.id.trim() === "") {
@@ -303,8 +304,10 @@ export default function questionnaire(pi: ExtensionAPI) {
 						const tabs: string[] = ["← "];
 						for (let i = 0; i < questions.length; i++) {
 							const isActive = i === currentTab;
-							const isAnswered = answers.has(questions[i].id);
-							const lbl = questions[i].label;
+							const question = questions[i];
+							if (!question) continue;
+							const isAnswered = answers.has(question.id);
+							const lbl = question.label;
 							const box = isAnswered ? "■" : "□";
 							const color = isAnswered ? "success" : "muted";
 							const text = ` ${box} ${lbl} `;
@@ -326,6 +329,7 @@ export default function questionnaire(pi: ExtensionAPI) {
 					function renderOptions() {
 						for (let i = 0; i < opts.length; i++) {
 							const opt = opts[i];
+							if (!opt) continue; // a hole in the option list renders nothing rather than throwing mid-frame
 							const selected = i === optionIndex;
 							const isOther = opt.isOther === true;
 							const prefix = selected ? theme.fg("accent", "> ") : "  ";
@@ -435,7 +439,9 @@ export default function questionnaire(pi: ExtensionAPI) {
 		},
 
 		renderResult(result, _options, theme, _context) {
-			if (result.isError) {
+			// `isError` on tool results is newer than the declared floor: pi 0.87.x does not carry
+			// it in its types, and an older host leaves it undefined, which reads as "not an error".
+			if ((result as { isError?: boolean }).isError) {
 				const text = result.content[0];
 				return new Text(theme.fg("error", text?.type === "text" ? text.text : ""), 0, 0);
 			}

package/extensions/opl-questionnaire/types.ts

@@ -18,6 +18,10 @@ export interface Question {
 	allowOther: boolean;
 }
 
+/** The fields `validateQuestions` reads: the same shape on raw tool params (where `label`
+ *  still has to be defaulted) and on normalized questions. */
+export type QuestionCheck = Pick<Question, "id" | "options"> & Partial<Pick<Question, "allowOther">>;
+
 export interface Answer {
 	id: string;
 	value: string;