@geraldmaron/construct 1.0.0 → 1.0.2

package/lib/hooks/mcp-audit.mjs

@@ -3,17 +3,17 @@
  * lib/hooks/mcp-audit.mjs — MCP audit hook — logs all MCP tool calls for observability and review.
  *
  * Runs as PostToolUse on MCP tool calls. Records tool name, input, and output summary to ~/.cx/mcp-audit.json for telemetry and security review.
+ *
+ * @p95ms 10
+ * @maxBlockingScope none (PostToolUse, non-blocking)
  */
-// PostToolUse(mcp__*) — audits every MCP tool call against the active workflow task.
-// Writes .cx/mcp-audit.json: per-server call log with task attribution.
-// Gives per-task MCP usage visibility that per-task scoped MCPs (OmO) cannot provide.
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
+import { shouldCreateCx } from '../project-detection.mjs';
 
 let input = {};
 try { input = JSON.parse(readFileSync(0, 'utf8')); } catch { process.exit(0); }
 
-const cwd = input?.cwd || process.cwd();
 const toolName = input?.tool_name || '';
 
 const match = toolName.match(/^mcp__([^_]+(?:__[^_]+)*)__(.+)$/);
@@ -22,36 +22,34 @@ if (!match) process.exit(0);
 const mcpServer = match[1].replace(/__/g, '-');
 const mcpTool = match[2];
 
-// Get active task key from workflow
-let activeTaskKey = null;
-let activeTaskTitle = null;
-try {
-  const wf = JSON.parse(readFileSync(join(cwd, '.cx', 'workflow.json'), 'utf8'));
-  activeTaskKey = wf.currentTaskKey || null;
-  if (activeTaskKey) {
-    const t = (wf.tasks || []).find(t => t.key === activeTaskKey);
-    activeTaskTitle = t?.title || null;
-  }
-} catch { /* no workflow */ }
+const cwd = input?.cwd || process.cwd();
+
+// Only create .cx if this is an initialized project
+const shouldCreateCxDir = shouldCreateCx(cwd);
 
 const auditPath = join(cwd, '.cx', 'mcp-audit.json');
 let audit = {};
-try { audit = JSON.parse(readFileSync(auditPath, 'utf8')); } catch { /* fresh */ }
+
+// Try to read existing audit file if it exists
+if (existsSync(auditPath)) {
+  try { audit = JSON.parse(readFileSync(auditPath, 'utf8')); } catch { /* fresh */ }
+}
 
 if (!audit[mcpServer]) audit[mcpServer] = [];
 audit[mcpServer].push({
   tool: mcpTool,
   ts: new Date().toISOString(),
-  taskKey: activeTaskKey,
-  taskTitle: activeTaskTitle,
+  coordination: 'tracker-plus-plan',
 });
 
 // Keep last 200 per server
 if (audit[mcpServer].length > 200) audit[mcpServer] = audit[mcpServer].slice(-200);
 
 try {
-  mkdirSync(join(cwd, '.cx'), { recursive: true });
-  writeFileSync(auditPath, JSON.stringify(audit, null, 2));
+  if (shouldCreateCxDir) {
+    mkdirSync(join(cwd, '.cx'), { recursive: true });
+    writeFileSync(auditPath, JSON.stringify(audit, null, 2));
+  }
 } catch { /* best effort */ }
 
 process.exit(0);

package/lib/hooks/mcp-health-check.mjs

@@ -3,6 +3,9 @@
  * lib/hooks/mcp-health-check.mjs — MCP health check hook — verifies MCP servers are reachable before tool use.
  *
  * Runs as PreToolUse on MCP tool calls. Checks that the target MCP server is running and reachable. Emits a warning (does not block) if the server is unavailable.
+ *
+ * @p95ms 51
+ * @maxBlockingScope none (PreToolUse, warn-only)
  */
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { homedir } from 'os';
@@ -47,5 +50,38 @@ if (entry?.status === 'unhealthy' && (Date.now() - entry.since) < CACHE_TTL_MS)
   process.exit(2);
 }
 
+// Role-fence check for MCP tool calls. Most personas have no MCP fence
+// declared (allows everything) — when fence.allowedMcpTools is present, the
+// tool name must match an entry. Out-of-fence MCP calls block with exit 2.
+
+if (process.env.CONSTRUCT_ROLES !== 'off') {
+  try {
+    const lastAgentPath = `${homedir()}/.cx/last-agent.json`;
+    if (existsSync(lastAgentPath)) {
+      const last = JSON.parse(readFileSync(lastAgentPath, 'utf8'));
+      const lastTs = last?.ts ? Date.parse(last.ts) : 0;
+      const fresh = lastTs && (Date.now() - lastTs) < 10 * 60 * 1000;
+      const id = String(last?.agent || '').replace(/^cx-/, '');
+      if (fresh && id) {
+        const { isOnboarded, loadManifest } = await import('../roles/manifest.mjs');
+        if (isOnboarded(id)) {
+          const manifest = loadManifest(id);
+          const allowedMcpTools = manifest?.fence?.allowedMcpTools;
+          if (Array.isArray(allowedMcpTools) && allowedMcpTools.length > 0) {
+            const matches = allowedMcpTools.some((p) => toolName === p || toolName.startsWith(p));
+            if (!matches) {
+              process.stderr.write(
+                `[fence] cx-${id} cannot call MCP tool ${toolName} — outside declared fence.\n` +
+                `Allowed MCP tools: ${allowedMcpTools.join(', ')}\n`
+              );
+              process.exit(2);
+            }
+          }
+        }
+      }
+    }
+  } catch { /* best effort */ }
+}
+
 process.stdout.write(JSON.stringify(input) + '\n');
 process.exit(0);

package/lib/hooks/model-fallback.mjs

@@ -1,36 +1,35 @@
 #!/usr/bin/env node
 /**
- * lib/hooks/model-fallback.mjs — Model fallback hook — reroutes requests when the primary model is unavailable.
+ * lib/hooks/model-fallback.mjs — Provider-aware model fallback hook.
  *
- * Runs as PostToolUse when model calls fail. Reads the error, selects a fallback provider from the model router, and retries the request with the alternate model.
+ * Runs as PostToolUse. On a retryable provider failure it:
+ *   1. Classifies the error via classifyProviderFailure.
+ *   2. Selects a fallback candidate via selectFallbackModel, skipping any
+ *      provider currently in its 5-minute cooldown window.
+ *   3. Writes the new model directly to the project .env via applyToEnv.
+ *   4. Records a cooldown entry for the failing provider.
+ *
+ * Falls back to `construct models --apply` only when no candidate is resolved
+ * (e.g. no registry fallback list, all candidates on cooldown, or no OpenRouter
+ * key for the free-tier path).
+ *
+ * @p95ms 150
+ * @maxBlockingScope none (PostToolUse, non-blocking)
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { readOpenRouterApiKeyFromOpenCodeConfig } from '../model-router.mjs';
+import { join } from 'node:path';
+import {
+  applyToEnv,
+  classifyProviderFailure,
+  readOpenRouterApiKeyFromOpenCodeConfig,
+  selectFallbackModel,
+  writeProviderCooldown,
+} from '../model-router.mjs';
 
-const RATE_LIMIT_PATTERNS = [
-  /\b429\b/i,
-  /rate limit/i,
-  /usage limits?/i,
-  /specified API usage limits?/i,
-  /regain access/i,
-  /weekly limit/i,
-  /monthly limit/i,
-  /daily limit/i,
-  /too many requests/i,
-  /quota exceeded/i,
-  /model unavailable/i,
-  /model.*overloaded/i,
-  /timeout/i,
-  /timed out/i,
-  /ETIMEDOUT/i,
-  /ECONNRESET/i,
-];
-
-const COOLDOWN_MS = 10 * 60 * 1000;
-const statePath = join(homedir(), '.cx', 'construct-model-fallback.json');
+const cooldownPath = join(homedir(), '.cx', 'provider-cooldowns.json');
+const envPath = join(process.cwd(), '.env');
 
 function readInput() {
   try {
@@ -41,65 +40,52 @@ function readInput() {
   }
 }
 
-function flatten(value) {
-  if (value === null || value === undefined) return '';
-  if (typeof value === 'string') return value;
-  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
-  if (Array.isArray(value)) return value.map(flatten).join('\n');
-  if (typeof value === 'object') return Object.values(value).map(flatten).join('\n');
-  return '';
-}
-
-function recentlyApplied(now) {
-  try {
-    const state = JSON.parse(readFileSync(statePath, 'utf8'));
-    return typeof state.lastAppliedAt === 'number' && now - state.lastAppliedAt < COOLDOWN_MS;
-  } catch {
-    return false;
-  }
-}
+const input = readInput();
 
-function writeState(payload) {
-  mkdirSync(dirname(statePath), { recursive: true });
-  writeFileSync(statePath, JSON.stringify(payload, null, 2));
-}
+const classified = classifyProviderFailure(input);
+if (!classified || !classified.retryable) process.exit(0);
 
-const input = readInput();
-const haystack = flatten(input);
-if (!RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(haystack))) process.exit(0);
+process.stderr.write(`[model-fallback] ${classified.kind} detected (provider: ${classified.provider ?? 'unknown'}).\n`);
 
 const now = Date.now();
-if (recentlyApplied(now)) {
-  process.stderr.write('[model-fallback] Rate limit/timeout detected; fallback recently applied, skipping cooldown window.\n');
+const result = selectFallbackModel({ hookInput: input, envPath, cooldownPath, now });
+
+if (result) {
+  process.stderr.write(`[model-fallback] Switching ${result.tier} → ${result.targetModel} (reason: ${result.reason}).\n`);
+  applyToEnv(envPath, { [result.tier]: result.targetModel });
+  if (classified.provider) writeProviderCooldown(cooldownPath, classified.provider, now);
   process.exit(0);
 }
 
+// No candidate resolved — fall back to full `construct models --apply` if possible.
 const toolkitDir = process.env.CX_TOOLKIT_DIR || join(homedir(), '.construct');
 const constructBin = join(toolkitDir, 'bin', 'construct');
 
 if (!existsSync(constructBin)) {
-  process.stderr.write(`[model-fallback] construct binary not found at ${constructBin}\n`);
+  process.stderr.write(`[model-fallback] No fallback candidate and construct binary not found at ${constructBin}.\n`);
+  if (classified.provider) writeProviderCooldown(cooldownPath, classified.provider, now);
   process.exit(0);
 }
 
 const openRouterApiKey = process.env.OPENROUTER_API_KEY || readOpenRouterApiKeyFromOpenCodeConfig();
 
 if (!openRouterApiKey) {
-  process.stderr.write('[model-fallback] Rate limit/timeout detected; no OpenRouter API key found in OPENROUTER_API_KEY or OpenCode config, so automatic fallback cannot poll models.\n');
+  process.stderr.write('[model-fallback] No fallback candidate and no OpenRouter API key — cannot poll models.\n');
+  if (classified.provider) writeProviderCooldown(cooldownPath, classified.provider, now);
   process.exit(0);
 }
 
 try {
-  process.stderr.write('[model-fallback] Rate limit/timeout detected. Running construct models --apply.\n');
+  process.stderr.write('[model-fallback] No direct candidate — running construct models --apply.\n');
   execFileSync(constructBin, ['models', '--apply'], {
     cwd: toolkitDir,
     stdio: 'inherit',
     env: { ...process.env, CX_TOOLKIT_DIR: toolkitDir, OPENROUTER_API_KEY: openRouterApiKey },
     timeout: 120_000,
   });
-  writeState({ lastAppliedAt: now, reason: 'rate-limit-or-timeout' });
+  if (classified.provider) writeProviderCooldown(cooldownPath, classified.provider, now);
 } catch (error) {
-  process.stderr.write(`[model-fallback] Fallback failed: ${error.message}\n`);
+  process.stderr.write(`[model-fallback] construct models --apply failed: ${error.message}\n`);
 }
 
 process.exit(0);

package/lib/hooks/policy-engine.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+/**
+ * lib/hooks/policy-engine.mjs — consolidated session policy enforcement hook.
+ *
+ * Handles three hook events:
+ *   PreToolUse        bootstrap gating (Write/Edit blocked until session is grounded)
+ *   Stop              drive-mode criteria blocks; red-CI and open-bd are advisory warns
+ *   UserPromptSubmit  reserved for workflow rule (no-op today)
+ *
+ * Stop is intentionally non-blocking for red CI and in-progress beads — those
+ * are normal states across sessions, not session-ending failures. Blocking
+ * with a sticky env-var bypass is the antipattern we removed elsewhere; it
+ * trades real friction for theoretical safety. Drive mode still blocks because
+ * drive mode represents an explicit user opt-in.
+ *
+ * @p95ms 80
+ * @maxBlockingScope PreToolUse, Stop, UserPromptSubmit
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+let input = {};
+try { input = JSON.parse(readFileSync(0, 'utf8')) || {}; } catch { process.exit(0); }
+
+const hookEvent = process.env.CONSTRUCT_HOOK_EVENT || input?.hook_event || process.argv[2] || '';
+const toolName = input?.tool_name || input?.tool || '';
+const toolInput = input?.tool_input || {};
+const cwd = input?.cwd || process.cwd();
+const home = homedir();
+
+function safeExec(cmd, opts = {}) {
+  try { return execSync(cmd, { cwd, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, ...opts }).toString().trim(); }
+  catch { return null; }
+}
+
+if (hookEvent === 'PreToolUse') {
+  // Bootstrap gate scope: only mutation tools (Write/Edit/MultiEdit/
+  // NotebookEdit/TodoWrite) require grounding. Bash is not gated here —
+  // dangerous Bash is owned by guard-bash.mjs; gating read-only shell
+  // here would block grep/find/git log and create chicken-and-egg
+  // friction when the same hook also needs Read calls to mark the
+  // session bootstrapped.
+
+  const BOOTSTRAP_TOOLS = new Set([
+    'mcp__construct-mcp__project_context',
+    'mcp__construct-mcp__memory_search',
+    'project_context', 'memory_search',
+  ]);
+  const READ_TOOLS = new Set(['Read', 'Grep', 'Glob', 'LS', 'NotebookRead']);
+  const BLOCKED_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit', 'TodoWrite']);
+
+  const stateDir = join(home, '.cx');
+  const statePath = join(stateDir, 'bootstrap-state.json');
+  const sessionId = input.session_id || input.sessionId || 'default';
+
+  let state = {};
+  if (existsSync(statePath)) {
+    try { state = JSON.parse(readFileSync(statePath, 'utf8')) || {}; } catch { state = {}; }
+  }
+  const now = Date.now();
+  for (const [k, v] of Object.entries(state)) {
+    if (!v?.ts || now - v.ts > 24 * 60 * 60 * 1000) delete state[k];
+  }
+
+  const s = state[sessionId] || { ts: now, reads: 0, bootstrap: [], done: false };
+  const bootstrapSet = new Set(Array.isArray(s.bootstrap) ? s.bootstrap : []);
+  s.ts = now;
+
+  if (BOOTSTRAP_TOOLS.has(toolName)) bootstrapSet.add(toolName.replace(/^.*__/, ''));
+  if (READ_TOOLS.has(toolName)) s.reads = (s.reads || 0) + 1;
+
+  if (!s.done) {
+    const hasPair = bootstrapSet.has('project_context') && bootstrapSet.has('memory_search');
+    if (hasPair || (s.reads || 0) >= 3) s.done = true;
+  }
+  if (!s.done && READ_TOOLS.has(toolName) && (s.reads || 0) >= 2) s.done = true;
+
+  const block = !s.done && BLOCKED_TOOLS.has(toolName);
+
+  try {
+    mkdirSync(stateDir, { recursive: true });
+    state[sessionId] = { ...s, bootstrap: Array.from(bootstrapSet) };
+    writeFileSync(statePath, JSON.stringify(state));
+  } catch {}
+
+  if (block) {
+    process.stderr.write(
+      `[policy-engine/bootstrap] ${toolName} requires session bootstrap.\n` +
+      `Run in parallel first: project_context, memory_search.\n` +
+      `(Or do 3+ exploratory reads — Read/Grep/Glob/LS.)\n`
+    );
+    process.exit(2);
+  }
+
+  process.exit(0);
+}
+
+if (hookEvent === 'Stop') {
+  const driveStatePath = join(cwd, '.cx', 'drive-state.json');
+
+  if (existsSync(driveStatePath)) {
+    let driveState = {};
+    try { driveState = JSON.parse(readFileSync(driveStatePath, 'utf8')); } catch { driveState = {}; }
+
+    if (driveState.active && !driveState.canStop) {
+      const allCriteria = Array.isArray(driveState.criteria) ? driveState.criteria : [];
+      const criteriaStatus = driveState.criteriaStatus || {};
+      const metCriteria = allCriteria.filter(c => criteriaStatus[c]?.met);
+      const unmetCriteria = allCriteria.filter(c => !criteriaStatus[c]?.met);
+      const pendingTodos = driveState.pendingTodos || 0;
+      const iteration = driveState.iteration || 1;
+      const momentum = driveState.momentumScore != null ? Math.round(driveState.momentumScore * 100) : null;
+
+      const hasPendingWork = unmetCriteria.length > 0 || (allCriteria.length === 0 && pendingTodos > 0);
+      if (hasPendingWork) {
+        const lines = [`[policy-engine/drive] Drive mode active — iteration ${iteration}. Cannot stop yet.`, ''];
+        if (unmetCriteria.length > 0) {
+          lines.push(`Unmet criteria (${unmetCriteria.length}/${allCriteria.length}):`);
+          for (const c of unmetCriteria) lines.push(`  ✗ ${c}`);
+          lines.push('');
+        }
+        if (metCriteria.length > 0) {
+          lines.push(`Verified criteria (${metCriteria.length}/${allCriteria.length}):`);
+          for (const c of metCriteria) {
+            const ev = criteriaStatus[c]?.evidence || 'recorded';
+            lines.push(`  ✓ ${c} — ${ev.slice(0, 80)}`);
+          }
+          lines.push('');
+        }
+        if (allCriteria.length === 0) {
+          lines.push(`Remaining: ${pendingTodos} pending todos`, '');
+        }
+        if (momentum != null) lines.push(`Momentum: ${momentum}% (iteration ${iteration})`);
+        lines.push('', `[policy-engine/drive] Set criteriaStatus["<criterion>"] = { met: true, evidence: "..." } to unblock.`);
+
+        process.stderr.write(lines.join('\n') + '\n');
+        process.exit(2);
+      }
+    }
+  }
+
+  const branch = safeExec('git branch --show-current');
+  const isFeatureBranch = branch && branch !== 'main' && branch !== 'dev' && branch !== 'master';
+  const filesChangedPath = join(home, '.cx', 'files-changed-count.txt');
+  let filesChanged = 0;
+  try { filesChanged = parseInt(readFileSync(filesChangedPath, 'utf8').trim() || '0', 10); } catch {}
+
+  if (isFeatureBranch && filesChanged > 0) {
+    const json = safeExec(
+      `gh run list --branch=${JSON.stringify(branch)} --limit=1 --json conclusion,databaseId,url`,
+      { timeout: 4000 },
+    );
+    if (json) {
+      let run = null;
+      try { [run] = JSON.parse(json); } catch {}
+      if (run?.conclusion === 'failure') {
+        process.stderr.write(
+          `[policy-engine/red-ci] CI is red on '${branch}' (advisory).\n` +
+          `  Run: ${run.url || `gh run view ${run.databaseId}`}\n` +
+          `  Logs: gh run view ${run.databaseId} --log-failed\n`,
+        );
+      }
+    }
+  }
+
+  if (safeExec('command -v bd', { timeout: 1000 })) {
+    const bdJson = safeExec('bd list --status in_progress --json', { timeout: 3000 });
+    if (bdJson) {
+      let issues = [];
+      try { issues = JSON.parse(bdJson) || []; } catch {}
+      if (Array.isArray(issues) && issues.length > 0) {
+        const lines = issues.slice(0, 10).map((iss) => {
+          const id = iss.id || iss.ID || '?';
+          const title = iss.title || iss.summary || '';
+          return `  - ${id}: ${title}`;
+        });
+        process.stderr.write(
+          `[policy-engine/open-bd] In-progress beads issues (${issues.length} total, advisory):\n` +
+          lines.join('\n') + '\n',
+        );
+      }
+    }
+  }
+
+  const driveSessionPath = join(home, '.cx', 'drive-session.json');
+  if (existsSync(driveSessionPath)) {
+    let ds = {};
+    try { ds = JSON.parse(readFileSync(driveSessionPath, 'utf8')); } catch {}
+    if (ds?.open === true) {
+      const id = ds.sessionId || ds.id || '<unknown>';
+      const goal = ds.goal || ds.title || '';
+      process.stderr.write(
+        `[policy-engine/drive-session] Open drive session detected (id ${id}).\n` +
+        (goal ? `  Goal: ${goal}\n` : '') +
+        `  Close it before assuming session is complete (advisory).\n`,
+      );
+    }
+  }
+
+  process.exit(0);
+}
+
+if (hookEvent === 'UserPromptSubmit') {
+  process.exit(0);
+}
+
+process.exit(0);

package/lib/hooks/post-merge-docs-check.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * post-merge-docs-check.mjs — PostToolUse / Bash (async)
+ *
+ * When a merge or pull lands on the working tree (detected via `git log -1
+ * --format=%P` returning two parents), diff the merge and emit
+ * `pr.merged.no-docs` if `src/`, `lib/`, or `bin/` changed without a touching
+ * file under `docs/**` or `CHANGELOG.md`. Emits `changelog.missing`
+ * specifically when no CHANGELOG entry was added.
+ *
+ * @p95ms 1500
+ * @maxBlockingScope none (async, non-blocking)
+ */
+
+import { readFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { logHookFailure } from './_lib/log.mjs';
+import { emitRoleEvent } from '../roles/hook-emit.mjs';
+
+let input = {};
+try { input = JSON.parse(readFileSync(0, 'utf8')); }
+catch (err) { logHookFailure({ hook: 'post-merge-docs-check', err, phase: 'parse' }); process.exit(0); }
+
+const command = input?.tool_input?.command || '';
+const exitCode = input?.tool_response?.exit_code ?? input?.tool_response?.exitCode;
+const isMergePull = /\bgit\s+(merge|pull|rebase|cherry-pick)\b/.test(command);
+if (!isMergePull) process.exit(0);
+if (exitCode !== 0 && exitCode !== undefined) process.exit(0);
+
+const cwd = input?.cwd || process.cwd();
+
+try {
+  const parents = execSync('git log -1 --format=%P', { cwd, timeout: 2000 }).toString().trim();
+  if (parents.split(/\s+/).filter(Boolean).length < 2) process.exit(0);
+
+  const files = execSync('git diff-tree --no-commit-id --name-only -r HEAD', { cwd, timeout: 2000 })
+    .toString().split('\n').filter(Boolean);
+
+  const codeChanged = files.some((f) => /^(src|lib|bin|app)\//.test(f));
+  if (!codeChanged) process.exit(0);
+
+  const docChanged = files.some((f) => /^docs\//.test(f) || /(^|\/)README\.md$/.test(f));
+  const changelogChanged = files.some((f) => /(^|\/)CHANGELOG\.md$/.test(f));
+
+  if (!changelogChanged) {
+    emitRoleEvent({
+      type: 'changelog.missing',
+      summary: `Merge landed without CHANGELOG update — ${files.length} file(s) changed`,
+      hookInput: input,
+      context: { files: files.slice(0, 50) },
+    });
+  }
+  if (!docChanged && !changelogChanged) {
+    emitRoleEvent({
+      type: 'pr.merged.no-docs',
+      summary: `Merge landed touching code without docs — ${files.length} file(s) changed`,
+      hookInput: input,
+      context: { files: files.slice(0, 50) },
+    });
+  }
+} catch {}
+
+process.exit(0);

package/lib/hooks/pre-compact.mjs

@@ -2,7 +2,10 @@
 /**
  * lib/hooks/pre-compact.mjs — Pre-compact hook — prepares context summary before compaction runs.
  *
- * Runs before context compaction. Writes a structured summary of active workflow, context state, and pending tasks to preserve continuity across the compaction boundary.
+ * Runs before context compaction. Writes a structured summary of context state and pending tasks to preserve continuity across the compaction boundary.
+ *
+ * @p95ms 100
+ * @maxBlockingScope PreCompact
  */
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { homedir } from 'os';
@@ -18,7 +21,6 @@ const transcriptPath = input?.transcript_path || '';
 const filesChanged = [];
 const decisions = [];
 const pendingTodos = [];
-const workflowTasks = [];
 const warnFlagsPath = join(homedir(), '.cx', 'warn-flags.txt');
 const efficiencyPath = join(homedir(), '.cx', 'session-efficiency.json');
 let lastSummary = '';
@@ -85,19 +87,6 @@ if (transcriptPath && existsSync(transcriptPath)) {
       }
     }
 
-    // Extract active workflow tasks from .cx/workflow.json
-    const workflowPath = join(cwd, '.cx', 'workflow.json');
-    if (existsSync(workflowPath)) {
-      try {
-        const wf = JSON.parse(readFileSync(workflowPath, 'utf8'));
-        const tasks = wf?.tasks || wf?.state?.tasks || [];
-        for (const task of tasks) {
-          if (task.status !== 'done' && task.status !== 'skipped') {
-            workflowTasks.push({ key: task.key || task.id, title: task.title || task.description || '' });
-          }
-        }
-      } catch { /* best effort */ }
-    }
   } catch { /* best effort */ }
 }
 
@@ -154,14 +143,6 @@ if (pendingTodos.length) {
   contextLines.push('');
 }
 
-if (workflowTasks.length) {
-  contextLines.push('## Active workflow tasks');
-  for (const task of workflowTasks.slice(0, 10)) {
-    contextLines.push(`- ${task.key}: ${task.title}`);
-  }
-  contextLines.push('');
-}
-
 if (efficiencySummary) {
   contextLines.push('## Session efficiency snapshot');
   contextLines.push(efficiencySummary);
@@ -179,7 +160,6 @@ const contextJson = {
   filesChanged: filesChanged.slice(0, 20),
   decisions: decisions.slice(-10),
   pendingTodos: pendingTodos.slice(0, 20),
-  workflowTasks: workflowTasks.slice(0, 10),
   efficiencySummary,
   warnFlags: warnFlags || 'None',
 };