chati-dev 4.0.10 → 4.1.0

package/src/extensions/loader.js

@@ -92,7 +92,7 @@ export function discoverExtensions(projectDir) {
       .map(f => join(extDir, f));
 
     return { files: jsFiles, dir: extDir };
-  } catch {
+  } catch { /* expected: directory may not exist */
     return { files: [], dir: extDir };
   }
 }

package/src/gates/g1-planning-complete.js

@@ -54,7 +54,7 @@ export class PlanningCompleteGate extends GateBase {
         try {
           const entries = readdirSync(dirPath);
           hasContent = entries.length > 0;
-        } catch {
+        } catch { /* expected: directory may not exist */
           hasContent = false;
         }
       }

package/src/gates/g2-qa-planning.js

@@ -56,7 +56,7 @@ export class QAPlanningGate extends GateBase {
               evidence.riskAssessment = true;
             }
           }
-        } catch {
+        } catch { /* expected: operation may fail gracefully */
           // Directory read failed, leave as false
         }
       }

package/src/gates/g3-implementation.js

@@ -89,7 +89,7 @@ export class ImplementationGate extends GateBase {
         } else {
           evidence.lintPasses = null; // Ambiguous — file exists but no clear verdict
         }
-      } catch {
+      } catch { /* expected: file may not exist */
         evidence.lintPasses = null;
       }
     }
@@ -112,7 +112,7 @@ export class ImplementationGate extends GateBase {
           } else {
             evidence.securityClean = null;
           }
-        } catch {
+        } catch { /* expected: file may not exist */
           evidence.securityClean = null;
         }
         break;
@@ -126,7 +126,7 @@ export class ImplementationGate extends GateBase {
         try {
           const entries = readdirSync(srcDir, { recursive: false });
           evidence.sourceFilesCreated = entries.length > 0;
-        } catch {
+        } catch { /* expected: directory may not exist */
           // Ignore
         }
       }
@@ -138,7 +138,7 @@ export class ImplementationGate extends GateBase {
         try {
           const entries = readdirSync(testDir, { recursive: false });
           evidence.testFilesCreated = entries.length > 0;
-        } catch {
+        } catch { /* expected: directory may not exist */
           // Ignore
         }
       }

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

@@ -87,7 +87,7 @@ export class QAImplementationGate extends GateBase {
           } else {
             evidence.performanceBenchmarksMet = null; // Ambiguous
           }
-        } catch {
+        } catch { /* expected: file may not exist */
           evidence.performanceBenchmarksMet = null;
         }
         break;
@@ -114,7 +114,7 @@ export class QAImplementationGate extends GateBase {
             // File exists but has no clear pass/fail indicators — ambiguous — not clean by default
             evidence.securityScanClean = null;
           }
-        } catch {
+        } catch { /* expected: operation may fail gracefully */
           // File exists but cannot be read — treat as not available
           evidence.securityScanClean = null;
         }

package/src/health/auto-fix.js

@@ -129,7 +129,7 @@ function fixStaleLocks(projectDir) {
         actions.push({ action: `Failed to check lock ${lockFile}`, success: false, error: err.message });
       }
     }
-  } catch {
+  } catch { /* expected: path may already be removed */
     // Directory read failed — skip
   }
 
@@ -199,11 +199,11 @@ function fixOrphanedWorktrees(projectDir) {
             actions.push({ action: `Removed empty worktree dir: ${entry}`, success: true });
           }
         }
-      } catch {
+      } catch { /* expected: directory may not exist */
         // Skip entries we can't read
       }
     }
-  } catch {
+  } catch { /* expected: directory may not exist */
     // Directory read failed
   }
 

package/src/health/engine.js

@@ -167,14 +167,14 @@ export async function checkDependencies() {
     if (major < 20) {
       issues.push(`Node.js ${nodeVersion} < required v20`);
     }
-  } catch {
+  } catch { /* expected: content may be malformed */
     issues.push('Node.js not found');
   }
 
   // Check git
   try {
     execSync('git --version', { stdio: 'ignore' });
-  } catch {
+  } catch { /* expected: git command may fail */
     issues.push('git not found');
   }
 

package/src/installer/brownfield-upgrader.js

@@ -186,8 +186,8 @@ export function upgradeInstallation(targetDir, newFrameworkDir, newVersion = '0.
           result.preserved.push(filePath);
           result.skipped.push(filePath);
         }
-      } catch {
-        // Merge failed => preserve user's version
+      } catch (err) {
+        process.stderr.write(`[chati] upgrader smart-merge: ${err.message}\n`);
         result.preserved.push(filePath);
         result.skipped.push(filePath);
       }
@@ -231,7 +231,7 @@ function collectRelativePaths(rootDir, base = '') {
   let entries;
   try {
     entries = readdirSync(join(rootDir, base), { withFileTypes: true });
-  } catch {
+  } catch { /* expected: directory may not exist */
     return paths;
   }
 

package/src/installer/manifest.js

@@ -16,7 +16,7 @@ let SIGNING_PUBLIC_KEY = null;
 try {
   const pemPath = join(__dirname, 'signing-public-key.pem');
   SIGNING_PUBLIC_KEY = createPublicKey(readFileSync(pemPath));
-} catch {
+} catch { /* expected: file may not exist */
   // Public key not available (dev environment without key generation)
 }
 

package/src/installer/transaction.js

@@ -203,7 +203,7 @@ export class InstallTransaction {
               try {
                 rmSync(reverseOp.absPath, { recursive: true, force: true });
                 rolledBack++;
-              } catch {
+              } catch { /* expected: path may already be removed */
                 // Directory may not be empty due to other changes; skip
               }
             }

package/src/installer/validator.js

@@ -222,8 +222,8 @@ export async function validateInstallation(targetDir) {
 
         results.context.details.push({ overlays: overlayDetails });
       }
-    } catch {
-      // Config parsing is best-effort for validation
+    } catch (err) {
+      process.stderr.write(`[chati] validator config-parse: ${err.message}\n`);
     }
   }
 

package/src/intelligence/decision-engine.js

@@ -179,7 +179,7 @@ export function loadRegistryEntities(registryPath) {
   try {
     const raw = readFileSync(registryPath, 'utf-8');
     return parseRegistryEntities(raw);
-  } catch {
+  } catch { /* expected: file may not exist */
     return [];
   }
 }

package/src/intelligence/memory-manager.js

@@ -182,7 +182,7 @@ export function parseMemoryFrontmatter(filePath) {
     }
 
     return meta;
-  } catch {
+  } catch { /* expected: operation may fail gracefully */
     return null;
   }
 }

package/src/intelligence/registry-manager.js

@@ -118,7 +118,7 @@ export function runHealthCheck(targetDir) {
       try {
         JSON.parse(readFileSync(schemaPath, 'utf-8'));
         validSchemas++;
-      } catch {
+      } catch { /* expected: file may not exist */
         // Invalid JSON
       }
     }
@@ -176,7 +176,7 @@ function loadRegistry(registryPath) {
   try {
     const content = readFileSync(registryPath, 'utf-8');
     return yaml.load(content);
-  } catch {
+  } catch { /* expected: file may not exist */
     return null;
   }
 }

package/src/intelligence/timeline.js

@@ -54,7 +54,7 @@ export function loadTimeline(projectDir) {
   if (!existsSync(timelinePath)) return [];
   try {
     return JSON.parse(readFileSync(timelinePath, 'utf-8'));
-  } catch {
+  } catch { /* expected: file may not exist */
     return [];
   }
 }

package/src/license/client.js

@@ -125,10 +125,28 @@ export async function validateLicense(_projectDir) {
 }
 
 /**
- * Remove license locally (does not deactivate machine slot on server).
+ * Remove license locally and deactivate machine slot on server (best-effort).
+ * Fails silently if API is unreachable.
  */
-export function deactivateLicense(_projectDir) {
+export async function deactivateLicense(_projectDir) {
   const data = readGlobal();
+  const key = data.key && data.key !== 'null' ? data.key : null;
+
+  // Best-effort server deactivation (key + machine_id = proof of ownership)
+  if (key) {
+    try {
+      const machineId = getMachineId();
+      await fetch(`${API_BASE}/license/self-deactivate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ key, machine_id: machineId }),
+        signal: AbortSignal.timeout(5000),
+      });
+    } catch { /* expected: network may be unavailable */
+      // Fail silently — local deactivation still proceeds
+    }
+  }
+
   writeGlobal({
     ...data,
     key: null,

package/src/license/commands.js

@@ -50,15 +50,15 @@ export async function runActivate(projectDir, keyArg) {
 // deactivate
 // ---------------------------------------------------------------------------
 
-export function runDeactivate(projectDir) {
+export async function runDeactivate(projectDir) {
   const key = getLicenseKey(projectDir);
   if (!key) {
     console.log('No license key found locally. Nothing to remove.');
     return;
   }
-  deactivateLicense(projectDir);
-  console.log(`\n✓ License key removed locally.`);
-  console.log(`  To free up a machine slot, visit https://chati.dev/dashboard\n`);
+  console.log('Deactivating...');
+  await deactivateLicense(projectDir);
+  console.log(`\n✓ License key removed and machine slot freed.\n`);
 }
 
 // ---------------------------------------------------------------------------
@@ -74,13 +74,13 @@ export async function runLicenseStatus(projectDir) {
     return;
   }
 
-  console.log(`\nChecking license...`);
+  console.log(`\nChecking license (refreshing cache)...`);
 
   let status;
   try {
     status = await validateLicense(projectDir);
-  } catch {
-    // Fallback to cache
+  } catch (err) {
+    process.stderr.write(`[chati] license validate: ${err.message}\n`);
     status = getLicenseStatus(projectDir) ?? { status: 'UNKNOWN' };
   }
 

package/src/memory/agent-memory.js

@@ -123,7 +123,7 @@ export function readAgentMemory(projectDir, agentName) {
       entries,
       raw,
     };
-  } catch {
+  } catch { /* expected: file may not exist */
     return {
       loaded: false,
       entries: [],
@@ -208,7 +208,7 @@ export function searchAgentMemories(projectDir, query) {
         }
       });
     }
-  } catch {
+  } catch { /* expected: operation may fail gracefully */
     return [];
   }
 
@@ -267,7 +267,7 @@ export function getAgentMemoryStats(projectDir) {
         categories: [...new Set(memory.entries.map(e => e.category))],
       };
     }
-  } catch {
+  } catch { /* expected: operation may fail gracefully */
     return { byAgent: {} };
   }
 

package/src/memory/daily-digest.js

@@ -0,0 +1,170 @@
+/**
+ * Daily Digest — KAIROS Lite session summary system.
+ *
+ * Inspired by Claude Code's KAIROS daemon (append-only daily logs),
+ * but implemented as a lightweight non-daemon approach that generates
+ * daily summaries on demand or at session end.
+ *
+ * Creates daily digest files at .chati/memories/shared/daily/YYYY-MM-DD.md
+ * with cumulative session activity: tasks completed/failed, decisions,
+ * gotchas, agent scores, and timing.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const DAILY_DIR = '.chati/memories/shared/daily';
+
+/**
+ * Build a daily digest entry from the current session state.
+ *
+ * @param {string} projectDir - Project root
+ * @param {object} sessionState - Current session.yaml data
+ * @param {object} [extras={}] - Additional context
+ * @param {string[]} [extras.decisions] - Decisions made
+ * @param {string[]} [extras.gotchas] - Gotchas found
+ * @param {number} [extras.duration] - Session duration in minutes
+ * @returns {object} Digest entry
+ */
+export function buildDailyEntry(projectDir, sessionState, extras = {}) {
+  const now = new Date();
+  const agents = sessionState.agents || {};
+
+  // Compute agent stats
+  const completed = [];
+  const failed = [];
+  const scores = {};
+
+  for (const [name, data] of Object.entries(agents)) {
+    if (data.status === 'completed') {
+      completed.push(name);
+      if (data.validation_score) scores[name] = data.validation_score;
+    } else if (data.status === 'failed') {
+      failed.push(name);
+    }
+  }
+
+  const avgScore = Object.values(scores).length > 0
+    ? Math.round(Object.values(scores).reduce((a, b) => a + b, 0) / Object.values(scores).length)
+    : null;
+
+  return {
+    time: now.toISOString().split('T')[1].split('.')[0],
+    phase: sessionState.project?.state || sessionState.mode || 'unknown',
+    current_agent: sessionState.current_agent || 'none',
+    tasks_completed: completed.length,
+    tasks_failed: failed.length,
+    agents_completed: completed,
+    agents_failed: failed,
+    avg_score: avgScore,
+    scores,
+    decisions: extras.decisions || [],
+    gotchas: extras.gotchas || [],
+    duration_min: extras.duration || null,
+  };
+}
+
+/**
+ * Append an entry to today's daily digest file.
+ *
+ * @param {string} projectDir - Project root
+ * @param {object} entry - Digest entry from buildDailyEntry()
+ * @returns {{ saved: boolean, path: string }}
+ */
+export function appendDailyDigest(projectDir, entry) {
+  const dir = join(projectDir, DAILY_DIR);
+  mkdirSync(dir, { recursive: true });
+
+  const dateStr = new Date().toISOString().split('T')[0];
+  const filePath = join(dir, `${dateStr}.md`);
+
+  // Build markdown entry
+  const lines = [];
+  lines.push(`### ${entry.time} — ${entry.phase}`);
+  lines.push(`- **Agent**: ${entry.current_agent}`);
+  lines.push(`- **Completed**: ${entry.tasks_completed} | **Failed**: ${entry.tasks_failed}`);
+  if (entry.avg_score) lines.push(`- **Avg Score**: ${entry.avg_score}%`);
+  if (entry.duration_min) lines.push(`- **Duration**: ${entry.duration_min} min`);
+
+  if (entry.agents_completed.length > 0) {
+    lines.push(`- **Agents done**: ${entry.agents_completed.join(', ')}`);
+  }
+  if (entry.agents_failed.length > 0) {
+    lines.push(`- **Agents failed**: ${entry.agents_failed.join(', ')}`);
+  }
+  if (entry.decisions.length > 0) {
+    lines.push('- **Decisions**:');
+    for (const d of entry.decisions.slice(0, 5)) {
+      lines.push(`  - ${d}`);
+    }
+  }
+  if (entry.gotchas.length > 0) {
+    lines.push('- **Gotchas**:');
+    for (const g of entry.gotchas.slice(0, 5)) {
+      lines.push(`  - ${g}`);
+    }
+  }
+  lines.push('');
+
+  try {
+    let existing = '';
+    if (existsSync(filePath)) {
+      existing = readFileSync(filePath, 'utf-8');
+    } else {
+      // Create header for new daily file
+      existing = `# Daily Digest — ${dateStr}\n\n`;
+    }
+
+    writeFileSync(filePath, existing + lines.join('\n') + '\n', 'utf-8');
+    return { saved: true, path: filePath };
+  } catch (err) {
+    process.stderr.write(`[chati] daily-digest append: ${err.message}\n`);
+    return { saved: false, path: filePath };
+  }
+}
+
+/**
+ * Load today's daily digest.
+ *
+ * @param {string} projectDir - Project root
+ * @returns {{ loaded: boolean, content: string|null, path: string }}
+ */
+export function loadTodayDigest(projectDir) {
+  const dateStr = new Date().toISOString().split('T')[0];
+  const filePath = join(projectDir, DAILY_DIR, `${dateStr}.md`);
+
+  if (!existsSync(filePath)) {
+    return { loaded: false, content: null, path: filePath };
+  }
+
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    return { loaded: true, content, path: filePath };
+  } catch (err) {
+    process.stderr.write(`[chati] daily-digest load today: ${err.message}\n`);
+    return { loaded: false, content: null, path: filePath };
+  }
+}
+
+/**
+ * Load a specific date's digest.
+ *
+ * @param {string} projectDir - Project root
+ * @param {string} dateStr - Date in YYYY-MM-DD format
+ * @returns {{ loaded: boolean, content: string|null, path: string }}
+ */
+export function loadDigestByDate(projectDir, dateStr) {
+  const filePath = join(projectDir, DAILY_DIR, `${dateStr}.md`);
+
+  if (!existsSync(filePath)) {
+    return { loaded: false, content: null, path: filePath };
+  }
+
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    return { loaded: true, content, path: filePath };
+  } catch (err) {
+    process.stderr.write(`[chati] daily-digest load date: ${err.message}\n`);
+    return { loaded: false, content: null, path: filePath };
+  }
+}