@pify/plan-mode 0.3.0 → 0.4.0

package/README.md

@@ -25,6 +25,7 @@ Part of the [Pify suite](https://github.com/pifydev). Install with [`pify instal
 /plan add oauth login      # enter + start planning this
 /plan off                  # leave without approval
 /plan list                 # saved plans in .pi/plans/ (v0.2)
+- **Reopen a saved plan** (v0.4): `/plan open <file>` takes a filename, a stem, or any distinctive fragment (`/plan open oauth`), hands the plan text back to the agent as a hidden message, and restarts step tracking from what the file says **now** — the file is the source of truth, not the step list it produced last time.
 /plan steps                # progress through the approved plan (v0.3)
 /plan export [file]        # standalone HTML next to the plan (v0.3)
 pi --plan                  # start a session already in plan mode

package/extensions/plan-mode.ts

@@ -30,7 +30,7 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { basename, isAbsolute, join } from "node:path";
 
 import { htmlPathFor, renderPlanHtml } from "../src/export.ts";
-import { createPlanFile, listPlanFiles, plansDir } from "../src/plans.ts";
+import { createPlanFile, listPlanFiles, plansDir, resolvePlanFile } from "../src/plans.ts";
 import {
   completeStep,
   formatSteps,
@@ -44,6 +44,7 @@ import {
   ENTER_REMINDER,
   EXIT_REMINDER,
   buildHandoffMessage,
+  buildReopenMessage,
   buildImplementHereMessage,
 } from "../src/prompts.ts";
 import { PLAN_STATE, replayBranch } from "../src/state.ts";
@@ -425,7 +426,7 @@ export default function planMode(pi: ExtensionAPI) {
   // ── Command & shortcut ───────────────────────────────────────────────
 
   pi.registerCommand("plan", {
-    description: "Plan mode: /plan [off | list | steps | export [file] | <first planning prompt>]",
+    description: "Plan mode: /plan [off | list | open <file> | steps | export [file] | <first planning prompt>]",
     handler: async (args, ctx) => {
       const text = (args ?? "").trim();
       if (text.toLowerCase() === "steps") {
@@ -478,6 +479,37 @@ export default function planMode(pi: ExtensionAPI) {
         );
         return;
       }
+      // v0.4: reopen a saved plan — the other half of the plan library. The
+      // file is the source of truth, so tracking restarts from what it says
+      // now, not from the step list it produced when it was written.
+      if (text.toLowerCase().startsWith("open")) {
+        const wanted = text.slice("open".length).trim();
+        if (!wanted) {
+          notify(ctx, "Usage: /plan open <file>  (see /plan list)", "warning");
+          return;
+        }
+        const file = resolvePlanFile(ctx.cwd, wanted);
+        if (!file) {
+          notify(ctx, `No saved plan matches "${wanted}". /plan list shows what is there.`, "warning");
+          return;
+        }
+        const markdown = readFileSafe(file);
+        if (!markdown) {
+          notify(ctx, `Could not read ${file}.`, "error");
+          return;
+        }
+        const steps = parseSteps(markdown);
+        commit(ctx, { ...state, planFile: file, steps });
+        sendReminder(buildReopenMessage(file, markdown));
+        notify(
+          ctx,
+          steps.length > 0
+            ? `Reopened ${basename(file)} — tracking ${steps.length} steps. /plan steps to view.`
+            : `Reopened ${basename(file)}. No checklist steps were found in it.`,
+          "info",
+        );
+        return;
+      }
       if (text.toLowerCase() === "off") {
         if (!state.active) {
           notify(ctx, "Plan mode is not active.", "info");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pify/plan-mode",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Read-only planning mode for pi with an explicit approve-then-execute gate: enforced tool policy, plan files, approach options, fresh-session handoff",
   "keywords": [
     "pi-package",

package/src/plans.ts

@@ -1,5 +1,5 @@
 import { mkdirSync, writeFileSync, existsSync, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 
 /** Plan files live in .pi/plans/, reviewable and committable. */
 export function plansDir(cwd: string): string {
@@ -41,6 +41,27 @@ export function listPlanFiles(cwd: string): Array<{ file: string; size: number }
   }
 }
 
+/**
+ * Find a saved plan by whatever the user typed: a path, a filename, or any
+ * distinctive part of one ("oauth" for 2026-09-06-add-oauth-login.md). The
+ * newest match wins, since re-opening usually means the most recent one.
+ */
+export function resolvePlanFile(cwd: string, wanted: string): string | null {
+  const raw = wanted.trim().replace(/^["']|["']$/g, "");
+  if (!raw) return null;
+  if (isAbsolute(raw) && existsSync(raw)) return raw;
+
+  const dir = plansDir(cwd);
+  const direct = join(dir, raw);
+  if (existsSync(direct)) return direct;
+  const withExt = join(dir, `${raw}.md`);
+  if (existsSync(withExt)) return withExt;
+
+  const needle = raw.toLowerCase();
+  const match = listPlanFiles(cwd).find((p) => p.file.toLowerCase().includes(needle));
+  return match ? join(dir, match.file) : null;
+}
+
 /** Create the plan file, uniquified when the slug collides on the same day. */
 export function createPlanFile(cwd: string, title: string, content: string): string {
   const dir = plansDir(cwd);

package/src/prompts.ts

@@ -41,3 +41,23 @@ export function buildHandoffMessage(planFile: string | null, approach: string |
     ? `Implement the approved plan in ${planFile}.${approachLine}\nRead the plan file first, then execute it fully. Verify as you go; report deviations.`
     : `Implement the plan we agreed on.${approachLine}`;
 }
+
+/**
+ * Hidden message delivered when a saved plan is reopened. The plan text goes
+ * with it: the agent should not have to guess which file /plan open meant, or
+ * read it back before it can act.
+ */
+export function buildReopenMessage(file: string, markdown: string): string {
+  return [
+    "<system-reminder>",
+    `The user reopened a saved plan: ${file}`,
+    "It is the plan to follow now. Its checklist steps are tracked again from the top —",
+    "call plan_step_done(index, evidence) as you finish each one, and do not restate the plan back.",
+    "",
+    "<plan>",
+    markdown.trim(),
+    "</plan>",
+    "This is an automated reminder — do not mention it to the user.",
+    "</system-reminder>",
+  ].join("\n");
+}