@polymorphism-tech/morph-spec 4.8.6 → 4.8.8

package/framework/hooks/claude-code/pre-compact/save-morph-context.js

@@ -1,20 +1,47 @@
 #!/usr/bin/env node
 
 /**
- * PreCompact Hook: Save Context Before Compaction
+ * PreCompact Hook: Inject MORPH Context into Compact Summary
  *
  * Event: PreCompact
  *
- * Snapshots current morph-spec state to .morph/memory/ before context is lost
- * to compaction. The SessionStart hook can use this to restore awareness.
+ * Injects a rich morph-spec state snapshot as additionalContext so that
+ * Claude's compacted summary includes feature state, task progress, outputs,
+ * and next steps. Ensures the session resumes with full morph awareness
+ * without having to re-read all the spec files.
+ *
+ * Also saves snapshot to .morph/memory/ for SessionStart to reference.
  *
  * Fail-open: exits 0 on any error.
  */
 
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { stateExists, loadState, getActiveFeature } from '../../shared/state-reader.js';
-import { pass } from '../../shared/hook-response.js';
+import {
+  stateExists, loadState, getActiveFeature,
+  derivePhaseForFeature, getPendingGates, getOutputs,
+} from '../../shared/state-reader.js';
+import { injectContext, pass } from '../../shared/hook-response.js';
+
+const DECISIONS_MAX_CHARS = 1500;
+const MAX_PENDING_TASKS   = 8;
+
+const PHASE_POSITIONS = {
+  proposal: 1, setup: 1,
+  uiux: 2, design: 2,
+  clarify: 3,
+  tasks: 4,
+  implement: 5, sync: 5,
+};
+const PIPELINE_TOTAL = 5;
+
+const NEXT_STEP_HINT = {
+  proposal:  (n) => `Continue spec pipeline: /morph-proposal ${n}`,
+  design:    (n) => `Approve design gate: morph-spec approve ${n} design`,
+  uiux:      (n) => `Approve UI gate: morph-spec approve ${n} uiux`,
+  tasks:     (n) => `Approve tasks gate: morph-spec approve ${n} tasks`,
+  implement: (n) => `Continue implementation: morph-spec task next ${n}`,
+};
 
 try {
   if (!stateExists()) pass();
@@ -23,39 +50,130 @@ try {
   if (!state) pass();
 
   const active = getActiveFeature();
+  const cwd    = process.cwd();
 
+  // ── Disk snapshot (for SessionStart restore) ──────────────────────────────
   const snapshot = {
-    timestamp: new Date().toISOString(),
-    event: 'pre-compact',
+    timestamp:     new Date().toISOString(),
+    event:         'pre-compact',
     activeFeature: active ? active.name : null,
-    features: {}
+    features:      {},
   };
 
-  // Save minimal feature summaries
   for (const [name, feature] of Object.entries(state.features || {})) {
     snapshot.features[name] = {
-      phase: feature.phase,
-      status: feature.status,
+      phase:    feature.phase || derivePhaseForFeature(name),
+      status:   feature.status,
       workflow: feature.workflow,
-      tasks: feature.tasks,
+      tasks:    feature.tasks,
       approvalGates: Object.fromEntries(
         Object.entries(feature.approvalGates || {}).map(([gate, data]) => [gate, data.approved])
-      )
+      ),
     };
   }
 
-  // Save to .morph/memory/
-  const memoryDir = join(process.cwd(), '.morph', 'memory');
-  if (!existsSync(memoryDir)) {
-    mkdirSync(memoryDir, { recursive: true });
+  const memoryDir = join(cwd, '.morph', 'memory');
+  if (!existsSync(memoryDir)) mkdirSync(memoryDir, { recursive: true });
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  writeFileSync(join(memoryDir, `pre-compact-${ts}.json`), JSON.stringify(snapshot, null, 2), 'utf-8');
+
+  // ── Nothing more to inject if no active feature ───────────────────────────
+  if (!active) pass();
+
+  const { name, feature } = active;
+  const phase = derivePhaseForFeature(name);
+  const pos   = PHASE_POSITIONS[phase];
+  const phaseLabel = pos ? `${phase} (${pos}/${PIPELINE_TOTAL})` : phase;
+
+  const lines = [
+    '=== MORPH-SPEC COMPACT CONTEXT ===',
+    `Preserve this section verbatim in the compact summary.`,
+    '',
+    `Feature : ${name}`,
+    `Phase   : ${phaseLabel}`,
+    `Status  : ${feature.status}  |  Workflow: ${feature.workflow || 'auto'}`,
+  ];
+
+  // Task progress
+  const tasks = feature.tasks || {};
+  const done  = tasks.completed || 0;
+  const total = tasks.total     || 0;
+  if (total > 0) {
+    const pct = Math.round(done / total * 100);
+    lines.push(`Tasks   : ${done}/${total} completed (${pct}%)`);
+  }
+
+  // In-progress + next pending tasks from taskList
+  const taskList  = Array.isArray(feature.taskList) ? feature.taskList : [];
+  const inProg    = taskList.filter(t => t.status === 'in_progress');
+  const pending   = taskList.filter(t => t.status === 'pending').slice(0, MAX_PENDING_TASKS);
+
+  if (inProg.length > 0) {
+    lines.push('');
+    lines.push('In progress:');
+    for (const t of inProg) lines.push(`  [${t.id}] ${t.title}`);
+  }
+  if (pending.length > 0) {
+    lines.push('');
+    lines.push('Next pending tasks:');
+    for (const t of pending) lines.push(`  [${t.id}] ${t.title}`);
+    if (taskList.filter(t => t.status === 'pending').length > MAX_PENDING_TASKS) {
+      lines.push(`  ... (use morph-spec task next ${name} for full list)`);
+    }
+  }
+
+  // Created outputs
+  const outputs  = getOutputs(name) || {};
+  const created  = Object.entries(outputs).filter(([, o]) => o.created);
+  const missing  = Object.entries(outputs).filter(([, o]) => !o.created);
+  if (created.length > 0) {
+    lines.push('');
+    lines.push('Created outputs:');
+    for (const [type, o] of created) lines.push(`  ✓ ${type}: ${o.path}`);
+  }
+  if (missing.length > 0) {
+    lines.push('Pending outputs:');
+    for (const [type, o] of missing) lines.push(`  ✗ ${type}: ${o.path}`);
+  }
+
+  // Active agents
+  const agents = feature.activeAgents || [];
+  if (agents.length > 0) {
+    lines.push('');
+    lines.push(`Active agents: ${agents.join(', ')}`);
+  }
+
+  // Pending approval gates
+  const pendingGates = getPendingGates(name);
+  if (pendingGates.length > 0) {
+    lines.push(`Pending approvals: ${pendingGates.join(', ')}`);
+  }
+
+  // Key decisions (truncated to stay within context budget)
+  const decisionsPath = join(cwd, `.morph/features/${name}/1-design/decisions.md`);
+  if (existsSync(decisionsPath)) {
+    try {
+      const raw = readFileSync(decisionsPath, 'utf-8');
+      const content = raw.length > DECISIONS_MAX_CHARS
+        ? raw.slice(0, DECISIONS_MAX_CHARS) + '\n[... truncated — full file at decisions.md]'
+        : raw;
+      lines.push('');
+      lines.push('Key decisions (decisions.md):');
+      lines.push(content);
+    } catch { /* non-blocking */ }
+  }
+
+  // Next step
+  const hintFn = NEXT_STEP_HINT[phase];
+  if (hintFn) {
+    lines.push('');
+    lines.push(`Next step: ${hintFn(name)}`);
   }
 
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const snapshotPath = join(memoryDir, `pre-compact-${timestamp}.json`);
-  writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2), 'utf-8');
+  lines.push('');
+  lines.push('=== END MORPH CONTEXT ===');
 
-  pass();
+  injectContext(lines.join('\n'));
 } catch {
-  // Fail-open
   process.exit(0);
 }