chati-dev 4.2.2 → 4.3.1

package/framework/hooks/reasoning-escalator.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+/**
+ * Reasoning Escalator Hook — Article XXIII enforcement.
+ *
+ * Two entry points via event-type branching:
+ *
+ *   UserPromptSubmit:
+ *     Read the user message, evaluate escalation triggers, update
+ *     session.reasoning_tier. Non-blocking — always allows the prompt
+ *     through. Side effect only.
+ *
+ *   PreToolUse (matcher Write|Edit|NotebookEdit):
+ *     If current tier is 'deliberate' AND the target is a source file
+ *     AND no recent plan exists in .planning/, DENY the tool call with
+ *     a message telling the agent to write a plan first. Otherwise allow.
+ *
+ * Pure evaluation logic is exported for unit tests. The main() entry
+ * point handles stdin/stdout and session persistence (regex-based YAML
+ * mutation — no js-yaml dependency).
+ */
+
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join, isAbsolute, relative } from 'path';
+import { execSync } from 'child_process';
+
+// ---------------------------------------------------------------------------
+// Pure helpers (exported for testing)
+// ---------------------------------------------------------------------------
+
+export const TIERS = ['standard', 'deep', 'deliberate'];
+export const TIER_RANK = { standard: 0, deep: 1, deliberate: 2 };
+
+// English-canonical friction keywords — always active regardless of
+// session.language. Article VII mandates English for all framework source
+// material; per-language patterns live in FRICTION_KEYWORDS_LOCALES and are
+// merged on top when session.language selects them.
+export const FRICTION_KEYWORDS_EN = [
+  /\bredesign\b/i,
+  /\brefactor(?:ing|s)?\b/i,
+  /\bstuck\b/i,
+  /\b(?:in a |a )?loop\b/i,
+  /\bnot working\b/i,
+  /\bbreak(?:ing|s)?\b/i,
+];
+
+// Locale-specific patterns merged on top of EN when session.language matches.
+// Each array MUST cover only that locale's phrasings of the same friction
+// concepts (refactoring / not working / stuck). Adding a locale does not
+// mutate the EN set.
+export const FRICTION_KEYWORDS_LOCALES = {
+  pt: [
+    /\brefatora[çc][aã]o\b/i,
+    /\bn[aã]o funciona\b/i,
+    /\btravad[oa]\b/i,
+  ],
+  es: [
+    /\brefactorizaci[oó]n\b/i,
+    /\bno funciona\b/i,
+    /\batascad[oa]\b/i,
+  ],
+  fr: [
+    /\brefactorisation\b/i,
+    /\bne marche pas\b/i,
+    /\bbloqu[eé]\b/i,
+  ],
+};
+
+/**
+ * Build the active friction-keyword set for a given language.
+ * EN is always included; the locale layer is appended if recognised.
+ *
+ * @param {string} [language='en'] ISO 639-1 language code from session.language
+ * @returns {RegExp[]}
+ */
+export function getFrictionKeywords(language = 'en') {
+  const locale = FRICTION_KEYWORDS_LOCALES[language] ?? [];
+  return [...FRICTION_KEYWORDS_EN, ...locale];
+}
+
+// Backwards-compat default export: English-only set. Callers that care about
+// locale coverage should use getFrictionKeywords(session.language) instead.
+export const FRICTION_KEYWORDS = getFrictionKeywords('en');
+
+export const SOURCE_FILE_EXT = /\.(?:js|jsx|ts|tsx|mjs|cjs|py|rb|go|rs|java|cs|php|swift|kt|scala|c|cc|cpp|h|hpp|css|scss|sass|html|vue|svelte|astro|sql)$/i;
+
+/**
+ * Parse slash-command style explicit tier commands from a user message.
+ * Returns one of 'ultraplan' | 'deliberate' | 'quick' | null.
+ */
+export function detectExplicitCommand(msg) {
+  if (!msg || typeof msg !== 'string') return null;
+  const m = msg.match(/(^|\s)\/(ultraplan|deliberate|quick)\b/i);
+  return m ? m[2].toLowerCase() : null;
+}
+
+/**
+ * Pure tier-escalation evaluator. All inputs are explicit so the function
+ * is fully deterministic and testable.
+ *
+ * @param {object} input
+ * @param {'standard'|'deep'|'deliberate'} [input.currentTier]
+ * @param {number} [input.correctionCycles]
+ * @param {number} [input.decisionTrailOpen]
+ * @param {number} [input.filesModifiedCount]
+ * @param {number} [input.linesModified]
+ * @param {string} [input.userMessage]
+ * @param {boolean} [input.crossViewportRegression]
+ * @param {boolean} [input.scopeEscalation]
+ * @param {string} [input.language='en'] ISO 639-1 session language; selects the
+ *   locale-specific friction-keyword layer on top of the English canonical set.
+ * @returns {{ tier: string, triggers: string[], reason: string }}
+ */
+export function evaluateTier(input = {}) {
+  const {
+    currentTier = 'standard',
+    correctionCycles = 0,
+    decisionTrailOpen = 0,
+    filesModifiedCount = 0,
+    linesModified = 0,
+    userMessage = '',
+    crossViewportRegression = false,
+    scopeEscalation = false,
+    language = 'en',
+  } = input;
+
+  // Explicit user command always wins.
+  const explicit = detectExplicitCommand(userMessage);
+  if (explicit === 'quick') {
+    return { tier: 'standard', triggers: ['user:/quick'], reason: 'User requested quick mode; tier forced to standard.' };
+  }
+  if (explicit === 'ultraplan' || explicit === 'deliberate') {
+    return { tier: 'deliberate', triggers: [`user:/${explicit}`], reason: 'User requested deliberate mode.' };
+  }
+
+  const triggers = [];
+  let targetTier = 'standard';
+  const promote = (toTier, label) => {
+    triggers.push(label);
+    if (TIER_RANK[toTier] > TIER_RANK[targetTier]) targetTier = toTier;
+  };
+
+  if (correctionCycles >= 2)          promote('deliberate', `correction_cycles=${correctionCycles}`);
+  if (scopeEscalation)                promote('deliberate', 'scope_escalation');
+  if (filesModifiedCount > 5)         promote('deep',       `files_modified=${filesModifiedCount}`);
+  if (linesModified > 200)            promote('deep',       `lines_modified=${linesModified}`);
+  if (decisionTrailOpen > 2)          promote('deep',       `decision_trail_open=${decisionTrailOpen}`);
+  if (crossViewportRegression)        promote('deep',       'cross_viewport_regression');
+  const frictionSet = getFrictionKeywords(language);
+  if (userMessage && frictionSet.some(r => r.test(userMessage))) {
+    const matched = frictionSet.filter(r => r.test(userMessage)).length;
+    promote('deep', `friction_keywords=${matched}`);
+  }
+
+  // Monotonic: never auto-demote within a task.
+  const finalTier = TIER_RANK[targetTier] > TIER_RANK[currentTier] ? targetTier : currentTier;
+  const reason = triggers.length === 0
+    ? `No escalation signals. Keeping tier "${finalTier}".`
+    : `Triggers (${triggers.length}): ${triggers.join(', ')}`;
+  return { tier: finalTier, triggers, reason };
+}
+
+/**
+ * Check whether a deliberate-tier tool call must be blocked pending a plan.
+ *
+ * @param {object} input
+ * @param {string} input.tier
+ * @param {string} input.toolName
+ * @param {object} input.toolInput
+ * @param {string} input.projectDir
+ * @param {number} [input.sessionStartedAt] - ms epoch; plans older than this do not count
+ * @returns {{ block: boolean, reason?: string, message?: string }}
+ */
+export function checkDeliberatePlanRequirement(input) {
+  const { tier, toolName, toolInput, projectDir, sessionStartedAt = 0 } = input || {};
+  if (tier !== 'deliberate') return { block: false };
+  if (!['Edit', 'Write', 'NotebookEdit'].includes(toolName)) return { block: false };
+
+  const rawTarget = (toolInput && (toolInput.file_path || toolInput.path)) || '';
+  if (!rawTarget) return { block: false };
+
+  const target = String(rawTarget);
+
+  // Writing TO a plan file is permitted (that's how the agent satisfies the gate).
+  if (/(^|\/)\.planning\//.test(target)) return { block: false };
+  // Writing to non-source files (configs, metadata) is permitted.
+  if (!SOURCE_FILE_EXT.test(target)) return { block: false };
+
+  const planningDir = projectDir ? join(projectDir, '.planning') : null;
+  if (!planningDir || !existsSync(planningDir)) {
+    return {
+      block: true,
+      reason: 'deliberate_tier_requires_plan',
+      message: 'Reasoning tier is DELIBERATE (Article XXIII). Create .planning/<task>-plan.md with approach, alternatives, risks, and acceptance criteria BEFORE editing code.',
+    };
+  }
+
+  let entries = [];
+  try { entries = readdirSync(planningDir); } catch { /* ignore */ }
+  const hasRecentPlan = entries.some(f => {
+    if (!f.endsWith('.md')) return false;
+    try {
+      const s = statSync(join(planningDir, f));
+      return s.mtimeMs >= sessionStartedAt;
+    } catch { return false; }
+  });
+  if (hasRecentPlan) return { block: false };
+
+  return {
+    block: true,
+    reason: 'deliberate_tier_requires_plan',
+    message: 'Reasoning tier is DELIBERATE (Article XXIII). No plan file in .planning/ newer than the session start. Write the plan before editing code.',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// I/O wrappers (not exercised in unit tests; covered by integration)
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse the reasoning_tier and started_at fields out of session.yaml using
+ * regex. Stays dependency-free (hooks do not import js-yaml).
+ */
+export function readSessionTier(projectDir) {
+  const sessionPath = join(projectDir, '.chati', 'session.yaml');
+  if (!existsSync(sessionPath)) return { tier: 'standard', startedAt: 0, raw: null };
+  let raw = '';
+  try { raw = readFileSync(sessionPath, 'utf-8'); } catch { return { tier: 'standard', startedAt: 0, raw: null }; }
+  const tierMatch = raw.match(/^\s*reasoning_tier:\s*(["']?)(\w+)\1\s*$/m);
+  const startedMatch = raw.match(/^\s*started_at:\s*(["']?)([^"'\n]+)\1\s*$/m);
+  let startedAt = 0;
+  if (startedMatch) {
+    const t = Date.parse(startedMatch[2]);
+    if (!Number.isNaN(t)) startedAt = t;
+  }
+  const tier = tierMatch ? tierMatch[2] : 'standard';
+  return { tier: TIERS.includes(tier) ? tier : 'standard', startedAt, raw };
+}
+
+/**
+ * Parse session.language out of session.yaml. Defaults to 'en' if the key is
+ * missing or unreadable. Kept regex-based to avoid a js-yaml dep in hooks.
+ */
+export function readSessionLanguage(projectDir) {
+  const sessionPath = join(projectDir, '.chati', 'session.yaml');
+  if (!existsSync(sessionPath)) return 'en';
+  let raw = '';
+  try { raw = readFileSync(sessionPath, 'utf-8'); } catch { return 'en'; }
+  const m = raw.match(/^\s*language:\s*(["']?)([a-z]{2})\1\s*$/m);
+  return m ? m[2] : 'en';
+}
+
+/**
+ * Update session.yaml with a new reasoning_tier value. Append `reasoning_tier:`
+ * if missing; replace in place if present. Silent on failure.
+ */
+export function writeSessionTier(projectDir, tier) {
+  if (!TIERS.includes(tier)) return false;
+  const sessionPath = join(projectDir, '.chati', 'session.yaml');
+  if (!existsSync(sessionPath)) return false;
+  let raw = '';
+  try { raw = readFileSync(sessionPath, 'utf-8'); } catch { return false; }
+  const line = `reasoning_tier: ${tier}`;
+  let next;
+  if (/^\s*reasoning_tier:\s*\w+\s*$/m.test(raw)) {
+    next = raw.replace(/^\s*reasoning_tier:\s*\w+\s*$/m, line);
+  } else {
+    next = raw.trimEnd() + '\n' + line + '\n';
+  }
+  try { writeFileSync(sessionPath, next, 'utf-8'); return true; } catch { return false; }
+}
+
+/**
+ * Count files modified since HEAD via git. Returns -1 when git is unavailable.
+ */
+export function gitDiffStats(projectDir) {
+  if (!projectDir) return { files: -1, lines: -1 };
+  try {
+    const files = execSync('git diff --name-only HEAD 2>/dev/null', {
+      cwd: projectDir, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim().split('\n').filter(Boolean);
+    let lines = 0;
+    try {
+      const stat = execSync('git diff --shortstat HEAD 2>/dev/null', {
+        cwd: projectDir, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim();
+      const m = stat.match(/(\d+)\s+insertion.*?(\d+)\s+deletion/);
+      if (m) lines = parseInt(m[1], 10) + parseInt(m[2], 10);
+      else {
+        const ins = stat.match(/(\d+)\s+insertion/);
+        if (ins) lines = parseInt(ins[1], 10);
+      }
+    } catch { /* ignore */ }
+    return { files: files.length, lines };
+  } catch {
+    return { files: -1, lines: -1 };
+  }
+}
+
+function allowOutput() {
+  return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' } };
+}
+function denyOutput(reason) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: reason,
+    },
+  };
+}
+function userPromptPassthrough() {
+  // UserPromptSubmit hooks emit a different shape; nothing to block here.
+  return {};
+}
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  try {
+    const event = JSON.parse(input || '{}');
+    const projectDir = event.cwd || process.cwd();
+    const hookEventName = event.hook_event_name || event.hookEventName || '';
+
+    if (hookEventName === 'UserPromptSubmit') {
+      const userMessage = event.user_message || event.prompt || '';
+      const { tier: currentTier, startedAt: _s } = readSessionTier(projectDir);
+      const language = readSessionLanguage(projectDir);
+      const { files: filesModifiedCount, lines: linesModified } = gitDiffStats(projectDir);
+      const result = evaluateTier({
+        currentTier,
+        userMessage,
+        filesModifiedCount: Math.max(0, filesModifiedCount),
+        linesModified: Math.max(0, linesModified),
+        language,
+      });
+      if (result.tier !== currentTier) {
+        writeSessionTier(projectDir, result.tier);
+      }
+      process.stdout.write(JSON.stringify(userPromptPassthrough()));
+      return;
+    }
+
+    if (hookEventName === 'PreToolUse') {
+      const toolName = event.tool_name || '';
+      const toolInput = event.tool_input || {};
+      const { tier, startedAt } = readSessionTier(projectDir);
+      const verdict = checkDeliberatePlanRequirement({
+        tier, toolName, toolInput, projectDir, sessionStartedAt: startedAt,
+      });
+      if (verdict.block) {
+        process.stdout.write(JSON.stringify(denyOutput(`[Article XXIII] ${verdict.message}`)));
+      } else {
+        process.stdout.write(JSON.stringify(allowOutput()));
+      }
+      return;
+    }
+
+    // Unknown event — pass through.
+    process.stdout.write(JSON.stringify(allowOutput()));
+  } catch (err) {
+    // Fail-OPEN: hook errors must not block user work.
+    process.stderr.write(`[chati-hook-error] reasoning-escalator: ${err?.message || 'unknown'}\n`);
+    process.stdout.write(JSON.stringify(allowOutput()));
+  }
+}
+
+// Only run main() when invoked as a script (tests can import pure helpers).
+if (import.meta.url === `file://${process.argv[1] || ''}`) {
+  main();
+}

package/framework/hooks/reference-trigger.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * Reference Trigger Hook — PostToolUse (runs after Write tool)
+ *
+ * When the Brief agent writes brief-report.md, this hook:
+ * 1. Extracts visual_references URLs
+ * 2. Launches reference-capture.js in BACKGROUND (detached)
+ * 3. Appends a "Visual Reference Captures" note to brief-report.md
+ *
+ * The capture runs in background so Claude doesn't wait ~9 min.
+ * The script writes capture-complete.json when ALL sites finish.
+ * Brand Architect polls for this file before spawning Visualizer.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { spawn } from 'child_process';
+
+async function readStdin() {
+  let data = '';
+  for await (const chunk of process.stdin) data += chunk;
+  return data;
+}
+
+async function main() {
+  let input;
+  try {
+    input = JSON.parse(await readStdin() || '{}');
+  } catch {
+    process.stdout.write('{}\n');
+    return;
+  }
+
+  const toolName = input.tool_name || '';
+  const toolInput = input.tool_input || {};
+  const filePath = toolInput.file_path || '';
+  const cwd = input.cwd || process.cwd();
+
+  process.stdout.write('{}\n');
+
+  if (toolName !== 'Write') return;
+  if (!filePath.endsWith('1-Brief/brief-report.md')) return;
+  if (!existsSync(filePath)) return;
+
+  let content;
+  try { content = readFileSync(filePath, 'utf-8'); } catch { return; }
+
+  // Don't re-run if already triggered (idempotency)
+  if (content.includes('## Visual Reference Captures')) return;
+
+  // Extract URLs — support both `url: "https://..."` YAML format and bare `- https://...` list items
+  const urlPatterns = [
+    /url:\s*["']?(https?:\/\/[^\s"']+)["']?/g,
+    /^\s*-\s+(https?:\/\/[^\s"']+)/gm,
+  ];
+  const urlSet = new Set();
+  for (const pattern of urlPatterns) {
+    for (const match of content.matchAll(pattern)) {
+      urlSet.add(match[1]);
+    }
+  }
+  const urls = [...urlSet];
+  if (urls.length === 0) return;
+
+  // Find script + playwright
+  const fwCandidates = ['.chati.dev', 'chati.dev'];
+  let scriptPath = null;
+  let nodePath = process.env.NODE_PATH || '';
+  for (const fw of fwCandidates) {
+    const p = join(cwd, fw, 'scripts', 'reference-capture.js');
+    if (existsSync(p)) { scriptPath = p; break; }
+  }
+  if (!scriptPath) return;
+  for (const fw of fwCandidates) {
+    const cliModules = join(cwd, fw, '_cli', 'node_modules');
+    if (existsSync(join(cliModules, 'playwright'))) {
+      nodePath = nodePath ? `${cliModules}:${nodePath}` : cliModules;
+      break;
+    }
+  }
+
+  const refOutput = join(cwd, 'artifacts', '4-UX', 'references');
+  mkdirSync(refOutput, { recursive: true });
+
+  // Launch capture in BACKGROUND — don't block Claude.
+  // The script writes capture-complete.json when done.
+  const child = spawn('node', [scriptPath, '--urls', ...urls, '--output', refOutput], {
+    cwd,
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, NODE_PATH: nodePath },
+  });
+  child.unref();
+
+  // Append note to brief-report.md immediately (capture runs in background)
+  const captureSection = `\n\n## Visual Reference Captures
+
+> Visual reference capture is running in background for ${urls.length} site(s).
+> Screenshots, scroll videos, and CSS tokens are being captured via Playwright.
+>
+> **IMPORTANT for planning agents:** This section contains preliminary data.
+> A deeper visual analysis of the scroll experience, animation patterns, and design DNA
+> will be performed by the **UX Brand Architect** using the Visualizer agent during planning.
+> Do NOT base final design decisions solely on this summary — wait for the full
+> Visual Experience Analysis in \`artifacts/4-UX/reference-analysis.md\`.
+>
+> **Sites being captured:** ${urls.map(u => `\`${u}\``).join(', ')}
+> **Output:** \`artifacts/4-UX/references/\`
+> **Status:** Check \`artifacts/4-UX/references/capture-complete.json\` for completion status.
+`;
+
+  try {
+    writeFileSync(filePath, content + captureSection, 'utf-8');
+  } catch { /* ignore */ }
+}
+
+main().catch(() => process.stdout.write('{}\n'));

package/framework/hooks/session-digest.js

@@ -96,6 +96,55 @@ async function main() {
 
       writeFileSync(join(digestDir, fileName), lines.join('\n') + '\n', 'utf-8');
 
+      // Memory-bootstrap-v1 (F-A5-006): when the current agent has no
+      // MEMORY.md yet (or it is empty), write a minimal one from this digest
+      // so prism-engine's L4 memory layer is never empty in early sessions.
+      // Inline here instead of importing from src/memory/agent-memory.js
+      // because hooks run via raw Node and cannot reliably import the
+      // package source on installed projects. The shape mirrors the
+      // writeBootstrapMemory() contract in agent-memory.js.
+      try {
+        const agent = digest.currentAgent;
+        if (agent && agent !== 'none') {
+          const memDir  = join(projectDir, '.chati', 'memories', agent);
+          const memPath = join(memDir, 'MEMORY.md');
+          let isEmpty = true;
+          if (existsSync(memPath)) {
+            try { isEmpty = readFileSync(memPath, 'utf-8').trim().length === 0; }
+            catch { /* treat as empty */ }
+          }
+          if (isEmpty) {
+            const bootstrap = [];
+            bootstrap.push('<!-- bootstrap-write: true -->');
+            bootstrap.push('<!-- source: session-digest bootstrap (memory-bootstrap-v1) -->');
+            bootstrap.push('');
+            bootstrap.push('## Episodic');
+            bootstrap.push('');
+            bootstrap.push(`- Resumed at mode=${digest.mode}, pipeline_position=${digest.pipelinePosition}, workflow=${digest.workflow || 'unknown'}. (low) [source:bootstrap]`);
+            if (digest.active_task) {
+              bootstrap.push('');
+              bootstrap.push('## Semantic');
+              bootstrap.push('');
+              bootstrap.push(`- Active task on resume: ${String(digest.active_task).slice(0, 500)} (low) [source:bootstrap]`);
+            }
+            if (Array.isArray(digest.gotchas_found) && digest.gotchas_found.length > 0) {
+              bootstrap.push('');
+              bootstrap.push('## Procedural');
+              bootstrap.push('');
+              for (const g of digest.gotchas_found.slice(0, 5)) {
+                if (!g?.message) continue;
+                bootstrap.push(`- Known gotcha [${g.severity || 'info'}] ${g.id || ''}: ${String(g.message).slice(0, 200)} (low) [source:bootstrap, severity:${g.severity || 'info'}]`);
+              }
+            }
+            bootstrap.push('');
+            mkdirSync(memDir, { recursive: true });
+            writeFileSync(memPath, bootstrap.join('\n'), 'utf-8');
+          }
+        }
+      } catch (err) {
+        process.stderr.write(`[chati] session-digest bootstrap: ${err.message}\n`);
+      }
+
       // Auto daily digest: append session entry on every PreCompact
       try {
         const dailyDir = join(projectDir, '.chati', 'memories', 'shared', 'daily');
@@ -139,7 +188,7 @@ async function main() {
             try {
               const child = spawn('node', [
                 '-e',
-                `import('./packages/chati-dev/src/memory/dream.js').then(m => m.runDreamConsolidation(${JSON.stringify(projectDir)}))`,
+                `import(${JSON.stringify(projectDir + '/node_modules/chati-dev/src/memory/dream.js')}).then(m => m.runDreamConsolidation(${JSON.stringify(projectDir)}))`,
               ], {
                 cwd: projectDir,
                 detached: true,

package/framework/hooks/settings.json

@@ -16,6 +16,10 @@
           {
             "type": "command",
             "command": "node chati.dev/hooks/model-governance.js"
+          },
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/reasoning-escalator.js"
           }
         ]
       }
@@ -31,6 +35,29 @@
         ]
       }
     ],
+    "PostToolUse": [
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/advance-trigger.js"
+          },
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/reference-trigger.js"
+          },
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/brief-validator.js"
+          },
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/post-dev.js"
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "Read",
@@ -42,7 +69,7 @@
         ]
       },
       {
-        "matcher": "Write|Edit",
+        "matcher": "Write|Edit|NotebookEdit",
         "hooks": [
           {
             "type": "command",
@@ -63,6 +90,10 @@
           {
             "type": "command",
             "command": "node chati.dev/hooks/team-quality-gate.js"
+          },
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/reasoning-escalator.js"
           }
         ]
       },

package/framework/hooks/style-guard.js

@@ -6,7 +6,7 @@
  * - No em-dashes (U+2013 EN DASH, U+2014 EM DASH)
  * - No emojis in generated content
  *
- * Mode: Advisory (warn, not block). Agent receives warning and should self-correct.
+ * Mode: Em-dashes are HARD BLOCKED (deny). Emojis are advisory (warn).
  * Feature-flag gated: respects anti_dash and no_emojis in config.yaml.
  *
  * Exempt paths: framework files (chati.dev/, .chati/), YAML configs, CLAUDE.md
@@ -35,8 +35,9 @@ const EXEMPT_PATTERNS = [
   /AGENTS\.md$/,
   /\.yaml$/,
   /\.yml$/,
-  /\.json$/,
   /package\.json$/,
+  /package-lock\.json$/,
+  /tsconfig\.json$/,
   /\.lock$/,
 ];
 
@@ -111,11 +112,19 @@ async function main() {
       result = checkBashStyle(command);
     }
 
-    if (result.violations.length > 0) {
-      // Advisory: surface as reason but allow. Style is a soft preference,
-      // not a security boundary — hard-blocking blocks legitimate markdown.
+    if (result.hasDash) {
+      // Em-dashes are HARD BLOCKED — they are never acceptable in project output.
+      // Use commas, semicolons, colons, or periods instead.
+      process.stdout.write(JSON.stringify(denyOutput(
+        `[Style Guard] Em-dash or en-dash detected. REWRITE without em-dashes. Use commas, semicolons, colons, or periods instead. This is non-negotiable.`
+      )));
+      return;
+    }
+
+    if (result.hasEmoji) {
+      // Emojis are advisory — warn but allow
       process.stdout.write(JSON.stringify(allowOutput(
-        `[Style Guard] ${result.violations.join(' ')} Consider rewriting without em-dashes and emojis (Article V).`
+        `[Style Guard] Emoji detected. Consider using icons from approved libraries instead.`
       )));
       return;
     }
@@ -127,6 +136,16 @@ async function main() {
   }
 }
 
+function denyOutput(reason) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: reason,
+    },
+  };
+}
+
 function allowOutput(reason) {
   const out = {
     hookSpecificOutput: {