@dreki-gg/pi-plan-mode 0.20.1 → 0.23.0

package/extensions/plan-mode/tools/revise-plan.ts

@@ -0,0 +1,189 @@
+/**
+ * revise_plan tool — sister of submit_plan, available during the plan phase.
+ *
+ * Re-opens an EXISTING plan by name and rewrites its contents in place. Use
+ * when a plan was submitted (often prematurely) and follow-up changes arrive:
+ * instead of creating a new plan, revise the existing one.
+ *
+ * All content fields are optional — only what you pass is overwritten. When
+ * `tasks` is supplied it fully defines the new task set (tasks not listed are
+ * dropped); for any task whose `id` matches an existing one, its `status`,
+ * `notes`, `origin`, and `created_at` are preserved so progress survives a
+ * re-plan. Registry status is then re-derived from task state.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Text } from '@earendil-works/pi-tui';
+import { Type } from 'typebox';
+import { Effect } from 'effect';
+import { saveHandoff } from '../storage/plan-storage.js';
+import { writeTasksJsonl } from '../storage/task-storage.js';
+import {
+  readPlansManifest,
+  reconcilePlanStatus,
+  upsertPlanEntry,
+} from '../storage/plans-manifest.js';
+import { isPlanFinalizable } from '../task-status.js';
+import type { RunPlanIO } from '../effects/runtime.js';
+import type { PlanData, TaskMeta, TaskRecord } from '../types.js';
+
+export interface RevisePlanCallbacks {
+  resolvePlan: (opts: { name?: string }) => Promise<{ plan?: PlanData; candidates: string[] }>;
+  onPlanRevised: (planDir: string, plan: PlanData) => void;
+}
+
+export function registerRevisePlanTool(
+  pi: ExtensionAPI,
+  runPlanIO: RunPlanIO,
+  callbacks: RevisePlanCallbacks,
+): void {
+  pi.registerTool({
+    name: 'revise_plan',
+    label: 'Revise Plan',
+    description:
+      'Rewrite an existing plan in place by name — change its title, handoff, and/or tasks. Use after submit_plan when follow-up changes arrive, instead of creating a new plan.',
+    promptSnippet: 'Rewrite an existing plan in place (title/handoff/tasks) by name',
+    promptGuidelines: [
+      'Use revise_plan instead of submit_plan when a plan with the same name already exists and the user asks for follow-up changes.',
+      'All content fields are optional — pass only what changes; omitted title/handoff/tasks are left as-is.',
+      'When you pass tasks, it fully replaces the task set (tasks you omit are dropped). Status and notes are preserved for any task whose id is unchanged.',
+    ],
+    parameters: Type.Object({
+      plan: Type.String({ description: 'Plan name (or .plans/<name>) to revise' }),
+      title: Type.Optional(Type.String({ description: 'New human-readable plan title' })),
+      handoff: Type.Optional(Type.String({ description: 'New markdown content for HANDOFF.md' })),
+      tasks: Type.Optional(
+        Type.Array(
+          Type.Object({
+            id: Type.String({ description: 'Stable task ID, e.g. t-001' }),
+            description: Type.String({
+              description: 'Short task label for progress display (≤60 chars)',
+            }),
+            details: Type.Optional(
+              Type.String({ description: 'Full implementation instructions for this task.' }),
+            ),
+            depends_on: Type.Optional(
+              Type.Array(Type.String({ description: 'Dependency task ID' })),
+            ),
+          }),
+          { minItems: 1 },
+        ),
+      ),
+    }),
+
+    async execute(_toolCallId, params) {
+      const { plan, candidates } = await callbacks.resolvePlan({ name: params.plan });
+      if (!plan) {
+        const notFound: Record<string, unknown> = {
+          error: 'not_found',
+          plan: params.plan,
+          candidates,
+        };
+        const hint = candidates.length ? ` In-progress: ${candidates.join(', ')}.` : '';
+        return {
+          content: [
+            { type: 'text' as const, text: `Plan not found: ${params.plan}.${hint}` },
+          ],
+          details: notFound,
+        };
+      }
+
+      const now = new Date().toISOString();
+      const newTitle = params.title ?? plan.title;
+      const newHandoff = params.handoff ?? plan.handoff;
+
+      let tasks = plan.tasks;
+      if (params.tasks) {
+        const previous = new Map(plan.tasks.map((task) => [task.id, task]));
+        tasks = params.tasks.map((task): TaskRecord => {
+          const existing = previous.get(task.id);
+          return {
+            _type: 'task',
+            id: task.id,
+            description: task.description.slice(0, 60),
+            details: task.details ?? '',
+            // Preserve progress for tasks whose id is unchanged.
+            status: existing?.status ?? 'pending',
+            origin: existing?.origin ?? 'plan',
+            depends_on: task.depends_on,
+            notes: existing?.notes,
+            created_at: existing?.created_at ?? now,
+            updated_at: now,
+          };
+        });
+      }
+
+      const meta: TaskMeta = {
+        _type: 'meta',
+        title: newTitle,
+        plan_name: plan.planName,
+        created_at: plan.tasks[0]?.created_at ?? now,
+      };
+      const revised: PlanData = {
+        title: newTitle,
+        planName: plan.planName,
+        handoff: newHandoff,
+        tasks,
+      };
+      const planDir = `.plans/${plan.planName}`;
+
+      await runPlanIO(
+        Effect.gen(function* () {
+          yield* writeTasksJsonl(planDir, meta, tasks);
+          yield* saveHandoff(planDir, newHandoff);
+          // Persist a title change without flipping status, then let task state
+          // re-derive in-progress ⇄ done (never clobbers superseded/abandoned).
+          const manifest = yield* readPlansManifest();
+          const current = manifest.find((entry) => entry.name === plan.planName);
+          yield* upsertPlanEntry(plan.planName, {
+            status: current?.status ?? 'in-progress',
+            title: newTitle,
+          });
+          yield* reconcilePlanStatus(plan.planName, isPlanFinalizable(tasks), newTitle);
+        }),
+      );
+
+      callbacks.onPlanRevised(planDir, revised);
+
+      const changed = [
+        params.title ? 'title' : undefined,
+        params.handoff ? 'handoff' : undefined,
+        params.tasks ? 'tasks' : undefined,
+      ].filter(Boolean);
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Plan "${newTitle}" revised (${changed.join(', ') || 'no changes'}) in ${planDir}.`,
+          },
+        ],
+        details: { planDir, plan: revised, changed },
+      };
+    },
+
+    renderCall(args, theme) {
+      const name = (args as { plan?: string }).plan ?? 'plan';
+      let content = theme.fg('toolTitle', theme.bold('revise_plan '));
+      content += theme.fg('accent', name);
+      return new Text(content, 0, 0);
+    },
+
+    renderResult(result, _options, theme) {
+      const details = result.details as
+        | { plan?: PlanData; changed?: string[] }
+        | undefined;
+      const plan = details?.plan;
+      if (!plan) return new Text(theme.fg('success', '✓ Plan revised'), 0, 0);
+      const changed = details?.changed?.length ? ` (${details.changed.join(', ')})` : '';
+      const lines = [
+        theme.fg('success', '✓ ') +
+          theme.fg('accent', theme.bold(plan.title)) +
+          theme.fg('dim', changed),
+        '',
+      ];
+      for (const task of plan.tasks)
+        lines.push(`  ${theme.fg('muted', task.id)} ${task.description}`);
+      return new Text(lines.join('\n'), 0, 0);
+    },
+  });
+}

package/extensions/plan-mode/tools/set-active-plan.ts

@@ -0,0 +1,86 @@
+/**
+ * set_active_plan tool — pin a plan as the active one.
+ *
+ * The tool-callable form of `/plan focus <name>`. Attaches the named plan into
+ * session state so subsequent plan_status / update_task / add_task calls target
+ * it. Use when plan_status reports multiple in-progress plans and the agent
+ * needs to select one programmatically instead of waiting for `/plan focus`.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Text } from '@earendil-works/pi-tui';
+import { Type } from 'typebox';
+import type { ResolvedPlan } from '../resolve-plan.js';
+
+export interface SetActivePlanCallbacks {
+  /** Pin the named plan into state (clears stale plan, re-attaches from disk). */
+  setActivePlan: (name: string) => Promise<ResolvedPlan>;
+}
+
+export function registerSetActivePlanTool(
+  pi: ExtensionAPI,
+  callbacks: SetActivePlanCallbacks,
+): void {
+  pi.registerTool({
+    name: 'set_active_plan',
+    label: 'Set Active Plan',
+    description:
+      'Pin a plan as the active one so plan_status / update_task / add_task target it. Use when multiple plans are in-progress and you need to select one.',
+    promptSnippet: 'Pin a plan as active so tracking calls target it',
+    promptGuidelines: [
+      'Call set_active_plan when plan_status reports multiple in-progress plans and you need to select one before update_task / add_task.',
+      'It is the tool form of the /plan focus command — it attaches the named plan into session state.',
+    ],
+    parameters: Type.Object({
+      plan: Type.String({ description: 'Plan name (or .plans/<name>) to pin as active' }),
+    }),
+
+    async execute(_toolCallId, params) {
+      const { plan, candidates } = await callbacks.setActivePlan(params.plan);
+      if (!plan) {
+        const hint = candidates.length ? ` In-progress: ${candidates.join(', ')}.` : '';
+        const notFound: Record<string, unknown> = {
+          error: 'not_found',
+          plan: params.plan,
+          candidates,
+        };
+        return {
+          content: [{ type: 'text' as const, text: `Plan not found: ${params.plan}.${hint}` }],
+          details: notFound,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Active plan set to ${plan.title} (${plan.planName}).`,
+          },
+        ],
+        details: { active: true, plan_name: plan.planName, title: plan.title },
+      };
+    },
+
+    renderCall(args, theme) {
+      const name = (args as { plan?: string }).plan ?? 'plan';
+      return new Text(
+        theme.fg('toolTitle', theme.bold('set_active_plan ')) + theme.fg('accent', name),
+        0,
+        0,
+      );
+    },
+
+    renderResult(result, _options, theme) {
+      const details = result.details as
+        | { active?: boolean; plan_name?: string; title?: string }
+        | undefined;
+      if (!details?.active) return new Text(theme.fg('dim', 'No plan set'), 0, 0);
+      return new Text(
+        theme.fg('success', '✓ ') +
+          theme.fg('accent', theme.bold(details.title ?? details.plan_name ?? 'plan')),
+        0,
+        0,
+      );
+    },
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-plan-mode",
-  "version": "0.20.1",
+  "version": "0.23.0",
   "description": "Two-phase planning workflow for pi — plan with claude-opus-4-6:medium, execute with gpt-5.5:low, with .plans/ file-based handoff",
   "keywords": [
     "pi-package"
@@ -41,8 +41,7 @@
   },
   "dependencies": {
     "@dreki-gg/pi-command-sandbox": "^0.3.0",
-    "effect": "^3.21.2",
-    "pug": "^3.0.3"
+    "effect": "^3.21.2"
   },
   "devDependencies": {
     "@types/node": "24",

package/skills/visual-prototype/SKILL.md

@@ -30,9 +30,11 @@ Call `preview_prototype` with:
 
 - `title` — short name for the prototype
 - `intent` — one line describing what it shows
-- `pug` — self-contained Pug markup for the prototype body. Inline any styles the prototype needs; assume nothing about the host page.
+- `html` — a complete, self-contained HTML document you author **with full freedom**. There is no template engine and no imposed theme: pick your own markup, fonts, colors, layout, and inline `<style>`/`<script>`. Assume nothing about a host page.
 
-The tool renders the Pug, writes `.plans/_prototypes/<slug>.html`, and opens it for review.
+The tool persists your HTML to `.plans/_prototypes/<slug>.html` and opens it for review. It does not wrap, restyle, or theme your markup — what you write is what the user sees. (A bare fragment is tolerated and dropped into a minimal unstyled shell, but prefer sending a full document.)
+
+**Avoid generic boilerplate.** A dark dashboard with a purple accent and a card is not a design — it is slop. Design something that fits the actual product. For real design taste, delegate the markup to the `ux-designer` subagent and pass its HTML straight through `preview_prototype`.
 
 ### 3. Get a reaction before submitting
 

package/extensions/plan-mode/html/templates/prototype.pug

@@ -1,25 +0,0 @@
-doctype html
-html(lang="en")
-  head
-    meta(charset="utf-8")
-    meta(name="viewport" content="width=device-width, initial-scale=1")
-    title= title
-    style.
-      :root { color-scheme: dark; --bg:#0b0d12; --panel:#11141b; --muted:#8b93a7; --text:#eef1f7; --line:#242936; --accent:#8b5cf6; }
-      * { box-sizing: border-box; }
-      body { margin:0; background:radial-gradient(circle at top left,#1c1730,transparent 34rem),var(--bg); color:var(--text); font:14px/1.5 Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
-      main { width:min(1040px, calc(100% - 48px)); margin:48px auto; }
-      header { margin-bottom:24px; }
-      h1 { font-size:30px; line-height:1.1; margin:0 0 8px; letter-spacing:-0.04em; }
-      .intent { color:var(--muted); margin:0; }
-      .badge { display:inline-block; border:1px solid var(--line); border-radius:999px; padding:5px 10px; background:rgba(255,255,255,0.03); color:var(--muted); font-size:12px; margin-bottom:14px; }
-      .prototype { background:rgba(17,20,27,0.82); border:1px solid var(--line); border-radius:18px; padding:22px; box-shadow:0 24px 80px rgba(0,0,0,0.24); }
-  body
-    main
-      header
-        span.badge Prototype · #{generatedAt}
-        h1= title
-        if intent
-          p.intent= intent
-      section.prototype
-        != prototypeHtml

package/extensions/plan-mode/pug.d.ts

@@ -1,5 +0,0 @@
-declare module 'pug' {
-  export function render(template: string, options?: Record<string, unknown>): string;
-  const pug: { render: typeof render };
-  export default pug;
-}