chati-dev 3.2.0 → 3.2.1

package/framework/config.yaml

@@ -1,8 +1,8 @@
 # chati.dev Configuration
-version: "3.2.0"
+version: "3.2.1"
 installed_at: "2026-02-07T10:00:00Z"
-updated_at: "2026-02-19T00:00:00Z"
-installer_version: "3.2.0"
+updated_at: "2026-02-20T00:00:00Z"
+installer_version: "3.2.1"
 project_type: greenfield
 language: en
 ides: [claude-code]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "AI-Powered Multi-Agent Orchestration System — Structured vibe coding for Full Stack Development",
   "type": "module",
   "bin": {

package/src/config/context-file-generator.js

@@ -29,11 +29,12 @@ const GEMINI_REPLACEMENTS = [
   ['CLAUDE.md', 'GEMINI.md'],
   ['Claude.md', 'GEMINI.md'],
   ['.claude/commands/', '.gemini/commands/'],
-  ['.claude/rules/', 'chati.dev/context/'],
+  ['.claude/rules/chati/', '.gemini/context/'],
+  ['.claude/rules/', '.gemini/context/'],
   ['.claude/mcp.json', '.gemini/settings.json'],
   ['claude --print', 'gemini --prompt'],
   ['claude -p', 'gemini --prompt'],
-  ['CLAUDE.local.md', 'GEMINI.local.md'],
+  ['CLAUDE.local.md', '.gemini/session-lock.md'],
 ];
 
 /**
@@ -56,22 +57,37 @@ const CODEX_REPLACEMENTS = [
   ['CLAUDE.md', 'AGENTS.md'],
   ['Claude.md', 'AGENTS.md'],
   ['.claude/commands/', 'chati.dev/orchestrator/'],
+  ['.claude/rules/chati/', 'chati.dev/context/'],
   ['.claude/rules/', 'chati.dev/context/'],
   ['.claude/mcp.json', '.codex/config.toml'],
   ['claude --print', 'codex exec'],
   ['claude -p', 'codex exec'],
-  ['CLAUDE.local.md', 'AGENTS.local.md'],
+  ['CLAUDE.local.md', 'AGENTS.override.md'],
 ];
 
 // ---------------------------------------------------------------------------
 // Generators
 // ---------------------------------------------------------------------------
 
+/**
+ * @import directives appended to GEMINI.md.
+ * Gemini CLI resolves @import automatically, loading the full governance
+ * context chain + session lock — equivalent to Claude Code's rules/ + CLAUDE.local.md.
+ */
+const GEMINI_IMPORTS = [
+  '@import .gemini/context/root.md',
+  '@import .gemini/context/governance.md',
+  '@import .gemini/context/protocols.md',
+  '@import .gemini/context/quality.md',
+  '@import .gemini/session-lock.md',
+];
+
 /**
  * Generate GEMINI.md content from CLAUDE.md content.
  *
  * Adapts the content by replacing Claude Code-specific references with
- * Gemini CLI equivalents. Preserves structure and formatting.
+ * Gemini CLI equivalents, then appends @import directives so Gemini CLI
+ * auto-loads governance rules and session lock (context parity with Claude).
  *
  * @param {string} content - Raw CLAUDE.md content
  * @returns {string} Adapted content for GEMINI.md
@@ -89,7 +105,10 @@ export function generateGeminiMd(content) {
     '',
   ].join('\n');
 
-  return header + result;
+  // Append @import directives for context parity
+  const imports = '\n' + GEMINI_IMPORTS.join('\n') + '\n';
+
+  return header + result + imports;
 }
 
 /**
@@ -97,12 +116,14 @@ export function generateGeminiMd(content) {
  *
  * Simplifies the content for Codex CLI: strips hook references,
  * replaces CLI-specific paths, and produces a leaner context file
- * focused on code execution.
+ * focused on code execution. When contextFiles are provided, inlines
+ * governance/protocols/quality for full context parity with Claude Code.
  *
  * @param {string} content - Raw CLAUDE.md content
+ * @param {object} [contextFiles] - Optional inline context { root, governance, protocols, quality }
  * @returns {string} Adapted content for AGENTS.md
  */
-export function generateAgentsMd(content) {
+export function generateAgentsMd(content, contextFiles = null) {
   let result = content;
 
   // Strip hook-related sections (Codex has no hooks support)
@@ -124,13 +145,39 @@ export function generateAgentsMd(content) {
     '',
   ].join('\n');
 
-  return header + result;
+  result = header + result;
+
+  // Inline context files for full governance parity (Codex has no @import)
+  if (contextFiles) {
+    const sections = [];
+    for (const [name, fileContent] of Object.entries(contextFiles)) {
+      if (fileContent) {
+        // Adapt context for Codex (replace Claude-specific refs)
+        let adapted = fileContent;
+        for (const [search, replace] of CODEX_REPLACEMENTS) {
+          adapted = adapted.replaceAll(search, replace);
+        }
+        sections.push(adapted.trim());
+      }
+    }
+    if (sections.length > 0) {
+      result += '\n---\n\n' + sections.join('\n\n---\n\n') + '\n';
+    }
+  }
+
+  return result;
 }
 
 // ---------------------------------------------------------------------------
 // Orchestrator
 // ---------------------------------------------------------------------------
 
+/**
+ * Context file names that provide governance parity across CLIs.
+ * These are read from chati.dev/context/ and inlined into AGENTS.md for Codex.
+ */
+const CONTEXT_FILES = ['root.md', 'governance.md', 'protocols.md', 'quality.md'];
+
 /**
  * Generate context files for all enabled alternative providers.
  *
@@ -138,6 +185,8 @@ export function generateAgentsMd(content) {
  * CLAUDE.md from the project root, and writes the appropriate context
  * files (GEMINI.md, AGENTS.md) when their providers are active.
  *
+ * For Codex, governance context files are inlined into AGENTS.md to provide
+ * the same rules awareness that Claude gets from .claude/rules/chati/.
  *
  * @param {string} projectDir - Project root directory
  * @param {string} [baseContent] - Optional base content (used when CLAUDE.md doesn't exist on disk)
@@ -160,15 +209,18 @@ export function generateContextFiles(projectDir, baseContent = null) {
   // Determine enabled providers from config.yaml
   const enabledProviders = resolveEnabledProviders(projectDir);
 
+  // Read context files for inline injection (Codex)
+  const contextFiles = readContextFilesFromDisk(projectDir);
+
   // Provider-to-generator mapping
   const generators = {
     gemini: {
       filename: 'GEMINI.md',
-      generate: generateGeminiMd,
+      generate: (content) => generateGeminiMd(content),
     },
     codex: {
       filename: 'AGENTS.md',
-      generate: generateAgentsMd,
+      generate: (content) => generateAgentsMd(content, contextFiles),
     },
   };
 
@@ -186,6 +238,30 @@ export function generateContextFiles(projectDir, baseContent = null) {
   return result;
 }
 
+/**
+ * Read context files from chati.dev/context/ for inline injection.
+ * Returns null if no context files found (backward compat).
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {object|null} { root, governance, protocols, quality } or null
+ */
+function readContextFilesFromDisk(projectDir) {
+  const contextDir = join(projectDir, 'chati.dev', 'context');
+  if (!existsSync(contextDir)) return null;
+
+  const files = {};
+  let found = false;
+  for (const file of CONTEXT_FILES) {
+    const filePath = join(contextDir, file);
+    if (existsSync(filePath)) {
+      const key = file.replace('.md', '');
+      files[key] = readFileSync(filePath, 'utf-8');
+      found = true;
+    }
+  }
+  return found ? files : null;
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/config/framework-adapter.js

@@ -50,12 +50,12 @@ const PROVIDER_META = {
   gemini: {
     cliName: 'Gemini CLI',
     contextFile: 'GEMINI.md',
-    localFile: '.chati/session.yaml',
+    localFile: '.gemini/session-lock.md',
   },
   codex: {
     cliName: 'Codex CLI',
     contextFile: 'AGENTS.md',
-    localFile: '.chati/session.yaml',
+    localFile: 'AGENTS.override.md',
   },
 };
 

package/src/config/gemini-hooks-generator.js

@@ -0,0 +1,494 @@
+/**
+ * @fileoverview Gemini CLI hooks generator.
+ *
+ * Generates thin wrapper hooks for Gemini CLI that import shared logic
+ * from chati.dev/hooks/. Each hook translates between Gemini CLI event
+ * format and the existing hook logic, providing governance parity with
+ * Claude Code.
+ *
+ * Constitution Article XIX — hooks are generated at install time, zero runtime overhead.
+ *
+ * Gemini CLI Hook Events (used by chati.dev):
+ * - BeforeModel: runs before model inference (PRISM injection, model advisory)
+ * - BeforeTool: runs before tool execution (mode governance, constitution guard, read protection)
+ * - PreCompress: runs before context compression (session digest)
+ */
+
+// ---------------------------------------------------------------------------
+// Hook Map — Claude Hook → Gemini Event
+// ---------------------------------------------------------------------------
+
+/**
+ * Maps each chati.dev hook to its Gemini CLI equivalent event.
+ */
+export const HOOK_MAP = {
+  'prism-engine': { event: 'BeforeModel', description: 'Inject PRISM context into model prompt' },
+  'model-governance': { event: 'BeforeModel', description: 'Advisory: recommended model per agent' },
+  'mode-governance': { event: 'BeforeTool', description: 'Block writes outside current mode scope' },
+  'constitution-guard': { event: 'BeforeTool', description: 'Block destructive commands and secret writes' },
+  'read-protection': { event: 'BeforeTool', description: 'Block reads of sensitive files' },
+  'session-digest': { event: 'PreCompress', description: 'Save session state before context compression' },
+};
+
+// ---------------------------------------------------------------------------
+// Hook Templates
+// ---------------------------------------------------------------------------
+
+/**
+ * Shared header for all generated hooks.
+ */
+const HOOK_HEADER = `#!/usr/bin/env node
+/**
+ * Auto-generated by chati.dev — Gemini CLI hook wrapper.
+ * Imports shared logic from chati.dev/hooks/ for governance parity.
+ * Do not edit manually — regenerate with \`npx chati-dev init\`.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = join(__filename, '..');
+const projectRoot = join(__dirname, '..', '..');
+`;
+
+/**
+ * Generate the PRISM engine hook for Gemini CLI.
+ * BeforeModel event — injects PRISM context XML into the model prompt.
+ */
+function generatePrismEngine() {
+  return `${HOOK_HEADER}
+/**
+ * PRISM Engine — BeforeModel
+ * Reads session state and injects PRISM context block.
+ */
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  try {
+    const event = JSON.parse(input);
+    const cwd = event.cwd || process.cwd();
+
+    const sessionPath = join(cwd, '.chati', 'session.yaml');
+    if (!existsSync(sessionPath)) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    // Delegate to shared PRISM engine logic
+    const hookPath = join(cwd, 'chati.dev', 'hooks', 'prism-engine.js');
+    if (existsSync(hookPath)) {
+      const mod = await import(hookPath);
+      if (typeof mod.buildPrismContext === 'function') {
+        const context = await mod.buildPrismContext(cwd);
+        if (context) {
+          console.log(JSON.stringify({ additionalContext: context }));
+          return;
+        }
+      }
+    }
+
+    console.log(JSON.stringify({}));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+
+main();
+`;
+}
+
+/**
+ * Generate the model governance hook for Gemini CLI.
+ * BeforeModel event — advisory about recommended model per agent.
+ */
+function generateModelGovernance() {
+  return `${HOOK_HEADER}
+/**
+ * Model Governance — BeforeModel
+ * Advisory: logs recommended model for current agent.
+ */
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  try {
+    const event = JSON.parse(input);
+    const cwd = event.cwd || process.cwd();
+
+    const sessionPath = join(cwd, '.chati', 'session.yaml');
+    if (!existsSync(sessionPath)) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    // Read current agent from session
+    const raw = readFileSync(sessionPath, 'utf-8');
+    const agentMatch = raw.match(/^\\s*current_agent:\\s*(.+)$/m);
+    const agent = agentMatch ? agentMatch[1].trim().replace(/^["']|["']$/g, '') : null;
+
+    if (agent) {
+      // Delegate to shared model governance logic
+      const hookPath = join(cwd, 'chati.dev', 'hooks', 'model-governance.js');
+      if (existsSync(hookPath)) {
+        const mod = await import(hookPath);
+        if (typeof mod.getRecommendedModel === 'function') {
+          const recommendation = mod.getRecommendedModel(cwd, agent);
+          if (recommendation) {
+            console.log(JSON.stringify({ advisory: \`Recommended model: \${recommendation}\` }));
+            return;
+          }
+        }
+      }
+    }
+
+    console.log(JSON.stringify({}));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+
+main();
+`;
+}
+
+/**
+ * Generate the mode governance hook for Gemini CLI.
+ * BeforeTool event — blocks writes outside the scope of current governance mode.
+ */
+function generateModeGovernance() {
+  return `${HOOK_HEADER}
+/**
+ * Mode Governance — BeforeTool
+ * Blocks write operations outside current mode scope.
+ * Constitution Article XI enforcement.
+ */
+const MODE_SCOPES = {
+  planning: { allowed: ['chati.dev/', '.chati/', 'chati.dev/artifacts/'] },
+  build: { allowed: ['*'] },
+  deploy: { allowed: ['*'] },
+};
+
+const STATE_TO_MODE = {
+  discover: 'planning', plan: 'planning', planning: 'planning',
+  build: 'build', validate: 'build',
+  deploy: 'deploy', completed: 'deploy',
+};
+
+function getCurrentMode(cwd) {
+  const sessionPath = join(cwd, '.chati', 'session.yaml');
+  if (!existsSync(sessionPath)) return 'planning';
+  const raw = readFileSync(sessionPath, 'utf-8');
+  const match = raw.match(/^\\s*state:\\s*(.+)$/m);
+  const state = match ? match[1].trim().replace(/^["']|["']$/g, '') : 'discover';
+  return STATE_TO_MODE[state] || 'planning';
+}
+
+function isPathAllowed(filePath, cwd, mode) {
+  const scope = MODE_SCOPES[mode];
+  if (!scope) return false;
+  if (scope.allowed.includes('*')) return true;
+
+  // Normalize to relative path
+  const rel = filePath.startsWith('/') ? filePath.slice(cwd.length + 1) : filePath;
+
+  // Check path escape
+  if (rel.startsWith('..') || rel.startsWith('/')) return false;
+
+  return scope.allowed.some(prefix => rel.startsWith(prefix));
+}
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  try {
+    const event = JSON.parse(input);
+    const cwd = event.cwd || process.cwd();
+    const toolName = event.tool_name || '';
+    const toolInput = event.tool_input || {};
+
+    // Only intercept write/edit operations
+    if (!['WriteFile', 'EditFile', 'Write', 'Edit'].includes(toolName)) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const filePath = toolInput.path || toolInput.file_path || '';
+    if (!filePath) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const mode = getCurrentMode(cwd);
+    if (isPathAllowed(filePath, cwd, mode)) {
+      console.log(JSON.stringify({}));
+    } else {
+      console.log(JSON.stringify({
+        error: \`[Article XI] Cannot write "\${filePath}" in \${mode} mode. Allowed: \${MODE_SCOPES[mode].allowed.join(', ')}\`
+      }));
+    }
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+
+main();
+`;
+}
+
+/**
+ * Generate the constitution guard hook for Gemini CLI.
+ * BeforeTool event — blocks destructive commands and secret writes.
+ */
+function generateConstitutionGuard() {
+  return `${HOOK_HEADER}
+/**
+ * Constitution Guard — BeforeTool
+ * Blocks destructive commands and secret writes.
+ * Constitution Article XI enforcement.
+ */
+
+const DESTRUCTIVE_PATTERNS = [
+  /rm\\s+-rf\\s+\\//,
+  /git\\s+reset\\s+--hard/,
+  /git\\s+push\\s+--force/,
+  /git\\s+push\\s+-f/,
+  /git\\s+clean\\s+-fd/,
+  /DROP\\s+TABLE/i,
+  /DROP\\s+DATABASE/i,
+  /TRUNCATE\\s+TABLE/i,
+  /chmod\\s+777/,
+];
+
+const SECRET_PATTERNS = [
+  /API_KEY\\s*=/,
+  /SECRET_KEY\\s*=/,
+  /PASSWORD\\s*=/,
+  /PRIVATE_KEY\\s*=/,
+  /aws_secret_access_key/i,
+  /-----BEGIN.*PRIVATE KEY-----/,
+];
+
+const PROTECTED_WRITE_FILES = ['.env', '.env.local', '.env.production', 'credentials.json', 'service-account.json'];
+const SAFE_PATTERNS = ['.env.example', '.env.template', '.env.sample'];
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  try {
+    const event = JSON.parse(input);
+    const toolName = event.tool_name || '';
+    const toolInput = event.tool_input || {};
+
+    // Check Bash commands for destructive patterns
+    if (['Bash', 'RunCommand'].includes(toolName)) {
+      const cmd = toolInput.command || '';
+      for (const pattern of DESTRUCTIVE_PATTERNS) {
+        if (pattern.test(cmd)) {
+          console.log(JSON.stringify({
+            error: \`[Constitution Guard] Blocked destructive command: \${cmd.slice(0, 80)}\`
+          }));
+          return;
+        }
+      }
+    }
+
+    // Check Write/Edit for secret patterns and protected files
+    if (['WriteFile', 'EditFile', 'Write', 'Edit'].includes(toolName)) {
+      const filePath = toolInput.path || toolInput.file_path || '';
+      const content = toolInput.content || toolInput.new_string || '';
+
+      // Check if writing to a protected file
+      if (PROTECTED_WRITE_FILES.some(p => filePath.endsWith(p)) &&
+          !SAFE_PATTERNS.some(s => filePath.endsWith(s))) {
+        console.log(JSON.stringify({
+          error: \`[Constitution Guard] Cannot write to protected file: \${filePath}\`
+        }));
+        return;
+      }
+
+      // Check content for secret patterns
+      for (const pattern of SECRET_PATTERNS) {
+        if (pattern.test(content)) {
+          console.log(JSON.stringify({
+            error: '[Constitution Guard] Blocked write containing secrets/credentials'
+          }));
+          return;
+        }
+      }
+    }
+
+    console.log(JSON.stringify({}));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+
+main();
+`;
+}
+
+/**
+ * Generate the read protection hook for Gemini CLI.
+ * BeforeTool event — blocks reads of sensitive files.
+ */
+function generateReadProtection() {
+  return `${HOOK_HEADER}
+/**
+ * Read Protection — BeforeTool
+ * Blocks reading sensitive files (.env, .pem, credentials).
+ * Constitution Article XI enforcement.
+ */
+
+const PROTECTED_FILES = ['.env', '.env.local', '.env.production', '.env.staging'];
+const PROTECTED_EXTENSIONS = ['.pem', '.key', '.p12', '.pfx', '.jks'];
+const PROTECTED_PATHS = ['credentials.json', 'service-account.json', '.git/config', '.aws/credentials', '.npmrc'];
+const SAFE_FILES = ['.env.example', '.env.template', '.env.sample'];
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  try {
+    const event = JSON.parse(input);
+    const toolName = event.tool_name || '';
+    const toolInput = event.tool_input || {};
+
+    // Only intercept read operations
+    if (!['ReadFile', 'Read'].includes(toolName)) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const filePath = toolInput.path || toolInput.file_path || '';
+    if (!filePath) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    // Allow safe patterns first
+    if (SAFE_FILES.some(s => filePath.endsWith(s))) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    // Block protected files
+    if (PROTECTED_FILES.some(p => filePath.endsWith(p))) {
+      console.log(JSON.stringify({
+        error: \`[Read Protection] Cannot read protected file: \${filePath}\`
+      }));
+      return;
+    }
+
+    // Block protected extensions
+    if (PROTECTED_EXTENSIONS.some(ext => filePath.endsWith(ext))) {
+      console.log(JSON.stringify({
+        error: \`[Read Protection] Cannot read sensitive file type: \${filePath}\`
+      }));
+      return;
+    }
+
+    // Block protected paths
+    if (PROTECTED_PATHS.some(p => filePath.includes(p))) {
+      console.log(JSON.stringify({
+        error: \`[Read Protection] Cannot read protected path: \${filePath}\`
+      }));
+      return;
+    }
+
+    console.log(JSON.stringify({}));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+
+main();
+`;
+}
+
+/**
+ * Generate the session digest hook for Gemini CLI.
+ * PreCompress event — saves session state before context compression.
+ */
+function generateSessionDigest() {
+  return `${HOOK_HEADER}
+/**
+ * Session Digest — PreCompress
+ * Saves session state before context compression.
+ */
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  try {
+    const event = JSON.parse(input);
+    const cwd = event.cwd || process.cwd();
+
+    // Delegate to shared session digest logic
+    const hookPath = join(cwd, 'chati.dev', 'hooks', 'session-digest.js');
+    if (existsSync(hookPath)) {
+      const mod = await import(hookPath);
+      if (typeof mod.saveDigest === 'function') {
+        await mod.saveDigest(cwd);
+      }
+    }
+
+    console.log(JSON.stringify({}));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+
+main();
+`;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate all 6 Gemini CLI hook files.
+ *
+ * @returns {Record<string, string>} Map of filename → file content
+ */
+export function generateAllGeminiHooks() {
+  return {
+    'prism-engine.js': generatePrismEngine(),
+    'model-governance.js': generateModelGovernance(),
+    'mode-governance.js': generateModeGovernance(),
+    'constitution-guard.js': generateConstitutionGuard(),
+    'read-protection.js': generateReadProtection(),
+    'session-digest.js': generateSessionDigest(),
+  };
+}
+
+/**
+ * Generate .gemini/settings.json content with hook configuration.
+ *
+ * @returns {string} JSON string for .gemini/settings.json
+ */
+export function generateGeminiSettings() {
+  const hooks = Object.entries(HOOK_MAP).map(([name, config]) => ({
+    path: `.gemini/hooks/${name}.js`,
+    event: config.event,
+  }));
+
+  return JSON.stringify({ hooks }, null, 2) + '\n';
+}

package/src/config/ide-configs.js

@@ -47,15 +47,19 @@ export const IDE_CONFIGS = {
     rulesFile: 'AGENTS.md',
     mcpConfigFile: null,
     formatNotes: 'Codex skill format (SKILL.md with YAML frontmatter)',
+    rulesPath: '.codex/rules/',
+    overrideFile: 'AGENTS.override.md',
   },
   'gemini-cli': {
     name: 'Gemini CLI',
     description: 'Google AI terminal agent',
     recommended: false,
     configPath: '.gemini/commands/',
-    rulesFile: null,
+    rulesFile: 'GEMINI.md',
     mcpConfigFile: '.gemini/settings.json',
     formatNotes: 'TOML command format',
+    contextPath: '.gemini/context/',
+    hooksPath: '.gemini/hooks/',
   },
 };
 

package/src/installer/core.js

@@ -3,7 +3,7 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { IDE_CONFIGS } from '../config/ide-configs.js';
 import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
-import { generateSessionYaml, generateConfigYaml, generateClaudeMd, generateClaudeLocalMd, generateCodexSkill, generateGeminiRouter } from './templates.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 { verifyManifest } from './manifest.js';
@@ -128,6 +128,9 @@ export async function installFramework(config) {
   if (hasNonClaude) {
     generateContextFiles(targetDir, baseContent);
   }
+
+  // 7. Update .gitignore with runtime session lock files
+  updateGitignore(targetDir, selectedIDEs);
 }
 
 /**
@@ -314,9 +317,42 @@ Pass through all context: session state, handoffs, artifacts, and user input.
     // 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');
+
+    // Session lock override file (equivalent to CLAUDE.local.md)
+    writeFileSync(join(targetDir, 'AGENTS.override.md'), generateAgentsOverrideMd(), 'utf-8');
+
+    // Starlark execution policies (equivalent to Claude hooks for constitution guard + read protection)
+    createDir(join(targetDir, '.codex', 'rules'));
+    writeFileSync(join(targetDir, '.codex', 'rules', 'constitution-guard.rules'), generateCodexConstitutionGuardRules(), 'utf-8');
+    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');
+
+    // Context files via @import (equivalent to .claude/rules/chati/)
+    const geminiContextDir = join(targetDir, '.gemini', 'context');
+    createDir(geminiContextDir);
+    const contextFileNames = ['root.md', 'governance.md', 'protocols.md', 'quality.md'];
+    for (const file of contextFileNames) {
+      const src = join(FRAMEWORK_SOURCE, 'context', file);
+      if (existsSync(src)) {
+        const content = readFileSync(src, 'utf-8');
+        writeFileSync(join(geminiContextDir, file), adaptFrameworkFile(content, `context/${file}`, 'gemini'), 'utf-8');
+      }
+    }
+
+    // Session lock (equivalent to CLAUDE.local.md, imported via @import in GEMINI.md)
+    writeFileSync(join(targetDir, '.gemini', 'session-lock.md'), generateGeminiSessionLock(), 'utf-8');
+
+    // Hooks (6 governance hooks — equivalent to Claude Code hooks)
+    const geminiHooksDir = join(targetDir, '.gemini', 'hooks');
+    createDir(geminiHooksDir);
+    const { generateAllGeminiHooks, generateGeminiSettings } = await import('../config/gemini-hooks-generator.js');
+    const hooks = generateAllGeminiHooks();
+    for (const [filename, hookContent] of Object.entries(hooks)) {
+      writeFileSync(join(geminiHooksDir, filename), hookContent, 'utf-8');
+    }
+    writeFileSync(join(targetDir, '.gemini', 'settings.json'), generateGeminiSettings(), 'utf-8');
   } else {
     // VS Code, Cursor, AntiGravity — generic rules file
     if (config.rulesFile) {
@@ -364,6 +400,42 @@ DEPLOY:   DevOps
 `;
 }
 
+/**
+ * Append chati.dev runtime entries to .gitignore.
+ * Session lock files are runtime-only and should never be committed.
+ */
+function updateGitignore(targetDir, selectedIDEs) {
+  const entries = [
+    '',
+    '# Chati.dev runtime files (session lock — not committed)',
+    '.chati/memories/*/session/',
+  ];
+
+  if (selectedIDEs.includes('claude-code')) {
+    entries.push('CLAUDE.local.md');
+  }
+  if (selectedIDEs.includes('gemini-cli')) {
+    entries.push('.gemini/session-lock.md');
+  }
+  if (selectedIDEs.includes('codex-cli')) {
+    entries.push('AGENTS.override.md');
+  }
+
+  entries.push('');
+
+  const gitignorePath = join(targetDir, '.gitignore');
+  const marker = '# Chati.dev runtime files';
+
+  if (existsSync(gitignorePath)) {
+    const existing = readFileSync(gitignorePath, 'utf-8');
+    // Don't duplicate if already present
+    if (existing.includes(marker)) return;
+    writeFileSync(gitignorePath, existing.trimEnd() + '\n' + entries.join('\n'), 'utf-8');
+  } else {
+    writeFileSync(gitignorePath, entries.join('\n'), 'utf-8');
+  }
+}
+
 /**
  * Recursively create directory if it doesn't exist
  */

package/src/installer/templates.js

@@ -243,3 +243,148 @@ _No decisions yet. Start with /chati._
 _Auto-updated by Chati.dev orchestrator_
 `;
 }
+
+/**
+ * Generate Gemini CLI session lock (.gemini/session-lock.md)
+ * Equivalent to CLAUDE.local.md — imported via @import in GEMINI.md.
+ */
+export function generateGeminiSessionLock() {
+  return `# Chati.dev Runtime State
+
+## Session Lock
+**Status: INACTIVE** — Type \`/chati\` to activate.
+
+<!-- SESSION-LOCK:INACTIVE -->
+
+## Current State
+- **Agent**: None (ready to start)
+- **Pipeline**: Pre-start
+- **Mode**: interactive
+
+## Recent Decisions
+_No decisions yet. Start with /chati._
+
+---
+_Auto-updated by Chati.dev orchestrator_
+`;
+}
+
+/**
+ * Generate Codex CLI session lock (AGENTS.override.md)
+ * Codex auto-loads this as an override to AGENTS.md.
+ */
+export function generateAgentsOverrideMd() {
+  return `# Chati.dev Runtime State
+
+## Session Lock
+**Status: INACTIVE** — Type \`$chati\` to activate.
+
+<!-- SESSION-LOCK:INACTIVE -->
+
+## Current State
+- **Agent**: None (ready to start)
+- **Pipeline**: Pre-start
+- **Mode**: interactive
+
+## Recent Decisions
+_No decisions yet. Start with $chati._
+
+---
+_Auto-updated by Chati.dev orchestrator_
+`;
+}
+
+/**
+ * Generate Codex CLI constitution guard rules (.codex/rules/constitution-guard.rules)
+ * Starlark execution policy that blocks destructive commands and secret writes.
+ */
+export function generateCodexConstitutionGuardRules() {
+  return `# Chati.dev Constitution Guard — Codex CLI Execution Policy
+# Article XI: Block destructive commands and secret writes
+
+# Destructive commands that require explicit user approval
+deny_commands = [
+    "rm -rf",
+    "git reset --hard",
+    "git push --force",
+    "git push -f",
+    "git clean -fd",
+    "DROP TABLE",
+    "DROP DATABASE",
+    "TRUNCATE TABLE",
+    "chmod 777",
+]
+
+# Patterns that indicate secret/credential writes
+deny_write_patterns = [
+    "API_KEY=",
+    "SECRET_KEY=",
+    "PASSWORD=",
+    "TOKEN=",
+    "PRIVATE_KEY=",
+    "aws_secret_access_key",
+    "-----BEGIN RSA PRIVATE KEY-----",
+    "-----BEGIN OPENSSH PRIVATE KEY-----",
+]
+
+# Files that should never be written to
+deny_write_files = [
+    ".env",
+    ".env.local",
+    ".env.production",
+    "credentials.json",
+    "service-account.json",
+]
+
+# Allow list — these are safe even though they match patterns
+allow_write_files = [
+    ".env.example",
+    ".env.template",
+    ".env.sample",
+]
+`;
+}
+
+/**
+ * Generate Codex CLI read protection rules (.codex/rules/read-protection.rules)
+ * Starlark execution policy that blocks reading sensitive files.
+ */
+export function generateCodexReadProtectionRules() {
+  return `# Chati.dev Read Protection — Codex CLI Execution Policy
+# Article XI: Protect sensitive files from being read
+
+# Files that should never be read
+deny_read_files = [
+    ".env",
+    ".env.local",
+    ".env.production",
+    ".env.staging",
+]
+
+# File extensions that indicate sensitive content
+deny_read_extensions = [
+    ".pem",
+    ".key",
+    ".p12",
+    ".pfx",
+    ".jks",
+]
+
+# Paths that should never be read
+deny_read_paths = [
+    "credentials.json",
+    "service-account.json",
+    ".git/config",
+    ".ssh/",
+    ".aws/credentials",
+    ".npmrc",
+]
+
+# Allow list — these are safe even though they match patterns
+allow_read_files = [
+    ".env.example",
+    ".env.template",
+    ".env.sample",
+]
+`;
+}

package/src/terminal/cli-registry.js

@@ -51,7 +51,7 @@ const PROVIDERS = {
     baseArgs: [],
     modelFlag: '--model',
     stdinSupport: true,
-    hooksSupport: false,
+    hooksSupport: true,
     mcpSupport: true,
     contextFile: 'GEMINI.md',
     modelMap: {