claude-prism 1.7.1 → 1.8.0

package/.claude-plugin/plugin.json

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

package/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.8.0] — 2026-03-06
+
+### Added
+- **Plan progress auto-tracking** — `PostToolUse [Edit|Write]` hook tracks file-level progress against active plan's "Files in Scope"
+- `plan-progress-tracker` rule: matches edited files to scoped files, records milestones (25/50/75%), auto-transitions `draft → active` on first edit
+- `PostToolUse [Edit|Write]` event matcher added to `settings.json` — enables hooks on file edits, not just Bash commands
+- `parseScopedFiles(content)` in `plan-lifecycle.mjs` — extracts file paths from "Files in Scope" section
+- `ensureFrontmatter(planPath, content)` in `plan-lifecycle.mjs` — auto-backfills frontmatter for plans without status (derives from checkbox progress)
+- Self-Correction Trigger: "Plan file checkboxes not updated after batch"
+- 27 new tests covering parseScopedFiles, ensureFrontmatter, plan-progress-tracker, and regression guards
+
+### Fixed
+- `mergeSettings()` now compares both command and matcher — prevents skipping new matchers for existing hook commands during `prism update`
+
+## [1.7.2] — 2026-03-06
+
+### Fixed
+- **Plan template frontmatter** — EUDEC plan template now includes `status: draft` frontmatter, so plans created during DECOMPOSE phase participate in lifecycle management automatically
+
 ## [1.7.1] — 2026-03-06
 
 ### Fixed

package/hooks/plan-progress-tracker.mjs

@@ -0,0 +1,121 @@
+/**
+ * claude-prism — Plan Progress Tracker
+ * PostToolUse rule: tracks file-level progress against active plan's "Files in Scope"
+ */
+
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join, relative } from 'path';
+import { readJsonState, writeJsonState } from '../lib/state.mjs';
+import { parseScopedFiles, ensureFrontmatter, updatePlanStatus, appendHistory } from '../lib/plan-lifecycle.mjs';
+import { parseFrontmatter } from '../lib/handoff.mjs';
+
+export const planProgressTracker = {
+  name: 'plan-progress-tracker',
+
+  /**
+   * @param {Object} ctx - { action, filePath, ... }
+   * @param {Object} config - Prism config (projectRoot, hooks settings)
+   * @param {string} stateDir - Session state directory
+   * @returns {{ type: string, message?: string }}
+   */
+  evaluate(ctx, config, stateDir) {
+    // Only process Edit/Write actions
+    if (ctx.action !== 'edit' && ctx.action !== 'write') return { type: 'pass' };
+    if (!ctx.filePath) return { type: 'pass' };
+
+    const projectRoot = config.projectRoot || process.cwd();
+
+    // Find most recent active/draft plan
+    const plan = findActivePlan(projectRoot);
+    if (!plan) return { type: 'pass' };
+
+    // Parse "Files in Scope" → check if edited file is in scope
+    const scopedFiles = parseScopedFiles(plan.content);
+    if (scopedFiles.length === 0) return { type: 'pass' };
+
+    const relativePath = relative(projectRoot, ctx.filePath);
+    const inScope = scopedFiles.some(f =>
+      relativePath === f || relativePath.endsWith(f) || f.endsWith(relativePath)
+    );
+    if (!inScope) return { type: 'pass' };
+
+    // Accumulate touched files in session state
+    const state = readJsonState(stateDir, 'plan-progress') || { touched: [], recordedMilestones: [] };
+    if (!state.recordedMilestones) state.recordedMilestones = [];
+    if (!state.touched.includes(relativePath)) {
+      state.touched.push(relativePath);
+    }
+
+    // Ensure frontmatter exists (auto-backfill if missing)
+    try {
+      ensureFrontmatter(plan.path, plan.content);
+    } catch { /* should not break the hook */ }
+
+    // Calculate progress
+    const pct = Math.floor((state.touched.length / scopedFiles.length) * 100);
+    const fm = plan.frontmatter;
+    const planStatus = fm.status || 'active';
+
+    // draft → active (first scoped file edit)
+    if (planStatus === 'draft') {
+      try {
+        updatePlanStatus(plan.path, 'active');
+        appendHistory(projectRoot, {
+          plan: plan.name, event: 'status_change',
+          from: 'draft', to: 'active',
+          actor: 'hook:plan-progress-tracker',
+          detail: 'First scoped file edited'
+        });
+      } catch { /* lifecycle errors should not break the hook */ }
+    }
+
+    // Progress milestones (25%, 50%, 75%)
+    for (const m of [25, 50, 75]) {
+      if (pct >= m && !state.recordedMilestones.includes(m)) {
+        state.recordedMilestones.push(m);
+        try {
+          appendHistory(projectRoot, {
+            plan: plan.name, event: 'progress',
+            actor: 'hook:plan-progress-tracker',
+            detail: `Progress: ${state.touched.length}/${scopedFiles.length} (${pct}%)`
+          });
+        } catch { /* ignore */ }
+      }
+    }
+
+    // Save state
+    writeJsonState(stateDir, 'plan-progress', state);
+
+    return {
+      type: 'info',
+      message: `🌈 Plan progress: ${state.touched.length}/${scopedFiles.length} files (${pct}%) — ${plan.name}`
+    };
+  }
+};
+
+/**
+ * Find the most recent active or draft plan in .prism/plans/
+ * @param {string} projectRoot
+ * @returns {{ name: string, path: string, content: string, frontmatter: Object }|null}
+ */
+function findActivePlan(projectRoot) {
+  const plansDir = join(projectRoot, '.prism', 'plans');
+  if (!existsSync(plansDir)) return null;
+
+  let files;
+  try {
+    files = readdirSync(plansDir).filter(f => f.endsWith('.md')).sort().reverse();
+  } catch { return null; }
+
+  for (const f of files) {
+    const path = join(plansDir, f);
+    let content;
+    try { content = readFileSync(path, 'utf8'); } catch { continue; }
+    const fm = parseFrontmatter(content);
+    const status = fm.status || 'active';
+    if (status === 'active' || status === 'draft') {
+      return { name: f, path, content, frontmatter: fm };
+    }
+  }
+  return null;
+}

package/lib/installer.mjs

@@ -66,6 +66,7 @@ export async function init(projectDir, options = {}) {
     copyFileSync(join(hooksSourceDir, 'session-end-handler.mjs'), join(rulesDestDir, 'session-end-handler.mjs'));
     copyFileSync(join(hooksSourceDir, 'subagent-scope-injector.mjs'), join(rulesDestDir, 'subagent-scope-injector.mjs'));
     copyFileSync(join(hooksSourceDir, 'task-plan-sync.mjs'), join(rulesDestDir, 'task-plan-sync.mjs'));
+    copyFileSync(join(hooksSourceDir, 'plan-progress-tracker.mjs'), join(rulesDestDir, 'plan-progress-tracker.mjs'));
 
     // Copy lib dependencies
     const libDestDir = join(claudeDir, 'lib');
@@ -661,7 +662,7 @@ export function dryRun(projectDir, options = {}) {
       });
     }
 
-    for (const rule of ['commit-guard.mjs', 'test-tracker.mjs', 'plan-enforcement.mjs', 'precompact-handler.mjs', 'session-end-handler.mjs', 'subagent-scope-injector.mjs', 'task-plan-sync.mjs']) {
+    for (const rule of ['commit-guard.mjs', 'test-tracker.mjs', 'plan-enforcement.mjs', 'precompact-handler.mjs', 'session-end-handler.mjs', 'subagent-scope-injector.mjs', 'task-plan-sync.mjs', 'plan-progress-tracker.mjs']) {
       const target = join(claudeDir, 'rules', rule);
       actions.push({
         type: 'rule',
@@ -904,6 +905,7 @@ function mergeSettings(claudeDir) {
         for (const hook of hookList) {
           const alreadyExists = existing.hooks[event].some(
             h => h.hooks?.[0]?.command === hook.hooks?.[0]?.command
+              && (h.matcher || '') === (hook.matcher || '')
           );
           if (!alreadyExists) {
             existing.hooks[event].push(hook);

package/lib/plan-lifecycle.mjs

@@ -119,6 +119,49 @@ export function resolvePlan(projectRoot, planName) {
   return plans.find(p => (p.status || 'active') === 'active') || plans[0];
 }
 
+// ─── Scoped Files & Frontmatter Helpers ───
+
+/**
+ * Parse "Files in Scope" section from plan content
+ * Extracts backtick-wrapped file paths (e.g., `path/to/file.ts`)
+ * @param {string} content - Plan markdown content
+ * @returns {string[]} File paths extracted
+ */
+export function parseScopedFiles(content) {
+  const section = content.match(/##\s+Files\s+in\s+Scope\s*\n([\s\S]*?)(?=\n##|\n---|\s*$)/i);
+  if (!section) return [];
+  return [...section[1].matchAll(/`([^`]+\.[a-z]+)`/g)].map(m => m[1]);
+}
+
+/**
+ * Ensure a plan file has frontmatter; add if missing
+ * Derives status from checkbox progress (0/N → draft, M/N → active, N/N → completed)
+ * @param {string} planPath - Absolute path to plan file
+ * @param {string} content - Plan file content
+ */
+export function ensureFrontmatter(planPath, content) {
+  const fm = parseFrontmatter(content);
+  if (fm.status) return; // Already has frontmatter with status
+
+  // Derive status from checkbox state
+  let total = 0, done = 0;
+  for (const line of content.split('\n')) {
+    if (/^[-*]\s+\[x\]/i.test(line)) { total++; done++; }
+    else if (/^[-*]\s+\[ \]/.test(line)) { total++; }
+  }
+
+  let status = 'active';
+  if (total > 0 && done === 0) status = 'draft';
+  else if (total > 0 && done === total) status = 'completed';
+
+  // Extract date from filename (YYYY-MM-DD-topic.md)
+  const dateMatch = planPath.match(/(\d{4}-\d{2}-\d{2})/);
+  const created = dateMatch ? dateMatch[1] : new Date().toISOString().slice(0, 10);
+
+  const fmBlock = `---\nstatus: ${status}\ncreated: ${created}\n---\n\n`;
+  writeFileSync(planPath, fmBlock + content);
+}
+
 // ─── Plan Discovery & Import ───
 
 const PLAN_PATTERN = /^\d{4}-\d{2}-\d{2}-.+\.md$/;

package/package.json

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

package/templates/rules.md

@@ -194,6 +194,11 @@ Save multi-step plans (6+ files) as markdown:
 - **Path**: `.prism/plans/YYYY-MM-DD-<topic>.md`
 
 ```markdown
+---
+status: draft
+created: YYYY-MM-DD
+---
+
 ## Goal
 One sentence: what we're building and why.
 
@@ -318,6 +323,7 @@ Choose verification proportional to the **risk of the change**, not the file pat
 - Adding workarounds to fix workarounds → "Design problem. Step back."
 - Copy-pasting similar code 3+ times → "Need abstraction? Ask user."
 - Dependency version mismatch detected → "Resolve before continuing."
+- Plan file checkboxes not updated after batch → "Update plan checkboxes and frontmatter before continuing"
 
 **Goal Recitation** (prevents drift in long sessions):
 - At every batch boundary, re-read the plan file and confirm: "Current work aligns with: [original goal]"

package/templates/runners/post-tool.mjs

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { runPipelineAsync } from '../lib/pipeline.mjs';
 import { testTracker } from '../rules/test-tracker.mjs';
+import { planProgressTracker } from '../rules/plan-progress-tracker.mjs';
 
 await runPipelineAsync([
   { name: 'test-tracker', rule: testTracker },
+  { name: 'plan-progress-tracker', rule: planProgressTracker },
 ], 'PostToolUse');

package/templates/settings.json

@@ -32,6 +32,16 @@
             "timeout": 5000
           }
         ]
+      },
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/post-tool.mjs",
+            "timeout": 5000
+          }
+        ]
       }
     ],
     "PreCompact": [