@pencil-agent/nano-pencil 1.12.0 → 1.13.0

package/dist/core/config/settings-manager.d.ts

@@ -87,6 +87,8 @@ export interface Settings {
     autocompleteMaxVisible?: number;
     showHardwareCursor?: boolean;
     markdown?: MarkdownSettings;
+    /** Directory for plan mode files. Relative paths must stay inside the project root. */
+    plansDirectory?: string;
     /** NanoMem / Dream settings */
     nanomem?: {
         autoDream?: {

package/dist/core/extensions/runner.js

@@ -66,6 +66,7 @@ const noOpUIContext = {
     setEditorText: () => { },
     getEditorText: () => "",
     editor: async () => undefined,
+    openExternalEditor: async () => false,
     setEditorComponent: () => { },
     get theme() {
         return theme;

package/dist/core/extensions/types.d.ts

@@ -105,6 +105,8 @@ export interface ExtensionUIContext {
     getEditorText(): string;
     /** Show a multi-line editor for text editing. */
     editor(title: string, prefill?: string): Promise<string | undefined>;
+    /** Open an existing file in the user's external editor. Returns true when the editor exits successfully. */
+    openExternalEditor(filePath: string, title?: string): Promise<boolean>;
     /**
      * Set a custom editor component via factory function.
      * Pass undefined to restore the default editor.

package/dist/extensions/defaults/AGENT.md

@@ -6,6 +6,16 @@ Member List
 link-world/index.ts: Internet access extension, provides internet-search Skill after setup
 mcp/index.ts: MCP protocol integration extension, MCP guidance resources
 presence/index.ts: AI-driven opening + idle presence lines, uses NanoMemEngine episodes/preferences/lessons + git/cwd snapshot, injects latest line into agent systemPrompt every turn for main-conversation perception, 30s debounce + idle in-flight lock, configurable via settings.presence.enabled, PRESENCE_MESSAGE_TYPE renderer
+plan/index.ts: Plan Mode extension entry, /plan /plan:validate /plan:approve commands, EnterPlanMode/ExitPlanMode tools, permission gating, TUI status/widget, workflow prompt injection
+plan/types.ts: Plan mode types, persisted state payload, attachment variants, permission result model
+plan/plan-file-manager.ts: Plan file path management, slug generation, settings-aware plans directory, plan state hydration/serialization, resume/fork copy helpers
+plan/plan-permissions.ts: Plan mode tool permission gating, exact plan-file write checks, read-only bash allowlist, agent/tool blocking policy
+plan/plan-workflow-prompt.ts: Plan mode full/sparse workflow prompt, reentry prompt, exit prompt, EnterPlanMode/ExitPlanMode tool result text
+plan/enter-plan-mode-tool.ts: EnterPlanMode tool for model-initiated plan mode entry and UI state activation
+plan/exit-plan-mode-tool.ts: ExitPlanMode tool for user-approved plan mode exit, validation, teammate approval, UI cleanup
+plan/plan-agents.ts: Explore/Plan subagent prompt helpers and read-only tool list for plan mode
+plan/plan-validation.ts: Plan structure validation for Context, Approach, Files/Changes, and Verification sections
+plan/teammate-approval.ts: Teammate plan approval mailbox integration and approval/waiting message formatting
 subagent/index.ts: SubAgent extension entry, /subagent:/subagent:run/:stop/:status/:report/:apply commands, SUBAGENT_MESSAGE_TYPE renderer
 subagent/subagent-parser.ts: SubAgent command parsing, parseSubAgentCommand/buildSubAgentHelp
 subagent/subagent-runner.ts: SubAgent orchestration — research (read-only) and implement (isolated worktree) roles, diff preview and apply flow
@@ -49,4 +59,4 @@ team/TESTING.md: Manual & smoke-test guide for Phase B AgentTeam
 
 Rule: Members complete, one item per line, parent links valid, precise terms first
 
-[COVENANT]: Update this file header on changes and verify against parent AGENT.md
+[COVENANT]: Update this file header on changes and verify against parent AGENT.md

package/dist/extensions/defaults/plan/enter-plan-mode-tool.d.ts

@@ -5,5 +5,5 @@
  * [HERE]: extensions/defaults/plan/enter-plan-mode-tool.ts - EnterPlanMode tool for model-initiated plan mode entry
  */
 import type { ExtensionAPI, ToolDefinition } from "../../../core/extensions/types.js";
-import type { PlanSessionState } from "./types.js";
+import { type PlanSessionState } from "./types.js";
 export declare function createEnterPlanModeTool(api: ExtensionAPI, getSessionState: () => PlanSessionState, isChannelsEnabled: () => boolean): ToolDefinition;

package/dist/extensions/defaults/plan/enter-plan-mode-tool.js

@@ -5,12 +5,14 @@
  * [HERE]: extensions/defaults/plan/enter-plan-mode-tool.ts - EnterPlanMode tool for model-initiated plan mode entry
  */
 import { Type } from "@sinclair/typebox";
+import { PLAN_CUSTOM_TYPE } from "./types.js";
 import { handlePlanModeTransition } from "./plan-permissions.js";
 import { getEnterPlanModeToolResult } from "./plan-workflow-prompt.js";
+import { getPlanFilePath, getPlansDirectory, serializePlanSessionState } from "./plan-file-manager.js";
 // ============================================================================
 // Schema
 // ============================================================================
-const EnterPlanModeInputSchema = Type.Object({});
+const EnterPlanModeInputSchema = Type.Object({}, { additionalProperties: false });
 // ============================================================================
 // Tool creation
 // ============================================================================
@@ -21,6 +23,7 @@ export function createEnterPlanModeTool(api, getSessionState, isChannelsEnabled)
         description: "Switch to plan mode to design an approach before coding. Use this when the task is complex and requires planning before implementation.",
         parameters: EnterPlanModeInputSchema,
         execute: async (_toolCallId, _input, _signal, _onUpdate, ctx) => {
+            getPlansDirectory(ctx.getSettings().plansDirectory, ctx.cwd);
             const sessionState = getSessionState();
             // Block in agent contexts (agents shouldn't enter plan mode themselves)
             // In nanoPencil, we check if we're in a subagent context via the event bus
@@ -41,6 +44,14 @@ export function createEnterPlanModeTool(api, getSessionState, isChannelsEnabled)
             handlePlanModeTransition(sessionState);
             sessionState.state.prePlanMode = previousMode;
             sessionState.state.mode = "plan";
+            api.appendEntry(PLAN_CUSTOM_TYPE, serializePlanSessionState(sessionState));
+            ctx.ui.setStatus("plan", "Plan mode");
+            ctx.ui.setWidget("plan-mode", [
+                "PLAN MODE",
+                `Plan: ${getPlanFilePath(api.events)}`,
+                "Read-only except the plan file",
+                "Use /plan open to edit; ExitPlanMode requests approval",
+            ], { placement: "aboveEditor" });
             return {
                 content: [{
                         type: "text",

package/dist/extensions/defaults/plan/exit-plan-mode-tool.d.ts

@@ -5,5 +5,5 @@
  * [HERE]: extensions/defaults/plan/exit-plan-mode-tool.ts - ExitPlanMode tool for model-requested plan approval
  */
 import type { ExtensionAPI, ToolDefinition } from "../../../core/extensions/types.js";
-import type { PlanSessionState } from "./types.js";
+import { type PlanSessionState } from "./types.js";
 export declare function createExitPlanModeTool(api: ExtensionAPI, getSessionState: () => PlanSessionState, hasAgentTool: () => boolean): ToolDefinition;

package/dist/extensions/defaults/plan/exit-plan-mode-tool.js

@@ -5,9 +5,9 @@
  * [HERE]: extensions/defaults/plan/exit-plan-mode-tool.ts - ExitPlanMode tool for model-requested plan approval
  */
 import { Type } from "@sinclair/typebox";
-import { writeFileSync } from "node:fs";
+import { PLAN_CUSTOM_TYPE } from "./types.js";
 import { handlePlanModeExit } from "./plan-permissions.js";
-import { getPlanFilePath, getPlan } from "./plan-file-manager.js";
+import { getPlanFilePath, getPlan, getPlansDirectory, serializePlanSessionState, writePlan, } from "./plan-file-manager.js";
 import { getExitPlanModeApprovedResult } from "./plan-workflow-prompt.js";
 import { validatePlan, formatValidationMessage } from "./plan-validation.js";
 import { isInTeammateContext, submitPlanToLeader, formatPlanSubmittedMessage, } from "./teammate-approval.js";
@@ -34,6 +34,7 @@ export function createExitPlanModeTool(api, getSessionState, hasAgentTool) {
         description: "Present your plan for approval and start coding. Only usable in plan mode after writing a plan.",
         parameters: ExitPlanModeInputSchema,
         execute: async (_toolCallId, input, _signal, _onUpdate, ctx) => {
+            getPlansDirectory(ctx.getSettings().plansDirectory, ctx.cwd);
             const sessionState = getSessionState();
             // Validate: must be in plan mode
             if (sessionState.state.mode !== "plan") {
@@ -58,13 +59,9 @@ export function createExitPlanModeTool(api, getSessionState, hasAgentTool) {
             // If input.plan was provided, write it back to the plan file
             const planWasEdited = inputPlan !== undefined;
             if (planWasEdited && plan !== null) {
-                try {
-                    writeFileSync(planFilePath, plan, "utf-8");
-                }
-                catch (err) {
-                    console.error(`Failed to write updated plan file: ${err}`);
-                }
+                writePlan(api.events, plan);
             }
+            sessionState.state.planSnapshot = plan ?? undefined;
             // Plan validation
             if (!forceExit) {
                 const validation = validatePlan(plan || "");
@@ -82,6 +79,9 @@ export function createExitPlanModeTool(api, getSessionState, hasAgentTool) {
             }
             // Check if we're in teammate context
             if (isInTeammateContext()) {
+                if (!plan || plan.trim().length === 0) {
+                    throw new Error(`No plan file found at ${planFilePath}. Please write your plan to this file before calling ExitPlanMode.`);
+                }
                 // Submit plan to leader for approval
                 try {
                     const { requestId } = await submitPlanToLeader(planFilePath, plan || "");
@@ -89,6 +89,7 @@ export function createExitPlanModeTool(api, getSessionState, hasAgentTool) {
                     // Mark as awaiting approval - mode is still "plan" until approved
                     sessionState.state.mode = "plan"; // Keep in plan mode
                     // Note: handlePlanModeExit is NOT called here - we stay in plan mode
+                    api.appendEntry(PLAN_CUSTOM_TYPE, serializePlanSessionState(sessionState));
                     return {
                         content: [{
                                 type: "text",
@@ -102,8 +103,43 @@ export function createExitPlanModeTool(api, getSessionState, hasAgentTool) {
                     console.error(`Failed to submit plan to leader: ${err}`);
                 }
             }
+            if (!ctx.hasUI) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "ExitPlanMode requires user approval, but no interactive UI is available. Stay in plan mode and ask the user to approve from an interactive session.",
+                        }],
+                    isError: true,
+                    details: null,
+                };
+            }
+            const preview = plan && plan.trim().length > 0
+                ? plan.trim().slice(0, 1200)
+                : "No plan content was written.";
+            const approved = await ctx.ui.confirm("Exit plan mode?", [
+                `Plan file: ${planFilePath}`,
+                "",
+                preview,
+                plan && plan.length > 1200 ? "\n...(truncated)" : "",
+                "",
+                "Approve this plan and allow implementation mode?",
+            ].join("\n"));
+            if (!approved) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "User rejected exiting plan mode. Stay in plan mode, revise the plan file, and call ExitPlanMode again when ready.",
+                        }],
+                    isError: true,
+                    details: null,
+                };
+            }
             // Normal exit: restore permissions
             handlePlanModeExit(sessionState);
+            api.appendEntry(PLAN_CUSTOM_TYPE, serializePlanSessionState(sessionState));
+            // Clear plan mode status in TUI footer
+            ctx.ui.setStatus("plan", undefined);
+            ctx.ui.setWidget("plan-mode", undefined);
             // Build result message
             const resultText = getExitPlanModeApprovedResult(plan, planFilePath, planWasEdited, hasAgentTool());
             // Notify user

package/dist/extensions/defaults/plan/index.js

@@ -4,11 +4,12 @@
  * [TO]: Auto-loaded by builtin-extensions.ts as a default extension
  * [HERE]: extensions/defaults/plan/index.ts - main plan mode extension entry point
  */
-import { getPlanSessionState, getPlanFilePath, getPlan, writePlan, getPlansDirectory, } from "./plan-file-manager.js";
+import { getPlanSessionState, getPlanFilePath, getPlan, writePlan, getPlansDirectory, serializePlanSessionState, } from "./plan-file-manager.js";
 import { handlePlanModeTransition, shouldAllowToolCall, } from "./plan-permissions.js";
 import { getPlanModeInstructions, getPlanModeExitInstructions, getPlanModeReentryInstructions, } from "./plan-workflow-prompt.js";
 import { createEnterPlanModeTool } from "./enter-plan-mode-tool.js";
 import { createExitPlanModeTool } from "./exit-plan-mode-tool.js";
+import { PLAN_CUSTOM_TYPE } from "./types.js";
 // ============================================================================
 // Constants
 // ============================================================================
@@ -16,24 +17,56 @@ const PLAN_ATTACHMENT_CONFIG = {
     TURNS_BETWEEN_ATTACHMENTS: 3,
     FULL_REMINDER_EVERY_N: 3,
 };
+function countHumanTurns(ctx) {
+    return ctx.sessionManager.getBranch().filter((entry) => {
+        if (entry.type !== "message")
+            return false;
+        if (entry.message.role !== "user")
+            return false;
+        const content = entry.message.content;
+        return typeof content === "string"
+            ? content.trim().length > 0
+            : content.some((block) => block.type === "text" && block.text.trim().length > 0);
+    }).length;
+}
 // ============================================================================
 // State helpers
 // ============================================================================
-function getSessionState(api) {
-    return getPlanSessionState(api.events);
+function preparePlansDirectory(ctx) {
+    const settings = ctx.getSettings();
+    getPlansDirectory(settings.plansDirectory, ctx.cwd);
+}
+function getSessionState(api, ctx) {
+    return getPlanSessionState(api.events, ctx?.sessionManager.getSessionId(), ctx?.sessionManager.getEntries());
+}
+function persistPlanState(api, sessionState) {
+    api.appendEntry(PLAN_CUSTOM_TYPE, serializePlanSessionState(sessionState));
+}
+function setPlanModeUi(ctx, api) {
+    const planFilePath = getPlanFilePath(api.events);
+    ctx.ui.setStatus("plan", "Plan mode");
+    ctx.ui.setWidget("plan-mode", [
+        "PLAN MODE",
+        `Plan: ${planFilePath}`,
+        "Read-only except the plan file",
+        "Use /plan open to edit; ExitPlanMode requests approval",
+    ], { placement: "aboveEditor" });
 }
 // ============================================================================
 // Plan mode entry helper
 // ============================================================================
-async function enterPlanMode(api, ctx, shouldQuery) {
-    const sessionState = getSessionState(api);
+async function enterPlanMode(api, ctx, description) {
+    preparePlansDirectory(ctx);
+    const sessionState = getSessionState(api, ctx);
     const previousMode = sessionState.state.mode;
     handlePlanModeTransition(sessionState);
     sessionState.state.prePlanMode = previousMode;
     sessionState.state.mode = "plan";
-    if (shouldQuery) {
-        // Send a follow-up message to trigger the agent to start planning
-        api.sendUserMessage("I've entered plan mode. Please start exploring and designing an approach.", { deliverAs: "followUp" });
+    setPlanModeUi(ctx, api);
+    persistPlanState(api, sessionState);
+    ctx.ui.notify("Enabled plan mode. Read-only except the plan file.", "info");
+    if (description) {
+        api.sendUserMessage(description, { deliverAs: "followUp" });
     }
 }
 // ============================================================================
@@ -47,6 +80,7 @@ function hasTool(api, name) {
 // Plan display helper
 // ============================================================================
 function displayPlan(api, ctx) {
+    preparePlansDirectory(ctx);
     const planFilePath = getPlanFilePath(api.events);
     const planContent = getPlan(api.events);
     if (!planContent) {
@@ -58,6 +92,10 @@ function displayPlan(api, ctx) {
         `Path: ${planFilePath}`,
         "",
         planContent,
+        "",
+        (process.env.VISUAL || process.env.EDITOR)
+            ? `Use /plan open to edit this plan in ${process.env.VISUAL || process.env.EDITOR}.`
+            : "Use /plan open to edit this plan.",
     ];
     ctx.ui.notify(output.join("\n"), "info");
 }
@@ -76,31 +114,46 @@ export default async function planExtension(api) {
     // /plan command handler
     // =========================================================================
     const handlePlanCommand = async (args, ctx) => {
-        const sessionState = getSessionState(api);
+        preparePlansDirectory(ctx);
+        const sessionState = getSessionState(api, ctx);
         const currentMode = sessionState.state.mode;
         // Not in plan mode: enter plan mode
         if (currentMode !== "plan") {
             const trimmed = args.trim();
-            const shouldQuery = trimmed.length > 0 && trimmed !== "open";
-            await enterPlanMode(api, ctx, shouldQuery);
-            ctx.ui.notify("Enabled plan mode", "info");
+            const description = trimmed.length > 0 && trimmed !== "open" ? trimmed : "";
+            await enterPlanMode(api, ctx, description);
             return;
         }
         // Already in plan mode
         const trimmed = args.trim();
         if (trimmed === "open") {
-            // Open plan file in inline editor
             const planFilePath = getPlanFilePath(api.events);
-            const existingPlan = getPlan(api.events) || "";
-            const editedContent = await ctx.ui.editor("Edit Plan", existingPlan);
-            if (editedContent !== undefined) {
-                // User saved the plan
-                writePlan(api.events, editedContent);
-                ctx.ui.notify(`Plan saved to: ${planFilePath}`, "info");
+            if (!getPlan(api.events)) {
+                writePlan(api.events, "");
             }
-            else {
+            if (process.env.VISUAL || process.env.EDITOR) {
+                const opened = await ctx.ui.openExternalEditor(planFilePath, "Edit Plan");
+                if (opened) {
+                    const state = getSessionState(api, ctx);
+                    state.state.planSnapshot = getPlan(api.events) ?? undefined;
+                    persistPlanState(api, state);
+                    ctx.ui.notify(`Opened plan in editor: ${planFilePath}`, "info");
+                }
+                else {
+                    ctx.ui.notify("Failed to open plan in external editor.", "warning");
+                }
+                return;
+            }
+            const editedContent = await ctx.ui.editor("Edit Plan", getPlan(api.events) || "");
+            if (editedContent === undefined) {
                 ctx.ui.notify("Plan editing cancelled.", "info");
+                return;
             }
+            writePlan(api.events, editedContent);
+            const state = getSessionState(api, ctx);
+            state.state.planSnapshot = editedContent;
+            persistPlanState(api, state);
+            ctx.ui.notify(`Plan saved to: ${planFilePath}`, "info");
             return;
         }
         // Display plan content
@@ -108,6 +161,7 @@ export default async function planExtension(api) {
     };
     api.registerCommand("plan", {
         description: "Enable plan mode or view the current session plan",
+        getArgumentCompletions: (argumentPrefix) => "open".startsWith(argumentPrefix.trim()) ? [{ value: "open", label: "open" }] : null,
         handler: handlePlanCommand,
     });
     // =========================================================================
@@ -202,7 +256,7 @@ export default async function planExtension(api) {
             input: event.input,
         };
         const planFilePath = getPlanFilePath(api.events);
-        const result = shouldAllowToolCall(toolCall, planFilePath);
+        const result = shouldAllowToolCall(toolCall, planFilePath, api.cwd);
         if (!result.allowed) {
             return { block: true, reason: result.reason };
         }
@@ -211,11 +265,13 @@ export default async function planExtension(api) {
     // System prompt injection: plan mode workflow
     // =========================================================================
     api.on("before_agent_start", async (_event, ctx) => {
-        const sessionState = getSessionState(api);
+        preparePlansDirectory(ctx);
+        const sessionState = getSessionState(api, ctx);
         const { mode, needsPlanModeExitAttachment, hasExitedPlanModeInSession, planAttachmentCount } = sessionState.state;
         // Exit attachment: injected once after plan mode exit
         if (mode !== "plan" && needsPlanModeExitAttachment) {
             sessionState.state.needsPlanModeExitAttachment = false;
+            persistPlanState(api, sessionState);
             const planFilePath = getPlanFilePath(api.events);
             const planExists = getPlan(api.events) !== null;
             return {
@@ -224,11 +280,19 @@ export default async function planExtension(api) {
         }
         // Plan mode: inject workflow prompt
         if (mode === "plan") {
+            setPlanModeUi(ctx, api);
             const planFilePath = getPlanFilePath(api.events);
             const existingPlan = getPlan(api.events);
+            const humanTurns = countHumanTurns(ctx);
+            if (sessionState.state.lastPlanAttachmentHumanTurn !== undefined &&
+                humanTurns - sessionState.state.lastPlanAttachmentHumanTurn < PLAN_ATTACHMENT_CONFIG.TURNS_BETWEEN_ATTACHMENTS) {
+                return;
+            }
             // Reentry detection
             if (hasExitedPlanModeInSession && existingPlan !== null) {
                 sessionState.state.hasExitedPlanModeInSession = false;
+                sessionState.state.lastPlanAttachmentHumanTurn = humanTurns;
+                persistPlanState(api, sessionState);
                 // Prepend reentry instructions
                 const reentry = getPlanModeReentryInstructions(planFilePath);
                 const workflow = getPlanModeInstructions(sessionState, planFilePath, existingPlan, "full");
@@ -240,6 +304,9 @@ export default async function planExtension(api) {
             const shouldFullReminder = planAttachmentCount % PLAN_ATTACHMENT_CONFIG.FULL_REMINDER_EVERY_N === 0;
             const reminderType = shouldFullReminder ? "full" : "sparse";
             sessionState.state.planAttachmentCount += 1;
+            sessionState.state.lastPlanAttachmentHumanTurn = humanTurns;
+            sessionState.state.planSnapshot = existingPlan ?? undefined;
+            persistPlanState(api, sessionState);
             const prompt = getPlanModeInstructions(sessionState, planFilePath, existingPlan, reminderType);
             return {
                 appendSystemPrompt: prompt,
@@ -249,9 +316,14 @@ export default async function planExtension(api) {
     // =========================================================================
     // Session lifecycle
     // =========================================================================
-    api.on("session_start", () => {
+    api.on("session_start", (_event, ctx) => {
         // Initialize plan directory
-        getPlansDirectory();
+        preparePlansDirectory(ctx);
+        // Restore plan mode status if we're in plan mode (session restored while in plan mode)
+        const sessionState = getSessionState(api, ctx);
+        if (sessionState.state.mode === "plan") {
+            setPlanModeUi(ctx, api);
+        }
     });
     api.on("session_shutdown", () => {
         // Cleanup: nothing needed for plan mode

package/dist/extensions/defaults/plan/plan-file-manager.d.ts

@@ -4,17 +4,23 @@
  * [TO]: Consumed by plan extension tools, workflow prompts, permission gating
  * [HERE]: extensions/defaults/plan/plan-file-manager.ts - plan file path management and I/O
  */
-import type { PlanSessionState } from "./types.js";
-export declare function getPlanSessionState(bus: unknown): PlanSessionState;
+import { type PlanSessionState, type PlanStateEntryData } from "./types.js";
+import type { SessionEntry } from "../../../core/session/session-manager.js";
+export declare function getPlanSessionState(bus: unknown, sessionId?: string, entries?: SessionEntry[]): PlanSessionState;
+export declare function hydratePlanSessionState(sessionState: PlanSessionState, sessionId: string, entries: SessionEntry[]): void;
+export declare function serializePlanSessionState(sessionState: PlanSessionState): PlanStateEntryData;
 export declare function generatePlanSlug(): string;
 export declare function getPlansDirectory(settingsPlansDir?: string, cwd?: string): string;
 export declare function resetPlansDirectoryCache(): void;
 export declare function getPlanSlug(bus: unknown): string;
 export declare function setPlanSlug(bus: unknown, slug: string): void;
 export declare function clearPlanSlug(bus: unknown): void;
+export declare function clearAllPlanSlugs(): void;
 export declare function getPlanFilePath(bus: unknown, agentId?: string): string;
 export declare function getPlan(bus: unknown, agentId?: string): string | null;
 export declare function writePlan(bus: unknown, content: string, agentId?: string): boolean;
 export declare function planExists(bus: unknown, agentId?: string): boolean;
 export declare function copyPlanForResume(sourceBus: unknown, targetBus: unknown): Promise<boolean>;
 export declare function copyPlanForFork(sourceBus: unknown, targetBus: unknown): Promise<boolean>;
+export declare function copyPlanFileToNewSlug(bus: unknown): boolean;
+export declare function copyPlanFile(sourcePath: string, targetPath: string): boolean;

package/dist/extensions/defaults/plan/plan-file-manager.js

@@ -4,9 +4,10 @@
  * [TO]: Consumed by plan extension tools, workflow prompts, permission gating
  * [HERE]: extensions/defaults/plan/plan-file-manager.ts - plan file path management and I/O
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve, sep } from "node:path";
+import { PLAN_CUSTOM_TYPE, } from "./types.js";
 // ============================================================================
 // Word lists for slug generation
 // ============================================================================
@@ -53,7 +54,8 @@ const MAX_SLUG_RETRIES = 10;
 // State management
 // ============================================================================
 const stateByBus = new WeakMap();
-export function getPlanSessionState(bus) {
+const allSessionStates = new Set();
+export function getPlanSessionState(bus, sessionId, entries) {
     const eventBus = bus;
     let state = stateByBus.get(eventBus);
     if (!state) {
@@ -64,13 +66,65 @@ export function getPlanSessionState(bus) {
                 needsPlanModeExitAttachment: false,
                 hasExitedPlanModeInSession: false,
                 planAttachmentCount: 0,
+                sessionId,
             },
             planSlugCache: undefined,
         };
         stateByBus.set(eventBus, state);
+        allSessionStates.add(state);
+    }
+    if (sessionId && state.state.hydratedSessionId !== sessionId) {
+        hydratePlanSessionState(state, sessionId, entries ?? []);
     }
     return state;
 }
+export function hydratePlanSessionState(sessionState, sessionId, entries) {
+    sessionState.state.hydratedSessionId = sessionId;
+    sessionState.state.sessionId = sessionId;
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.type !== "custom" || entry.customType !== PLAN_CUSTOM_TYPE)
+            continue;
+        const data = entry.data;
+        if (!data || data.version !== 1)
+            continue;
+        if (data.sessionId && data.sessionId !== sessionId)
+            continue;
+        sessionState.state.mode = data.mode ?? "default";
+        sessionState.state.prePlanMode = data.prePlanMode ?? "default";
+        sessionState.state.needsPlanModeExitAttachment = data.needsPlanModeExitAttachment ?? false;
+        sessionState.state.hasExitedPlanModeInSession = data.hasExitedPlanModeInSession ?? false;
+        sessionState.state.planAttachmentCount = data.planAttachmentCount ?? 0;
+        sessionState.state.lastPlanAttachmentHumanTurn = data.lastPlanAttachmentHumanTurn;
+        sessionState.state.planSlug = data.planSlug;
+        sessionState.state.planSnapshot = data.planSnapshot;
+        sessionState.planSlugCache = data.planSlug;
+        return;
+    }
+    sessionState.state.mode = "default";
+    sessionState.state.prePlanMode = "default";
+    sessionState.state.needsPlanModeExitAttachment = false;
+    sessionState.state.hasExitedPlanModeInSession = false;
+    sessionState.state.planAttachmentCount = 0;
+    sessionState.state.lastPlanAttachmentHumanTurn = undefined;
+    sessionState.state.planSlug = undefined;
+    sessionState.state.planSnapshot = undefined;
+    sessionState.planSlugCache = undefined;
+}
+export function serializePlanSessionState(sessionState) {
+    return {
+        version: 1,
+        sessionId: sessionState.state.sessionId,
+        mode: sessionState.state.mode,
+        prePlanMode: sessionState.state.prePlanMode,
+        needsPlanModeExitAttachment: sessionState.state.needsPlanModeExitAttachment,
+        hasExitedPlanModeInSession: sessionState.state.hasExitedPlanModeInSession,
+        planAttachmentCount: sessionState.state.planAttachmentCount,
+        lastPlanAttachmentHumanTurn: sessionState.state.lastPlanAttachmentHumanTurn,
+        planSlug: sessionState.planSlugCache ?? sessionState.state.planSlug,
+        planSnapshot: sessionState.state.planSnapshot,
+    };
+}
 // ============================================================================
 // Slug generation
 // ============================================================================
@@ -84,13 +138,18 @@ export function generatePlanSlug() {
 // Plans directory
 // ============================================================================
 let cachedPlansDir;
+let cachedPlansDirKey;
 export function getPlansDirectory(settingsPlansDir, cwd) {
-    if (cachedPlansDir)
+    const key = `${cwd ?? ""}\0${settingsPlansDir ?? ""}`;
+    if (cachedPlansDir && !settingsPlansDir && !cwd)
+        return cachedPlansDir;
+    if (cachedPlansDir && cachedPlansDirKey === key)
         return cachedPlansDir;
     if (settingsPlansDir && cwd) {
         const resolved = resolve(cwd, settingsPlansDir);
         if (!resolved.startsWith(cwd + sep) && resolved !== cwd) {
             // Out of project root, fall back to default
+            mkdirSync(DEFAULT_PLANS_DIR, { recursive: true });
             cachedPlansDir = DEFAULT_PLANS_DIR;
         }
         else {
@@ -102,10 +161,12 @@ export function getPlansDirectory(settingsPlansDir, cwd) {
         mkdirSync(DEFAULT_PLANS_DIR, { recursive: true });
         cachedPlansDir = DEFAULT_PLANS_DIR;
     }
+    cachedPlansDirKey = key;
     return cachedPlansDir;
 }
 export function resetPlansDirectoryCache() {
     cachedPlansDir = undefined;
+    cachedPlansDirKey = undefined;
 }
 // ============================================================================
 // Plan slug caching (per session)
@@ -124,15 +185,24 @@ export function getPlanSlug(bus) {
     }
     slug = slug;
     sessionState.planSlugCache = slug;
+    sessionState.state.planSlug = slug;
     return slug;
 }
 export function setPlanSlug(bus, slug) {
     const sessionState = getPlanSessionState(bus);
     sessionState.planSlugCache = slug;
+    sessionState.state.planSlug = slug;
 }
 export function clearPlanSlug(bus) {
     const sessionState = getPlanSessionState(bus);
     sessionState.planSlugCache = undefined;
+    sessionState.state.planSlug = undefined;
+}
+export function clearAllPlanSlugs() {
+    for (const sessionState of allSessionStates) {
+        sessionState.planSlugCache = undefined;
+        sessionState.state.planSlug = undefined;
+    }
 }
 // ============================================================================
 // Plan file path
@@ -198,3 +268,20 @@ export async function copyPlanForFork(sourceBus, targetBus) {
     writePlan(targetBus, content);
     return true;
 }
+export function copyPlanFileToNewSlug(bus) {
+    const content = getPlan(bus);
+    if (content === null)
+        return false;
+    clearPlanSlug(bus);
+    return writePlan(bus, content);
+}
+export function copyPlanFile(sourcePath, targetPath) {
+    try {
+        mkdirSync(dirname(targetPath), { recursive: true });
+        copyFileSync(sourcePath, targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/extensions/defaults/plan/plan-permissions.d.ts

@@ -10,6 +10,6 @@ import type { PlanSessionState } from "./types.js";
  * Check if a tool call is allowed in plan mode.
  * Returns { allowed: true } or { allowed: false, reason: string }.
  */
-export declare function shouldAllowToolCall(toolCall: ToolCallInput, planFilePath: string): ToolPermissionResult;
+export declare function shouldAllowToolCall(toolCall: ToolCallInput, planFilePath: string, cwd?: string): ToolPermissionResult;
 export declare function handlePlanModeTransition(sessionState: PlanSessionState): void;
 export declare function handlePlanModeExit(sessionState: PlanSessionState): void;