chati-dev 4.2.1 → 4.3.0

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');
@@ -115,7 +164,9 @@ async function main() {
         process.stderr.write(`[chati] session-digest daily-append: ${err.message}\n`);
       }
 
-      // Auto memory consolidation: trigger when memories accumulate
+      // Auto memory consolidation: trigger when memories accumulate.
+      // CRITICAL: must be fully async (detached spawn) — PreCompact runs on the
+      // hot path and execSync would add up to 10s of latency to every compact.
       try {
         const memBase = join(projectDir, '.chati', 'memories');
         if (existsSync(memBase)) {
@@ -132,16 +183,19 @@ async function main() {
           // Consolidate when > 100 entries (50% of 200 cap)
           if (totalEntries > 100) {
             process.stderr.write(`[chati] auto-dream: ${totalEntries} entries, triggering consolidation\n`);
-            // Fire-and-forget: consolidation runs in background
-            // Import would fail in hook context, so we spawn a child process
-            const { execSync } = await import('child_process');
+            // Fire-and-forget detached spawn — returns immediately, child outlives parent.
+            const { spawn } = await import('child_process');
             try {
-              execSync(`node -e "import('./packages/chati-dev/src/memory/dream.js').then(m => m.runDreamConsolidation('${projectDir.replace(/'/g, "\\'")}'))"`, {
+              const child = spawn('node', [
+                '-e',
+                `import(${JSON.stringify(projectDir + '/node_modules/chati-dev/src/memory/dream.js')}).then(m => m.runDreamConsolidation(${JSON.stringify(projectDir)}))`,
+              ], {
                 cwd: projectDir,
-                timeout: 10000,
+                detached: true,
                 stdio: 'ignore',
               });
-            } catch { /* expected: consolidation may timeout or fail */ }
+              child.unref();
+            } catch { /* expected: spawn may fail in restricted env */ }
           }
         }
       } catch (err) {
@@ -149,8 +203,9 @@ async function main() {
       }
     }
 
-    // Session telemetry ping (moved from license-guard to reduce per-prompt overhead)
-    // 5-minute throttle with phase/agent change detection
+    // Session telemetry ping (owned by session-digest, was moved here from license-guard).
+    // 5-minute throttle with phase/agent change detection.
+    // Pings.yaml format: '/path/to/project': '<ISO8601>|<phase>|<agent>'
     try {
       const homedir = process.env.HOME || '';
       const pingsPath = join(homedir, '.chati-dev', 'pings.yaml');
@@ -163,15 +218,17 @@ async function main() {
 
         if (licenseKey && digest) {
           let shouldPing = false;
-          const now = Date.now();
+          const nowIso = new Date().toISOString();
           const currentState = `${digest.mode}|${digest.currentAgent}`;
 
           if (existsSync(pingsPath)) {
             const pingsRaw = readFileSync(pingsPath, 'utf-8');
-            const entryMatch = pingsRaw.match(new RegExp(`${projectDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?'([^']+)'`));
+            const escaped = projectDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const entryMatch = pingsRaw.match(new RegExp(`^${escaped}:\\s*'([^']+)'`, 'm'));
             if (entryMatch) {
               const [ts, phase, agent] = entryMatch[1].split('|');
-              const elapsed = now - parseInt(ts);
+              const lastTime = new Date(ts).getTime();
+              const elapsed = isNaN(lastTime) ? Infinity : Date.now() - lastTime;
               const stateChanged = `${phase}|${agent}` !== currentState;
               shouldPing = elapsed > 300000 || stateChanged; // 5 min or state change
             } else {
@@ -182,16 +239,24 @@ async function main() {
           }
 
           if (shouldPing) {
-            // Update ping timestamp
+            // Update ping entry — preserve other projects in the file.
             mkdirSync(join(homedir, '.chati-dev'), { recursive: true });
-            writeFileSync(pingsPath, `'${projectDir}': '${now}|${currentState}'\n`, 'utf-8');
+            const newEntry = `${projectDir}: '${nowIso}|${currentState}'\n`;
+            let content = existsSync(pingsPath) ? readFileSync(pingsPath, 'utf-8') : '';
+            const escaped = projectDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            if (new RegExp(`^${escaped}:`, 'm').test(content)) {
+              content = content.replace(new RegExp(`^${escaped}:.*$`, 'm'), newEntry.trim());
+            } else {
+              content += newEntry;
+            }
+            writeFileSync(pingsPath, content, 'utf-8');
 
             // Fire-and-forget telemetry (3s timeout, never blocks)
             try {
               const body = JSON.stringify({
                 license_key: licenseKey,
                 project_name: digest.currentAgent || 'unknown',
-                events: [{ type: 'session_active', timestamp: new Date().toISOString(), properties: { pipeline_phase: digest.mode, current_agent: digest.currentAgent } }],
+                events: [{ type: 'session_active', timestamp: nowIso, properties: { pipeline_phase: digest.mode, current_agent: digest.currentAgent } }],
               });
               fetch('https://chati.dev/api/telemetry', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body, signal: AbortSignal.timeout(3000) }).catch(() => {});
             } catch { /* expected: network may be unavailable */ }
@@ -202,15 +267,24 @@ async function main() {
       process.stderr.write(`[chati] session-digest telemetry-ping: ${err.message}\n`);
     }
 
-    process.stdout.write(JSON.stringify({ result: 'allow' }));
+    // PreCompact is observational only — empty output is the canonical "no-op".
+    process.stdout.write('{}');
   } catch (err) {
     process.stderr.write(`[chati] session-digest: ${err.message}\n`);
-    process.stdout.write(JSON.stringify({ result: 'allow' }));
+    process.stdout.write('{}');
   }
 }
 
-// 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 */ }
 }