chati-dev 4.5.15 → 4.5.27

package/framework/orchestrator/chati-router.js

@@ -16,10 +16,17 @@
  */
 
 import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { join, resolve } from 'path';
+import { readHookSession } from '../hooks/session-reader.js';
 
 const PROJECT_DIR = process.cwd();
-const ROUTER_ARGS = process.argv.slice(2);
+const RAW_ROUTER_ARGS = process.argv.slice(2);
+const harnessFlagIndex = RAW_ROUTER_ARGS.indexOf('--harness');
+const ACTIVE_HARNESS = harnessFlagIndex >= 0 ? RAW_ROUTER_ARGS[harnessFlagIndex + 1] : null;
+const ROUTER_ARGS = harnessFlagIndex >= 0
+  ? RAW_ROUTER_ARGS.filter((_, index) => index !== harnessFlagIndex && index !== harnessFlagIndex + 1)
+  : RAW_ROUTER_ARGS;
 
 async function readEnabledHarnesses(projectDir) {
   const installationPath = join(projectDir, '.chati', 'v2', 'installation.json');
@@ -40,6 +47,7 @@ async function readEnabledHarnesses(projectDir) {
 
   const detected = [];
   if (existsSync(join(projectDir, '.claude', 'commands', 'chati.md'))) detected.push('claude');
+  if (existsSync(join(projectDir, '.gemini', 'commands', 'chati.toml'))) detected.push('gemini');
   if (existsSync(join(projectDir, '.agents', 'skills', 'chati', 'SKILL.md'))) detected.push('codex');
   if (existsSync(join(projectDir, '.grok', 'commands', 'chati.md'))) detected.push('grok');
   return { harnesses: detected, error: null };
@@ -64,7 +72,7 @@ export async function validateProviderIntegrity(projectDir) {
   const { harnesses, error } = await readEnabledHarnesses(projectDir);
 
   if (error) missing.push(error);
-  const supportedHarnesses = new Set(['claude', 'codex', 'grok']);
+  const supportedHarnesses = new Set(['claude', 'gemini', 'codex', 'grok']);
   for (const harness of harnesses) {
     if (!supportedHarnesses.has(harness)) missing.push(`unsupported harness ${harness}`);
   }
@@ -132,9 +140,40 @@ export async function validateProviderIntegrity(projectDir) {
     }
   }
 
+  if (harnesses.includes('gemini')) {
+    for (const [label, relativePath] of [
+      ['gemini command', '.gemini/commands/chati.toml'],
+      ['gemini session lock', '.gemini/session-lock.md'],
+      ['gemini governance context', '.gemini/context/governance.md'],
+      ['gemini license hook file', '.gemini/hooks/license-guard.js'],
+    ]) {
+      if (!hasContent(join(projectDir, relativePath))) missing.push(label);
+    }
+    const settingsPath = join(projectDir, '.gemini', 'settings.json');
+    if (!hasContent(settingsPath)) {
+      missing.push('gemini settings');
+    } else {
+      try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        const firstHook = settings.hooks?.BeforeModel?.[0]?.hooks?.[0];
+        if (firstHook?.name !== 'license-guard'
+          || firstHook?.command !== 'node .gemini/hooks/license-guard.js') {
+          missing.push('gemini license hook');
+        }
+      } catch {
+        missing.push('gemini settings invalid');
+      }
+    }
+  }
+
   if (harnesses.includes('grok')) {
     if (!hasContent(join(projectDir, '.grok', 'commands', 'chati.md'))) missing.push('grok command');
     if (!hasContent(join(projectDir, '.grok', 'session-lock.md'))) missing.push('grok session lock');
+    const governancePath = join(projectDir, '.grok', 'rules', 'chati-governance.md');
+    if (!hasContent(governancePath)
+      || !readFileSync(governancePath, 'utf-8').includes('chati-router.js --harness grok')) {
+      missing.push('grok governance rule');
+    }
   }
 
   return { valid: missing.length === 0, missing };
@@ -312,9 +351,23 @@ const VALID_ORCHESTRATE_SUBS = new Set([
   'spawn-team', 'team-status', 'team-dissolve',
   'wait-for-capture', 'wave-status', 'assess-coverage',
   'wait-for-license', 'doctor', 'run-script-task',
+  'activate-harness',
 ]);
 
-const VALID_RAIL_SUBS = new Set(['rail-next']);
+const VALID_RAIL_SUBS = new Set([
+  'rail-next',
+  'rail-dispatch',
+  'rail-review-run',
+  'rail-rework',
+  'rail-adjudicate',
+  'rail-recover',
+  'rail-complete',
+  'rail-release-ready',
+  'rail-tracking-reconcile',
+  'rail-tracking-pending',
+  'rail-tracking-ack',
+  'rail-tracking-lookup',
+]);
 
 /**
  * Parse --flag value pairs and standalone --flag bools from argv.
@@ -380,8 +433,17 @@ async function dispatchRail(subCommand, argv) {
   }
 
   const flags = parseFlagArgs(argv);
+  const parseJsonFlag = (name, { required = false } = {}) => {
+    const raw = flags[name];
+    if (raw === undefined) {
+      if (required) throw Object.assign(new Error(`Missing --${name}`), { code: 'RAIL_INPUT_REQUIRED' });
+      return undefined;
+    }
+    try { return JSON.parse(raw); }
+    catch (error) { throw Object.assign(new Error(`Invalid JSON in --${name}: ${error.message}`), { code: 'RAIL_INPUT_INVALID' }); }
+  };
   if (subCommand === 'rail-next') {
-    if (!flags['handoff-id']) return { ok: false, error: 'Missing --handoff-id' };
+    if (!flags['handoff-id']) return { ok: false, action: 'error', error: 'RAIL_INPUT_REQUIRED', detail: 'Missing --handoff-id' };
     try {
       const { selectReadyRailTasks } = await import(runtimePath);
       return selectReadyRailTasks({ projectDir: PROJECT_DIR, handoff_id: flags['handoff-id'] });
@@ -389,6 +451,173 @@ async function dispatchRail(subCommand, argv) {
       return { ok: false, action: 'error', error: error.code || error.message };
     }
   }
+  if (subCommand === 'rail-dispatch') {
+    if (!flags['handoff-id'] || !flags['task-id']) return { ok: false, action: 'error', error: 'RAIL_INPUT_REQUIRED', detail: 'Missing --handoff-id or --task-id' };
+    const attemptId = flags['attempt-id'] || `attempt-${randomUUID()}`;
+    try {
+      const runnerPath = join(PROJECT_DIR, fwDir, '_cli', 'terminal', 'run-rail-task.js');
+      if (!existsSync(runnerPath)) return { ok: false, action: 'error', error: 'rail_dispatch_runtime_not_found' };
+      const { executeReadyRailTask } = await import(runnerPath);
+      const browserRequest = flags['browser-request-json']
+        ? JSON.parse(flags['browser-request-json'])
+        : undefined;
+      return await executeReadyRailTask({
+        projectDir: PROJECT_DIR,
+        handoff_id: flags['handoff-id'],
+        task_id: flags['task-id'],
+        attempt_id: attemptId,
+        operator_id: flags['operator-id'] || `operator://chati/${ACTIVE_HARNESS || 'runtime'}`,
+        ...(flags.timeout ? { timeout: Number(flags.timeout) } : {}),
+        ...(browserRequest === undefined ? {} : { browser_request: browserRequest }),
+      });
+    } catch (error) {
+      let nextRequiredAction = 'rail_retry_same_attempt';
+      try {
+        const runtime = await import(runtimePath);
+        runtime.resolveRailAttemptContext({ projectDir: PROJECT_DIR, handoff_id: flags['handoff-id'], attempt_id: attemptId });
+        nextRequiredAction = 'rail_recover_same_attempt_after_lease_expiry';
+      } catch {
+        // The dispatch never created a canonical claim.
+      }
+      return {
+        ok: false, action: 'error', error: error.code || 'RAIL_DISPATCH_FAILED',
+        detail: error.message, attempt_id: error.details?.attempt_id || attemptId,
+        next_required_action: nextRequiredAction,
+      };
+    }
+  }
+  if (subCommand === 'rail-recover') {
+    if (!flags['handoff-id'] || !flags['attempt-id'] || !flags['operator-id']) {
+      return { ok: false, action: 'error', error: 'RAIL_INPUT_REQUIRED', detail: 'Missing --handoff-id, --attempt-id or --operator-id' };
+    }
+    const attemptId = flags['attempt-id'];
+    try {
+      const runnerPath = join(PROJECT_DIR, fwDir, '_cli', 'terminal', 'run-rail-task.js');
+      if (!existsSync(runnerPath)) return { ok: false, action: 'error', error: 'rail_dispatch_runtime_not_found' };
+      const runtime = await import(runtimePath);
+      const { executeReadyRailTask } = await import(runnerPath);
+      const context = runtime.resolveRailAttemptContext({
+        projectDir: PROJECT_DIR,
+        handoff_id: flags['handoff-id'],
+        attempt_id: attemptId,
+      });
+      const browserRequest = flags['browser-request-json']
+        ? JSON.parse(flags['browser-request-json'])
+        : undefined;
+      return await executeReadyRailTask({
+        projectDir: PROJECT_DIR,
+        handoff_id: flags['handoff-id'],
+        task_id: context.task.task_id,
+        attempt_id: attemptId,
+        operator_id: flags['operator-id'],
+        recover_expired: true,
+        ...(flags.timeout ? { timeout: Number(flags.timeout) } : {}),
+        ...(browserRequest === undefined ? {} : { browser_request: browserRequest }),
+      });
+    } catch (error) {
+      return {
+        ok: false, action: 'error', error: error.code || 'RAIL_RECOVERY_FAILED',
+        detail: error.message, attempt_id: error.details?.attempt_id || attemptId,
+        next_required_action: 'rail_recover_and_dispatch_same_attempt',
+      };
+    }
+  }
+  if (subCommand === 'rail-review-run') {
+    if (!flags['handoff-id'] || !flags['attempt-id']) return { ok: false, action: 'error', error: 'Missing --handoff-id or --attempt-id' };
+    try {
+      const runnerPath = join(PROJECT_DIR, fwDir, '_cli', 'terminal', 'run-rail-review.js');
+      if (!existsSync(runnerPath)) return { ok: false, action: 'error', error: 'rail_review_runtime_not_found' };
+      const { executeRailReview } = await import(runnerPath);
+      return await executeRailReview({
+        projectDir: PROJECT_DIR,
+        handoff_id: flags['handoff-id'],
+        attempt_id: flags['attempt-id'],
+        ...(flags.timeout ? { timeout: Number(flags.timeout) } : {}),
+      });
+    } catch (error) {
+      return { ok: false, action: 'error', error: error.code || 'RAIL_REVIEW_FAILED', detail: error.message };
+    }
+  }
+  if (subCommand === 'rail-rework') {
+    if (!flags['handoff-id'] || !flags['attempt-id']) return { ok: false, action: 'error', error: 'Missing --handoff-id or --attempt-id' };
+    try {
+      const runnerPath = join(PROJECT_DIR, fwDir, '_cli', 'terminal', 'run-rail-rework.js');
+      if (!existsSync(runnerPath)) return { ok: false, action: 'error', error: 'rail_rework_runtime_not_found' };
+      const { executeRailRework } = await import(runnerPath);
+      return await executeRailRework({
+        projectDir: PROJECT_DIR,
+        handoff_id: flags['handoff-id'],
+        attempt_id: flags['attempt-id'],
+        ...(flags.timeout ? { timeout: Number(flags.timeout) } : {}),
+      });
+    } catch (error) {
+      return { ok: false, action: 'error', error: error.code || 'RAIL_REWORK_FAILED', detail: error.message };
+    }
+  }
+  if (subCommand === 'rail-adjudicate') {
+    if (!flags['handoff-id'] || !flags['attempt-id']) return { ok: false, action: 'error', error: 'Missing --handoff-id or --attempt-id' };
+    try {
+      const runnerPath = join(PROJECT_DIR, fwDir, '_cli', 'terminal', 'run-rail-adjudication.js');
+      if (!existsSync(runnerPath)) return { ok: false, action: 'error', error: 'rail_adjudication_runtime_not_found' };
+      const { executeRailAdjudication } = await import(runnerPath);
+      return await executeRailAdjudication({
+        projectDir: PROJECT_DIR,
+        handoff_id: flags['handoff-id'],
+        attempt_id: flags['attempt-id'],
+        ...(flags.timeout ? { timeout: Number(flags.timeout) } : {}),
+      });
+    } catch (error) {
+      return { ok: false, action: 'error', error: error.code || 'RAIL_ADJUDICATION_FAILED', detail: error.message };
+    }
+  }
+  try {
+    const runtime = await import(runtimePath);
+    if (subCommand === 'rail-complete') {
+      const completion = parseJsonFlag('completion-json', { required: true });
+      const { completion_id, attempt_id, claim_id, operator_id, state, git, ci, reviews, acceptance_evidence_refs, acceptance_authority_receipt, completed_at, metrics } = completion;
+      return runtime.completeRailTask({
+        projectDir: PROJECT_DIR, handoff_id: flags['handoff-id'], completion_id, attempt_id, claim_id, operator_id, state, git, ci,
+        reviews, acceptance_evidence_refs, acceptance_authority_receipt, ...(completed_at === undefined ? {} : { completed_at }), ...(metrics === undefined ? {} : { metrics }),
+      });
+    }
+    if (subCommand === 'rail-release-ready') {
+      return runtime.selectRailReleaseReadiness({ projectDir: PROJECT_DIR, handoff_id: flags['handoff-id'] });
+    }
+    if (subCommand === 'rail-tracking-reconcile') {
+      return runtime.reconcileProjectClickUpTracking({ projectDir: PROJECT_DIR, handoff_id: flags['handoff-id'] });
+    }
+    if (subCommand === 'rail-tracking-pending') {
+      const clickUpRuntimePath = join(PROJECT_DIR, fwDir, '_cli', 'orchestrator', 'clickup-runtime.js');
+      const clickUpRuntime = await import(clickUpRuntimePath);
+      return clickUpRuntime.preparePendingClickUpProjections({ projectDir: PROJECT_DIR });
+    }
+    if (subCommand === 'rail-tracking-ack') {
+      if (!flags['handoff-id'] || !flags['projection-id'] || !flags.receipt) {
+        throw Object.assign(new Error('Missing --handoff-id, --projection-id or --receipt'), { code: 'RAIL_INPUT_REQUIRED' });
+      }
+      const clickUpRuntimePath = join(PROJECT_DIR, fwDir, '_cli', 'orchestrator', 'clickup-runtime.js');
+      const clickUpRuntime = await import(clickUpRuntimePath);
+      const receipt = JSON.parse(readFileSync(resolve(flags.receipt), 'utf8'));
+      return clickUpRuntime.acknowledgeClickUpProjection({
+        projectDir: PROJECT_DIR, handoff_id: flags['handoff-id'],
+        projection_id: flags['projection-id'], receipt,
+      });
+    }
+    if (subCommand === 'rail-tracking-lookup') {
+      if (!flags['handoff-id'] || !flags['projection-id'] || !flags.result) {
+        throw Object.assign(new Error('Missing --handoff-id, --projection-id or --result'), { code: 'RAIL_INPUT_REQUIRED' });
+      }
+      const clickUpRuntimePath = join(PROJECT_DIR, fwDir, '_cli', 'orchestrator', 'clickup-runtime.js');
+      const clickUpRuntime = await import(clickUpRuntimePath);
+      const result = JSON.parse(readFileSync(resolve(flags.result), 'utf8'));
+      return clickUpRuntime.resolveClickUpProjectionLookup({
+        projectDir: PROJECT_DIR, handoff_id: flags['handoff-id'],
+        projection_id: flags['projection-id'], result,
+      });
+    }
+  } catch (error) {
+    return { ok: false, action: 'error', error: error.code || 'RAIL_RUNTIME_FAILED', detail: error.message };
+  }
   return { ok: false, action: 'error', error: `Unsupported RAIL command: ${subCommand}` };
 }
 
@@ -486,30 +715,49 @@ async function main() {
     pipeline: null,
     team: null,
     error: null,
+    active_harness: ACTIVE_HARNESS,
   };
 
+  const sessionRead = readHookSession(PROJECT_DIR);
+  if (!sessionRead.loaded && !sessionRead.missing) {
+    result.ok = false;
+    result.action = 'error';
+    result.error = `unsafe_session: ${sessionRead.error}`;
+    console.log(JSON.stringify(result));
+    return;
+  }
+  if (ACTIVE_HARNESS && sessionRead.loaded) {
+    const cliMod = await findCliModule(PROJECT_DIR);
+    if (!cliMod) {
+      result.ok = false;
+      result.action = 'error';
+      result.error = 'cli_module_not_found';
+      console.log(JSON.stringify(result));
+      return;
+    }
+    const activation = await captureOrchestrate(cliMod, 'activate-harness', ['--harness', ACTIVE_HARNESS], PROJECT_DIR);
+    if (!activation.activated) {
+      result.ok = false;
+      result.action = 'error';
+      result.error = activation.error || 'harness_activation_failed';
+      console.log(JSON.stringify(result));
+      return;
+    }
+  }
+
   // -----------------------------------------------------------------------
   // 1. Session state
   // -----------------------------------------------------------------------
-  try {
-    const sessionPath = join(PROJECT_DIR, '.chati', 'session.yaml');
-    if (existsSync(sessionPath)) {
-      const raw = readFileSync(sessionPath, 'utf-8');
-      const extract = (key) => {
-        const m = raw.match(new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm'));
-        return m ? m[1].trim().replace(/^["']|["']$/g, '') : null;
-      };
-      result.session = {
-        language: extract('language') || 'en',
-        project_name: extract('name') || '',
-        project_type: extract('type') || 'greenfield',
-        state: extract('state') || 'discover',
-        current_agent: extract('current_agent') || '',
-        workflow: extract('workflow') || 'full',
-      };
-    }
-  } catch {
-    result.session = null;
+  if (sessionRead.loaded) {
+    const session = sessionRead.session;
+    result.session = {
+      language: session.language || 'en',
+      project_name: session.project?.name || '',
+      project_type: session.project?.type || session.project_type || 'greenfield',
+      state: session.project?.state || session.mode || 'discover',
+      current_agent: session.current_agent || '',
+      workflow: session.workflow || 'full',
+    };
   }
 
   // -----------------------------------------------------------------------
@@ -521,14 +769,20 @@ async function main() {
     const cliMod = await findCliModule(PROJECT_DIR);
     if (findCliModule._mismatch) result.version_mismatch = findCliModule._mismatch;
     if (!cliMod) {
+      result.ok = false;
       result.action = 'error';
       result.error = 'cli_module_not_found';
       result.reason = 'Bundled CLI missing in .chati.dev/_cli/. Reinstall with: npx chati-dev upgrade';
     } else {
       result.pipeline = await captureOrchestrate(cliMod, 'next', [], PROJECT_DIR);
       result.action = result.pipeline.action;
+      if (result.action === 'error' || result.pipeline?.ok === false) {
+        result.ok = false;
+        result.error = result.pipeline?.error || result.pipeline?.code || 'pipeline_routing_failed';
+      }
     }
   } catch (err) {
+    result.ok = false;
     result.action = 'error';
     result.error = `pipeline_routing_failed: ${err.message?.slice(0, 200)}`;
   }