chati-dev 4.2.1 → 4.3.0

package/framework/hooks/prism-engine.js

@@ -2,28 +2,133 @@
 /**
  * PRISM Engine Hook — UserPromptSubmit
  *
- * Injects PRISM context block into every user prompt.
- * Reads session state to determine bracket, agent, and mode,
- * then runs the PRISM pipeline to produce XML context.
+ * Injects PRISM context block into every user prompt, and — since the
+ * context-window-detection v1 refactor — maintains the cumulative token
+ * counter and detected model state on session.yaml so downstream consumers
+ * (/chati status, session-digest) see a token-accurate picture.
+ *
+ * Why this rewrite:
+ *   Gabriel reported false DEPLETED alerts at 13.6% of an Opus 1M window.
+ *   The old primary path used turn-count (`session.turnCount / maxTurns`)
+ *   scaled to a fixed 40-turn ceiling — token-blind and model-blind.
+ *   On a 1M window, 40 turns ≈ 10% of context, but the heuristic reported
+ *   0%. This rewrite replaces the primary metric with token-based
+ *   cumulative estimation and resolves the window from the active model.
+ *
+ * Detection chain for the active model (first hit wins):
+ *   1. process.env.CLAUDE_MODEL           (Claude Code set)
+ *   2. event.session.model                (future-proof for event payload)
+ *   3. session.active_model               (written by /chati boot)
+ *   4. HOOK_AGENT_MODELS[currentAgent]    (last-resort default)
+ *   5. null                                (provider fallback takes over)
+ *
+ * Context limits come from the shared JSON table at either
+ * `.chati.dev/data/model-limits.json` (installed) or
+ * `chati.dev/data/model-limits.json` (monorepo/dev). The table maps
+ * normalized keys — `opus`, `opus[1m]`, `sonnet`, `sonnet[1m]`, `haiku`,
+ * `pro`, `flash`, `codex` — to window sizes, distinguishing Opus default
+ * (200K) from the 1M variant explicitly.
  *
  * Claude Code Hook: triggers on every user message submission.
  */
 
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, renameSync } from 'fs';
 import { join } from 'path';
 
-/**
- * Read session.yaml and extract key fields for PRISM.
- */
+// ---------------------------------------------------------------------------
+// Context window limits — load from shared JSON, fall back to embedded.
+// ---------------------------------------------------------------------------
+
+function loadLimits(projectDir) {
+  const candidates = [
+    join(projectDir, '.chati.dev', 'data', 'model-limits.json'),
+    join(projectDir, 'chati.dev', 'data', 'model-limits.json'),
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      try {
+        return JSON.parse(readFileSync(candidate, 'utf-8'));
+      } catch { /* malformed — fall through */ }
+    }
+  }
+  // Last-resort fallback. Matches chati.dev/data/model-limits.json verbatim.
+  // Scan-stale check #25 guards parity between this block and the JSON.
+  return {
+    providers: { claude: 200_000, gemini: 1_000_000, codex: 128_000 },
+    models: {
+      opus:         200_000,
+      'opus[1m]':   1_000_000,
+      sonnet:       200_000,
+      'sonnet[1m]': 1_000_000,
+      haiku:        200_000,
+      pro:          1_000_000,
+      flash:        1_000_000,
+      codex:        128_000,
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Model normalization (duplicate of src/utils/model-id.js — hooks cannot
+// import package modules. Keep in sync if parser changes.)
+// ---------------------------------------------------------------------------
+
+const FAMILIES = new Set(['opus', 'sonnet', 'haiku']);
+
+function parseClaudeModelId(raw) {
+  if (typeof raw !== 'string') return null;
+  const s = raw.trim().toLowerCase();
+  if (!s) return null;
+  let variant = 'default';
+  let body = s;
+  const variantMatch = body.match(/[[(:]\s*(1m)\s*\)?\]?$/);
+  if (variantMatch) {
+    variant = variantMatch[1];
+    body = body.slice(0, variantMatch.index).trim();
+  }
+  let family = null;
+  for (const candidate of FAMILIES) {
+    if (new RegExp(`(^|-)${candidate}(-|$)`).test(body)) {
+      family = candidate;
+      break;
+    }
+  }
+  if (!family) return null;
+  const normalized = variant === 'default' ? family : `${family}[${variant}]`;
+  return { family, variant, normalized, provider: 'claude' };
+}
+
+function resolveLimit(limits, modelKey, provider) {
+  if (modelKey && limits.models[modelKey] != null) return limits.models[modelKey];
+  if (modelKey) {
+    const parsed = parseClaudeModelId(modelKey);
+    if (parsed && limits.models[parsed.normalized] != null) return limits.models[parsed.normalized];
+    if (parsed && limits.models[parsed.family] != null) return limits.models[parsed.family];
+  }
+  if (provider && limits.providers[provider] != null) return limits.providers[provider];
+  return 200_000;
+}
+
+// ---------------------------------------------------------------------------
+// Session read — lightweight YAML extraction (avoids js-yaml dependency).
+// ---------------------------------------------------------------------------
+
 function readSessionState(projectDir) {
   const sessionPath = join(projectDir, '.chati', 'session.yaml');
   if (!existsSync(sessionPath)) return null;
 
   const raw = readFileSync(sessionPath, 'utf-8');
-  // Lightweight YAML extraction (avoid dependency)
   const extract = (key) => {
     const match = raw.match(new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm'));
-    return match ? match[1].trim().replace(/^["']|["']$/g, '') : null;
+    if (!match) return null;
+    const v = match[1].trim().replace(/^["']|["']$/g, '');
+    return v === 'null' || v === '' ? null : v;
+  };
+  const extractNum = (key) => {
+    const v = extract(key);
+    if (v === null) return null;
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) ? n : null;
   };
 
   // Detect active team (Article XXI)
@@ -38,26 +143,131 @@ function readSessionState(projectDir) {
   }
 
   return {
+    raw,
+    sessionPath,
     mode: extract('mode') || 'discover',
     currentAgent: extract('current_agent') || null,
     workflow: extract('workflow') || null,
     pipelinePosition: extract('pipeline_position') || null,
-    turnCount: parseInt(extract('turn_count') || '0', 10),
-    provider: extract('provider') || 'claude',
+    provider: extract('active_provider') || extract('provider') || 'claude',
+    // v1.2 context detection fields.
+    activeModel: extract('active_model'),
+    contextTokensUsed: extractNum('context_tokens_used') || 0,
+    contextWindowTokens: extractNum('context_window_tokens'),
     activeTeamId,
     activeTeamPhase,
   };
 }
 
-/**
- * Main hook handler.
- * Reads stdin for hook event, outputs context to inject.
- */
+// ---------------------------------------------------------------------------
+// Session write — targeted line replacement on session.yaml.
+// Atomic via tmp+rename. Only touches the fields we own.
+// ---------------------------------------------------------------------------
+
+function writeBackSession(sessionPath, rawContent, updates) {
+  let out = rawContent;
+  for (const [key, value] of Object.entries(updates)) {
+    const serialized =
+      value === null || value === undefined ? 'null' :
+      typeof value === 'number'             ? String(value) :
+      typeof value === 'string'             ? value :
+                                              JSON.stringify(value);
+    const re = new RegExp(`^(\\s*${key}:\\s*)(.*)$`, 'm');
+    if (re.test(out)) {
+      out = out.replace(re, `$1${serialized}`);
+    } else {
+      // Key not present — append at end (migration path).
+      out += (out.endsWith('\n') ? '' : '\n') + `${key}: ${serialized}\n`;
+    }
+  }
+  const tmpPath = sessionPath + '.tmp';
+  writeFileSync(tmpPath, out, 'utf-8');
+  renameSync(tmpPath, sessionPath);
+}
+
+// ---------------------------------------------------------------------------
+// Model detection chain.
+// ---------------------------------------------------------------------------
+
+const HOOK_AGENT_MODELS = {
+  orchestrator: 'sonnet', 'greenfield-wu': 'haiku', 'brownfield-wu': 'opus',
+  brief: 'sonnet', detail: 'opus', architect: 'opus', ux: 'sonnet',
+  phases: 'sonnet', tasks: 'sonnet', 'qa-planning': 'opus',
+  'qa-implementation': 'opus', 'qa-visual': 'opus', dev: 'opus', devops: 'sonnet',
+};
+
+function detectModel(event, session) {
+  // 1. Environment override — Claude Code or user-set.
+  if (process.env.CLAUDE_MODEL) {
+    const parsed = parseClaudeModelId(process.env.CLAUDE_MODEL);
+    if (parsed) return parsed.normalized;
+    return process.env.CLAUDE_MODEL; // trust the raw string
+  }
+  // 2. Event payload (future-proof — Claude Code may populate this).
+  if (event && event.session && event.session.model) {
+    const parsed = parseClaudeModelId(event.session.model);
+    if (parsed) return parsed.normalized;
+  }
+  // 3. Session-recorded active model — written at /chati boot.
+  if (session && session.activeModel) return session.activeModel;
+  // 4. Agent default (last resort, matches historic behavior).
+  if (session && session.currentAgent && HOOK_AGENT_MODELS[session.currentAgent]) {
+    return HOOK_AGENT_MODELS[session.currentAgent];
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Token accounting.
+// Token-length heuristic: 1 token ≈ 4 characters (Claude's own rough rule).
+// Tool-output multiplier: each UserPromptSubmit represents roughly one
+// user-prompt + a mixed bag of preceding tool responses. We add a 3x
+// multiplier on the user prompt to approximate that overhead, clamped at
+// the window size.
+// ---------------------------------------------------------------------------
+
+const TOOL_OUTPUT_MULTIPLIER = 3;
+
+function estimatePromptDelta(promptText) {
+  if (!promptText) return 0;
+  const baseTokens = Math.ceil(promptText.length / 4);
+  return baseTokens * (1 + TOOL_OUTPUT_MULTIPLIER);
+}
+
+function computeBracket(remainingPercent) {
+  if (remainingPercent < 25) return 'CRITICAL';
+  if (remainingPercent < 40) return 'DEPLETED';
+  if (remainingPercent < 60) return 'MODERATE';
+  return 'FRESH';
+}
+
+// ---------------------------------------------------------------------------
+// Frustration detection — unchanged.
+// ---------------------------------------------------------------------------
+
+const FRUSTRATION_PATTERNS = [
+  /this (is|isn't|isnt) working/i,
+  /I (already|just) (told|said|asked)/i,
+  /why (won't|doesn't|can't|isn't|wont|doesnt|cant|isnt)/i,
+  /stop (doing|repeating|ignoring)/i,
+  /you('re| are) (not|never) (listening|reading|understanding)/i,
+  /for the (second|third|fourth|last) time/i,
+  /!!+/,
+  /\b(WTF|WHAT THE|FFS|OMG)\b/i,
+];
+
+function detectFrustration(prompt) {
+  if (!prompt || prompt.length < 5) return false;
+  return FRUSTRATION_PATTERNS.some(p => p.test(prompt));
+}
+
+// ---------------------------------------------------------------------------
+// Main handler.
+// ---------------------------------------------------------------------------
+
 async function main() {
   let input = '';
-  for await (const chunk of process.stdin) {
-    input += chunk;
-  }
+  for await (const chunk of process.stdin) input += chunk;
 
   try {
     const event = JSON.parse(input);
@@ -65,72 +275,55 @@ async function main() {
     const session = readSessionState(projectDir);
 
     if (!session) {
-      // No active session — don't inject anything
-      process.stdout.write(JSON.stringify({ result: 'allow' }));
+      process.stdout.write('{}');
       return;
     }
 
-    // Estimate remaining context — prefer token-based estimation over turn count
-    // Token estimation: 1 token ≈ 4 characters (Claude Code pattern)
-    // SYNC: These limits MUST match packages/chati-dev/src/utils/provider-limits.js
-    const HOOK_MODEL_LIMITS = { opus: 1_000_000, sonnet: 200_000, haiku: 200_000, pro: 1_000_000, flash: 1_000_000, codex: 128_000 };
-    const HOOK_PROVIDER_LIMITS = { claude: 200_000, gemini: 1_000_000, codex: 128_000 };
-
-    // Infer model from current agent via AGENT_MODELS map
-    const HOOK_AGENT_MODELS = {
-      orchestrator: 'sonnet', 'greenfield-wu': 'haiku', 'brownfield-wu': 'opus',
-      brief: 'sonnet', detail: 'opus', architect: 'opus', ux: 'sonnet',
-      phases: 'sonnet', tasks: 'sonnet', 'qa-planning': 'opus',
-      'qa-implementation': 'opus', dev: 'opus', devops: 'sonnet',
-    };
-    const inferredModel = session.currentAgent ? HOOK_AGENT_MODELS[session.currentAgent] : null;
-
-    // Resolve context limit: model > provider > default
-    function hookResolveLimit(model, provider) {
-      if (model && HOOK_MODEL_LIMITS[model]) return HOOK_MODEL_LIMITS[model];
-      if (provider && HOOK_PROVIDER_LIMITS[provider]) return HOOK_PROVIDER_LIMITS[provider];
-      return 200_000;
-    }
+    const limits = loadLimits(projectDir);
 
-    // Primary: turn-count tracks cumulative context consumption across the session.
-    // Fallback: prompt-length for first turn or missing session data.
+    // 1. Model + window detection.
+    const detectedModel = detectModel(event, session);
+    const contextLimit = resolveLimit(limits, detectedModel, session.provider);
+
+    // 2. Token accounting — cumulative, replaces turn-count.
     const promptText = event.prompt || '';
-    let remainingPercent;
-    const maxTurns = 40;
-    if (session.turnCount > 0) {
-      remainingPercent = Math.max(0, Math.round((1 - session.turnCount / maxTurns) * 100));
-    } else {
-      const estimatedTokens = Math.ceil(promptText.length / 4);
-      const contextLimit = hookResolveLimit(inferredModel, session.provider);
-      remainingPercent = Math.max(0, Math.round((1 - estimatedTokens / contextLimit) * 100));
-    }
+    const delta = estimatePromptDelta(promptText);
+    const tokensUsed = Math.min(contextLimit, session.contextTokensUsed + delta);
+    const remainingPercent = Math.max(0, Math.round((1 - tokensUsed / contextLimit) * 100));
 
-    // Determine bracket
-    let bracket = 'FRESH';
-    if (remainingPercent < 25) bracket = 'CRITICAL';
-    else if (remainingPercent < 40) bracket = 'DEPLETED';
-    else if (remainingPercent < 60) bracket = 'MODERATE';
+    // 3. Bracket computation (percentage-based, model-scaled).
+    const bracket = computeBracket(remainingPercent);
 
-    // Load agent memory (if active agent has MEMORY.md)
+    // 4. Persist back to session.yaml (best-effort, non-fatal on write error).
+    try {
+      writeBackSession(session.sessionPath, session.raw, {
+        context_tokens_used:    tokensUsed,
+        context_window_tokens:  contextLimit,
+        context_last_bracket:   bracket,
+        // If we detected a model and the session did not have one, cache it.
+        ...(detectedModel && !session.activeModel ? { active_model: detectedModel } : {}),
+      });
+    } catch (err) {
+      process.stderr.write(`[chati] prism-engine write-back failed (non-fatal): ${err.message}\n`);
+    }
+
+    // 5. Agent-local memory block (unchanged).
     let memoryBlock = '';
     if (session.currentAgent) {
       const memoryPath = join(projectDir, '.chati', 'memories', session.currentAgent, 'MEMORY.md');
       if (existsSync(memoryPath)) {
         const raw = readFileSync(memoryPath, 'utf-8').trim();
         if (raw) {
-          const trimmed = raw.slice(0, 500);
-          memoryBlock = `  <agent-memory agent="${session.currentAgent}">\n${trimmed}\n  </agent-memory>`;
+          memoryBlock = `  <agent-memory agent="${session.currentAgent}">\n${raw.slice(0, 500)}\n  </agent-memory>`;
         }
       }
     }
 
-    // L6 Team Roster Layer (Article XII, Article XXI) — injected when a team is active
-    // Max 500 tokens, flat budget. Contains team metadata + shared task status only.
+    // 6. Team context block (unchanged).
     let teamContextBlock = '';
     if (session.activeTeamId && bracket !== 'CRITICAL') {
       const taskListPath = join(projectDir, '.chati', 'teams', session.activeTeamId, 'tasks.yaml');
       if (existsSync(taskListPath)) {
-        // Read and cap at 800 chars (~200 tokens) to stay within 500-token budget
         const rawTasks = readFileSync(taskListPath, 'utf-8').trim().slice(0, 800);
         teamContextBlock = [
           `  <team-context team-id="${session.activeTeamId}" phase="${session.activeTeamPhase}">`,
@@ -140,18 +333,16 @@ async function main() {
       }
     }
 
-    // Frustration detection — adapt response style when user is frustrated
+    // 7. Advisories.
     const frustrationDetected = detectFrustration(promptText);
+    const microcompactAdvisory =
+      (bracket === 'DEPLETED' || bracket === 'CRITICAL')
+        ? '  <advisory priority="medium">Context constrained. Avoid re-reading files already in context. Summarize stale outputs before proceeding.</advisory>'
+        : '';
 
-    // Microcompact advisory — hint to economize context when depleted + idle
-    let microcompactAdvisory = '';
-    if ((bracket === 'DEPLETED' || bracket === 'CRITICAL') && session.turnCount > 10) {
-      microcompactAdvisory = '  <advisory priority="medium">Context constrained. Avoid re-reading files already in context. Summarize stale outputs before proceeding.</advisory>';
-    }
-
-    // Build minimal context block (full PRISM pipeline is used by orchestrator internally)
+    // 8. Compose the context block.
     const contextBlock = [
-      `<chati-context bracket="${bracket}">`,
+      `<chati-context bracket="${bracket}" model="${detectedModel || 'unknown'}" window="${contextLimit}" used="${tokensUsed}">`,
       `  <mode>${session.mode}</mode>`,
       session.currentAgent ? `  <agent>${session.currentAgent}</agent>` : '',
       session.pipelinePosition ? `  <pipeline-position>${session.pipelinePosition}</pipeline-position>` : '',
@@ -164,45 +355,37 @@ async function main() {
     ].filter(Boolean).join('\n');
 
     process.stdout.write(JSON.stringify({
-      result: 'allow',
-      prefix: contextBlock,
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext: contextBlock,
+      },
     }));
   } catch (err) {
     process.stderr.write(`[chati] prism-engine: ${err.message}\n`);
-    process.stdout.write(JSON.stringify({ result: 'allow' }));
+    process.stdout.write('{}');
   }
 }
 
-/**
- * Frustration detection patterns.
- * Inspired by Claude Code's regex-based emotion detection.
- * Soft advisory only — never blocks or overrides behavior.
- */
-const FRUSTRATION_PATTERNS = [
-  /this (is|isn't|isnt) working/i,
-  /I (already|just) (told|said|asked)/i,
-  /why (won't|doesn't|can't|isn't|wont|doesnt|cant|isnt)/i,
-  /stop (doing|repeating|ignoring)/i,
-  /you('re| are) (not|never) (listening|reading|understanding)/i,
-  /for the (second|third|fourth|last) time/i,
-  /!!+/,
-  /\b(WTF|WHAT THE|FFS|OMG)\b/i,
-];
+export {
+  readSessionState,
+  detectFrustration,
+  detectModel,
+  parseClaudeModelId,
+  resolveLimit,
+  loadLimits,
+  estimatePromptDelta,
+  computeBracket,
+  writeBackSession,
+  TOOL_OUTPUT_MULTIPLIER,
+};
 
-/**
- * Detect user frustration from prompt text.
- * @param {string} prompt - User prompt text
- * @returns {boolean} True if frustration patterns detected
- */
-function detectFrustration(prompt) {
-  if (!prompt || prompt.length < 5) return false;
-  return FRUSTRATION_PATTERNS.some(p => p.test(prompt));
-}
-
-export { readSessionState, detectFrustration };
-
-// Only run main when executed directly (not imported by tests)
+// Only run main when executed directly (not imported by tests).
 import { fileURLToPath } from 'url';
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  main();
+import { realpathSync } from 'fs';
+if (process.argv[1]) {
+  try {
+    if (realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
+      main();
+    }
+  } catch { /* path resolution failed — not invoked as a script */ }
 }

package/framework/hooks/read-protection.js

@@ -93,24 +93,52 @@ async function main() {
     const result = isSensitivePath(filePath, cwd);
 
     if (result.sensitive) {
-      process.stdout.write(JSON.stringify({
-        decision: 'block',
-        reason: `[Article IV] ${result.reason}. Use environment variables or secure vaults instead of reading sensitive files directly.`,
-      }));
+      process.stdout.write(JSON.stringify(denyOutput(
+        `[Article IV] ${result.reason}. Use environment variables or secure vaults instead of reading sensitive files directly.`
+      )));
       return;
     }
 
-    process.stdout.write(JSON.stringify({ decision: 'allow' }));
+    process.stdout.write(JSON.stringify(allowOutput()));
   } catch (err) {
     process.stderr.write(`[chati-hook-error] read-protection: ${err?.message || 'unknown'}\n`);
-    process.stdout.write(JSON.stringify({ decision: 'block', reason: 'Hook error — fail-closed for safety' }));
+    // Fail-open: a broken hook should not prevent reads. Real protection
+    // patterns are explicit above and run before this catch.
+    process.stdout.write(JSON.stringify(allowOutput()));
   }
 }
 
+function allowOutput() {
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+    },
+  };
+}
+
+function denyOutput(reason) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: reason,
+    },
+  };
+}
+
 export { isSensitivePath, SENSITIVE_PATTERNS, ALLOWED_EXCEPTIONS };
 
-// Only run main when executed directly (not imported by tests)
+// Only run main when executed directly (not imported by tests).
+// realpathSync resolves symlinks on both sides — important on macOS where
+// /tmp is a symlink to /private/tmp. Without realpath the comparison fails
+// silently and main() never runs.
 import { fileURLToPath } from 'url';
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  main();
+import { realpathSync } from 'fs';
+if (process.argv[1]) {
+  try {
+    if (realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
+      main();
+    }
+  } catch { /* path resolution failed — not invoked as a script */ }
 }