smart-context-mcp 1.6.2 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-context-mcp",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "MCP server that reduces agent token usage by 90% with intelligent context compression, task checkpoint persistence, and workflow-aware agent guidance.",
   "author": "Francisco Caballero Portero <fcp1978@hotmail.com>",
   "type": "module",

package/scripts/report-metrics.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { smartMetrics } from '../src/tools/smart-metrics.js';
 import { formatAdoptionReport } from '../src/analytics/adoption.js';
-import { formatProductQualityReport } from '../src/analytics/product-quality.js';
+import { formatProductQualityReport, hasProductQualitySignals } from '../src/analytics/product-quality.js';
 
 const requireValue = (argv, index, flag) => {
   const value = argv[index + 1];
@@ -101,7 +101,7 @@ const printHuman = (report) => {
     console.log(formatAdoptionReport(report.adoption));
   }
 
-  if (report.productQuality?.turnsMeasured > 0) {
+  if (hasProductQualitySignals(report.productQuality)) {
     console.log(formatProductQualityReport(report.productQuality));
   }
 };

package/src/analytics/product-quality.js

@@ -12,6 +12,139 @@ const isTaskRunnerQualityEntry = (entry) =>
   entry?.tool === 'task_runner'
   && entry?.metadata?.analyticsKind === TASK_RUNNER_QUALITY_ANALYTICS_KIND;
 
+const roundAverage = (total, count) =>
+  count > 0 ? Number((total / count).toFixed(1)) : 0;
+
+const getMetricsClient = (entry) =>
+  entry?.metadata?.adapterClient
+  ?? entry?.metadata?.client
+  ?? null;
+
+const hasMeasuredClientAdapters = (stats) =>
+  Number(stats?.clientAdapters?.clientsMeasured ?? 0) > 0;
+
+const appendClientAdapterSignals = (lines, stats) => {
+  if (!hasMeasuredClientAdapters(stats)) {
+    return;
+  }
+
+  const clients = stats.clientAdapters.byClient;
+  const lowestOverheadClient = clients.reduce((best, current) => {
+    if (!best) {
+      return current;
+    }
+
+    if (current.averageContextOverheadTokens < best.averageContextOverheadTokens) {
+      return current;
+    }
+
+    if (current.averageContextOverheadTokens === best.averageContextOverheadTokens
+      && current.client.localeCompare(best.client) < 0) {
+      return current;
+    }
+
+    return best;
+  }, null);
+  const highestAutoStartClient = clients.reduce((best, current) => {
+    if (!best) {
+      return current;
+    }
+
+    if (current.autoStartCoveragePct > best.autoStartCoveragePct) {
+      return current;
+    }
+
+    if (current.autoStartCoveragePct === best.autoStartCoveragePct
+      && current.client.localeCompare(best.client) < 0) {
+      return current;
+    }
+
+    return best;
+  }, null);
+
+  lines.push('Client Adapter Signals:');
+  lines.push(`Clients measured:      ${stats.clientAdapters.clientsMeasured}`);
+  lines.push(`Adapter events:        ${clients.reduce((total, client) => total + client.adapterEvents, 0)}`);
+  lines.push(`Overhead total:        ${stats.clientAdapters.totalContextOverheadTokens} tokens`);
+  if (lowestOverheadClient) {
+    lines.push(`Lowest avg overhead:   ${lowestOverheadClient.client} (${lowestOverheadClient.averageContextOverheadTokens} tokens)`);
+  }
+  if (highestAutoStartClient) {
+    lines.push(`Best auto-start rate:  ${highestAutoStartClient.client} (${highestAutoStartClient.autoStartCoveragePct}%)`);
+  }
+  lines.push('');
+
+  for (const client of clients) {
+    lines.push(`${client.client}:`);
+    lines.push(`  Entries measured:    ${client.entriesMeasured}`);
+    lines.push(`  Adapter coverage:    ${client.adapterEvents}/${client.entriesMeasured} (${client.adapterCoveragePct}%)`);
+    lines.push(`  Base orchestrated:   ${client.baseOrchestratedEvents}/${client.entriesMeasured} (${client.baseOrchestratorCoveragePct}%)`);
+    lines.push(`  Auto-started:        ${client.autoStartedEvents}/${client.entriesMeasured} (${client.autoStartCoveragePct}%)`);
+    lines.push(`  Auto-preflighted:    ${client.autoPreflightedEvents}/${client.entriesMeasured} (${client.autoPreflightCoveragePct}%)`);
+    lines.push(`  Auto-checkpointed:   ${client.autoCheckpointedEvents}/${client.entriesMeasured} (${client.autoCheckpointCoveragePct}%)`);
+    lines.push(`  Context overhead:    ${client.contextOverheadTokens} tokens total (${client.averageContextOverheadTokens} avg)`);
+    if (client.blockedEvents > 0) {
+      lines.push(`  Blocked events:      ${client.blockedEvents}`);
+    }
+    lines.push('');
+  }
+};
+
+const analyzeClientAdapterQuality = (entries = []) => {
+  const clientEntries = entries.filter((entry) => Boolean(getMetricsClient(entry)));
+
+  const byClient = [...clientEntries.reduce((acc, entry) => {
+    const client = getMetricsClient(entry);
+    const current = acc.get(client) ?? {
+      client,
+      entriesMeasured: 0,
+      adapterEvents: 0,
+      wrapperEvents: 0,
+      taskRunnerEvents: 0,
+      baseOrchestratedEvents: 0,
+      autoStartedEvents: 0,
+      autoPreflightedEvents: 0,
+      autoCheckpointedEvents: 0,
+      blockedEvents: 0,
+      contextOverheadEntries: 0,
+      contextOverheadTokens: 0,
+    };
+
+    const overheadTokens = Math.max(0, Number(entry.metadata?.overheadTokens ?? 0));
+    current.entriesMeasured += 1;
+    current.adapterEvents += entry.metadata?.managedByClientAdapter ? 1 : 0;
+    current.wrapperEvents += entry.tool === 'agent_wrapper' ? 1 : 0;
+    current.taskRunnerEvents += entry.tool === 'task_runner' ? 1 : 0;
+    current.baseOrchestratedEvents += entry.metadata?.managedByBaseOrchestrator ? 1 : 0;
+    current.autoStartedEvents += (entry.metadata?.autoStartTriggered || entry.metadata?.autoStarted) ? 1 : 0;
+    current.autoPreflightedEvents += entry.metadata?.autoPreflightTriggered ? 1 : 0;
+    current.autoCheckpointedEvents += (entry.metadata?.autoCheckpointTriggered || entry.metadata?.autoAppended) ? 1 : 0;
+    current.blockedEvents += entry.metadata?.blocked ? 1 : 0;
+    current.contextOverheadEntries += overheadTokens > 0 ? 1 : 0;
+    current.contextOverheadTokens += overheadTokens;
+
+    acc.set(client, current);
+    return acc;
+  }, new Map()).values()]
+    .map((entry) => ({
+      ...entry,
+      averageContextOverheadTokens: roundAverage(entry.contextOverheadTokens, entry.contextOverheadEntries),
+      adapterCoveragePct: roundPct(entry.adapterEvents, entry.entriesMeasured),
+      baseOrchestratorCoveragePct: roundPct(entry.baseOrchestratedEvents, entry.entriesMeasured),
+      autoStartCoveragePct: roundPct(entry.autoStartedEvents, entry.entriesMeasured),
+      autoPreflightCoveragePct: roundPct(entry.autoPreflightedEvents, entry.entriesMeasured),
+      autoCheckpointCoveragePct: roundPct(entry.autoCheckpointedEvents, entry.entriesMeasured),
+    }))
+    .sort((a, b) => a.client.localeCompare(b.client));
+
+  return {
+    clientsMeasured: byClient.length,
+    entriesMeasured: clientEntries.length,
+    totalContextOverheadTokens: byClient.reduce((total, entry) => total + entry.contextOverheadTokens, 0),
+    byClient,
+  };
+};
+
 const analyzeTaskRunnerQuality = (entries = []) => {
   const runnerEntries = entries.filter(isTaskRunnerQualityEntry);
   const workflowEntries = runnerEntries.filter((entry) => entry.metadata?.isWorkflowCommand);
@@ -25,6 +158,16 @@ const analyzeTaskRunnerQuality = (entries = []) => {
   const blockedWithDoctor = blockedEntries.filter((entry) => entry.metadata?.doctorIssued);
   const checkpointEntries = runnerEntries.filter((entry) => entry.action === 'checkpoint');
   const persistedCheckpointEntries = checkpointEntries.filter((entry) => entry.metadata?.checkpointPersisted);
+  const baseOrchestratedEntries = workflowEntries.filter((entry) => entry.metadata?.managedByBaseOrchestrator);
+  const autoStartedEntries = workflowEntries.filter((entry) => entry.metadata?.autoStartTriggered);
+  const autoPreflightEntries = workflowEntries.filter((entry) => entry.metadata?.autoPreflightTriggered);
+  const autoCheckpointEntries = runnerEntries.filter((entry) => entry.metadata?.autoCheckpointTriggered);
+  const isolatedWorkflowEntries = workflowEntries.filter((entry) => entry.metadata?.isolatedSession);
+  const contextOverheadEntries = runnerEntries.filter((entry) => Number(entry.metadata?.contextOverheadTokens ?? 0) > 0);
+  const contextOverheadTokens = runnerEntries.reduce(
+    (total, entry) => total + Number(entry.metadata?.contextOverheadTokens ?? 0),
+    0,
+  );
 
   const commandBreakdown = [...runnerEntries.reduce((acc, entry) => {
     const key = entry.action ?? 'unknown';
@@ -71,6 +214,20 @@ const analyzeTaskRunnerQuality = (entries = []) => {
       persistedCommands: persistedCheckpointEntries.length,
       persistenceRatePct: roundPct(persistedCheckpointEntries.length, checkpointEntries.length),
     },
+    automaticity: {
+      baseOrchestratedCommands: baseOrchestratedEntries.length,
+      autoStartedCommands: autoStartedEntries.length,
+      autoPreflightedCommands: autoPreflightEntries.length,
+      autoCheckpointedCommands: autoCheckpointEntries.length,
+      isolatedWorkflowCommands: isolatedWorkflowEntries.length,
+      contextOverheadTokens,
+      averageContextOverheadTokens: contextOverheadEntries.length > 0
+        ? Number((contextOverheadTokens / contextOverheadEntries.length).toFixed(1))
+        : 0,
+      baseOrchestratorCoveragePct: roundPct(baseOrchestratedEntries.length, workflowEntries.length),
+      autoStartCoveragePct: roundPct(autoStartedEntries.length, workflowEntries.length),
+      autoPreflightCoveragePct: roundPct(autoPreflightEntries.length, workflowEntries.length),
+    },
   };
 };
 
@@ -132,15 +289,24 @@ export const analyzeProductQuality = (entries = []) => {
       blockedEnds,
       persistenceRatePct: roundPct(persistedEnds, endEntries.length),
     },
+    clientAdapters: analyzeClientAdapterQuality(entries),
     taskRunner: analyzeTaskRunnerQuality(entries),
   };
 };
 
+export const hasProductQualitySignals = (stats) =>
+  Boolean(stats)
+  && (
+    Number(stats.turnsMeasured ?? 0) > 0
+    || Number(stats?.taskRunner?.commandsMeasured ?? 0) > 0
+    || hasMeasuredClientAdapters(stats)
+  );
+
 export const formatProductQualityReport = (stats) => {
   const hasSmartTurn = Number(stats?.turnsMeasured ?? 0) > 0;
   const hasTaskRunner = Number(stats?.taskRunner?.commandsMeasured ?? 0) > 0;
 
-  if (!stats || (!hasSmartTurn && !hasTaskRunner)) {
+  if (!hasProductQualitySignals(stats)) {
     return '';
   }
 
@@ -193,11 +359,20 @@ export const formatProductQualityReport = (stats) => {
     lines.push('Blocked-State Routing:');
     lines.push(`Blocked with doctor:   ${stats.taskRunner.blockedState.blockedWithDoctor}/${stats.taskRunner.blockedState.blockedCommands} (${stats.taskRunner.blockedState.doctorCoveragePct}%)`);
     lines.push('');
+    lines.push('Automaticity:');
+    lines.push(`Base orchestrated:     ${stats.taskRunner.automaticity.baseOrchestratedCommands}/${stats.taskRunner.workflowCommands} (${stats.taskRunner.automaticity.baseOrchestratorCoveragePct}%)`);
+    lines.push(`Auto-started:          ${stats.taskRunner.automaticity.autoStartedCommands}/${stats.taskRunner.workflowCommands} (${stats.taskRunner.automaticity.autoStartCoveragePct}%)`);
+    lines.push(`Auto-preflighted:      ${stats.taskRunner.automaticity.autoPreflightedCommands}/${stats.taskRunner.workflowCommands} (${stats.taskRunner.automaticity.autoPreflightCoveragePct}%)`);
+    lines.push(`Auto-checkpointed:     ${stats.taskRunner.automaticity.autoCheckpointedCommands}`);
+    lines.push(`Context overhead:      ${stats.taskRunner.automaticity.contextOverheadTokens} tokens total (${stats.taskRunner.automaticity.averageContextOverheadTokens} avg)`);
+    lines.push('');
     lines.push('Checkpoint Commands:');
     lines.push(`Persisted checkpoints: ${stats.taskRunner.checkpointing.persistedCommands}/${stats.taskRunner.checkpointing.commandsMeasured} (${stats.taskRunner.checkpointing.persistenceRatePct}%)`);
     lines.push('');
   }
 
+  appendClientAdapterSignals(lines, stats);
+
   lines.push('Notes:');
   lines.push('- These are measured orchestration signals, not direct answer-quality scores.');
   lines.push('- Context refresh usefulness is proxied by whether refreshed turns surfaced top-file signals.');

package/src/hooks/claude-hooks.js

@@ -1,423 +1 @@
-import { persistMetrics } from '../metrics.js';
-import { buildOperationalContextLines } from '../client-contract.js';
-import { getRepoMutationSafety } from '../repo-safety.js';
-import { countTokens } from '../tokenCounter.js';
-import { smartSummary } from '../tools/smart-summary.js';
-import { smartTurn } from '../tools/smart-turn.js';
-import {
-  deleteHookTurnState,
-  getHookTurnState,
-  setHookTurnState,
-} from '../storage/sqlite.js';
-
-const HOOK_CLIENT = 'claude';
-const START_MAX_TOKENS = 350;
-const STOP_MAX_TOKENS = 300;
-const MAX_CONTEXT_LINES = 7;
-const MAX_CONTEXT_CHARS = 420;
-const MAX_PROMPT_PREVIEW = 160;
-const WRITE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit']);
-const SIGNIFICANT_RESPONSE_LENGTH = 140;
-
-const normalizeWhitespace = (value) => String(value ?? '').replace(/\s+/g, ' ').trim();
-
-const truncate = (value, maxLength = MAX_PROMPT_PREVIEW) => {
-  const normalized = normalizeWhitespace(value);
-  if (normalized.length <= maxLength) {
-    return normalized;
-  }
-
-  if (maxLength <= 3) {
-    return '';
-  }
-
-  return `${normalized.slice(0, maxLength - 3)}...`;
-};
-
-const countPromptTerms = (value) =>
-  normalizeWhitespace(value)
-    .split(/[^a-z0-9_.-]+/i)
-    .map((term) => term.trim())
-    .filter((term) => term.length >= 3)
-    .length;
-
-const isMeaningfulPrompt = (value) => {
-  const normalized = normalizeWhitespace(value);
-  return normalized.length >= 20 && countPromptTerms(normalized) >= 4;
-};
-
-const uniq = (values) => [...new Set(values.filter((value) => typeof value === 'string' && value.trim().length > 0))];
-
-const buildHookKey = ({ sessionId, agentId = null }) =>
-  agentId ? `${HOOK_CLIENT}:subagent:${sessionId}:${agentId}` : `${HOOK_CLIENT}:main:${sessionId}`;
-
-const buildAdditionalContext = ({ result, sessionStart = false }) => {
-  return buildOperationalContextLines(result, {
-    sessionStart,
-    maxLineLength: 110,
-    maxLines: MAX_CONTEXT_LINES,
-    maxChars: MAX_CONTEXT_CHARS,
-  });
-};
-
-const buildHookContextResponse = (hookEventName, additionalContext) => {
-  if (!additionalContext) {
-    return null;
-  }
-
-  return {
-    hookSpecificOutput: {
-      hookEventName,
-      additionalContext,
-    },
-  };
-};
-
-const readHookTurnState = (hookKey) =>
-  getHookTurnState({
-    hookKey,
-    readOnly: getRepoMutationSafety().shouldBlock,
-  });
-
-const maybeSetTrackedTurnState = async ({ hookKey, state }) => {
-  if (getRepoMutationSafety().shouldBlock) {
-    return null;
-  }
-
-  return setHookTurnState({ hookKey, state });
-};
-
-const maybeDeleteTrackedTurnState = async ({ hookKey }) => {
-  if (getRepoMutationSafety().shouldBlock) {
-    return null;
-  }
-
-  return deleteHookTurnState({ hookKey });
-};
-
-const recordHookMetrics = async ({
-  action,
-  sessionId,
-  additionalContext = '',
-  blocked = false,
-  autoAppended = false,
-  continuityState = null,
-} = {}) => {
-  const overheadTokens = additionalContext ? countTokens(additionalContext) : 0;
-
-  await persistMetrics({
-    tool: 'claude_hook',
-    action,
-    sessionId,
-    rawTokens: 0,
-    compressedTokens: 0,
-    savedTokens: 0,
-    savingsPct: 0,
-    metadata: {
-      isContextOverhead: overheadTokens > 0,
-      overheadTokens,
-      blocked,
-      autoAppended,
-      continuityState,
-    },
-    timestamp: new Date().toISOString(),
-  });
-};
-
-const isSmartTurnTool = (toolName) => /^mcp__.+__smart_turn$/i.test(toolName ?? '');
-const isSmartSummaryTool = (toolName) => /^mcp__.+__smart_summary$/i.test(toolName ?? '');
-
-const isCheckpointToolUse = ({ toolName, toolInput }) => {
-  if (isSmartTurnTool(toolName)) {
-    return toolInput?.phase === 'end'
-      ? { matched: true, event: toolInput?.event ?? 'manual' }
-      : { matched: false, event: null };
-  }
-
-  if (isSmartSummaryTool(toolName)) {
-    const action = toolInput?.action;
-    if (action === 'checkpoint') {
-      return { matched: true, event: toolInput?.event ?? 'manual' };
-    }
-
-    if (action === 'append' || action === 'auto_append' || action === 'update') {
-      return { matched: true, event: action };
-    }
-  }
-
-  return { matched: false, event: null };
-};
-
-const extractTouchedFiles = ({ toolName, toolInput, toolResponse }) => {
-  if (!WRITE_TOOLS.has(toolName)) {
-    return [];
-  }
-
-  return uniq([
-    toolInput?.file_path,
-    toolInput?.filePath,
-    toolResponse?.file_path,
-    toolResponse?.filePath,
-  ]);
-};
-
-const extractNextStep = (message) => {
-  const normalized = normalizeWhitespace(message);
-  if (!normalized) {
-    return '';
-  }
-
-  const explicitMatch = normalized.match(/(?:next step|siguiente paso)\s*[:\-]\s*([^.;\n]{12,180})/i);
-  if (explicitMatch?.[1]) {
-    return truncate(explicitMatch[1], 150);
-  }
-
-  return '';
-};
-
-const buildCarryoverUpdate = (state, lastAssistantMessage) => {
-  const promptPreview = truncate(state.promptPreview, 140);
-  const nextStep = extractNextStep(lastAssistantMessage);
-  const pinnedContext = promptPreview ? [`Uncheckpointed turn: ${promptPreview}`] : [];
-
-  return {
-    ...(promptPreview ? { currentFocus: promptPreview } : {}),
-    ...(pinnedContext.length > 0 ? { pinnedContext } : {}),
-    ...(state.touchedFiles.length > 0 ? { touchedFiles: state.touchedFiles } : {}),
-    ...(nextStep ? { nextStep } : {}),
-  };
-};
-
-const computeStopEnforcement = (state, lastAssistantMessage) => {
-  const nextStep = extractNextStep(lastAssistantMessage);
-  const responseLength = normalizeWhitespace(lastAssistantMessage).length;
-  let score = 0;
-
-  if (state.meaningfulWriteCount > 0) {
-    score += 3;
-  }
-
-  if (state.touchedFiles.length > 0) {
-    score += 1;
-  }
-
-  if (nextStep) {
-    score += 2;
-  }
-
-  if (responseLength >= SIGNIFICANT_RESPONSE_LENGTH) {
-    score += 1;
-  }
-
-  if (state.continuityState === 'task_switch' || state.continuityState === 'possible_shift') {
-    score += 1;
-  }
-
-  return {
-    shouldBlock: score >= 3,
-    score,
-    nextStep,
-  };
-};
-
-const maybeTrackTurn = async ({
-  hookKey,
-  claudeSessionId,
-  projectSessionId,
-  prompt,
-  continuityState,
-}) => {
-  const promptMeaningful = isMeaningfulPrompt(prompt);
-  const shouldTrack = Boolean(projectSessionId) && promptMeaningful;
-
-  if (!shouldTrack) {
-    await deleteHookTurnState({ hookKey });
-    return null;
-  }
-
-  return maybeSetTrackedTurnState({
-    hookKey,
-    state: {
-      client: HOOK_CLIENT,
-      claudeSessionId,
-      projectSessionId,
-      turnId: `${claudeSessionId}:${Date.now()}`,
-      promptPreview: truncate(prompt),
-      continuityState,
-      requireCheckpoint: true,
-      promptMeaningful,
-      checkpointed: false,
-      checkpointEvent: null,
-      touchedFiles: [],
-      meaningfulWriteCount: 0,
-    },
-  });
-};
-
-const handleSessionStart = async (input) => {
-  const result = await smartTurn({
-    phase: 'start',
-    maxTokens: START_MAX_TOKENS,
-  });
-  const additionalContext = buildAdditionalContext({ result, sessionStart: true });
-  await recordHookMetrics({
-    action: 'SessionStart',
-    sessionId: result.sessionId ?? null,
-    additionalContext,
-    continuityState: result.continuity?.state ?? null,
-  });
-  return buildHookContextResponse('SessionStart', additionalContext);
-};
-
-const handleUserPromptSubmit = async (input) => {
-  const result = await smartTurn({
-    phase: 'start',
-    prompt: input.prompt,
-    ensureSession: true,
-    maxTokens: START_MAX_TOKENS,
-  });
-
-  const trackedState = await maybeTrackTurn({
-    hookKey: buildHookKey({ sessionId: input.session_id }),
-    claudeSessionId: input.session_id,
-    projectSessionId: result.sessionId ?? null,
-    prompt: input.prompt,
-    continuityState: result.continuity?.state ?? '',
-  });
-  const additionalContext = buildAdditionalContext({ result });
-  await recordHookMetrics({
-    action: 'UserPromptSubmit',
-    sessionId: trackedState?.projectSessionId ?? result.sessionId ?? null,
-    additionalContext,
-    continuityState: result.continuity?.state ?? null,
-  });
-  return buildHookContextResponse('UserPromptSubmit', additionalContext);
-};
-
-const handlePostToolUse = async (input) => {
-  const hookKey = buildHookKey({ sessionId: input.session_id });
-  const existing = await readHookTurnState(hookKey);
-  if (!existing) {
-    return null;
-  }
-
-  const checkpoint = isCheckpointToolUse({
-    toolName: input.tool_name,
-    toolInput: input.tool_input,
-  });
-  const touchedFiles = extractTouchedFiles({
-    toolName: input.tool_name,
-    toolInput: input.tool_input,
-    toolResponse: input.tool_response,
-  });
-
-  const nextState = {
-    ...existing,
-    checkpointed: checkpoint.matched ? true : existing.checkpointed,
-    checkpointEvent: checkpoint.matched ? checkpoint.event : existing.checkpointEvent,
-    touchedFiles: uniq([...existing.touchedFiles, ...touchedFiles]),
-    meaningfulWriteCount: existing.meaningfulWriteCount + touchedFiles.length,
-    updatedAt: new Date().toISOString(),
-  };
-
-  await maybeSetTrackedTurnState({ hookKey, state: nextState });
-  if (checkpoint.matched || touchedFiles.length > 0) {
-    await recordHookMetrics({
-      action: 'PostToolUse',
-      sessionId: existing.projectSessionId,
-      additionalContext: '',
-      continuityState: existing.continuityState,
-    });
-  }
-  return null;
-};
-
-const handleStop = async (input) => {
-  const hookKey = buildHookKey({ sessionId: input.session_id });
-  const state = await readHookTurnState(hookKey);
-  if (!state) {
-    return null;
-  }
-
-  if (getRepoMutationSafety().shouldBlock) {
-    await recordHookMetrics({
-      action: 'Stop',
-      sessionId: state.projectSessionId,
-      additionalContext: '',
-      blocked: false,
-      continuityState: state.continuityState,
-    });
-    return null;
-  }
-
-  const enforcement = computeStopEnforcement(state, input.last_assistant_message);
-  const shouldEnforce = (state.requireCheckpoint || state.meaningfulWriteCount > 0) && enforcement.shouldBlock;
-  if (!shouldEnforce || state.checkpointed) {
-    await recordHookMetrics({
-      action: 'Stop',
-      sessionId: state.projectSessionId,
-      additionalContext: '',
-      blocked: false,
-      continuityState: state.continuityState,
-    });
-    await maybeDeleteTrackedTurnState({ hookKey });
-    return null;
-  }
-
-  if (input.stop_hook_active) {
-    const update = buildCarryoverUpdate(state, input.last_assistant_message);
-    if (state.projectSessionId && Object.keys(update).length > 0) {
-      await smartSummary({
-        action: 'auto_append',
-        sessionId: state.projectSessionId,
-        update,
-        maxTokens: STOP_MAX_TOKENS,
-      });
-    }
-
-    await recordHookMetrics({
-      action: 'Stop',
-      sessionId: state.projectSessionId,
-      additionalContext: '',
-      blocked: false,
-      autoAppended: true,
-      continuityState: state.continuityState,
-    });
-    await maybeDeleteTrackedTurnState({ hookKey });
-    return null;
-  }
-
-  await recordHookMetrics({
-    action: 'Stop',
-    sessionId: state.projectSessionId,
-    additionalContext: '',
-    blocked: true,
-    continuityState: state.continuityState,
-  });
-  return {
-    decision: 'block',
-    reason: `Persist this turn with mcp__devctx__smart_turn phase=end before stopping.${state.touchedFiles.length > 0 ? ' Include touchedFiles and the nextStep.' : ' Include the nextStep.'}`,
-  };
-};
-
-export const handleClaudeHookEvent = async (input = {}) => {
-  const eventName = input.hook_event_name;
-
-  if (eventName === 'SessionStart') {
-    return handleSessionStart(input);
-  }
-
-  if (eventName === 'UserPromptSubmit') {
-    return handleUserPromptSubmit(input);
-  }
-
-  if (eventName === 'PostToolUse') {
-    return handlePostToolUse(input);
-  }
-
-  if (eventName === 'Stop') {
-    return handleStop(input);
-  }
-
-  return null;
-};
+export { handleClaudeHookEvent } from '../orchestration/adapters/claude-adapter.js';

package/src/hooks/cursor-hooks.js

@@ -0,0 +1 @@
+export { handleCursorHookEvent } from '../orchestration/adapters/cursor-adapter.js';