chati-dev 1.4.0 → 2.0.2

package/src/autonomy/safety-net.js

@@ -0,0 +1,320 @@
+/**
+ * @fileoverview Safety net for autonomous execution
+ * Auto-pauses pipeline on dangerous conditions
+ */
+
+/**
+ * Safety conditions that trigger automatic pause.
+ */
+export const SAFETY_TRIGGERS = {
+  CONSECUTIVE_FAILURES: 'consecutive_failures', // 3+ failures in a row
+  LOW_SCORE: 'low_score', // Score < 70%
+  CRITICAL_RISK: 'critical_risk', // Security/data risk detected
+  TIMEOUT: 'timeout', // Agent exceeded time limit
+  GOTCHA_SPIKE: 'gotcha_spike', // 5+ new gotchas in current session
+};
+
+// Critical risk keywords
+const CRITICAL_RISK_KEYWORDS = [
+  'security',
+  'vulnerability',
+  'exploit',
+  'injection',
+  'authentication',
+  'authorization',
+  'data loss',
+  'data corruption',
+  'production',
+  'database drop',
+  'rm -rf',
+  'delete all',
+];
+
+/**
+ * Check all safety conditions against current state.
+ * @param {object} state
+ * @param {number} state.consecutiveFailures - Number of consecutive gate failures
+ * @param {number} state.lastScore - Most recent gate score
+ * @param {string[]} state.riskFlags - Active risk flags
+ * @param {number} state.sessionGotchas - New gotchas this session
+ * @param {number} [state.agentDurationMs] - Time current agent has been running
+ * @param {number} [state.timeoutMs] - Maximum allowed duration
+ * @returns {{ safe: boolean, triggers: object[], recommendation: string }}
+ */
+export function checkSafety(state) {
+  const triggers = [];
+
+  // Check each trigger
+  Object.values(SAFETY_TRIGGERS).forEach(trigger => {
+    const result = evaluateTrigger(trigger, state);
+    if (result.triggered) {
+      triggers.push(result);
+    }
+  });
+
+  const safe = triggers.length === 0;
+  const recommendation = safe
+    ? 'All safety checks passed'
+    : getRecommendedAction(triggers).reason;
+
+  return {
+    safe,
+    triggers,
+    recommendation,
+  };
+}
+
+/**
+ * Evaluate a single safety condition.
+ * @param {string} trigger - SAFETY_TRIGGERS value
+ * @param {object} state
+ * @returns {{ triggered: boolean, severity: 'warning'|'critical', details: string }}
+ */
+export function evaluateTrigger(trigger, state) {
+  switch (trigger) {
+    case SAFETY_TRIGGERS.CONSECUTIVE_FAILURES:
+      return evaluateConsecutiveFailures(state);
+
+    case SAFETY_TRIGGERS.LOW_SCORE:
+      return evaluateLowScore(state);
+
+    case SAFETY_TRIGGERS.CRITICAL_RISK:
+      return evaluateCriticalRisk(state);
+
+    case SAFETY_TRIGGERS.TIMEOUT:
+      return evaluateTimeout(state);
+
+    case SAFETY_TRIGGERS.GOTCHA_SPIKE:
+      return evaluateGotchaSpike(state);
+
+    default:
+      return {
+        triggered: false,
+        severity: 'warning',
+        details: 'Unknown trigger',
+      };
+  }
+}
+
+/**
+ * Get recommended action when safety net triggers.
+ * @param {object[]} triggers - Triggered safety conditions
+ * @returns {{ action: 'pause'|'warn'|'abort', reason: string, resumable: boolean }}
+ */
+export function getRecommendedAction(triggers) {
+  if (triggers.length === 0) {
+    return {
+      action: 'warn',
+      reason: 'No safety triggers detected',
+      resumable: true,
+    };
+  }
+
+  // Check for critical severity
+  const hasCritical = triggers.some(t => t.severity === 'critical');
+
+  if (hasCritical) {
+    const criticalTriggers = triggers.filter(t => t.severity === 'critical');
+    return {
+      action: 'pause',
+      reason: `Critical safety conditions: ${criticalTriggers.map(t => t.details).join('; ')}`,
+      resumable: true,
+    };
+  }
+
+  // Only warnings
+  return {
+    action: 'warn',
+    reason: `Safety warnings: ${triggers.map(t => t.details).join('; ')}`,
+    resumable: true,
+  };
+}
+
+/**
+ * Evaluate consecutive failures trigger.
+ * @param {object} state
+ * @returns {{ triggered: boolean, severity: string, details: string }}
+ */
+function evaluateConsecutiveFailures(state) {
+  const threshold = 3;
+  const failures = state.consecutiveFailures || 0;
+
+  if (failures >= threshold) {
+    return {
+      triggered: true,
+      severity: 'critical',
+      details: `${failures} consecutive gate failures (threshold: ${threshold})`,
+    };
+  }
+
+  return {
+    triggered: false,
+    severity: 'warning',
+    details: 'No consecutive failures',
+  };
+}
+
+/**
+ * Evaluate low score trigger.
+ * @param {object} state
+ * @returns {{ triggered: boolean, severity: string, details: string }}
+ */
+function evaluateLowScore(state) {
+  const threshold = 70;
+  const score = state.lastScore;
+
+  if (typeof score !== 'number') {
+    return {
+      triggered: false,
+      severity: 'warning',
+      details: 'No score available',
+    };
+  }
+
+  if (score < threshold) {
+    return {
+      triggered: true,
+      severity: 'warning',
+      details: `Low quality score: ${score}% (threshold: ${threshold}%)`,
+    };
+  }
+
+  return {
+    triggered: false,
+    severity: 'warning',
+    details: 'Score within acceptable range',
+  };
+}
+
+/**
+ * Evaluate critical risk trigger.
+ * @param {object} state
+ * @returns {{ triggered: boolean, severity: string, details: string }}
+ */
+function evaluateCriticalRisk(state) {
+  const riskFlags = state.riskFlags || [];
+
+  // Check for critical risk keywords
+  const criticalFlags = riskFlags.filter(flag =>
+    CRITICAL_RISK_KEYWORDS.some(keyword =>
+      flag.toLowerCase().includes(keyword.toLowerCase())
+    )
+  );
+
+  if (criticalFlags.length > 0) {
+    return {
+      triggered: true,
+      severity: 'critical',
+      details: `Critical risks detected: ${criticalFlags.join(', ')}`,
+    };
+  }
+
+  return {
+    triggered: false,
+    severity: 'warning',
+    details: 'No critical risks detected',
+  };
+}
+
+/**
+ * Evaluate timeout trigger.
+ * @param {object} state
+ * @returns {{ triggered: boolean, severity: string, details: string }}
+ */
+function evaluateTimeout(state) {
+  const { agentDurationMs, timeoutMs } = state;
+
+  if (typeof agentDurationMs !== 'number' || typeof timeoutMs !== 'number') {
+    return {
+      triggered: false,
+      severity: 'warning',
+      details: 'No timeout configured',
+    };
+  }
+
+  if (agentDurationMs >= timeoutMs) {
+    const minutes = Math.round(agentDurationMs / 60000);
+    const maxMinutes = Math.round(timeoutMs / 60000);
+    return {
+      triggered: true,
+      severity: 'critical',
+      details: `Agent timeout: ${minutes}min (max: ${maxMinutes}min)`,
+    };
+  }
+
+  return {
+    triggered: false,
+    severity: 'warning',
+    details: 'Agent within time limits',
+  };
+}
+
+/**
+ * Evaluate gotcha spike trigger.
+ * @param {object} state
+ * @returns {{ triggered: boolean, severity: string, details: string }}
+ */
+function evaluateGotchaSpike(state) {
+  const threshold = 5;
+  const gotchas = state.sessionGotchas || 0;
+
+  if (gotchas >= threshold) {
+    return {
+      triggered: true,
+      severity: 'warning',
+      details: `High gotcha count: ${gotchas} (threshold: ${threshold})`,
+    };
+  }
+
+  return {
+    triggered: false,
+    severity: 'warning',
+    details: 'Gotcha count within limits',
+  };
+}
+
+/**
+ * Get critical risk keywords list.
+ * @returns {string[]}
+ */
+export function getCriticalRiskKeywords() {
+  return [...CRITICAL_RISK_KEYWORDS];
+}
+
+/**
+ * Check if a risk flag contains critical keywords.
+ * @param {string} flag
+ * @returns {boolean}
+ */
+export function isCriticalRisk(flag) {
+  return CRITICAL_RISK_KEYWORDS.some(keyword =>
+    flag.toLowerCase().includes(keyword.toLowerCase())
+  );
+}
+
+/**
+ * Build safety report for user.
+ * @param {object} state
+ * @returns {{ status: string, message: string, triggers: object[] }}
+ */
+export function buildSafetyReport(state) {
+  const result = checkSafety(state);
+
+  let status;
+  let message;
+
+  if (result.safe) {
+    status = 'safe';
+    message = 'All safety checks passed. Pipeline can continue.';
+  } else {
+    const action = getRecommendedAction(result.triggers);
+    status = action.action === 'pause' ? 'unsafe' : 'warning';
+    message = action.reason;
+  }
+
+  return {
+    status,
+    message,
+    triggers: result.triggers,
+  };
+}

package/src/context/bracket-tracker.js

@@ -0,0 +1,79 @@
+/**
+ * Bracket Tracker — Pure arithmetic for context window management.
+ *
+ * Brackets determine how much context to inject:
+ *   FRESH    (60-100%) → All 5 layers active
+ *   MODERATE (40-60%)  → L0 + L1 + L2 + L3 (skip L4 task detail)
+ *   DEPLETED (25-40%)  → L0 + L1 + L2 only
+ *   CRITICAL (<25%)    → L0 + L1 only (handoff mandatory)
+ */
+
+const BRACKETS = {
+  FRESH:    { min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4'], tokenBudget: 8000 },
+  MODERATE: { min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3'],       tokenBudget: 5000 },
+  DEPLETED: { min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],             tokenBudget: 3000 },
+  CRITICAL: { min: 0,  max: 25,  layers: ['L0', 'L1'],                   tokenBudget: 1500 },
+};
+
+const MEMORY_LEVELS = {
+  FRESH:    'full',
+  MODERATE: 'chunks',
+  DEPLETED: 'metadata',
+  CRITICAL: 'none',
+};
+
+/**
+ * Calculate bracket from remaining context percentage.
+ * @param {number} remainingPercent - 0 to 100
+ * @returns {{ bracket: string, activeLayers: string[], tokenBudget: number, memoryLevel: string, handoffRequired: boolean }}
+ */
+export function calculateBracket(remainingPercent) {
+  const pct = Math.max(0, Math.min(100, remainingPercent));
+
+  let name = 'CRITICAL';
+  if (pct >= 60) name = 'FRESH';
+  else if (pct >= 40) name = 'MODERATE';
+  else if (pct >= 25) name = 'DEPLETED';
+
+  const def = BRACKETS[name];
+  return {
+    bracket: name,
+    activeLayers: [...def.layers],
+    tokenBudget: def.tokenBudget,
+    memoryLevel: MEMORY_LEVELS[name],
+    handoffRequired: pct < 15,
+    remainingPercent: pct,
+  };
+}
+
+/**
+ * Estimate remaining context percentage from prompt/turn count.
+ * Heuristic: each turn consumes ~2-4% of context window.
+ * @param {number} turnCount - Number of conversation turns so far
+ * @param {number} [maxTurns=40] - Estimated max turns before context exhaustion
+ * @returns {number} Estimated remaining percentage (0-100)
+ */
+export function estimateRemaining(turnCount, maxTurns = 40) {
+  const used = Math.min(turnCount, maxTurns) / maxTurns;
+  return Math.round((1 - used) * 100);
+}
+
+/**
+ * Check if a specific layer is active for a given bracket.
+ * @param {string} bracket - FRESH, MODERATE, DEPLETED, or CRITICAL
+ * @param {string} layer - L0, L1, L2, L3, or L4
+ * @returns {boolean}
+ */
+export function isLayerActive(bracket, layer) {
+  const def = BRACKETS[bracket];
+  if (!def) return false;
+  return def.layers.includes(layer);
+}
+
+/**
+ * Get all bracket definitions (for display/dashboard).
+ * @returns {Record<string, { min: number, max: number, layers: string[], tokenBudget: number }>}
+ */
+export function getBracketDefinitions() {
+  return { ...BRACKETS };
+}

package/src/context/domain-loader.js

@@ -0,0 +1,107 @@
+/**
+ * Domain Loader — Parses YAML domain files for context injection.
+ *
+ * Domain files live in chati.dev/domains/ and contain rules/context
+ * that PRISM injects into agent prompts based on the active layer.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Load a single domain YAML file.
+ * @param {string} filePath - Absolute path to YAML file
+ * @returns {{ loaded: boolean, data: object|null, error: string|null }}
+ */
+export function loadDomainFile(filePath) {
+  if (!existsSync(filePath)) {
+    return { loaded: false, data: null, error: `File not found: ${filePath}` };
+  }
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    const data = yaml.load(raw) || {};
+    return { loaded: true, data, error: null };
+  } catch (err) {
+    return { loaded: false, data: null, error: `Parse error in ${filePath}: ${err.message}` };
+  }
+}
+
+/**
+ * Load all agent domain files from chati.dev/domains/agents/.
+ * @param {string} domainsDir - Path to chati.dev/domains/
+ * @returns {Map<string, object>} Map of agentName → domain data
+ */
+export function loadAgentDomains(domainsDir) {
+  const agentsDir = join(domainsDir, 'agents');
+  const domains = new Map();
+
+  if (!existsSync(agentsDir)) return domains;
+
+  const files = readdirSync(agentsDir).filter(f => f.endsWith('.yaml'));
+  for (const file of files) {
+    const name = basename(file, '.yaml');
+    const result = loadDomainFile(join(agentsDir, file));
+    if (result.loaded) {
+      domains.set(name, result.data);
+    }
+  }
+  return domains;
+}
+
+/**
+ * Load all workflow domain files from chati.dev/domains/workflows/.
+ * @param {string} domainsDir - Path to chati.dev/domains/
+ * @returns {Map<string, object>} Map of workflowName → domain data
+ */
+export function loadWorkflowDomains(domainsDir) {
+  const workflowsDir = join(domainsDir, 'workflows');
+  const domains = new Map();
+
+  if (!existsSync(workflowsDir)) return domains;
+
+  const files = readdirSync(workflowsDir).filter(f => f.endsWith('.yaml'));
+  for (const file of files) {
+    const name = basename(file, '.yaml');
+    const result = loadDomainFile(join(workflowsDir, file));
+    if (result.loaded) {
+      domains.set(name, result.data);
+    }
+  }
+  return domains;
+}
+
+/**
+ * Load the constitution domain (extracted rules from constitution.md).
+ * @param {string} domainsDir - Path to chati.dev/domains/
+ * @returns {object|null}
+ */
+export function loadConstitutionDomain(domainsDir) {
+  const result = loadDomainFile(join(domainsDir, 'constitution.yaml'));
+  return result.loaded ? result.data : null;
+}
+
+/**
+ * Load the global domain (coding standards, bracket rules).
+ * @param {string} domainsDir - Path to chati.dev/domains/
+ * @returns {object|null}
+ */
+export function loadGlobalDomain(domainsDir) {
+  const result = loadDomainFile(join(domainsDir, 'global.yaml'));
+  return result.loaded ? result.data : null;
+}
+
+/**
+ * Extract rules array from a domain object.
+ * Domain files have a `rules` key with an array of rule objects.
+ * @param {object} domain - Parsed domain object
+ * @returns {Array<{ id: string, text: string, priority: string }>}
+ */
+export function extractRules(domain) {
+  if (!domain || !Array.isArray(domain.rules)) return [];
+  return domain.rules.map(r => ({
+    id: r.id || 'unknown',
+    text: r.text || r.rule || '',
+    priority: r.priority || 'normal',
+  }));
+}

package/src/context/engine.js

@@ -0,0 +1,144 @@
+/**
+ * PRISM Context Engine — 5-layer context injection pipeline.
+ *
+ * Orchestrates L0-L4 layers, respects bracket constraints,
+ * and produces formatted XML context for agent prompts.
+ *
+ * Pipeline: bracket calculation → layer processing → formatting → output
+ */
+
+import { calculateBracket, isLayerActive } from './bracket-tracker.js';
+import { processL0 } from './layers/l0-constitution.js';
+import { processL1 } from './layers/l1-global.js';
+import { processL2 } from './layers/l2-agent.js';
+import { processL3 } from './layers/l3-workflow.js';
+import { processL4 } from './layers/l4-task.js';
+import { formatContext } from './formatter.js';
+
+const LAYER_TIMEOUT_MS = 100;
+
+/**
+ * Run the PRISM context engine pipeline.
+ *
+ * @param {object} input
+ * @param {string} input.domainsDir - Path to chati.dev/domains/
+ * @param {number} input.remainingPercent - Context window remaining (0-100)
+ * @param {string} [input.mode] - Current mode (clarity, build, deploy)
+ * @param {string} [input.agent] - Active agent name
+ * @param {string} [input.workflow] - Active workflow name
+ * @param {string} [input.pipelinePosition] - Current pipeline step
+ * @param {string} [input.taskId] - Active task ID
+ * @param {object} [input.handoff] - Handoff data from previous agent
+ * @param {string[]} [input.artifacts] - Relevant artifact paths
+ * @param {string[]} [input.taskCriteria] - Active task criteria
+ * @returns {{ xml: string, bracket: object, layers: object[], errors: string[] }}
+ */
+export function runPrism(input) {
+  const errors = [];
+  const layers = [];
+
+  // 1. Calculate bracket
+  const bracket = calculateBracket(input.remainingPercent);
+
+  // 2. Build context for layer processors
+  const ctx = {
+    domainsDir: input.domainsDir,
+    mode: input.mode || 'clarity',
+    bracket: bracket.bracket,
+    agent: input.agent || null,
+    workflow: input.workflow || null,
+    pipelinePosition: input.pipelinePosition || null,
+    taskId: input.taskId || null,
+    handoff: input.handoff || {},
+    artifacts: input.artifacts || [],
+    taskCriteria: input.taskCriteria || [],
+  };
+
+  // 3. Process each active layer with timeout protection
+  const layerResults = {};
+
+  // L0 — Always active
+  const l0 = safeProcess('L0', () => processL0(ctx), errors);
+  if (l0) { layers.push(l0); layerResults.l0 = l0; }
+
+  // L1 — Always active
+  if (isLayerActive(bracket.bracket, 'L1')) {
+    const l1 = safeProcess('L1', () => processL1(ctx), errors);
+    if (l1) { layers.push(l1); layerResults.l1 = l1; }
+  }
+
+  // L2 — Agent layer
+  if (isLayerActive(bracket.bracket, 'L2') && ctx.agent) {
+    const l2 = safeProcess('L2', () => processL2(ctx), errors);
+    if (l2) { layers.push(l2); layerResults.l2 = l2; }
+  }
+
+  // L3 — Workflow/Pipeline layer
+  if (isLayerActive(bracket.bracket, 'L3') && ctx.workflow) {
+    const l3 = safeProcess('L3', () => processL3(ctx), errors);
+    if (l3) { layers.push(l3); layerResults.l3 = l3; }
+  }
+
+  // L4 — Task layer
+  if (isLayerActive(bracket.bracket, 'L4') && ctx.taskId) {
+    const l4 = safeProcess('L4', () => processL4(ctx), errors);
+    if (l4) { layers.push(l4); layerResults.l4 = l4; }
+  }
+
+  // 4. Format output
+  const xml = formatContext({
+    bracket: bracket.bracket,
+    tokenBudget: bracket.tokenBudget,
+    ...layerResults,
+  });
+
+  return {
+    xml,
+    bracket,
+    layers,
+    errors,
+    layerCount: layers.length,
+  };
+}
+
+/**
+ * Run a layer processor with error protection.
+ * If the processor throws, capture the error and return null (graceful degradation).
+ */
+function safeProcess(layerName, processFn, errors) {
+  try {
+    const start = Date.now();
+    const result = processFn();
+    const elapsed = Date.now() - start;
+
+    if (elapsed > LAYER_TIMEOUT_MS) {
+      errors.push(`${layerName} exceeded timeout (${elapsed}ms > ${LAYER_TIMEOUT_MS}ms)`);
+    }
+
+    return result;
+  } catch (err) {
+    errors.push(`${layerName} failed: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Get a summary of PRISM capabilities for display.
+ * @returns {{ layers: number, brackets: string[], features: string[] }}
+ */
+export function getPrismInfo() {
+  return {
+    name: 'PRISM',
+    version: '1.0.0',
+    layers: 5,
+    layerNames: ['L0 Constitution', 'L1 Global', 'L2 Agent', 'L3 Workflow', 'L4 Task'],
+    brackets: ['FRESH', 'MODERATE', 'DEPLETED', 'CRITICAL'],
+    features: [
+      'Priority-based context truncation',
+      'Per-layer timeout protection',
+      'Graceful degradation on layer failure',
+      'XML structured output',
+      'Bracket-aware layer activation',
+    ],
+  };
+}