aiwcli 0.10.1 → 0.10.3

package/dist/lib/template-installer.js

@@ -2,98 +2,6 @@ import { promises as fs } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { IdePathResolver } from './ide-path-resolver.js';
 import { pathExists } from './paths.js';
-import { mergeTemplateContent } from './template-merger.js';
-/**
- * Deep merge two settings objects, combining hook arrays.
- * Used to merge _shared/settings.json into .claude/settings.json
- */
-function deepMergeSettings(target, source) {
-    const result = { ...target };
-    for (const key of Object.keys(source)) {
-        // Skip comment fields
-        if (key.startsWith('$') || key.startsWith('_')) {
-            continue;
-        }
-        const sourceValue = source[key];
-        const targetValue = result[key];
-        if (key === 'hooks' && typeof sourceValue === 'object' && sourceValue !== null) {
-            // Special handling for hooks - merge by event type
-            result[key] = mergeHooks(targetValue || {}, sourceValue);
-        }
-        else if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
-            // Concatenate arrays
-            result[key] = [...targetValue, ...sourceValue];
-        }
-        else if (typeof sourceValue === 'object' && sourceValue !== null && typeof targetValue === 'object' && targetValue !== null) {
-            // Recursively merge objects
-            result[key] = deepMergeSettings(targetValue, sourceValue);
-        }
-        else {
-            // Override with source value
-            result[key] = sourceValue;
-        }
-    }
-    return result;
-}
-/**
- * Merge hook configurations, combining arrays for each event type.
- */
-function mergeHooks(target, source) {
-    const result = { ...target };
-    for (const eventType of Object.keys(source)) {
-        const targetHooks = result[eventType];
-        const sourceHooks = source[eventType];
-        if (targetHooks && sourceHooks) {
-            // Append source hooks to existing event type
-            result[eventType] = [...targetHooks, ...sourceHooks];
-        }
-        else if (sourceHooks) {
-            // New event type
-            result[eventType] = sourceHooks;
-        }
-    }
-    return result;
-}
-/**
- * Merge settings from a source settings.json file into the IDE settings file.
- * Reads from the provided source path and merges into .claude/settings.json at project root.
- *
- * @param targetDir - Project root directory
- * @param sourceSettingsPath - Absolute path to source settings.json file
- * @returns true if merge successful, false otherwise
- */
-async function mergeSharedSettingsFromSource(targetDir, sourceSettingsPath) {
-    const resolver = new IdePathResolver(targetDir);
-    const ideSettingsPath = resolver.getClaudeSettings();
-    // Check if source settings exists
-    if (!(await pathExists(sourceSettingsPath))) {
-        return false;
-    }
-    try {
-        // Read source settings
-        const sourceContent = await fs.readFile(sourceSettingsPath, 'utf8');
-        const sourceSettings = JSON.parse(sourceContent);
-        // Read IDE settings (create empty object if doesn't exist)
-        let ideSettings = {};
-        if (await pathExists(ideSettingsPath)) {
-            const ideContent = await fs.readFile(ideSettingsPath, 'utf8');
-            ideSettings = JSON.parse(ideContent);
-        }
-        else {
-            // Create .claude directory if it doesn't exist
-            await fs.mkdir(dirname(ideSettingsPath), { recursive: true });
-        }
-        // Merge source settings into IDE settings
-        const mergedSettings = deepMergeSettings(ideSettings, sourceSettings);
-        // Write merged settings back
-        await fs.writeFile(ideSettingsPath, JSON.stringify(mergedSettings, null, 4) + '\n', 'utf8');
-        return true;
-    }
-    catch {
-        // Silently fail on parse/write errors
-        return false;
-    }
-}
 /**
  * Check template installation status for a method.
  * Returns which items exist and which are missing.
@@ -186,32 +94,6 @@ export function shouldExclude(name) {
         return pattern.test(name);
     });
 }
-/**
- * Merge source directory into destination, skipping existing files.
- * Unlike copyDir, this preserves existing files in destination.
- *
- * @param src - Source directory path
- * @param dest - Destination directory path
- */
-async function mergeDirectory(src, dest) {
-    await fs.mkdir(dest, { recursive: true });
-    const entries = await fs.readdir(src, { withFileTypes: true });
-    for (const entry of entries) {
-        if (shouldExclude(entry.name))
-            continue;
-        const srcPath = join(src, entry.name);
-        const destPath = join(dest, entry.name);
-        if (entry.isDirectory()) {
-            await mergeDirectory(srcPath, destPath);
-        }
-        else {
-            // Skip if file already exists
-            if (!(await pathExists(destPath))) {
-                await fs.copyFile(srcPath, destPath);
-            }
-        }
-    }
-}
 /**
  * Copy directory recursively with proper error handling.
  * Excludes test files, cache directories, and output folders.
@@ -249,20 +131,45 @@ export async function copyDir(src, dest, excludeIdeFolders = false) {
     });
     await Promise.all(operations);
 }
+/**
+ * Merge source directory into destination, skipping existing files.
+ * Unlike copyDir, this preserves existing files in destination.
+ *
+ * @param src - Source directory path
+ * @param dest - Destination directory path
+ */
+async function mergeDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    const ops = entries
+        .filter((entry) => !shouldExclude(entry.name))
+        .map(async (entry) => {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await mergeDirectory(srcPath, destPath);
+        }
+        else if (!(await pathExists(destPath))) {
+            await fs.copyFile(srcPath, destPath);
+        }
+    });
+    await Promise.all(ops);
+}
 /**
  * Install template with IDE-specific folder selection.
- * Supports selective installation - only installs items that don't already exist.
  *
  * Template structure:
- * - Non-dot folders (e.g., _bmad/, GSR/) are installed if not already present
- * - Dot folders (e.g., .claude/, .windsurf/) are installed only if matching IDE flag and not already present
+ * - Non-dot folders (e.g., _bmad/, GSR/) → .aiwcli/ (always overwritten)
+ * - _shared/ → .aiwcli/_shared/ (always overwritten)
+ * - IDE dot folders (e.g., .claude/) → decomposed into method-owned subdirs
+ *
+ * Settings reconstruction is handled separately by the caller via reconstructIdeSettings().
  *
  * @param config - Installation configuration
- * @param skipExisting - If true, skip items that already exist (default: true for regeneration support)
- * @returns Installation result with list of installed and skipped folders
+ * @returns Installation result with list of installed folders
  * @throws Error if template doesn't exist or requested IDE folder not found
  */
-export async function installTemplate(config, skipExisting = true) {
+export async function installTemplate(config) {
     const { templateName, targetDir, ides, templatePath } = config;
     // Verify template exists
     try {
@@ -295,108 +202,77 @@ export async function installTemplate(config, skipExisting = true) {
             `Available: ${availableIdes.join(', ')}`);
     }
     const installedFolders = [];
-    const skippedFolders = [];
-    const mergedFolders = [];
-    let mergedFileCount = 0;
     // Create .aiwcli container folder for method-specific files
     const resolver = new IdePathResolver(targetDir);
     const containerDir = resolver.getAiwcliContainer();
     await fs.mkdir(containerDir, { recursive: true });
-    // Install non-dot folders into .aiwcli/ container (skip if already exist and skipExisting is true)
+    // Install non-dot folders into .aiwcli/ container (always overwrite)
     const nonDotInstalls = nonDotFolders.map(async (folder) => {
         const srcPath = join(templatePath, folder);
-        // Destination is inside .aiwcli/ container
         const destPath = join(containerDir, folder);
-        if (skipExisting && (await pathExists(destPath))) {
-            return { folder, skipped: true };
-        }
         await copyDir(srcPath, destPath);
-        return { folder, skipped: false };
+        return folder;
     });
     const nonDotResults = await Promise.all(nonDotInstalls);
-    for (const result of nonDotResults) {
-        if (result.skipped) {
-            skippedFolders.push(result.folder);
-        }
-        else {
-            installedFolders.push(result.folder);
-        }
-    }
+    installedFolders.push(...nonDotResults);
     // Install root-level _shared directory (shared across all templates)
-    // This is at templates/_shared, not inside the specific template directory
     // Exclude IDE config folders (.claude, .windsurf) - they are used for settings merging only
     const templatesRoot = dirname(templatePath);
     const rootSharedSrc = join(templatesRoot, '_shared');
     const rootSharedDest = join(containerDir, '_shared');
     if (await pathExists(rootSharedSrc)) {
-        if (skipExisting && (await pathExists(rootSharedDest))) {
-            skippedFolders.push('_shared');
-        }
-        else {
-            await copyDir(rootSharedSrc, rootSharedDest, true); // excludeIdeFolders = true
-            installedFolders.push('_shared');
-        }
-        // Merge shared IDE folders (commands, workflows) into project IDE folders
-        // This handles _shared/.claude/, _shared/.windsurf/, etc.
+        await copyDir(rootSharedSrc, rootSharedDest, true); // excludeIdeFolders = true
+        installedFolders.push('_shared');
+        // Copy shared IDE content (e.g., _shared/.claude/commands/handoff.md)
+        // These are non-method-owned files that live in IDE folders
         const sharedIdeInstalls = ides.map(async (ide) => {
             const sharedIdeFolder = join(rootSharedSrc, `.${ide}`);
             if (await pathExists(sharedIdeFolder)) {
                 const destIdeFolder = resolver.getIdeDir(ide);
                 await fs.mkdir(destIdeFolder, { recursive: true });
-                // Recursively copy, but skip files that already exist
+                // Merge shared IDE content, skipping files that already exist
                 await mergeDirectory(sharedIdeFolder, destIdeFolder);
             }
         });
         await Promise.all(sharedIdeInstalls);
     }
-    // Install matching IDE folders
-    // If folder exists, merge content recursively by looking for method name folders
+    // Install method-owned IDE content (decomposed approach)
+    // Instead of copying entire .claude/ from template, only copy method-namespaced subdirectories
     const ideInstalls = ides.map(async (ide) => {
         const folderName = dotFolders.get(ide);
-        if (folderName) {
-            const srcPath = join(templatePath, folderName);
-            const destPath = resolver.getIdeDir(ide);
-            if (await pathExists(destPath)) {
-                if (skipExisting) {
-                    // Folder exists - merge template content by finding method-named folders
-                    const mergeResult = await mergeTemplateContent(srcPath, destPath, templateName);
-                    return {
-                        folder: folderName,
-                        skipped: false,
-                        merged: true,
-                        mergedFiles: mergeResult.copiedFiles.length,
-                    };
-                }
-                // skipExisting is false, so overwrite
-                await copyDir(srcPath, destPath);
-                return { folder: folderName, skipped: false, merged: false, mergedFiles: 0 };
+        if (!folderName)
+            return null;
+        const srcIdePath = join(templatePath, folderName);
+        const destIdePath = resolver.getIdeDir(ide);
+        await fs.mkdir(destIdePath, { recursive: true });
+        // Scan the template IDE folder for subdirectories and copy method-owned content
+        const ideEntries = await fs.readdir(srcIdePath, { withFileTypes: true });
+        const subdirOps = ideEntries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const subdirSrc = join(srcIdePath, entry.name);
+            const subdirDest = join(destIdePath, entry.name);
+            // Check for method-namespaced child within this subdirectory
+            const methodChildSrc = join(subdirSrc, templateName);
+            if (await pathExists(methodChildSrc)) {
+                // Copy only the method-namespaced subdirectory (overwrite)
+                const methodChildDest = join(subdirDest, templateName);
+                await copyDir(methodChildSrc, methodChildDest);
             }
-            await copyDir(srcPath, destPath);
-            return { folder: folderName, skipped: false, merged: false, mergedFiles: 0 };
-        }
-        return null;
+            else {
+                // No method-namespaced child — copy the entire subdirectory, merging with existing
+                await mergeDirectory(subdirSrc, subdirDest);
+            }
+        });
+        await Promise.all(subdirOps);
+        return folderName;
     });
     const ideResults = (await Promise.all(ideInstalls)).filter((result) => result !== null);
-    for (const result of ideResults) {
-        if (result.merged) {
-            mergedFolders.push(result.folder);
-            mergedFileCount += result.mergedFiles;
-        }
-        else if (result.skipped) {
-            skippedFolders.push(result.folder);
-        }
-        else {
-            installedFolders.push(result.folder);
-        }
-    }
-    // Settings merging is now handled by the caller via mergeMethodsSettings()
-    // This allows unified merging of _shared + method-specific settings
+    installedFolders.push(...ideResults);
+    // Settings reconstruction is handled by the caller via reconstructIdeSettings()
     return {
         installedFolders,
-        skippedFolders,
-        mergedFolders,
-        mergedFileCount,
-        sharedSettingsMerged: false, // Deprecated, kept for backwards compatibility
+        sharedSettingsMerged: false,
         templatePath,
     };
 }

package/dist/lib/template-settings-reconstructor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Unified reconstruction of shared IDE settings files.
+ *
+ * Both `aiw init` and `aiw clear` use the same operation: reconstruct shared
+ * settings from the union of all active templates. Install adds a template to
+ * the list; clear removes one. The reconstruction logic is identical.
+ *
+ * Template files fall into two categories:
+ * 1. **Method-owned** — lives in method-namespaced paths (e.g., `.claude/commands/cc-native/`),
+ *    owned exclusively by one template. Handled by copy/delete, not by this module.
+ * 2. **Shared** — lives in common locations (e.g., `settings.json`), multiple templates
+ *    contribute. Handled by this module via reconstruction from source.
+ *
+ * @module lib/template-settings-reconstructor
+ */
+/**
+ * Reconstruct .claude/settings.json and .windsurf/hooks.json from the union
+ * of all specified templates.
+ *
+ * The function:
+ * 1. Starts with empty settings
+ * 2. Merges _shared template settings (always included)
+ * 3. For each active template, merges its template-source settings
+ * 4. Writes the result to the IDE settings file
+ *
+ * Uses mergeClaudeSettings() from hooks-merger.ts for dedup-aware merging.
+ *
+ * Install calls: reconstructIdeSettings(targetDir, [...existingTemplates, newTemplate], ides)
+ * Clear calls:   reconstructIdeSettings(targetDir, existingTemplates.filter(t => t !== removed), ides)
+ *
+ * @param targetDir - Project root directory
+ * @param activeTemplates - Template names to include (e.g., ['cc-native', 'bmad'])
+ * @param ides - IDEs to reconstruct for (e.g., ['claude', 'windsurf'])
+ */
+export declare function reconstructIdeSettings(targetDir: string, activeTemplates: string[], ides: string[]): Promise<void>;

package/dist/lib/template-settings-reconstructor.js

@@ -0,0 +1,130 @@
+/**
+ * Unified reconstruction of shared IDE settings files.
+ *
+ * Both `aiw init` and `aiw clear` use the same operation: reconstruct shared
+ * settings from the union of all active templates. Install adds a template to
+ * the list; clear removes one. The reconstruction logic is identical.
+ *
+ * Template files fall into two categories:
+ * 1. **Method-owned** — lives in method-namespaced paths (e.g., `.claude/commands/cc-native/`),
+ *    owned exclusively by one template. Handled by copy/delete, not by this module.
+ * 2. **Shared** — lives in common locations (e.g., `settings.json`), multiple templates
+ *    contribute. Handled by this module via reconstruction from source.
+ *
+ * @module lib/template-settings-reconstructor
+ */
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mergeClaudeSettings } from './hooks-merger.js';
+import { IdePathResolver } from './ide-path-resolver.js';
+import { readClaudeSettings, writeClaudeSettings } from './settings-hierarchy.js';
+import { getTemplatePath } from './template-resolver.js';
+import { getTargetHooksFile, readWindsurfHooks, writeWindsurfHooks } from './windsurf-hooks-hierarchy.js';
+import { mergeWindsurfHooks } from './windsurf-hooks-merger.js';
+/**
+ * Get the path to the _shared template directory.
+ *
+ * @returns Absolute path to the _shared template
+ */
+function getSharedTemplatePath() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const currentDir = dirname(currentFilePath);
+    return join(currentDir, '..', 'templates', '_shared');
+}
+/**
+ * Reconstruct .claude/settings.json and .windsurf/hooks.json from the union
+ * of all specified templates.
+ *
+ * The function:
+ * 1. Starts with empty settings
+ * 2. Merges _shared template settings (always included)
+ * 3. For each active template, merges its template-source settings
+ * 4. Writes the result to the IDE settings file
+ *
+ * Uses mergeClaudeSettings() from hooks-merger.ts for dedup-aware merging.
+ *
+ * Install calls: reconstructIdeSettings(targetDir, [...existingTemplates, newTemplate], ides)
+ * Clear calls:   reconstructIdeSettings(targetDir, existingTemplates.filter(t => t !== removed), ides)
+ *
+ * @param targetDir - Project root directory
+ * @param activeTemplates - Template names to include (e.g., ['cc-native', 'bmad'])
+ * @param ides - IDEs to reconstruct for (e.g., ['claude', 'windsurf'])
+ */
+export async function reconstructIdeSettings(targetDir, activeTemplates, ides) {
+    const sharedTemplatePath = getSharedTemplatePath();
+    if (ides.includes('claude')) {
+        await reconstructClaudeSettings(targetDir, activeTemplates, sharedTemplatePath);
+    }
+    if (ides.includes('windsurf')) {
+        await reconstructWindsurfHooks(targetDir, activeTemplates, sharedTemplatePath);
+    }
+}
+/**
+ * Reconstruct .claude/settings.json from scratch using template sources.
+ */
+async function reconstructClaudeSettings(targetDir, activeTemplates, sharedTemplatePath) {
+    const resolver = new IdePathResolver(targetDir);
+    const settingsPath = resolver.getClaudeSettings();
+    // Read existing settings to preserve non-template fields (methods tracking, etc.)
+    const existingSettings = await readClaudeSettings(settingsPath);
+    // Preserve the methods tracking from existing settings
+    const methodsTracking = existingSettings?.methods;
+    // Start from empty and merge all template settings
+    let reconstructed = {};
+    // 1. Merge _shared template settings
+    const sharedSettingsPath = join(sharedTemplatePath, '.claude', 'settings.json');
+    const sharedSettings = await readClaudeSettings(sharedSettingsPath);
+    if (sharedSettings) {
+        reconstructed = mergeClaudeSettings(reconstructed, sharedSettings);
+    }
+    // 2. Merge each active template's settings (sequential for deterministic merge order)
+    for (const template of activeTemplates) {
+        try {
+            const templatePath = await getTemplatePath(template); // eslint-disable-line no-await-in-loop
+            const templateSettingsPath = join(templatePath, '.claude', 'settings.json');
+            const templateSettings = await readClaudeSettings(templateSettingsPath); // eslint-disable-line no-await-in-loop
+            if (templateSettings) {
+                reconstructed = mergeClaudeSettings(reconstructed, templateSettings);
+            }
+        }
+        catch {
+            // Template not found — skip
+        }
+    }
+    // 3. Restore methods tracking
+    if (methodsTracking && Object.keys(methodsTracking).length > 0) {
+        reconstructed.methods = methodsTracking;
+    }
+    // 4. Write reconstructed settings
+    await writeClaudeSettings(settingsPath, reconstructed);
+}
+/**
+ * Reconstruct .windsurf/hooks.json from scratch using template sources.
+ */
+async function reconstructWindsurfHooks(targetDir, activeTemplates, sharedTemplatePath) {
+    const hooksPath = getTargetHooksFile(targetDir);
+    // Start from empty
+    let reconstructed = { hooks: {} };
+    // 1. Merge _shared template hooks
+    const sharedHooksPath = join(sharedTemplatePath, '.windsurf', 'hooks.json');
+    const sharedHooks = await readWindsurfHooks(sharedHooksPath);
+    if (sharedHooks) {
+        reconstructed = mergeWindsurfHooks(reconstructed, sharedHooks);
+    }
+    // 2. Merge each active template's hooks (sequential for deterministic merge order)
+    for (const template of activeTemplates) {
+        try {
+            const templatePath = await getTemplatePath(template); // eslint-disable-line no-await-in-loop
+            const templateHooksPath = join(templatePath, '.windsurf', 'hooks.json');
+            const templateHooks = await readWindsurfHooks(templateHooksPath); // eslint-disable-line no-await-in-loop
+            if (templateHooks) {
+                reconstructed = mergeWindsurfHooks(reconstructed, templateHooks);
+            }
+        }
+        catch {
+            // Template not found — skip
+        }
+    }
+    // 3. Write reconstructed hooks
+    await writeWindsurfHooks(hooksPath, reconstructed);
+}

package/dist/templates/_shared/hooks/archive_plan.py

@@ -39,7 +39,7 @@ from lib.base.hook_utils import load_hook_input, log_debug, log_info, log_warn,
 from lib.base.utils import project_dir
 from lib.base.constants import get_context_dir
 from lib.context.context_store import get_context_by_session_id
-from lib.context.plan_manager import archive_plan, extract_plan_path_from_result
+from lib.context.plan_manager import archive_plan, extract_plan_path_from_result, find_plan_path_in_transcript
 
 # Import debug cleanup function from cc-native lib
 _cc_native_lib = SCRIPT_DIR.parent / "_cc-native" / "lib"
@@ -70,7 +70,15 @@ def _find_plan_path(hook_input: dict, project_root: Path) -> Optional[str]:
     if not plan_path:
         plan_path = tool_input.get("plan_path") or tool_input.get("planPath")
 
-    # Search standard locations
+    # Parse transcript for most recent Write to .claude/plans/
+    if not plan_path:
+        transcript_path = hook_input.get("transcript_path")
+        if transcript_path:
+            plan_path = find_plan_path_in_transcript(transcript_path)
+            if plan_path:
+                log_info("archive_plan", f"Found plan path via transcript: {plan_path}")
+
+    # Search standard locations (mtime-based fallback)
     if not plan_path:
         log_debug("archive_plan", "No plan_path found, searching standard locations...")
         claude_plans_dir = Path.home() / ".claude" / "plans"

package/dist/templates/_shared/hooks/session_end.py

@@ -106,35 +106,43 @@ def main():
         }
         state.last_active = now_iso()
 
-        # Fallback: assign plan fields if PostToolUse:ExitPlanMode didn't fire.
-        # When ExitPlanMode triggers /clear, the session terminates before PostToolUse
-        # hooks can run, so plan_accepted.py never fires. Detect this by checking
-        # for an archived plan that hasn't been assigned yet.
-        if not state.plan_hash:
-            latest_plan_path = find_latest_plan(state.id, project_root)
-            if latest_plan_path:
-                try:
-                    content = Path(latest_plan_path).read_text(encoding="utf-8")
-                    normalized = normalize_plan_content(content)
-                    state.plan_hash = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:12]
-                    state.plan_path = latest_plan_path
-                    state.plan_signature = content[:200]
-                    state.plan_id = generate_plan_id()
-                    state.plan_anchors = extract_plan_anchors(content)
-                    state.plan_consumed = False
-                    log_info("session_end", f"Fallback: assigned archived plan for {state.id} (hash: {state.plan_hash})")
-                except Exception as e:
-                    log_warn("session_end", f"Fallback plan assignment failed: {e}")
-
-        # If a plan is assigned, not yet consumed, and mode is active, stage it for next session
-        if state.plan_hash and state.mode == "active" and not state.plan_consumed:
-            state.mode = "has_plan"
-            log_info("session_end", f"Staged plan for next session: {state.id} -> has_plan")
-        elif state.plan_hash and state.mode == "active" and state.plan_consumed:
-            log_debug("session_end", f"Plan already consumed for {state.id}, not re-staging")
-            log_diagnostic("session_end", "decide", f"Skipping re-stage for {state.id}",
-                            decision="skip_restage", reasoning="plan_hash exists but plan_consumed=True",
-                            inputs={"plan_hash": state.plan_hash, "plan_consumed": True})
+        # Only assign plan fields and stage if NOT in plan mode.
+        # If permission_mode == "plan", ExitPlanMode was rejected (user pressed Escape),
+        # so we should not stage the archived plan for the next session.
+        permission_mode = hook_input.get("permission_mode", "default")
+
+        if permission_mode != "plan":
+            # Fallback: assign plan fields if PostToolUse:ExitPlanMode didn't fire.
+            # When ExitPlanMode triggers /clear, the session terminates before PostToolUse
+            # hooks can run, so plan_accepted.py never fires. Detect this by checking
+            # for an archived plan that hasn't been assigned yet.
+            if not state.plan_hash:
+                latest_plan_path = find_latest_plan(state.id, project_root)
+                if latest_plan_path:
+                    try:
+                        content = Path(latest_plan_path).read_text(encoding="utf-8")
+                        normalized = normalize_plan_content(content)
+                        state.plan_hash = hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:12]
+                        state.plan_path = latest_plan_path
+                        state.plan_signature = content[:200]
+                        state.plan_id = generate_plan_id()
+                        state.plan_anchors = extract_plan_anchors(content)
+                        state.plan_consumed = False
+                        log_info("session_end", f"Fallback: assigned archived plan for {state.id} (hash: {state.plan_hash})")
+                    except Exception as e:
+                        log_warn("session_end", f"Fallback plan assignment failed: {e}")
+
+            # If a plan is assigned, not yet consumed, and mode is active, stage it for next session
+            if state.plan_hash and state.mode == "active" and not state.plan_consumed:
+                state.mode = "has_plan"
+                log_info("session_end", f"Staged plan for next session: {state.id} -> has_plan")
+            elif state.plan_hash and state.mode == "active" and state.plan_consumed:
+                log_debug("session_end", f"Plan already consumed for {state.id}, not re-staging")
+                log_diagnostic("session_end", "decide", f"Skipping re-stage for {state.id}",
+                                decision="skip_restage", reasoning="plan_hash exists but plan_consumed=True",
+                                inputs={"plan_hash": state.plan_hash, "plan_consumed": True})
+        else:
+            log_info("session_end", f"Plan mode active (rejected), skipping plan staging for {state.id}")
 
         # Handoff staging (mirrors plan staging above)
         # Note: if plan already set has_plan, mode != "active" so handoff check skips (plan takes priority)