claude-prism 1.2.7 → 1.5.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "claude-prism",
+  "version": "1.5.0",
+  "description": "AI agent harness implementing the EUDEC methodology",
+  "author": { "name": "lazysaturday91" },
+  "repository": "https://github.com/lazysaturday91/claude-prism",
+  "license": "MIT",
+  "skills": "./templates/skills/",
+  "hooks": "./plugin-hooks.json"
+}

package/CHANGELOG.md

@@ -5,6 +5,73 @@ 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.5.0] — 2026-03-04
+
+### Changed
+- **Adaptive Weight routing** — EUDEC path auto-scales by task size (Lightweight/Standard/Full)
+- **Bugfix Fast Path** — 4-step lightweight path: symptom → cause → fix → verify (skips formal EUDEC)
+- **Verification Fallback Ladder** simplified from 6 levels to 3 (Tests/Build/Diff)
+- **Adaptive checkpoints** — frequency proportional to task weight (no pause for lightweight)
+- **Rationalization Defense** compressed from 17 to 4 highest-impact items
+- Section numbering corrected (4-8 moved after 4-7)
+- Package description and keywords updated with "agent harness" positioning
+
+## [1.4.0] — 2026-03-03
+
+### Added
+- **4 new hook events** — PreCompact, SessionEnd, SubagentStart, TaskCompleted
+  - `precompact-handler` — auto-generates `docs/HANDOFF.md` before context compaction
+  - `session-end-handler` — saves HANDOFF + appends session summary to `docs/PROJECT-MEMORY.md`
+  - `subagent-scope-injector` — injects current plan batch context into subagent via `additionalContext`
+  - `task-plan-sync` — auto-updates plan file checkboxes on task completion (fuzzy keyword match)
+- **Native Claude Code plugin** — `.claude-plugin/plugin.json` + `plugin-hooks.json`
+  - `claude plugin install claude-prism` for plugin mode
+  - `prism init` (CLI mode) remains for CLAUDE.md injection
+  - 6 plugin script runners in `scripts/`
+- **HTTP webhook dispatcher** (`lib/webhook.mjs`) — non-blocking fire-and-forget notifications
+  - Configure via `.prism/config.json` `webhooks` array
+  - Events: `compaction`, `session-end`, `batch-complete`
+- **HANDOFF.md generator** (`lib/handoff.mjs`) — shared logic for auto-generating session handoff documents
+  - Plan progress parsing (checkbox counting, batch detection)
+  - Git status integration (branch, uncommitted, recent commits)
+- **Checkpoint integration** in EUDEC rules — `Esc+Esc` / `/rewind` references in EXECUTE protocol
+- 30 new tests covering all new handlers, utilities, plugin structure, and installer paths
+
+### Changed
+- `templates/settings.json` — 6 events (was 2)
+- `lib/installer.mjs` — installs 6 runners, 7 rules, 8 libs (was 2/3/6)
+- `lib/config.mjs` — defaults include `webhooks` and 4 new hook configs
+- `lib/messages.mjs` — 4 new message templates
+- `package.json` `files` includes `scripts/`, `.claude-plugin/`, `plugin-hooks.json`
+
+## [1.3.0] — 2026-03-03
+
+### Added
+- **`.prism/` brand directory** — unified home for all Prism project files
+  - `.prism/config.json` — hook configuration (committed to git, visible on GitHub)
+  - `.prism/.version` — installed version (gitignored via `.prism/.gitignore`)
+  - `.prism/plans/` — plan files (committed)
+- **3-stage migration chain** in `prism update`:
+  - `.prism.json` → `.claude-prism.json` → `.prism/config.json`
+  - `.claude/.prism-version` → `.prism/.version`
+  - `docs/plans/` → `.prism/plans/` (moves files, cleans empty dirs)
+- **Backward-compatible fallback** in plan-enforcement hook (`docs/plans/` still checked)
+- Migration tests (4 new: config, version, plans, `.claude-prism.json` detection)
+- `.prism/.gitignore` auto-creation (ignores `.version`)
+
+### Changed
+- Config path: `.claude-prism.json` → `.prism/config.json`
+- Version path: `.claude/.prism-version` → `.prism/.version`
+- Plans path: `docs/plans/` → `.prism/plans/`
+- `.claude-prism.json` removed from `.gitignore` (config is now committed via `.prism/`)
+- All templates, commands, and docs updated to reference new paths
+- `prism doctor` now detects legacy `.claude-prism.json` as a migration target
+- `prism stats` reads plans from `.prism/plans/` with `docs/plans/` fallback
+- `prism uninstall` cleans both new and legacy paths
+
+### Migration
+Existing users: run `prism update` — all files are automatically migrated. No manual steps needed. The `docs/plans/` fallback ensures hooks work even without migration.
+
 ## [1.2.6] — 2026-02-28
 
 ### Fixed
@@ -56,7 +123,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - session.mjs included in installed lib files
 - CHANGELOG.md (this file)
 - GitHub Actions CI workflow (test on push/PR)
-- Config schema versioning (`.claude-prism.json` version field)
+- Config schema versioning (config version field)
 - Verification Fallback Ladder (7-level, from automated tests to manual diff)
 - Quality Gates between DECOMPOSE→EXECUTE and EXECUTE→CHECKPOINT
 - Goal Recitation mechanism at batch boundaries

package/README.md

@@ -16,9 +16,14 @@
 
 # claude-prism
 
-**EUDEC methodology framework for AI coding agents.**
+**AI agent harness implementing the EUDEC methodology for reliable AI-assisted coding.**
 
-Installs the EUDEC methodology — **Essence, Understand, Decompose, Execute, Checkpoint** — directly into your project's Claude Code environment. Includes a session transition protocol (Handoff) that bookends the core cycle. Three lightweight hooks enforce the methodology where it matters most.
+Prism is an [agent harness](https://martinfowler.com/articles/exploring-gen-ai/harness-engineering.html) —
+the infrastructure that channels AI coding agents toward correct, verified output.
+It combines a behavioral methodology (EUDEC), deterministic hooks for enforcement,
+session lifecycle automation, and adaptive process weight that scales with task complexity.
+
+Installs the EUDEC methodology — **Essence, Understand, Decompose, Execute, Checkpoint** — directly into your project's Claude Code environment. Includes a session transition protocol (Handoff) that bookends the core cycle. Seven hooks enforce the methodology and automate session management.
 
 ## The Problem
 
@@ -75,27 +80,47 @@ Injected into `CLAUDE.md`, EUDEC is a behavioral framework that corrects how AI
 - **Medium risk** (new components, API integration): Build + runtime check
 - **Low risk** (imports, types, renaming): Build/lint passes
 - **No test infra** (legacy PHP, WordPress): Grep-based static check + syntax validation
-- Fallback: Automated Tests → Approval Testing → Build → Lint → Smoke Check → Manual Diff
+- Fallback Ladder: Tests → Build → Diff (use highest available)
 
 **Quality gates** between phases prevent executing on broken baselines.
 
-**New in v1.2.5:**
+**v1.5.0:**
+- **Adaptive Weight**: EUDEC auto-scales — lightweight (1-2 files), standard, or full path
+- **Bugfix Fast Path**: symptom → cause → fix → verify (skips formal EUDEC cycle)
+- **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.4.0:**
+- **Native Claude Code plugin** — `claude plugin install claude-prism` for zero-config setup
+- **4 new hook events** — PreCompact (auto-HANDOFF), SessionEnd (session protection), SubagentStart (scope injection), TaskCompleted (plan auto-update)
+- **HTTP webhooks** — fire-and-forget notifications on compaction, session-end, batch-complete
+- **Checkpoint integration** — `Esc+Esc` / `/rewind` references complement Git-as-Memory
+
+**v1.3.0:**
+- `.prism/` brand directory — config, version, and plans live under `.prism/`
+- Automatic 3-stage migration from legacy paths
+
+**v1.2.5:**
 - **Analysis-only branch**: When no code change is needed, UNDERSTAND reports findings without entering DECOMPOSE/EXECUTE/CHECKPOINT
 - **Git-as-Memory**: Commits after each batch as rollback points; `git diff` summaries maintain context in long sessions
 - **Verification scoping**: Build check output filtered to changed files only — pre-existing errors are ignored
 - **Agent failure recovery**: 3-step protocol when delegated agents produce incomplete results
 
-### 2. Three Focused Hooks
+### 2. Seven Focused Hooks
 
-Hooks enforce the methodology at critical points. All three are deterministic (no heuristics, no state accumulation issues):
+Hooks enforce the methodology at critical points:
 
-| Hook | What It Does | Trigger |
+| Hook | Event | What It Does |
 |---|---|---|
-| **commit-guard** | Blocks commits when tests failed or haven't run | `git commit` |
-| **test-tracker** | Records test pass/fail results | Test commands (20 patterns) |
-| **plan-enforcement** | Warns when editing 6+ files without a plan | `Edit` / `Write` |
+| **commit-guard** | PreToolUse | Blocks commits when tests failed or haven't run |
+| **plan-enforcement** | PreToolUse | Warns when editing 6+ files without a plan |
+| **test-tracker** | PostToolUse | Records test pass/fail results |
+| **precompact-handler** | PreCompact | Auto-generates `docs/HANDOFF.md` before compaction |
+| **session-end-handler** | SessionEnd | Saves HANDOFF + appends to `docs/PROJECT-MEMORY.md` |
+| **scope-injector** | SubagentStart | Injects current plan batch context into subagent |
+| **plan-sync** | TaskCompleted | Auto-updates plan file checkboxes on task completion |
 
-**Why only three?** Previous versions had 6 hooks (scope-guard, debug-loop, alignment, turn-reporter). They produced false positives that undermined the methodology they were supposed to enforce. These three survive because they're deterministic: file count + plan existence, test result parsing, commit detection. No ambiguity.
+The original three hooks (commit-guard, test-tracker, plan-enforcement) are deterministic enforcers. The four new hooks (v1.4.0) are **session lifecycle automations** — they don't block or warn, they auto-save context and sync plan state.
 
 ### 3. Slash Commands
 
@@ -150,6 +175,16 @@ prism analytics --detail    # Include per-session breakdown
 
 ## Installation
 
+### Option A: Plugin Mode (recommended)
+
+```bash
+claude plugin install claude-prism
+```
+
+Plugin mode auto-registers hooks and skills. Run `prism init` additionally if you want CLAUDE.md methodology injection (plugins cannot modify CLAUDE.md).
+
+### Option B: CLI Mode
+
 ```bash
 npx claude-prism init              # Install with hooks (prompts for HUD)
 npx claude-prism init --hud        # Install + auto-enable HUD
@@ -162,15 +197,19 @@ npx claude-prism init --dry-run    # Preview what would be installed
 
 ```
 your-project/
-├── CLAUDE.md                    # EUDEC methodology injected
-├── .claude-prism.json           # Hook configuration
+├── CLAUDE.md                    # EUDEC methodology injected (CLI mode only)
+├── .prism/
+│   ├── config.json              # Hook configuration (committed)
+│   ├── .version                 # Installed version (gitignored)
+│   ├── .gitignore               # Ignores .version
+│   └── plans/                   # Plan files (created during work)
 ├── .claude/
 │   ├── commands/claude-prism/   # 9 slash commands
-│   ├── hooks/                   # pre-tool.mjs, post-tool.mjs
-│   ├── rules/                   # commit-guard, test-tracker, plan-enforcement
-│   ├── lib/                     # Shared dependencies
-│   └── settings.json            # Hook registration
-└── docs/plans/                  # Plan files (created during work)
+│   ├── hooks/                   # 6 runners (pre-tool, post-tool, precompact,
+│   │                            #   session-end, subagent-start, task-completed)
+│   ├── rules/                   # 7 rule modules
+│   ├── lib/                     # 8 shared dependencies
+│   └── settings.json            # Hook registration (6 events)
 
 ~/.claude/                       # (global install / HUD)
 ├── commands/claude-prism/       # 9 slash commands (--global)
@@ -180,7 +219,7 @@ your-project/
 
 ## Configuration
 
-Edit `.claude-prism.json`:
+Edit `.prism/config.json`:
 
 ```json
 {
@@ -188,8 +227,19 @@ Edit `.claude-prism.json`:
   "hooks": {
     "commit-guard": { "enabled": true, "maxTestAge": 300 },
     "test-tracker": { "enabled": true },
-    "plan-enforcement": { "enabled": true, "warnAt": 6 }
-  }
+    "plan-enforcement": { "enabled": true, "warnAt": 6 },
+    "precompact-handler": { "enabled": true },
+    "session-end-handler": { "enabled": true },
+    "subagent-scope-injector": { "enabled": true },
+    "task-plan-sync": { "enabled": true, "matchThreshold": 0.3 }
+  },
+  "webhooks": [
+    {
+      "url": "https://your-server.com/webhook",
+      "events": ["compaction", "session-end", "batch-complete"],
+      "headers": { "Authorization": "Bearer token" }
+    }
+  ]
 }
 ```
 
@@ -198,6 +248,8 @@ Edit `.claude-prism.json`:
 | `version` | 1 | Config schema version (for future migrations) |
 | `commit-guard.maxTestAge` | 300 | Seconds before test run is considered stale |
 | `plan-enforcement.warnAt` | 6 | Unique source file count that triggers plan warning |
+| `task-plan-sync.matchThreshold` | 0.3 | Keyword overlap ratio for fuzzy task matching |
+| `webhooks` | `[]` | HTTP endpoints for event notifications |
 
 ## CLI Commands
 
@@ -235,6 +287,25 @@ prism hud disable                                  # Deactivate HUD statusline
 
 Prism auto-detects [oh-my-claudecode](https://github.com/Yeachan-Heo/oh-my-claudecode). When present, `prism stats` and `prism doctor` show OMC version. No configuration needed.
 
+## Upgrading
+
+### To v1.4.0
+
+```bash
+npx claude-prism update
+```
+
+v1.4.0 adds 4 new hook runners + 4 rule files + 2 new libs. `prism update` installs them automatically. Existing hooks and configuration are preserved.
+
+**Optional**: Install as a native plugin for auto-registration:
+```bash
+claude plugin install claude-prism
+```
+
+### To v1.3.0
+
+v1.3.0 moves project files to `.prism/` directory. Migration is automatic via `prism update`.
+
 ## Design Philosophy
 
 EUDEC is the product. Everything else serves it.

package/bin/cli.mjs

@@ -340,7 +340,7 @@ Options:
   if (/EACCES|permission/i.test(msg)) {
     process.stderr.write('💡 Check directory permissions\n');
   } else if (/JSON|parse/i.test(msg)) {
-    process.stderr.write('💡 Config file may be corrupted. Try `prism reset` or delete .claude-prism.json\n');
+    process.stderr.write('💡 Config file may be corrupted. Try `prism reset` or delete .prism/config.json\n');
   } else if (/ENOENT.*package\.json/i.test(msg)) {
     process.stderr.write('💡 Not in a project directory?\n');
   }

package/hooks/plan-enforcement.mjs

@@ -39,13 +39,18 @@ export const planEnforcement = {
     const threshold = config.warnAt || 6;
     if (files.length < threshold) return { type: 'pass' };
 
-    // Check for plan file in docs/plans/
+    // Check for plan file in .prism/plans/ (with docs/plans/ fallback)
     const projectRoot = config.projectRoot || process.cwd();
-    const plansDir = join(projectRoot, 'docs', 'plans');
+    const plansDir = join(projectRoot, '.prism', 'plans');
     if (existsSync(plansDir)) {
       const plans = readdirSync(plansDir).filter(f => f.endsWith('.md'));
       if (plans.length > 0) return { type: 'pass' };
     }
+    const legacyPlansDir = join(projectRoot, 'docs', 'plans');
+    if (existsSync(legacyPlansDir)) {
+      const plans = readdirSync(legacyPlansDir).filter(f => f.endsWith('.md'));
+      if (plans.length > 0) return { type: 'pass' };
+    }
 
     return {
       type: 'warn',

package/hooks/precompact-handler.mjs

@@ -0,0 +1,44 @@
+/**
+ * claude-prism — PreCompact Handler
+ * Auto-generates HANDOFF.md before context compaction
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { generateHandoff } from '../lib/handoff.mjs';
+import { dispatchWebhook } from '../lib/webhook.mjs';
+import { getMessage } from '../lib/messages.mjs';
+
+export const precompactHandler = {
+  name: 'precompact-handler',
+
+  /**
+   * @param {Object} input - { session_id, trigger, custom_instructions }
+   * @param {Object} config - Prism config
+   * @returns {Object} Hook output with additionalContext
+   */
+  evaluate(input, config) {
+    const projectRoot = config.projectRoot || process.cwd();
+
+    // Generate HANDOFF.md
+    const handoffContent = generateHandoff(projectRoot);
+    const docsDir = join(projectRoot, 'docs');
+    if (!existsSync(docsDir)) {
+      mkdirSync(docsDir, { recursive: true });
+    }
+    writeFileSync(join(docsDir, 'HANDOFF.md'), handoffContent);
+
+    // Webhook dispatch (fire-and-forget)
+    dispatchWebhook(config, 'compaction', {
+      session_id: input.session_id,
+      trigger: input.trigger || 'auto',
+    }).catch(() => {});
+
+    return {
+      hookSpecificOutput: {
+        hookEventName: 'PreCompact',
+        additionalContext: getMessage('en', 'precompact-handler.info.saved')
+      }
+    };
+  }
+};

package/hooks/session-end-handler.mjs

@@ -0,0 +1,57 @@
+/**
+ * claude-prism — SessionEnd Handler
+ * Saves HANDOFF.md and appends session summary to PROJECT-MEMORY.md
+ */
+
+import { writeFileSync, appendFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { generateHandoff, getActivePlanInfo } from '../lib/handoff.mjs';
+import { dispatchWebhook } from '../lib/webhook.mjs';
+
+export const sessionEndHandler = {
+  name: 'session-end-handler',
+
+  /**
+   * @param {Object} input - { session_id, reason }
+   * @param {Object} config - Prism config
+   * @returns {Object} Empty output (SessionEnd has no visible output)
+   */
+  evaluate(input, config) {
+    const projectRoot = config.projectRoot || process.cwd();
+
+    // 1. Generate HANDOFF.md
+    const handoffContent = generateHandoff(projectRoot);
+    const docsDir = join(projectRoot, 'docs');
+    if (!existsSync(docsDir)) {
+      mkdirSync(docsDir, { recursive: true });
+    }
+    writeFileSync(join(docsDir, 'HANDOFF.md'), handoffContent);
+
+    // 2. Append session summary to PROJECT-MEMORY.md
+    const planInfo = getActivePlanInfo(projectRoot);
+    const memoryPath = join(docsDir, 'PROJECT-MEMORY.md');
+    const date = new Date().toISOString().slice(0, 10);
+    let entry = `\n## Session ${date}\n`;
+    entry += `- Reason: ${input.reason || 'unknown'}\n`;
+    if (planInfo) {
+      const pct = planInfo.total > 0 ? Math.round((planInfo.done / planInfo.total) * 100) : 0;
+      entry += `- Plan: \`${planInfo.planName}\` — ${planInfo.done}/${planInfo.total} (${pct}%)\n`;
+    }
+    entry += `- Session ID: ${input.session_id || 'unknown'}\n`;
+
+    if (existsSync(memoryPath)) {
+      appendFileSync(memoryPath, entry);
+    } else {
+      writeFileSync(memoryPath, `# PROJECT-MEMORY\n\nCumulative knowledge across sessions.\n${entry}`);
+    }
+
+    // 3. Webhook dispatch
+    dispatchWebhook(config, 'session-end', {
+      session_id: input.session_id,
+      reason: input.reason,
+      plan_progress: planInfo ? `${planInfo.done}/${planInfo.total}` : null,
+    }).catch(() => {});
+
+    return {};
+  }
+};

package/hooks/subagent-scope-injector.mjs

@@ -0,0 +1,53 @@
+/**
+ * claude-prism — SubagentStart Scope Injector
+ * Injects current plan batch context into subagent
+ */
+
+import { getMessage } from '../lib/messages.mjs';
+import { getActivePlanInfo } from '../lib/handoff.mjs';
+
+export const scopeInjector = {
+  name: 'subagent-scope-injector',
+
+  /**
+   * @param {Object} input - { session_id, agent_id, agent_type }
+   * @param {Object} config - Prism config
+   * @returns {Object|null} Hook output with additionalContext or null
+   */
+  evaluate(input, config) {
+    const projectRoot = config.projectRoot || process.cwd();
+    const planInfo = getActivePlanInfo(projectRoot);
+
+    if (!planInfo || planInfo.total === 0) {
+      return null;
+    }
+
+    const pct = Math.round((planInfo.done / planInfo.total) * 100);
+    const parts = [
+      `Plan: ${planInfo.planName} (${planInfo.done}/${planInfo.total}, ${pct}%)`
+    ];
+
+    if (planInfo.nextBatch) {
+      parts.push(`Current batch: ${planInfo.nextBatch}`);
+    }
+
+    if (planInfo.currentBatchFiles && planInfo.currentBatchFiles.length > 0) {
+      const uniqueFiles = [...new Set(planInfo.currentBatchFiles)].slice(0, 10);
+      parts.push(`Files in scope: ${uniqueFiles.join(', ')}`);
+    }
+
+    if (planInfo.nextTasks.length > 0) {
+      parts.push('Tasks:');
+      for (const task of planInfo.nextTasks.slice(0, 3)) {
+        parts.push(`  - ${task}`);
+      }
+    }
+
+    return {
+      hookSpecificOutput: {
+        hookEventName: 'SubagentStart',
+        additionalContext: getMessage('en', 'subagent-scope-injector.info.scope') + '\n' + parts.join('\n')
+      }
+    };
+  }
+};

package/hooks/task-plan-sync.mjs

@@ -0,0 +1,143 @@
+/**
+ * claude-prism — TaskCompleted Plan Sync
+ * Auto-updates plan file checkboxes when tasks complete
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { dispatchWebhook } from '../lib/webhook.mjs';
+import { getMessage } from '../lib/messages.mjs';
+
+export const planSync = {
+  name: 'task-plan-sync',
+
+  /**
+   * @param {Object} input - { task_id, task_subject, task_description, team_name? }
+   * @param {Object} config - Prism config
+   * @returns {Object|null} Hook output with additionalContext
+   */
+  evaluate(input, config) {
+    const projectRoot = config.projectRoot || process.cwd();
+    const plansDir = join(projectRoot, '.prism', 'plans');
+
+    if (!existsSync(plansDir)) return null;
+
+    const planFiles = readdirSync(plansDir)
+      .filter(f => f.endsWith('.md'))
+      .sort()
+      .reverse();
+
+    if (planFiles.length === 0) return null;
+
+    const planPath = join(plansDir, planFiles[0]);
+    const content = readFileSync(planPath, 'utf8');
+    const subject = input.task_subject || '';
+
+    if (!subject) return null;
+
+    // Find matching unchecked task by keyword overlap
+    const lines = content.split('\n');
+    let matched = false;
+    let matchedTask = '';
+    let batchDone = 0;
+    let batchTotal = 0;
+    let currentBatchName = '';
+    let matchedBatchName = '';
+
+    for (let i = 0; i < lines.length; i++) {
+      // Track batch headers
+      const batchMatch = lines[i].match(/^#{1,3}\s+(Batch\s+\d+[:\s]*.+)/i);
+      if (batchMatch) {
+        // Check if previous batch is now complete
+        if (matched && batchTotal > 0) {
+          matchedBatchName = currentBatchName;
+        }
+        currentBatchName = batchMatch[1];
+        batchDone = 0;
+        batchTotal = 0;
+      }
+
+      const checkboxMatch = lines[i].match(/^([-*]\s+)\[ \]\s+(.+)/);
+      if (checkboxMatch) {
+        batchTotal++;
+        const taskText = checkboxMatch[2];
+
+        if (!matched && matchTask(subject, taskText, config.matchThreshold || 0.3)) {
+          lines[i] = lines[i].replace('[ ]', '[x]');
+          matched = true;
+          matchedTask = taskText;
+          matchedBatchName = currentBatchName;
+          batchDone++; // This one is now done
+        }
+      } else {
+        const doneMatch = lines[i].match(/^[-*]\s+\[x\]/);
+        if (doneMatch) {
+          batchTotal++;
+          batchDone++;
+        }
+      }
+    }
+
+    if (!matched) return null;
+
+    // Write updated plan
+    writeFileSync(planPath, lines.join('\n'));
+
+    // Count overall progress
+    let total = 0, done = 0;
+    for (const line of lines) {
+      if (line.match(/^[-*]\s+\[x\]/)) { total++; done++; }
+      else if (line.match(/^[-*]\s+\[ \]/)) { total++; }
+    }
+
+    // Check if batch is complete
+    const batchComplete = batchTotal > 0 && batchDone >= batchTotal;
+    if (batchComplete) {
+      dispatchWebhook(config, 'batch-complete', {
+        batch: matchedBatchName,
+        plan: planFiles[0],
+        progress: `${done}/${total}`,
+      }).catch(() => {});
+    }
+
+    const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+    return {
+      hookSpecificOutput: {
+        hookEventName: 'TaskCompleted',
+        additionalContext: getMessage('en', 'task-plan-sync.info.updated', {
+          task: matchedTask.slice(0, 60),
+          done: String(done),
+          total: String(total),
+          pct: String(pct),
+        })
+      }
+    };
+  }
+};
+
+/**
+ * Match task subject against plan task text using keyword overlap
+ * @param {string} subject - Task subject from TaskCompleted event
+ * @param {string} taskText - Task text from plan file
+ * @param {number} threshold - Minimum overlap ratio (0-1)
+ * @returns {boolean}
+ */
+function matchTask(subject, taskText, threshold) {
+  const normalize = (s) => s.toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 2);
+
+  const subjectWords = new Set(normalize(subject));
+  const taskWords = normalize(taskText);
+
+  if (subjectWords.size === 0 || taskWords.length === 0) return false;
+
+  let overlap = 0;
+  for (const word of taskWords) {
+    if (subjectWords.has(word)) overlap++;
+  }
+
+  const ratio = overlap / Math.max(subjectWords.size, taskWords.length);
+  return ratio >= threshold;
+}

package/lib/config.mjs

@@ -1,6 +1,6 @@
 /**
  * claude-prism — Configuration Loader
- * Reads .claude-prism.json from project root, with defaults
+ * Reads .prism/config.json from project root, with defaults
  */
 
 import { readFileSync, existsSync } from 'fs';
@@ -10,15 +10,20 @@ const DEFAULTS = {
   sourceExtensions: ['ts', 'tsx', 'js', 'jsx', 'py', 'go', 'rs', 'java', 'c', 'cpp', 'h', 'svelte', 'vue', 'rb', 'kt', 'swift', 'php', 'cs', 'scala', 'ex', 'clj', 'zig', 'lua', 'dart'],
   testPatterns: ['test', 'spec', '_test'],
   customRules: [],
+  webhooks: [],
   hooks: {
     'commit-guard': { enabled: true, maxTestAge: 300 },
     'test-tracker': { enabled: true },
-    'plan-enforcement': { enabled: true, warnAt: 6 }
+    'plan-enforcement': { enabled: true, warnAt: 6 },
+    'precompact-handler': { enabled: true },
+    'session-end-handler': { enabled: true },
+    'subagent-scope-injector': { enabled: true },
+    'task-plan-sync': { enabled: true, matchThreshold: 0.3 }
   }
 };
 
 export function loadConfig(projectRoot) {
-  const configPath = join(projectRoot, '.claude-prism.json');
+  const configPath = join(projectRoot, '.prism', 'config.json');
 
   if (!existsSync(configPath)) {
     return JSON.parse(JSON.stringify(DEFAULTS));