chati-dev 3.2.5 → 3.3.0

package/src/gates/g4-qa-implementation.js

@@ -12,7 +12,7 @@
  *   WAIVED   — Human explicitly overrode
  */
 
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { GateBase, determineVerdict } from './gate-base.js';
 import { loadSession } from '../orchestrator/session-manager.js';
@@ -69,26 +69,55 @@ export class QAImplementationGate extends GateBase {
       evidence.noCriticalBugs = evidence.qaImplHandoff.blockers.length === 0;
     }
 
-    // Check for performance benchmark results
+    // Check for performance benchmark results — parse content for real findings
     const perfPaths = [
       join(projectDir, 'chati.dev', 'artifacts', 'performance-report.md'),
       join(projectDir, '.performance-benchmark'),
     ];
     for (const perfPath of perfPaths) {
       if (existsSync(perfPath)) {
-        evidence.performanceBenchmarksMet = true;
+        try {
+          const content = readFileSync(perfPath, 'utf-8');
+          const hasFailures = /fail|exceeded|timeout|regression|degradation|below\s*threshold/i.test(content);
+          const hasPassIndicator = /pass|met|within\s*budget|no\s*(regressions|issues)|acceptable/i.test(content);
+          if (hasFailures && !hasPassIndicator) {
+            evidence.performanceBenchmarksMet = false;
+          } else if (hasPassIndicator) {
+            evidence.performanceBenchmarksMet = true;
+          } else {
+            evidence.performanceBenchmarksMet = null; // Ambiguous
+          }
+        } catch {
+          evidence.performanceBenchmarksMet = null;
+        }
         break;
       }
     }
 
-    // Check for security scan
+    // Check for security scan — parse content for real findings
     const secPaths = [
       join(projectDir, 'chati.dev', 'artifacts', 'security-report.md'),
       join(projectDir, '.security-scan'),
     ];
     for (const secPath of secPaths) {
       if (existsSync(secPath)) {
-        evidence.securityScanClean = true;
+        try {
+          const content = readFileSync(secPath, 'utf-8').toLowerCase();
+          // Look for indicators of security failures
+          const hasBlockers = /blocker|critical|high\s*severity|vulnerability found|failed/i.test(content);
+          const hasPassIndicator = /pass|clean|no\s*(issues|vulnerabilities|findings)|score:\s*(9[5-9]|100)/i.test(content);
+          if (hasBlockers) {
+            evidence.securityScanClean = false;
+          } else if (hasPassIndicator) {
+            evidence.securityScanClean = true;
+          } else {
+            // File exists but has no clear pass/fail indicators — ambiguous — not clean by default
+            evidence.securityScanClean = null;
+          }
+        } catch {
+          // File exists but cannot be read — treat as not available
+          evidence.securityScanClean = null;
+        }
         break;
       }
     }

package/src/gates/gate-base.js

@@ -7,6 +7,7 @@
  */
 
 import { evaluateGate, getGateThreshold, resolveGateAction } from '../autonomy/autonomous-gate.js';
+import { track as telemetryTrack } from '../telemetry/collector.js';
 
 /**
  * Gate verdict constants (v3.0.0).
@@ -101,6 +102,14 @@ export class GateBase {
       const hasCriticalBlocker = warnings.some(w => w.toLowerCase().includes('critical'));
       const verdict = determineVerdict(gateResult.score, threshold, hasCriticalBlocker);
 
+      // Track telemetry
+      telemetryTrack('gate_evaluated', {
+        gate: this.id,
+        result: verdict,
+        score: gateResult.score,
+        blockers: warnings.filter(w => w.toLowerCase().includes('critical')),
+      });
+
       return {
         gateId: this.id,
         gateName: this.name,

package/src/health/auto-fix.js

@@ -0,0 +1,216 @@
+/**
+ * @fileoverview Auto-fix for common health check issues.
+ *
+ * Automatically repairs stale locks, oversized error logs,
+ * missing directories, and other recoverable problems.
+ *
+ * Constitution Article XIV — Framework Registry Governance.
+ */
+
+import { existsSync, mkdirSync, rmSync, statSync, readdirSync, truncateSync } from 'fs';
+import { join } from 'path';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Maximum error log size before truncation (1 MB). */
+const MAX_ERROR_LOG_SIZE = 1_024 * 1_024;
+
+/** Stale lock file age threshold (30 seconds). */
+const STALE_LOCK_AGE_MS = 30_000;
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} FixAction
+ * @property {string} action - Description of what was fixed
+ * @property {boolean} success - Whether the fix was applied
+ * @property {string} [error] - Error message if fix failed
+ */
+
+/**
+ * @typedef {object} AutoFixResult
+ * @property {number} fixed - Number of issues fixed
+ * @property {number} failed - Number of fixes that failed
+ * @property {FixAction[]} actions - Detailed action log
+ */
+
+/**
+ * Run auto-fix on a project directory.
+ *
+ * @param {string} projectDir
+ * @param {object[]} [checkResults=[]] - Results from health checks (for targeted fixes)
+ * @returns {AutoFixResult}
+ */
+export function autoFix(projectDir, checkResults = []) {
+  const actions = [];
+
+  // Fix 1: Ensure required directories exist
+  actions.push(...fixMissingDirectories(projectDir));
+
+  // Fix 2: Remove stale .lock files
+  actions.push(...fixStaleLocks(projectDir));
+
+  // Fix 3: Truncate oversized error logs
+  actions.push(...fixOversizedLogs(projectDir));
+
+  // Fix 4: Clean up orphaned worktrees directory entries
+  actions.push(...fixOrphanedWorktrees(projectDir));
+
+  const fixed = actions.filter(a => a.success).length;
+  const failed = actions.filter(a => !a.success).length;
+
+  return { fixed, failed, actions };
+}
+
+// ---------------------------------------------------------------------------
+// Individual Fixers
+// ---------------------------------------------------------------------------
+
+/**
+ * Ensure required .chati/ subdirectories exist.
+ *
+ * @param {string} projectDir
+ * @returns {FixAction[]}
+ */
+function fixMissingDirectories(projectDir) {
+  const actions = [];
+  const requiredDirs = [
+    '.chati',
+    '.chati/memory',
+    '.chati/metrics',
+  ];
+
+  for (const dir of requiredDirs) {
+    const fullPath = join(projectDir, dir);
+    if (!existsSync(fullPath)) {
+      try {
+        mkdirSync(fullPath, { recursive: true });
+        actions.push({ action: `Created missing directory: ${dir}`, success: true });
+      } catch (err) {
+        actions.push({ action: `Failed to create ${dir}`, success: false, error: err.message });
+      }
+    }
+  }
+
+  return actions;
+}
+
+/**
+ * Remove .lock files that are stale (old + no active PID).
+ *
+ * @param {string} projectDir
+ * @returns {FixAction[]}
+ */
+function fixStaleLocks(projectDir) {
+  const actions = [];
+  const chatiDir = join(projectDir, '.chati');
+
+  if (!existsSync(chatiDir)) return actions;
+
+  try {
+    const entries = readdirSync(chatiDir);
+    const lockFiles = entries.filter(e => e.endsWith('.lock'));
+
+    for (const lockFile of lockFiles) {
+      const lockPath = join(chatiDir, lockFile);
+      try {
+        const stat = statSync(lockPath);
+        const age = Date.now() - stat.mtimeMs;
+
+        if (age > STALE_LOCK_AGE_MS) {
+          rmSync(lockPath, { force: true });
+          actions.push({ action: `Removed stale lock: ${lockFile}`, success: true });
+        }
+      } catch (err) {
+        actions.push({ action: `Failed to check lock ${lockFile}`, success: false, error: err.message });
+      }
+    }
+  } catch {
+    // Directory read failed — skip
+  }
+
+  return actions;
+}
+
+/**
+ * Truncate oversized error/gotcha logs.
+ *
+ * @param {string} projectDir
+ * @returns {FixAction[]}
+ */
+function fixOversizedLogs(projectDir) {
+  const actions = [];
+  const logFiles = [
+    join(projectDir, '.chati', 'memory', 'errors.json'),
+    join(projectDir, '.chati', 'memory', 'gotchas.json'),
+  ];
+
+  for (const logPath of logFiles) {
+    if (!existsSync(logPath)) continue;
+
+    try {
+      const stat = statSync(logPath);
+      if (stat.size > MAX_ERROR_LOG_SIZE) {
+        truncateSync(logPath, 0);
+        actions.push({
+          action: `Truncated oversized log: ${logPath.split('/').pop()} (${Math.round(stat.size / 1024)}KB)`,
+          success: true,
+        });
+      }
+    } catch (err) {
+      actions.push({
+        action: `Failed to truncate ${logPath.split('/').pop()}`,
+        success: false,
+        error: err.message,
+      });
+    }
+  }
+
+  return actions;
+}
+
+/**
+ * Clean up orphaned worktree directory entries (empty dirs).
+ *
+ * @param {string} projectDir
+ * @returns {FixAction[]}
+ */
+function fixOrphanedWorktrees(projectDir) {
+  const actions = [];
+  const worktreeDir = join(projectDir, '.chati', 'worktrees');
+
+  if (!existsSync(worktreeDir)) return actions;
+
+  try {
+    const entries = readdirSync(worktreeDir);
+
+    for (const entry of entries) {
+      const entryPath = join(worktreeDir, entry);
+      try {
+        const stat = statSync(entryPath);
+        if (stat.isDirectory()) {
+          const contents = readdirSync(entryPath);
+          if (contents.length === 0) {
+            rmSync(entryPath, { recursive: true, force: true });
+            actions.push({ action: `Removed empty worktree dir: ${entry}`, success: true });
+          }
+        }
+      } catch {
+        // Skip entries we can't read
+      }
+    }
+  } catch {
+    // Directory read failed
+  }
+
+  return actions;
+}
+
+/**
+ * Exported constants for testing.
+ */
+export { MAX_ERROR_LOG_SIZE, STALE_LOCK_AGE_MS };

package/src/installer/core.js

@@ -1,11 +1,12 @@
 import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { IDE_CONFIGS } from '../config/ide-configs.js';
+import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
 import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
 import { generateSessionYaml, generateConfigYaml, generateClaudeMd, generateClaudeLocalMd, generateCodexSkill, generateGeminiRouter, generateGeminiSessionLock, generateAgentsOverrideMd, generateCodexConstitutionGuardRules, generateCodexReadProtectionRules } from './templates.js';
 import { generateContextFiles } from '../config/context-file-generator.js';
 import { adaptFrameworkFile, ADAPTABLE_FILES } from '../config/framework-adapter.js';
+import { generateProviderOverlays } from './provider-overlay.js';
 import { verifyManifest } from './manifest.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -20,7 +21,7 @@ const FRAMEWORK_SOURCE = existsSync(BUNDLED_SOURCE) ? BUNDLED_SOURCE : MONOREPO_
  * Install Chati.dev framework into target directory
  */
 export async function installFramework(config) {
-  const { targetDir, projectType, language, selectedIDEs, selectedMCPs, projectName, version, llmProvider } = config;
+  const { targetDir, projectType, language, selectedIDEs, selectedMCPs, projectName, version, llmProvider, allProviders } = config;
 
   // 0. Verify framework signature (supply chain protection)
   const manifestPath = join(FRAMEWORK_SOURCE, 'manifest.json');
@@ -40,7 +41,7 @@ export async function installFramework(config) {
   createDir(join(targetDir, '.chati'));
   writeFileSync(
     join(targetDir, '.chati', 'session.yaml'),
-    generateSessionYaml({ projectName, projectType, language, selectedIDEs, selectedMCPs, llmProvider }),
+    generateSessionYaml({ projectName, projectType, language, selectedIDEs, selectedMCPs, llmProvider, allProviders }),
     'utf-8'
   );
 
@@ -58,7 +59,7 @@ export async function installFramework(config) {
     'i18n', 'migrations', 'data', 'context',
     'artifacts/0-WU', 'artifacts/1-Brief', 'artifacts/2-PRD',
     'artifacts/3-Architecture', 'artifacts/4-UX', 'artifacts/5-Phases',
-    'artifacts/6-Tasks', 'artifacts/7-QA-Planning', 'artifacts/8-Validation',
+    'artifacts/6-Tasks', 'artifacts/7-QA-Planning', 'artifacts/9-QA-Implementation', 'artifacts/10-Deploy',
     'artifacts/handoffs', 'artifacts/decisions',
   ];
 
@@ -90,16 +91,27 @@ export async function installFramework(config) {
   // Copy framework files from source (adapted for non-Claude providers)
   copyFrameworkFiles(frameworkDir, llmProvider || 'claude');
 
+  // Generate provider overlays for secondary CLI providers
+  if (allProviders && allProviders.length > 1) {
+    generateProviderOverlays(targetDir, FRAMEWORK_SOURCE, llmProvider || 'claude', allProviders);
+  }
+
   // Write config.yaml
   writeFileSync(
     join(frameworkDir, 'config.yaml'),
-    generateConfigYaml({ version, projectType, language, selectedIDEs, llmProvider }),
+    generateConfigYaml({ version, projectType, language, selectedIDEs, llmProvider, allProviders }),
     'utf-8'
   );
 
-  // 3. Configure IDEs
+  // 3. Configure IDEs (secondary providers get overlay orchestrator path)
+  const primary = llmProvider || 'claude';
   for (const ideKey of selectedIDEs) {
-    await configureIDE(targetDir, ideKey, selectedMCPs);
+    const ideProvider = IDE_TO_PROVIDER[ideKey];
+    const isSecondary = ideProvider && ideProvider !== primary && allProviders && allProviders.length > 1;
+    const orchestratorPath = isSecondary
+      ? `chati.dev/.adapted/${ideProvider}/orchestrator/chati.md`
+      : 'chati.dev/orchestrator/chati.md';
+    await configureIDE(targetDir, ideKey, selectedMCPs, { orchestratorPath, isSecondary, providerName: ideProvider });
   }
 
   const hasClaude = selectedIDEs.includes('claude-code');
@@ -261,7 +273,8 @@ function copyFrameworkFiles(destDir, provider = 'claude') {
 /**
  * Configure a specific IDE
  */
-async function configureIDE(targetDir, ideKey, selectedMCPs) {
+async function configureIDE(targetDir, ideKey, selectedMCPs, options = {}) {
+  const { orchestratorPath, isSecondary } = options;
   const config = IDE_CONFIGS[ideKey];
   if (!config) return;
 
@@ -290,7 +303,7 @@ If session.yaml does not exist or has no language field, default to English.
 
 ## Load
 
-Read and execute the full orchestrator at \`chati.dev/orchestrator/chati.md\`.
+Read and execute the full orchestrator at \`${orchestratorPath || 'chati.dev/orchestrator/chati.md'}\`.
 
 Pass through all context: session state, handoffs, artifacts, and user input.
 
@@ -316,7 +329,7 @@ Pass through all context: session state, handoffs, artifacts, and user input.
   } else if (ideKey === 'codex-cli') {
     // Codex CLI: chati skill via .agents/skills/chati/SKILL.md (invoke with $chati)
     createDir(join(targetDir, '.agents', 'skills', 'chati'));
-    writeFileSync(join(targetDir, '.agents', 'skills', 'chati', 'SKILL.md'), generateCodexSkill(), 'utf-8');
+    writeFileSync(join(targetDir, '.agents', 'skills', 'chati', 'SKILL.md'), generateCodexSkill({ orchestratorPath }), 'utf-8');
 
     // Session lock override file (equivalent to CLAUDE.local.md)
     writeFileSync(join(targetDir, 'AGENTS.override.md'), generateAgentsOverrideMd(), 'utf-8');
@@ -327,7 +340,7 @@ Pass through all context: session state, handoffs, artifacts, and user input.
     writeFileSync(join(targetDir, '.codex', 'rules', 'read-protection.rules'), generateCodexReadProtectionRules(), 'utf-8');
   } else if (ideKey === 'gemini-cli') {
     // Gemini CLI: TOML command file (native format for /chati command)
-    writeFileSync(join(targetDir, '.gemini', 'commands', 'chati.toml'), generateGeminiRouter(), 'utf-8');
+    writeFileSync(join(targetDir, '.gemini', 'commands', 'chati.toml'), generateGeminiRouter({ orchestratorPath }), 'utf-8');
 
     // Context files via @import (equivalent to .claude/rules/chati/)
     const geminiContextDir = join(targetDir, '.gemini', 'context');

package/src/installer/provider-overlay.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Provider Overlay Generator for multi-CLI continuity.
+ *
+ * When multiple CLI providers are selected (e.g. Claude Code + Gemini CLI),
+ * the primary provider's adapted files go in chati.dev/ (main). For each
+ * secondary provider, this module generates an overlay directory at
+ * chati.dev/.adapted/<provider>/ with the ADAPTABLE_FILES adapted for
+ * that provider. Each CLI reads only its own files — zero runtime translation.
+ *
+ * Constitution Article XIX — multi-CLI governance.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { adaptFrameworkFile, ADAPTABLE_FILES } from '../config/framework-adapter.js';
+
+/**
+ * Generate adapted framework overlays for secondary providers.
+ *
+ * For each non-primary CLI provider, creates chati.dev/.adapted/<provider>/
+ * with provider-adapted copies of all ADAPTABLE_FILES.
+ *
+ * Reads CANONICAL (Claude) content from frameworkSource, then adapts for
+ * each secondary provider. This avoids double-adaptation issues when the
+ * primary provider is not Claude.
+ *
+ * @param {string} targetDir - Project root directory
+ * @param {string} frameworkSource - Source directory with canonical framework files
+ * @param {string} primaryProvider - Primary provider name ('claude', 'gemini', 'codex')
+ * @param {string[]} allProviders - All CLI provider names
+ * @returns {{ generated: string[], skipped: string[] }}
+ */
+export function generateProviderOverlays(targetDir, frameworkSource, primaryProvider, allProviders) {
+  const result = { generated: [], skipped: [] };
+  const frameworkDir = join(targetDir, 'chati.dev');
+
+  for (const provider of allProviders) {
+    if (provider === primaryProvider) {
+      result.skipped.push(provider);
+      continue;
+    }
+
+    const overlayDir = join(frameworkDir, '.adapted', provider);
+
+    for (const file of ADAPTABLE_FILES) {
+      const srcPath = join(frameworkSource, file);
+      if (!existsSync(srcPath)) continue;
+
+      // Read CANONICAL (Claude) content from source, then adapt for target provider
+      const canonicalContent = readFileSync(srcPath, 'utf-8');
+      const adapted = adaptFrameworkFile(canonicalContent, file, provider);
+
+      const destPath = join(overlayDir, file);
+      mkdirSync(dirname(destPath), { recursive: true });
+      writeFileSync(destPath, adapted, 'utf-8');
+    }
+
+    result.generated.push(provider);
+  }
+
+  return result;
+}
+
+/**
+ * Resolve the correct framework file path for a given provider.
+ *
+ * Returns the overlay path for secondary providers (if it exists),
+ * otherwise falls back to the main chati.dev/ path.
+ *
+ * @param {string} projectDir - Project root directory
+ * @param {string} relativePath - Path relative to chati.dev/ (e.g. 'agents/build/dev.md')
+ * @param {string} provider - Target provider name
+ * @returns {string} Absolute path to the adapted file
+ */
+export function resolveOverlayPath(projectDir, relativePath, provider) {
+  // Check overlay first
+  const overlayPath = join(projectDir, 'chati.dev', '.adapted', provider, relativePath);
+  if (existsSync(overlayPath)) return overlayPath;
+
+  // Fallback to main chati.dev/
+  return join(projectDir, 'chati.dev', relativePath);
+}

package/src/installer/templates.js

@@ -4,9 +4,10 @@ import yaml from 'js-yaml';
  * Generate session.yaml content
  */
 export function generateSessionYaml(config) {
-  const { projectName, projectType, language, selectedIDEs, selectedMCPs, llmProvider } = config;
+  const { projectName, projectType, language, selectedIDEs, selectedMCPs, llmProvider, allProviders } = config;
 
   const session = {
+    schema_version: '1.0',
     project: {
       name: projectName,
       type: projectType,
@@ -18,7 +19,9 @@ export function generateSessionYaml(config) {
     language: language,
     ides: selectedIDEs,
     mcps: selectedMCPs,
-    providers_enabled: [llmProvider || 'claude'],
+    providers_enabled: allProviders && allProviders.length > 0 ? allProviders : [llmProvider || 'claude'],
+    primary_provider: llmProvider || 'claude',
+    active_provider: llmProvider || 'claude',
     user_level: 'auto',
     user_level_confidence: 0.0,
     agents: {},
@@ -86,8 +89,9 @@ export const PROVIDER_MODEL_MAPS = {
  * Generate config.yaml content
  */
 export function generateConfigYaml(config) {
-  const { version, projectType, language, selectedIDEs, llmProvider } = config;
+  const { version, projectType, language, selectedIDEs, llmProvider, allProviders } = config;
   const provider = llmProvider || 'claude';
+  const providers = allProviders && allProviders.length > 0 ? allProviders : [provider];
 
   const configData = {
     version: version,
@@ -98,12 +102,18 @@ export function generateConfigYaml(config) {
     language: language,
     ides: selectedIDEs,
     providers: {
-      claude: { enabled: true, primary: provider === 'claude' },
-      gemini: { enabled: provider === 'gemini' || selectedIDEs.includes('gemini-cli'), model_default: 'pro', primary: provider === 'gemini' },
-      codex: { enabled: provider === 'codex' || selectedIDEs.includes('codex-cli'), model_default: 'codex', primary: provider === 'codex' },
+      claude: { enabled: providers.includes('claude') || provider === 'claude', primary: provider === 'claude' },
+      gemini: { enabled: providers.includes('gemini') || selectedIDEs.includes('gemini-cli'), model_default: 'pro', primary: provider === 'gemini' },
+      codex: { enabled: providers.includes('codex') || selectedIDEs.includes('codex-cli'), model_default: 'codex', primary: provider === 'codex' },
     },
   };
 
+  // Add telemetry config
+  configData.telemetry = {
+    enabled: config.telemetryEnabled || false,
+    anonymous_id: null,
+  };
+
   // Add agent_overrides with optimal model map for the selected provider
   if (provider !== 'claude') {
     const modelMap = PROVIDER_MODEL_MAPS[provider];
@@ -144,7 +154,8 @@ Type \`/chati\` to start.
  * The user invokes with $chati or Codex auto-detects based on description.
  * Also reads AGENTS.md for project context (auto-generated by context-file-generator).
  */
-export function generateCodexSkill() {
+export function generateCodexSkill(options = {}) {
+  const orchPath = options.orchestratorPath || 'chati.dev/orchestrator/chati.md';
   return `---
 name: chati
 description: >
@@ -175,7 +186,7 @@ If session.yaml does not exist or has no language field, default to English.
 The orchestrator and all agent files are **pre-configured for Codex CLI**.
 No translation needed — follow all instructions as written.
 
-Read and execute the full orchestrator at \`chati.dev/orchestrator/chati.md\`.
+Read and execute the full orchestrator at \`${orchPath}\`.
 
 **NEVER create or reference CLAUDE.md, CLAUDE.local.md, or .claude/ directories.**
 
@@ -195,7 +206,8 @@ Read and execute the full orchestrator at \`chati.dev/orchestrator/chati.md\`.
  * Gemini CLI custom commands use TOML format with `description` and `prompt` fields.
  * Supports {{args}} for user arguments and @{file} for file injection.
  */
-export function generateGeminiRouter() {
+export function generateGeminiRouter(options = {}) {
+  const orchPath = options.orchestratorPath || 'chati.dev/orchestrator/chati.md';
   return `description = "Activate Chati.dev orchestrator"
 prompt = """
 CRITICAL — Language Override:
@@ -206,7 +218,7 @@ If session.yaml does not exist or has no language field, default to English.
 The orchestrator and all agent files are pre-configured for Gemini CLI.
 No translation needed — follow all instructions as written.
 
-Read and execute the full orchestrator at chati.dev/orchestrator/chati.md.
+Read and execute the full orchestrator at ${orchPath}.
 NEVER create or reference CLAUDE.md, CLAUDE.local.md, or .claude/ directories.
 
 Context to load:

package/src/installer/transaction.js

@@ -210,8 +210,9 @@ export class InstallTransaction {
             break;
           }
         }
-      } catch {
-        // Best-effort rollback: continue even if individual reversals fail
+      } catch (err) {
+        // Best-effort rollback: log and continue
+        console.error('[chati] rollback warning:', err?.message);
       }
     }