claude-prism 1.6.1 → 1.7.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-prism",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "description": "AI agent harness implementing the EUDEC methodology",
   "author": { "name": "lazysaturday91" },
   "repository": "https://github.com/lazysaturday91/claude-prism",

package/CHANGELOG.md

@@ -5,10 +5,38 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [1.6.1] — 2026-03-05
+## [1.7.1] — 2026-03-06
 
 ### Fixed
-- **Re-publish of v1.6.0** — npm ghost publish recovery (v1.6.0 was internally registered but never propagated to CDN)
+- **Monorepo hook compatibility** — hooks now use `input.cwd` from Claude Code instead of `process.cwd()` to resolve the correct project root
+- `findProjectRoot()` upward search for nearest `.prism/config.json` — prevents wrong config in monorepo setups
+- `config.projectRoot` injection for all hook rules — existing `config.projectRoot || process.cwd()` fallbacks now receive the correct value
+- All 4 template runners (`precompact`, `session-end`, `subagent-start`, `task-completed`) updated to use `findProjectRoot(input.cwd)`
+- `pipeline.mjs` — `runPipeline()`, `runPipelineAsync()`, `loadCustomRules()` all resolve project root from hook input
+
+## [1.7.0] — 2026-03-06
+
+### Added
+- **Plan Lifecycle Management** — 6 states (`draft`, `active`, `blocked`, `completed`, `archived`, `abandoned`) with validated state machine transitions
+- **Plan History Log** — `.prism/plans/.history.jsonl` records all status changes and progress milestones as timestamped JSONL events
+- **8 new `/plan` subcommands** — `complete`, `archive`, `block`, `unblock`, `abandon`, `reopen`, `history`, `status`
+- **Auto-complete** — plan auto-transitions to `completed` when all tasks are checked (via task-plan-sync hook)
+- **Draft-to-active** — plan auto-transitions from `draft` to `active` on first task check
+- **Progress milestones** — 25%, 50%, 75% progress events recorded to history log
+- `lib/plan-lifecycle.mjs` — core lifecycle functions (`validateTransition`, `updatePlanStatus`, `appendHistory`, `readHistory`, `resolvePlan`)
+- `STATUS_ICONS` export — emoji mapping for all 6 plan statuses
+- 3 new message templates (`plan-lifecycle.completed`, `plan-lifecycle.status-changed`, `plan-lifecycle.auto-activated`)
+- **Plan Discovery** — `prism init`/`prism update` automatically scans `docs/`, `docs/plans/` for existing plan files and offers to import them into `.prism/plans/` (copy, originals preserved). Plans without frontmatter get auto-assigned status based on task progress (draft/active/completed).
+
+### Changed
+- `hooks/task-plan-sync.mjs` — integrates lifecycle auto-transitions (draft→active, active→completed, progress milestones)
+- `lib/installer.mjs` — installs 9 lib files (was 8, added `plan-lifecycle.mjs`)
+- Backward compatible: plans without frontmatter default to `active` status
+
+## [1.6.1] — 2026-03-06
+
+### Fixed
+- Version sync with npm registry (1.6.0 content, version bump only)
 
 ## [1.6.0] — 2026-03-05
 

package/README.md

@@ -90,9 +90,16 @@ Injected into `CLAUDE.md`, EUDEC is a behavioral framework that corrects how AI
 - **Streamlined verification**: 3-level fallback ladder (Tests → Build → Diff)
 - **Adaptive checkpoints**: no pause for small tasks, summary for medium, full for large
 
-**New in v1.6.0:**
+**New in v1.7.0:**
+- **Plan Lifecycle Management** — 6 states (`draft` → `active` → `completed` → `archived`, plus `blocked` and `abandoned`) with validated state machine transitions
+- **Auto-transitions** — plans auto-activate on first task check, auto-complete when all tasks done, with progress milestones (25/50/75%) logged
+- **Plan History** — `.prism/plans/.history.jsonl` records all status changes and milestones as timestamped events
+- **8 new `/plan` subcommands** — `complete`, `archive`, `block`, `unblock`, `abandon`, `reopen`, `history`, `status`
+- **Plan Discovery** — `prism init`/`update` scans `docs/` for existing plan files and offers to import them (originals preserved, frontmatter auto-derived from task progress)
+
+**v1.6.0:**
 - **Session Bootstrap** — agents auto-read `PROJECT-MEMORY.md`, `HANDOFF.md`, active plans, and registry on session start
-- **Plan Lifecycle** — frontmatter (`status`, `created`, `depends_on`), `/plan check` for cross-plan file conflict detection
+- **Plan Frontmatter** — frontmatter (`status`, `created`, `depends_on`), `/plan check` for cross-plan file conflict detection
 - **Docs Scaffolding** — `prism init --docs` creates `docs/` with templates + `.prism/registry.json`
 - **Lightweight Recording** — even small tasks append a 1-line summary to `docs/PROJECT-MEMORY.md`
 
@@ -134,7 +141,7 @@ The original three hooks (commit-guard, test-tracker, plan-enforcement) are dete
 |---------|---------|
 | `/claude-prism:prism` | Run full EUDEC cycle |
 | `/claude-prism:checkpoint` | Check batch progress with plan-reality sync |
-| `/claude-prism:plan` | List/create/view plan files |
+| `/claude-prism:plan` | Plan lifecycle (list/create/complete/archive/block/unblock/abandon/reopen/history/status) |
 | `/claude-prism:analytics` | Show usage analytics (blocks, warns, tests) |
 | `/claude-prism:doctor` | Diagnose installation health |
 | `/claude-prism:stats` | Version, hooks, plan count |
@@ -215,7 +222,7 @@ your-project/
 │   ├── hooks/                   # 6 runners (pre-tool, post-tool, precompact,
 │   │                            #   session-end, subagent-start, task-completed)
 │   ├── rules/                   # 7 rule modules
-│   ├── lib/                     # 8 shared dependencies
+│   ├── lib/                     # 9 shared dependencies
 │   └── settings.json            # Hook registration (6 events)
 
 ~/.claude/                       # (global install / HUD)
@@ -313,6 +320,16 @@ Prism auto-detects [oh-my-claudecode](https://github.com/Yeachan-Heo/oh-my-claud
 
 ## Upgrading
 
+### To v1.7.0
+
+```bash
+npx claude-prism update
+```
+
+v1.7.0 adds plan lifecycle management with 6 states and auto-transitions. During `update`, Prism will scan `docs/` and `docs/plans/` for existing plan files and offer to import them into `.prism/plans/` (originals are preserved). Plans without frontmatter get auto-assigned status based on task progress.
+
+New lib file (`plan-lifecycle.mjs`) is installed automatically. No manual steps needed.
+
 ### To v1.4.0
 
 ```bash

package/bin/cli.mjs

@@ -12,6 +12,7 @@
  */
 
 import { init, check, uninstall, update, doctor, stats, reset, initGlobal, uninstallGlobal, installHud, uninstallHud, hudStatus } from '../lib/installer.mjs';
+import { discoverPlans, importPlans, STATUS_ICONS } from '../lib/plan-lifecycle.mjs';
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -101,6 +102,9 @@ switch (command) {
       console.log(`✅ HUD enabled → ${scriptPath}`);
     }
 
+    // Plan discovery — find existing plan files in known paths
+    await promptPlanDiscovery(cwd);
+
     console.log('\n🌈 Done. Use /prism before complex tasks.');
     break;
   }
@@ -243,6 +247,10 @@ switch (command) {
     }
     console.log('✅ Commands updated');
     console.log('✅ Commit guard updated');
+
+    // Plan discovery — find existing plan files in known paths
+    await promptPlanDiscovery(cwd);
+
     console.log('\n🌈 Prism updated to latest.');
     break;
   }
@@ -341,7 +349,7 @@ Options:
   }
 }
 } catch (err) {
-  const msg = err.message || String(err);
+  const msg = err?.message || String(err);
   process.stderr.write(`🌈 Prism Error: ${msg}\n`);
 
   if (/EACCES|permission/i.test(msg)) {
@@ -354,3 +362,43 @@ Options:
 
   process.exit(1);
 }
+
+// ─── Plan Discovery Helper ───
+
+async function promptPlanDiscovery(projectDir) {
+  const found = discoverPlans(projectDir);
+  if (found.length === 0) return;
+
+  console.log(`\n📋 Plan discovery: ${found.length} plan file(s) found outside .prism/plans/\n`);
+  for (const p of found) {
+    const icon = STATUS_ICONS[p.status] || '📄';
+    const pct = p.total > 0 ? Math.round((p.done / p.total) * 100) : 0;
+    const progress = p.total > 0 ? ` — ${p.done}/${p.total} (${pct}%)` : '';
+    const fm = p.hasFrontmatter ? '' : ' (no frontmatter)';
+    console.log(`  ${icon} ${p.source}${p.file}${progress}${fm}`);
+  }
+
+  if (!process.stdin.isTTY) {
+    console.log('\n  Run interactively to import, or use: prism import-plans');
+    return;
+  }
+
+  const { createInterface } = await import('readline');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise(resolve =>
+    rl.question('\n  Import these plans into .prism/plans/? Originals will be preserved. (y/N): ', a => {
+      rl.close();
+      resolve(a.trim().toLowerCase());
+    })
+  );
+
+  if (answer === 'y' || answer === 'yes') {
+    const result = importPlans(projectDir, found);
+    console.log(`  ✅ ${result.imported} plan(s) imported, ${result.skipped} skipped`);
+    if (result.imported > 0) {
+      console.log('  Plans without frontmatter were assigned status based on task progress.');
+    }
+  } else {
+    console.log('  ⏭️  Plan import skipped');
+  }
+}

package/hooks/task-plan-sync.mjs

@@ -7,6 +7,8 @@ import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { dispatchWebhook } from '../lib/webhook.mjs';
 import { getMessage } from '../lib/messages.mjs';
+import { updatePlanStatus, appendHistory } from '../lib/plan-lifecycle.mjs';
+import { parseFrontmatter } from '../lib/handoff.mjs';
 
 export const planSync = {
   name: 'task-plan-sync',
@@ -101,6 +103,56 @@ export const planSync = {
     }
 
     const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+
+    // ── Plan lifecycle auto-transitions ──
+    try {
+      const planContent = readFileSync(planPath, 'utf8');
+      const fm = parseFrontmatter(planContent);
+      const currentStatus = fm.status || 'active';
+      const planFile = planFiles[0];
+
+      // draft → active: first task checked
+      if (done === 1 && (currentStatus === 'draft' || !fm.status)) {
+        const result = updatePlanStatus(planPath, 'active');
+        if (result.success) {
+          appendHistory(projectRoot, {
+            plan: planFile, event: 'status_change',
+            from: result.oldStatus, to: 'active',
+            actor: 'hook:task-plan-sync',
+            detail: 'First task checked'
+          });
+        }
+      }
+
+      // active → completed: all tasks done
+      if (done === total && total > 0 && currentStatus !== 'completed') {
+        const today = new Date().toISOString().slice(0, 10);
+        const result = updatePlanStatus(planPath, 'completed', { completed_at: today });
+        if (result.success) {
+          appendHistory(projectRoot, {
+            plan: planFile, event: 'status_change',
+            from: currentStatus, to: 'completed',
+            actor: 'hook:task-plan-sync',
+            detail: `All ${total} tasks completed`
+          });
+        }
+      }
+
+      // Progress milestones (25%, 50%, 75%)
+      if (total > 0) {
+        const prevPct = Math.round(((done - 1) / total) * 100);
+        for (const m of [25, 50, 75]) {
+          if (pct >= m && prevPct < m) {
+            appendHistory(projectRoot, {
+              plan: planFile, event: 'progress',
+              actor: 'hook:task-plan-sync',
+              detail: `Progress: ${done}/${total} (${pct}%)`
+            });
+          }
+        }
+      }
+    } catch { /* lifecycle errors should not break the hook */ }
+
     return {
       hookSpecificOutput: {
         hookEventName: 'TaskCompleted',

package/lib/config.mjs

@@ -4,7 +4,7 @@
  */
 
 import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 
 const DEFAULTS = {
   rulesMode: 'full',
@@ -23,6 +23,20 @@ const DEFAULTS = {
   }
 };
 
+/**
+ * Search upward from startDir for nearest .prism/config.json
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string} Project root with .prism/config.json, or startDir as fallback
+ */
+export function findProjectRoot(startDir) {
+  let current = startDir;
+  while (current !== dirname(current)) {
+    if (existsSync(join(current, '.prism', 'config.json'))) return current;
+    current = dirname(current);
+  }
+  return startDir;
+}
+
 export function loadConfig(projectRoot) {
   const configPath = join(projectRoot, '.prism', 'config.json');
 

package/lib/installer.mjs

@@ -71,7 +71,7 @@ export async function init(projectDir, options = {}) {
     const libDestDir = join(claudeDir, 'lib');
     mkdirSync(libDestDir, { recursive: true });
     const libSourceDir = join(__dirname);
-    for (const file of ['state.mjs', 'config.mjs', 'utils.mjs', 'messages.mjs', 'pipeline.mjs', 'session.mjs', 'handoff.mjs', 'webhook.mjs']) {
+    for (const file of ['state.mjs', 'config.mjs', 'utils.mjs', 'messages.mjs', 'pipeline.mjs', 'session.mjs', 'handoff.mjs', 'webhook.mjs', 'plan-lifecycle.mjs']) {
       copyFileSync(join(libSourceDir, file), join(libDestDir, file));
     }
 
@@ -670,7 +670,7 @@ export function dryRun(projectDir, options = {}) {
       });
     }
 
-    for (const lib of ['state.mjs', 'config.mjs', 'utils.mjs', 'messages.mjs', 'pipeline.mjs', 'session.mjs', 'handoff.mjs', 'webhook.mjs']) {
+    for (const lib of ['state.mjs', 'config.mjs', 'utils.mjs', 'messages.mjs', 'pipeline.mjs', 'session.mjs', 'handoff.mjs', 'webhook.mjs', 'plan-lifecycle.mjs']) {
       const target = join(claudeDir, 'lib', lib);
       actions.push({
         type: 'lib',

package/lib/messages.mjs

@@ -12,6 +12,9 @@ const MESSAGES = {
   'session-end-handler.info.saved': '🌈 Prism > Session summary saved to PROJECT-MEMORY.md.',
   'subagent-scope-injector.info.scope': '🌈 Prism Scope >',
   'task-plan-sync.info.updated': '🌈 Prism > Plan updated: {task}. Progress: {done}/{total} ({pct}%)',
+  'plan-lifecycle.completed': '🌈 Prism > Plan completed: {plan}. All {total} tasks done.',
+  'plan-lifecycle.status-changed': '🌈 Prism > Plan {plan}: {from} → {to}',
+  'plan-lifecycle.auto-activated': '🌈 Prism > Plan {plan} activated (first task checked)',
 };
 
 export function getMessage(_lang, key, params = {}) {

package/lib/pipeline.mjs

@@ -6,7 +6,7 @@
 import { readFileSync } from 'fs';
 import { join } from 'path';
 import { sanitizeId } from './utils.mjs';
-import { loadConfig } from './config.mjs';
+import { loadConfig, findProjectRoot } from './config.mjs';
 import { getStateDir } from './state.mjs';
 import { logEvent } from './session.mjs';
 
@@ -68,8 +68,10 @@ export function runPipeline(rules, hookEventName) {
   const input = parseInput();
   if (!input) process.exit(0);
 
-  // Read config ONCE
-  const fullConfig = loadConfig(process.cwd());
+  // Resolve project root from hook input's cwd (monorepo-safe)
+  const projectRoot = findProjectRoot(input.cwd || process.cwd());
+  const fullConfig = loadConfig(projectRoot);
+  fullConfig.projectRoot = projectRoot;
 
   const ctx = toContext(input, hookEventName);
   const stateDir = getStateDir(ctx.sessionId, ctx.agentId);
@@ -128,13 +130,13 @@ export function runPipeline(rules, hookEventName) {
  * @param {string[]} customRulePaths - Paths relative to project root
  * @returns {Promise<Array<{name: string, rule: Object}>>}
  */
-export async function loadCustomRules(builtInRules, customRulePaths) {
+export async function loadCustomRules(builtInRules, customRulePaths, projectRoot) {
   if (!customRulePaths || customRulePaths.length === 0) return builtInRules;
 
   const rules = [...builtInRules];
   for (const rulePath of customRulePaths) {
     try {
-      const absPath = join(process.cwd(), rulePath);
+      const absPath = join(projectRoot || process.cwd(), rulePath);
       const mod = await import(absPath);
       const rule = mod.default || mod[Object.keys(mod)[0]];
       if (rule && typeof rule.evaluate === 'function') {
@@ -156,9 +158,11 @@ export async function runPipelineAsync(builtInRules, hookEventName) {
   const input = parseInput();
   if (!input) process.exit(0);
 
-  const fullConfig = loadConfig(process.cwd());
+  const projectRoot = findProjectRoot(input.cwd || process.cwd());
+  const fullConfig = loadConfig(projectRoot);
+  fullConfig.projectRoot = projectRoot;
   const customRulePaths = fullConfig.customRules || [];
-  const rules = await loadCustomRules(builtInRules, customRulePaths);
+  const rules = await loadCustomRules(builtInRules, customRulePaths, projectRoot);
 
   const ctx = toContext(input, hookEventName);
   const stateDir = getStateDir(ctx.sessionId, ctx.agentId);

package/lib/plan-lifecycle.mjs

@@ -0,0 +1,245 @@
+/**
+ * claude-prism — Plan Lifecycle Management
+ * State machine, status transitions, and history logging for plan files
+ */
+
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { parseFrontmatter, getAllPlans, parsePlanContent } from './handoff.mjs';
+
+// Valid state transitions
+export const TRANSITIONS = {
+  draft:     ['active', 'blocked', 'abandoned'],
+  active:    ['completed', 'blocked', 'abandoned'],
+  blocked:   ['active', 'abandoned'],
+  completed: ['archived', 'active'],  // active = reopen
+  // archived, abandoned = terminal (no transitions)
+};
+
+export const STATUS_ICONS = {
+  draft: '📝', active: '📋', blocked: '🚫',
+  completed: '✅', archived: '📦', abandoned: '🗑️'
+};
+
+/**
+ * Check if a status transition is valid
+ * @param {string} from - Current status (null/undefined treated as 'active' for backward compat)
+ * @param {string} to - Target status
+ * @returns {{ valid: boolean, reason?: string }}
+ */
+export function validateTransition(from, to) {
+  const fromStatus = from || 'active';
+  const allowed = TRANSITIONS[fromStatus];
+  if (!allowed) return { valid: false, reason: `Terminal status: ${fromStatus}` };
+  if (!allowed.includes(to)) return { valid: false, reason: `${fromStatus} → ${to} not allowed` };
+  return { valid: true };
+}
+
+/**
+ * Update a plan file's frontmatter status
+ * @param {string} planPath - Absolute path to plan file
+ * @param {string} newStatus - Target status
+ * @param {Object} extra - Additional frontmatter fields to set
+ * @returns {{ success: boolean, oldStatus: string, newStatus: string, error?: string }}
+ */
+export function updatePlanStatus(planPath, newStatus, extra = {}) {
+  const content = readFileSync(planPath, 'utf8');
+  const fm = parseFrontmatter(content);
+  const oldStatus = fm.status || 'active';
+
+  const validation = validateTransition(oldStatus, newStatus);
+  if (!validation.valid) return { success: false, oldStatus, newStatus, error: validation.reason };
+
+  // Build updated frontmatter fields
+  const fields = { ...fm, status: newStatus, ...extra };
+
+  // Remove fields explicitly set to null (e.g., removing blocked_reason on unblock)
+  for (const [k, v] of Object.entries(extra)) {
+    if (v === null) delete fields[k];
+  }
+
+  const fmStr = Object.entries(fields)
+    .map(([k, v]) => `${k}: ${Array.isArray(v) ? JSON.stringify(v) : v}`)
+    .join('\n');
+
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  let newContent;
+  if (fmMatch) {
+    newContent = content.replace(/^---\n[\s\S]*?\n---/, `---\n${fmStr}\n---`);
+  } else {
+    newContent = `---\n${fmStr}\n---\n\n${content}`;
+  }
+
+  writeFileSync(planPath, newContent);
+  return { success: true, oldStatus, newStatus };
+}
+
+/**
+ * Append an event to the plan history log
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} event - Event data (plan, event type, from, to, actor, detail)
+ */
+export function appendHistory(projectRoot, event) {
+  const dir = join(projectRoot, '.prism', 'plans');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const historyPath = join(dir, '.history.jsonl');
+  const entry = { ts: new Date().toISOString(), ...event };
+  appendFileSync(historyPath, JSON.stringify(entry) + '\n');
+}
+
+/**
+ * Read plan history events
+ * @param {string} projectRoot - Project root directory
+ * @param {string} [planFile] - Optional filter by plan filename
+ * @returns {Array<Object>} History events
+ */
+export function readHistory(projectRoot, planFile) {
+  const historyPath = join(projectRoot, '.prism', 'plans', '.history.jsonl');
+  if (!existsSync(historyPath)) return [];
+  const lines = readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
+  const events = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  if (planFile) return events.filter(e => e.plan === planFile);
+  return events;
+}
+
+/**
+ * Resolve a plan by name or find the most recent active plan
+ * @param {string} projectRoot - Project root directory
+ * @param {string} [planName] - Optional plan filename or partial match
+ * @returns {Object|null} Plan object or null
+ */
+export function resolvePlan(projectRoot, planName) {
+  const plans = getAllPlans(projectRoot);
+  if (!plans.length) return null;
+  if (planName) {
+    const match = plans.find(p => p.file === planName || p.file.includes(planName));
+    if (match) return match;
+  }
+  // Default: most recent active plan
+  return plans.find(p => (p.status || 'active') === 'active') || plans[0];
+}
+
+// ─── Plan Discovery & Import ───
+
+const PLAN_PATTERN = /^\d{4}-\d{2}-\d{2}-.+\.md$/;
+
+/**
+ * Scan known paths for plan-like files not yet in .prism/plans/
+ * @param {string} projectRoot - Project root directory
+ * @returns {Array<{ path: string, file: string, source: string, hasFrontmatter: boolean, status: string, total: number, done: number }>}
+ */
+export function discoverPlans(projectRoot) {
+  const plansDir = join(projectRoot, '.prism', 'plans');
+  const existing = new Set();
+  if (existsSync(plansDir)) {
+    for (const f of readdirSync(plansDir).filter(f => f.endsWith('.md'))) {
+      existing.add(f);
+    }
+  }
+
+  const discovered = [];
+
+  // Known paths to scan
+  const scanPaths = [
+    { dir: join(projectRoot, 'docs'), source: 'docs/' },
+    { dir: join(projectRoot, 'docs', 'plans'), source: 'docs/plans/' },
+  ];
+
+  for (const { dir, source } of scanPaths) {
+    if (!existsSync(dir)) continue;
+    let files;
+    try { files = readdirSync(dir).filter(f => f.endsWith('.md')); } catch { continue; }
+
+    for (const f of files) {
+      // Skip if already in .prism/plans/
+      if (existing.has(f)) continue;
+
+      const fullPath = join(dir, f);
+      let content;
+      try { content = readFileSync(fullPath, 'utf8'); } catch { continue; }
+
+      // Detect plan-like files: filename pattern OR content with checkboxes + batch headers
+      const isNameMatch = PLAN_PATTERN.test(f);
+      const hasCheckboxes = /^[-*]\s+\[[ x]\]/m.test(content);
+      const hasBatchHeader = /^#{1,3}\s+Batch\s+\d+/im.test(content);
+      const isPlanLike = isNameMatch || (hasCheckboxes && hasBatchHeader);
+
+      if (!isPlanLike) continue;
+
+      // Skip generic docs (HANDOFF.md, PROJECT-MEMORY.md, etc.)
+      const skipFiles = ['HANDOFF.md', 'PROJECT-MEMORY.md', 'README.md', 'CHANGELOG.md'];
+      if (skipFiles.includes(f)) continue;
+
+      const fm = parseFrontmatter(content);
+      const progress = parsePlanContent(content, f);
+
+      discovered.push({
+        path: fullPath,
+        file: f,
+        source,
+        hasFrontmatter: !!fm.status,
+        status: fm.status || 'unknown',
+        total: progress.total,
+        done: progress.done,
+      });
+    }
+  }
+
+  return discovered;
+}
+
+/**
+ * Import discovered plans into .prism/plans/ (copy, original preserved)
+ * Adds frontmatter if missing, derives status from checkbox state
+ * @param {string} projectRoot - Project root directory
+ * @param {Array<{ path: string, file: string }>} plans - Plans to import
+ * @returns {{ imported: number, skipped: number }}
+ */
+export function importPlans(projectRoot, plans) {
+  const plansDir = join(projectRoot, '.prism', 'plans');
+  mkdirSync(plansDir, { recursive: true });
+
+  let imported = 0;
+  let skipped = 0;
+
+  for (const plan of plans) {
+    const destPath = join(plansDir, plan.file);
+
+    // Skip if already exists
+    if (existsSync(destPath)) {
+      skipped++;
+      continue;
+    }
+
+    let content = readFileSync(plan.path, 'utf8');
+    const fm = parseFrontmatter(content);
+
+    // Add frontmatter if missing
+    if (!fm.status) {
+      const progress = parsePlanContent(content, plan.file);
+      let status = 'active';
+      if (progress.total > 0 && progress.done === progress.total) {
+        status = 'completed';
+      } else if (progress.done === 0) {
+        status = 'draft';
+      }
+
+      const today = new Date().toISOString().slice(0, 10);
+      const fmBlock = `---\nstatus: ${status}\ncreated: ${today}\nimported_from: ${plan.source || 'unknown'}${plan.file}\n---\n\n`;
+      content = fmBlock + content;
+    }
+
+    writeFileSync(destPath, content);
+
+    appendHistory(projectRoot, {
+      plan: plan.file,
+      event: 'imported',
+      actor: 'cli:plan-discovery',
+      detail: `Imported from ${plan.source || ''}${plan.file}`,
+    });
+
+    imported++;
+  }
+
+  return { imported, skipped };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-prism",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "description": "AI agent harness implementing the EUDEC methodology — Essence, Understand, Decompose, Execute, Checkpoint.",
   "type": "module",
   "bin": {

package/templates/commands/claude-prism/plan.md

@@ -79,7 +79,7 @@ If user requests a conflict check:
    - Recommendation: check dependency order or merge plans
 5. If no overlaps found: "✅ No file conflicts across active plans."
 
-## View Specific Plan
+## View [plan]
 
 If user specifies a plan file:
 
@@ -87,3 +87,85 @@ If user specifies a plan file:
 2. **Show progress** with completion percentage
 3. **Highlight** current batch (first batch with incomplete tasks)
 4. **List blockers** from "Risks / Open Questions" section
+
+## Complete [plan]
+
+1. Resolve target plan (argument or most recent active)
+2. Read frontmatter, validate transition: active → completed
+3. Update frontmatter: `status: completed`, `completed_at: YYYY-MM-DD`
+4. Append to `.prism/plans/.history.jsonl`
+5. Report: "✅ Plan completed: <plan> (N/N tasks done)"
+
+## Archive [plan]
+
+1. Resolve target plan
+2. Validate: must be `completed` status
+3. Update frontmatter: `status: archived`, `archived_at: YYYY-MM-DD`
+4. Append history event
+5. Report: "📦 Plan archived: <plan>"
+
+## Block [plan] [reason]
+
+1. Resolve target plan
+2. Validate: `active` or `draft` status
+3. Update frontmatter: `status: blocked`, `blocked_reason: <reason>`
+4. Append history event
+5. Report: "🚫 Plan blocked: <plan> — <reason>"
+
+## Unblock [plan]
+
+1. Resolve target plan
+2. Validate: must be `blocked` status
+3. Update frontmatter: `status: active`, remove `blocked_reason`
+4. Append history event
+5. Report: "📋 Plan unblocked: <plan>"
+
+## Abandon [plan]
+
+1. Resolve target plan
+2. Validate: not already terminal (archived/abandoned)
+3. Update frontmatter: `status: abandoned`, `abandoned_at: YYYY-MM-DD`
+4. Append history event
+5. Report: "🗑️ Plan abandoned: <plan>"
+
+## Reopen [plan]
+
+1. Resolve target plan
+2. Validate: must be `completed` status
+3. Update frontmatter: `status: active`, remove `completed_at`
+4. Append history event
+5. Report: "📋 Plan reopened: <plan>"
+
+## History [plan]
+
+1. Read `.prism/plans/.history.jsonl`
+2. If plan specified, filter by plan filename
+3. Format as timeline:
+   ```
+   📜 Plan History: <plan>
+   [2026-03-06 12:00] 📝 Created
+   [2026-03-06 12:05] 📋 draft → active (First task checked)
+   [2026-03-06 14:00] 📊 Progress: 5/8 (62%)
+   [2026-03-06 15:00] ✅ active → completed (All 8 tasks done)
+   ```
+4. If no plan specified, show last 20 events across all plans
+
+## Status
+
+1. Read all plans via getAllPlans()
+2. Group by status
+3. Display dashboard:
+   ```
+   📊 Plan Status Dashboard
+
+   📋 Active (2)
+     • 2026-03-06-feature-x.md — 60% (6/10)
+     • 2026-03-05-bugfix-y.md — 30% (3/10)
+
+   🚫 Blocked (1)
+     • 2026-03-04-migration.md — reason: waiting for API v2
+
+   ✅ Completed (3)
+   📦 Archived (5)
+   🗑️ Abandoned (1)
+   ```

package/templates/runners/precompact.mjs

@@ -5,11 +5,13 @@
  */
 import { readFileSync } from 'fs';
 import { precompactHandler } from '../rules/precompact-handler.mjs';
-import { loadConfig } from '../lib/config.mjs';
+import { loadConfig, findProjectRoot } from '../lib/config.mjs';
 
 try {
   const input = JSON.parse(readFileSync(0, 'utf8'));
-  const config = loadConfig(process.cwd());
+  const projectRoot = findProjectRoot(input.cwd || process.cwd());
+  const config = loadConfig(projectRoot);
+  config.projectRoot = projectRoot;
   const result = precompactHandler.evaluate(input, config);
   if (result) {
     process.stdout.write(JSON.stringify(result));

package/templates/runners/session-end.mjs

@@ -5,11 +5,13 @@
  */
 import { readFileSync } from 'fs';
 import { sessionEndHandler } from '../rules/session-end-handler.mjs';
-import { loadConfig } from '../lib/config.mjs';
+import { loadConfig, findProjectRoot } from '../lib/config.mjs';
 
 try {
   const input = JSON.parse(readFileSync(0, 'utf8'));
-  const config = loadConfig(process.cwd());
+  const projectRoot = findProjectRoot(input.cwd || process.cwd());
+  const config = loadConfig(projectRoot);
+  config.projectRoot = projectRoot;
   const result = sessionEndHandler.evaluate(input, config);
   if (result) {
     process.stdout.write(JSON.stringify(result));

package/templates/runners/subagent-start.mjs

@@ -5,11 +5,13 @@
  */
 import { readFileSync } from 'fs';
 import { scopeInjector } from '../rules/subagent-scope-injector.mjs';
-import { loadConfig } from '../lib/config.mjs';
+import { loadConfig, findProjectRoot } from '../lib/config.mjs';
 
 try {
   const input = JSON.parse(readFileSync(0, 'utf8'));
-  const config = loadConfig(process.cwd());
+  const projectRoot = findProjectRoot(input.cwd || process.cwd());
+  const config = loadConfig(projectRoot);
+  config.projectRoot = projectRoot;
   const result = scopeInjector.evaluate(input, config);
   if (result) {
     process.stdout.write(JSON.stringify(result));

package/templates/runners/task-completed.mjs

@@ -5,11 +5,13 @@
  */
 import { readFileSync } from 'fs';
 import { planSync } from '../rules/task-plan-sync.mjs';
-import { loadConfig } from '../lib/config.mjs';
+import { loadConfig, findProjectRoot } from '../lib/config.mjs';
 
 try {
   const input = JSON.parse(readFileSync(0, 'utf8'));
-  const config = loadConfig(process.cwd());
+  const projectRoot = findProjectRoot(input.cwd || process.cwd());
+  const config = loadConfig(projectRoot);
+  config.projectRoot = projectRoot;
   const result = planSync.evaluate(input, config);
   if (result) {
     process.stdout.write(JSON.stringify(result));