chati-dev 4.5.13 → 4.5.15

package/framework/orchestrator/chati.md

@@ -38,13 +38,13 @@ After EVERY agent completes and the user approves:
 
 ## On Activation
 
-When the user invokes `/chati`, execute this sequence:
+When the user invokes the provider-native Chati entry point, execute this sequence:
 
 ### Step 1: Load Context
 
 ```
 1. Read .chati/session.yaml (session state)
-2. Read CLAUDE.md (project context)
+2. Read .chati/project-context.md (provider-neutral project context)
 3. Read chati.dev/constitution.md (if first run or FRESH bracket - governance rules)
 4. Read chati.dev/config.yaml (version info, provider overrides)
 5. Detect language from session.yaml → respond in that language
@@ -275,7 +275,7 @@ only what executes it, and it is invisible when the feature is off.
 
 ## Action: Autonomous Agent
 
-These agents run in separate Claude Code processes.
+These agents run in separate processes using the exact provider and model binding returned by the router.
 
 1. Track context bracket internally - do NOT display it.
 2. Check `handoff_status.valid` from JSON:
@@ -309,10 +309,9 @@ If terminal spawning fails (CLI not found, system error), fall back **silently**
 6. Continue pipeline normally — the user should not notice any difference
 ```
 
-**NOTE:** A PostToolUse hook (`advance-trigger.js`) ALSO fires on handoff write,
-but ONLY when `execution_mode: autonomous` (Article XVII). In `interactive`
-(default), the hook is silent except on QA failure, and Claude's explicit
-advance call is the sole forward trigger.
+**NOTE:** A provider-native post-tool hook may also fire on handoff write when
+supported. In interactive mode, the explicit router advance call remains the
+portable source of truth.
 
 If the advance response contains `"already_advanced": true`, the hook or a
 prior call already committed the transition — proceed silently using the
@@ -350,7 +349,7 @@ Planning phase agents (detail, architect, ux) run simultaneously.
 
 ## Action: Spawn Team (Article XXI)
 
-Agent Teams enable real-time peer communication between agents. The orchestrator acts as Team Lead, spawning teammates as native Claude Code sub-agents (Agent tool), and coordinating their work through a shared task list and filesystem-based mailbox.
+Agent Teams enable peer communication through a shared task list and filesystem mailbox. A harness profile may use native sub-agents when available; otherwise the same team contract runs through Chati's provider-neutral parallel process runner.
 
 ### Step 1: Register Team in Session
 
@@ -553,7 +552,7 @@ Agent tool call:
   description: "QA-Visual - visual quality validation"
   prompt: [Read and follow .chati.dev/agents/quality/qa-visual.md.
     Phase 1: Run visual-qa.js script on all pages.
-    Phase 2: Spawn the Visualizer sub-agent (model: sonnet) to analyze build screenshots and compare with references.
+    Phase 2: Spawn the Visualizer sub-agent using its router-provided binding to analyze build screenshots and compare with references.
     Phase 3-4: Verify animation libraries and brandbook compliance from report.json.
     Scoring: Run qa-visual-score CLI for deterministic score.
     Write your handoff to artifacts/handoffs/qa-visual-handoff.md when done.]
@@ -675,7 +674,7 @@ review, bounded rework, ClickUp projection and the Release Lane.
 1. Read the immutable handoff id returned in `rail_execute`.
 2. Run:
    ```
-   node .chati.dev/_cli/bin/chati.js rail-next --handoff-id {handoff_id}
+   node .chati.dev/orchestrator/chati-router.js rail-next --handoff-id {handoff_id}
    ```
 3. Execute only a dependency-ready task. Use its selected provider and model
    binding from `.chati/v2/installation.json`. Never substitute an unselected
@@ -770,7 +769,7 @@ Session lock is written by `orchestrate init` and removed by `orchestrate exit`.
 1. Read `chati.dev/orchestrator/chati.md` and follow its routing logic for EVERY message
 2. Route ALL user messages through the current agent
 3. NEVER respond outside of the Chati.dev system - you ARE the orchestrator
-4. NEVER act as generic Claude while session is locked
+4. NEVER act as a generic assistant while session is locked
 5. Off-scope requests go to Deviation Protocol, NOT outside the system
 6. The ONLY way to exit is via explicit exit commands
 
@@ -959,7 +958,7 @@ When the independent RAIL reviewer classifies a fault:
 ### ALLOWED
 - Read any file in the project (for state detection)
 - Write to .chati/session.yaml (session state)
-- Write to CLAUDE.local.md (session lock block)
+- Reconcile every enabled harness's native session-lock file
 - Present status dashboards
 - Generate session digests
 
@@ -996,7 +995,7 @@ Level 2 - Escalate:
   3. Return to previous agent
 
 Level 3 - Session Recovery:
-  session.yaml corrupted → attempt reconstruction from CLAUDE.md + artifacts
+  session.yaml corrupted → attempt reconstruction from .chati/project-context.md + artifacts
   If reconstruction fails → suggest re-init preserving artifacts
 
 Level 4 - Graceful Degradation:

package/framework/schemas/session.schema.json

@@ -78,7 +78,7 @@
     "providers_enabled": {
       "type": "array",
       "items": { "type": "string" },
-      "default": ["claude"],
+      "default": [],
       "description": "List of enabled CLI providers"
     },
     "current_agent": {

package/package.json

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

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

@@ -1,93 +1,21 @@
 /**
- * @fileoverview Context file generator for multi-CLI support.
+ * @fileoverview Provider-native context generation from a neutral Chati core.
  *
- * When alternative CLI providers are enabled, generates provider-specific
- * context files (GEMINI.md, AGENTS.md) derived from CLAUDE.md content.
- * Constitution Article XIX — context file generation is automatic.
- *
- * Provider conventions (verified Feb 2026):
- * - Gemini CLI: auto-loads GEMINI.md, uses .gemini/commands/*.toml, no rules/
- * - Codex CLI:  auto-loads AGENTS.md, uses .agents/skills/chati/SKILL.md for $chati
+ * The canonical project context lives at .chati/project-context.md. Harness
+ * files consume that context through their native loading mechanisms. No
+ * provider file is derived from another provider's file.
  */
 
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { getEnabledNonClaudeProviders } from '../utils/config-parser.js';
+import { parseProviderConfig } from '../utils/config-parser.js';
 import { resolveFrameworkDir } from '../utils/framework-dir.js';
+import { HARNESS_PROFILES } from './framework-adapter.js';
 
-// ---------------------------------------------------------------------------
-// Replacement Maps
-// ---------------------------------------------------------------------------
-
-/**
- * Text replacements for Gemini CLI context file.
- * Transforms Claude Code-specific references into Gemini CLI equivalents.
- * Note: Gemini has no rules/ directory — references point to chati.dev/context/.
- */
-const GEMINI_REPLACEMENTS = [
-  ['Claude Code', 'Gemini CLI'],
-  ['claude code', 'Gemini CLI'],
-  ['CLAUDE.md', 'GEMINI.md'],
-  ['Claude.md', 'GEMINI.md'],
-  ['.claude/commands/', '.gemini/commands/'],
-  ['.claude/rules/chati/', '.gemini/context/'],
-  ['.claude/rules/', '.gemini/context/'],
-  ['.mcp.json', '.gemini/settings.json'],
-  ['claude --print', 'gemini --prompt'],
-  ['claude -p', 'gemini --prompt'],
-  ['CLAUDE.local.md', '.gemini/session-lock.md'],
-];
-
-/**
- * Sections to strip from Codex CLI context file.
- * Codex does not support hooks, so hook-related content is removed.
- */
-const CODEX_STRIP_PATTERNS = [
-  /## (?:Hooks?|Hook System)[\s\S]*?(?=\n## |\n---|\n$)/gi,
-  /- \*\*Hooks?\*\*:.*\n/gi,
-  /hook[s]? \(.*?\)/gi,
-];
-
-/**
- * Build text replacements for Codex CLI context file.
- * Note: Codex has no commands/ or rules/ directories — references point to the framework dir.
- *
- * @param {string} [frameworkDir='chati.dev'] - Resolved framework directory name (e.g. 'chati.dev' or '.chati.dev')
- * @returns {Array<[string, string]>} Replacement pairs
- */
-function buildCodexReplacements(frameworkDir = 'chati.dev') {
-  return [
-    ['Claude Code', 'Codex CLI'],
-    ['claude code', 'Codex CLI'],
-    ['CLAUDE.md', 'AGENTS.md'],
-    ['Claude.md', 'AGENTS.md'],
-    ['.claude/commands/', `${frameworkDir}/orchestrator/`],
-    ['.claude/rules/chati/', `${frameworkDir}/context/`],
-    ['.claude/rules/', `${frameworkDir}/context/`],
-    ['.mcp.json', '.codex/config.toml'],
-    ['claude --print', 'codex exec'],
-    ['claude -p', 'codex exec'],
-    ['CLAUDE.local.md', 'AGENTS.override.md'],
-  ];
-}
-
-/**
- * Convert the interactive slash command without touching filesystem paths such
- * as `.chati.dev/orchestrator/chati.md`.
- */
-function adaptCodexInvocation(content) {
-  return content.replace(/(?<![\w/])\/chati(?=\s|$|[`'".,;:!?)]|\b)/gm, '$chati');
-}
+export const PROJECT_CONTEXT_PATH = join('.chati', 'project-context.md');
 
-// ---------------------------------------------------------------------------
-// Generators
-// ---------------------------------------------------------------------------
+const CONTEXT_FILES = ['root.md', 'governance.md', 'protocols.md', 'quality.md'];
 
-/**
- * @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',
@@ -96,207 +24,87 @@ const GEMINI_IMPORTS = [
   '@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, 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
- */
+/** Generate Gemini's native root context from the neutral Chati context. */
 export function generateGeminiMd(content) {
-  let result = content;
-
-  for (const [search, replace] of GEMINI_REPLACEMENTS) {
-    result = result.replaceAll(search, replace);
-  }
-
-  // Prepend a header noting this file is auto-generated
-  const header = [
-    '<!-- Auto-generated by chati.dev from CLAUDE.md — do not edit manually -->',
+  return [
+    '<!-- Auto-generated by chati.dev from .chati/project-context.md. -->',
+    '',
+    content.trim(),
+    '',
+    ...GEMINI_IMPORTS,
     '',
   ].join('\n');
-
-  // Append @import directives for context parity
-  const imports = '\n' + GEMINI_IMPORTS.join('\n') + '\n';
-
-  return header + result + imports;
 }
 
 /**
- * Generate AGENTS.md content from CLAUDE.md content.
- *
- * Simplifies the content for Codex CLI: strips hook references,
- * replaces CLI-specific paths, and produces a leaner context file
- * 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 }
- * @param {string} [frameworkDir='chati.dev'] - Resolved framework directory name
- * @returns {string} Adapted content for AGENTS.md
+ * Generate the shared AGENTS.md consumed by Codex and Grok. Governance is
+ * inlined because these harnesses do not share Gemini's import mechanism.
  */
-export function generateAgentsMd(content, contextFiles = null, frameworkDir = 'chati.dev') {
-  let result = content;
-  const replacements = buildCodexReplacements(frameworkDir);
-
-  // Strip hook-related sections (Codex has no hooks support)
-  for (const pattern of CODEX_STRIP_PATTERNS) {
-    result = result.replace(pattern, '');
-  }
-
-  // Apply text replacements
-  for (const [search, replace] of replacements) {
-    result = result.replaceAll(search, replace);
-  }
-  result = adaptCodexInvocation(result);
-
-  // Clean up any double blank lines left by stripping
-  result = result.replace(/\n{3,}/g, '\n\n');
-
-  // Prepend a header noting this file is auto-generated
-  const header = [
-    '<!-- Auto-generated by chati.dev from CLAUDE.md — do not edit manually -->',
+export function generateAgentsMd(content, contextFiles = null, enabledProviders = []) {
+  const sections = [
+    '<!-- Auto-generated by chati.dev from .chati/project-context.md. -->',
     '',
-  ].join('\n');
+    content.trim(),
+  ];
 
-  result = header + result;
+  const runtimePointers = enabledProviders
+    .filter((provider) => provider === 'codex' || provider === 'grok')
+    .map((provider) => `- **${provider === 'codex' ? 'Codex' : 'Grok'} runtime lock**: \`${HARNESS_PROFILES[provider].sessionLockFile}\``);
+  if (runtimePointers.length > 0) {
+    sections.push('', '## Native Runtime State', '', ...runtimePointers);
+  }
 
-  // Inline context files for full governance parity (Codex has no @import)
   if (contextFiles) {
-    const sections = [];
-    for (const [, fileContent] of Object.entries(contextFiles)) {
-      if (fileContent) {
-        // Adapt context for Codex (replace Claude-specific refs)
-        let adapted = fileContent;
-        for (const [search, replace] of replacements) {
-          adapted = adapted.replaceAll(search, replace);
-        }
-        adapted = adaptCodexInvocation(adapted);
-        sections.push(adapted.trim());
-      }
-    }
-    if (sections.length > 0) {
-      result += '\n---\n\n' + sections.join('\n\n---\n\n') + '\n';
+    for (const fileContent of Object.values(contextFiles)) {
+      if (fileContent) sections.push('', '---', '', fileContent.trim());
     }
   }
 
-  return result;
+  return sections.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
 }
 
-// ---------------------------------------------------------------------------
-// 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.
- *
- * Reads config.yaml to determine which providers are enabled, reads
- * 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)
- * @returns {{ generated: string[], skipped: string[], warning: string|null }}
- */
-export function generateContextFiles(projectDir, baseContent = null) {
+/** Regenerate every enabled harness context from the neutral canonical file. */
+export function generateContextFiles(projectDir, neutralContent = null) {
   const result = { generated: [], skipped: [], warning: null };
+  const canonicalPath = join(projectDir, PROJECT_CONTEXT_PATH);
 
-  // Use provided base content or read CLAUDE.md from disk
-  let claudeContent = baseContent;
-  if (!claudeContent) {
-    const claudeMdPath = join(projectDir, 'CLAUDE.md');
-    if (!existsSync(claudeMdPath)) {
-      result.warning = 'CLAUDE.md not found and no base content provided — skipping context file generation';
+  let content = neutralContent;
+  if (!content) {
+    if (!existsSync(canonicalPath)) {
+      result.warning = `${PROJECT_CONTEXT_PATH} not found and no neutral content provided`;
       return result;
     }
-    claudeContent = readFileSync(claudeMdPath, 'utf-8');
+    content = readFileSync(canonicalPath, 'utf-8');
   }
 
-  // Determine enabled providers from config.yaml
-  const enabledProviders = resolveEnabledProviders(projectDir);
-
-  // Read context files for inline injection (Codex)
+  const { enabled } = parseProviderConfig(projectDir);
   const contextFiles = readContextFilesFromDisk(projectDir);
 
-  // Resolve framework directory for dynamic path generation
-  const fwDir = resolveFrameworkDir(projectDir);
-
-  // Provider-to-generator mapping
-  const generators = {
-    gemini: {
-      filename: 'GEMINI.md',
-      generate: (content) => generateGeminiMd(content),
-    },
-    codex: {
-      filename: 'AGENTS.md',
-      generate: (content) => generateAgentsMd(content, contextFiles, fwDir),
-    },
-  };
+  if (enabled.includes('gemini')) {
+    writeFileSync(join(projectDir, 'GEMINI.md'), generateGeminiMd(content), 'utf-8');
+    result.generated.push('GEMINI.md');
+  } else {
+    result.skipped.push('GEMINI.md');
+  }
 
-  for (const [provider, config] of Object.entries(generators)) {
-    if (enabledProviders.includes(provider)) {
-      const outputPath = join(projectDir, config.filename);
-      const content = config.generate(claudeContent);
-      writeFileSync(outputPath, content, 'utf-8');
-      result.generated.push(config.filename);
-    } else {
-      result.skipped.push(config.filename);
-    }
+  if (enabled.includes('codex') || enabled.includes('grok')) {
+    writeFileSync(join(projectDir, 'AGENTS.md'), generateAgentsMd(content, contextFiles, enabled), 'utf-8');
+    result.generated.push('AGENTS.md');
+  } else {
+    result.skipped.push('AGENTS.md');
   }
 
   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) {
-  // Support both new (.chati.dev/) and legacy (chati.dev/) structures
-  const newDir = join(projectDir, '.chati.dev', 'context');
-  const legacyDir = join(projectDir, 'chati.dev', 'context');
-  const contextDir = existsSync(newDir) ? newDir : legacyDir;
+  const contextDir = join(projectDir, resolveFrameworkDir(projectDir), '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;
-    }
+    if (existsSync(filePath)) files[file.replace('.md', '')] = readFileSync(filePath, 'utf-8');
   }
-  return found ? files : null;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve which alternative providers are enabled from config.yaml.
- * Delegates to shared config parser utility.
- *
- * @param {string} projectDir - Project root directory
- * @returns {string[]} List of enabled non-Claude provider names
- */
-function resolveEnabledProviders(projectDir) {
-  return getEnabledNonClaudeProviders(projectDir);
+  return Object.keys(files).length > 0 ? files : null;
 }