chati-dev 4.2.0 → 4.2.2

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

@@ -22,6 +22,10 @@
  * Maps each chati.dev hook to its Gemini CLI equivalent event.
  */
 export const HOOK_MAP = {
+  // license-guard MUST be first on BeforeModel so license check runs before
+  // any model call. Without this, an expired trial could keep using Gemini
+  // indefinitely from a long-running session.
+  'license-guard': { event: 'BeforeModel', description: 'Validate license on every turn (chati.dev governance)' },
   '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' },
@@ -611,6 +615,7 @@ main();
  */
 export function generateAllGeminiHooks() {
   return {
+    'license-guard.js': generateLicenseGuard(),
     'prism-engine.js': generatePrismEngine(),
     'model-governance.js': generateModelGovernance(),
     'mode-governance.js': generateModeGovernance(),
@@ -622,6 +627,59 @@ export function generateAllGeminiHooks() {
   };
 }
 
+/**
+ * Generate the license guard hook for Gemini CLI.
+ * BeforeModel event — validates license on every turn.
+ *
+ * Delegates to chati.dev/hooks/license-guard.js (canonical implementation)
+ * via dynamic import of checkLicense(). Translates the verdict object to
+ * Gemini's blocking schema (exit code 2 + stderr is the universal block).
+ */
+function generateLicenseGuard() {
+  return `${HOOK_HEADER}
+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 canonical license check
+    const hookPath = join(cwd, 'chati.dev', 'hooks', 'license-guard.js');
+    if (!existsSync(hookPath)) {
+      // No canonical hook present — fail open
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const mod = await import(hookPath);
+    if (typeof mod.checkLicense !== 'function') {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    const result = await mod.checkLicense();
+    if (result.valid) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+
+    // Block via exit code 2 (universal Gemini block) + stderr message.
+    process.stderr.write(result.reason || 'License invalid');
+    process.exit(2);
+  } catch {
+    // Fail open on any parse/import error — never block on bugs.
+    console.log(JSON.stringify({}));
+  }
+}
+
+main();
+`;
+}
+
 /**
  * Generate .gemini/settings.json content with hook configuration.
  *

package/src/installer/core.js

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync } from 'fs';
+import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
@@ -6,6 +6,7 @@ import { generateClaudeMCPConfig } from '../config/mcp-configs.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 { generateClaudeSettings } from '../config/claude-settings-generator.js';
 import { generateProviderOverlays } from './provider-overlay.js';
 import { verifyManifest } from './manifest.js';
 
@@ -146,144 +147,103 @@ export async function installFramework(config) {
 }
 
 /**
- * Copy framework files from the Chati.dev source directory
+ * Framework directories to copy recursively from source to target.
+ * This list controls WHICH top-level directories under chati.dev/ get copied.
+ * Everything inside each directory is copied automatically — no need to
+ * enumerate individual files.
+ *
+ * New files added to the source framework are picked up automatically.
  */
-export function copyFrameworkFiles(destDir, provider = 'claude') {
-  if (!existsSync(FRAMEWORK_SOURCE)) return;
-
-  const filesToCopy = [
-    'constitution.md',
-    'orchestrator/chati.md',
-    // DISCOVER agents
-    'agents/discover/greenfield-wu.md',
-    'agents/discover/brownfield-wu.md',
-    'agents/discover/brief.md',
-    // PLAN agents
-    'agents/plan/detail.md',
-    'agents/plan/architect.md',
-    'agents/plan/architect-system.md',
-    'agents/plan/architect-data-engineer.md',
-    'agents/plan/ux.md',
-    'agents/plan/ux-brand-architect.md',
-    'agents/plan/ux-researcher.md',
-    'agents/plan/ux-component-engineer.md',
-    'agents/plan/phases.md',
-    'agents/plan/tasks.md',
-    // Quality agents
-    'agents/quality/qa-planning.md',
-    'agents/quality/qa-implementation.md',
-    // BUILD + DEPLOY agents
-    'agents/build/dev.md',
-    'agents/deploy/devops.md',
-    // Templates
-    'templates/prd-tmpl.yaml',
-    'templates/brownfield-prd-tmpl.yaml',
-    'templates/fullstack-architecture-tmpl.yaml',
-    'templates/task-tmpl.yaml',
-    'templates/qa-gate-tmpl.yaml',
-    'templates/quick-brief-tmpl.yaml',
-    'templates/brandbook-tmpl.yaml',
-    'templates/brandbook-html-tmpl.md',
-    'templates/design-token-tmpl.yaml',
-    'templates/component-spec-tmpl.yaml',
-    'templates/icon-system-tmpl.yaml',
-    'templates/session-memory-tmpl.yaml',
-    // Workflows
-    'workflows/greenfield-fullstack.yaml',
-    'workflows/brownfield-fullstack.yaml',
-    'workflows/brownfield-discovery.yaml',
-    'workflows/brownfield-service.yaml',
-    'workflows/brownfield-ui.yaml',
-    'workflows/quick-flow.yaml',
-    'workflows/standard-flow.yaml',
-    // Quality gates
-    'quality-gates/planning-gate.md',
-    'quality-gates/implementation-gate.md',
-    // Schemas
-    'schemas/session.schema.json',
-    'schemas/config.schema.json',
-    'schemas/task.schema.json',
-    'schemas/context.schema.json',
-    'schemas/memory.schema.json',
-    // Frameworks
-    'frameworks/quality-dimensions.yaml',
-    'frameworks/decision-heuristics.yaml',
-    // Intelligence
-    'intelligence/gotchas.yaml',
-    'intelligence/patterns.yaml',
-    'intelligence/confidence.yaml',
-    'intelligence/context-engine.md',
-    'intelligence/memory-layer.md',
-    'intelligence/decision-engine.md',
-    // Patterns
-    'patterns/elicitation.md',
-    'patterns/elicitation-library.yaml',
-    // Hooks
-    'hooks/prism-engine.js',
-    'hooks/mode-governance.js',
-    'hooks/constitution-guard.js',
-    'hooks/session-digest.js',
-    'hooks/model-governance.js',
-    'hooks/settings.json',
-    'hooks/read-protection.js',
-    // Domains (PRISM Context Engine)
-    'domains/constitution.yaml',
-    'domains/global.yaml',
-    'domains/agents/orchestrator.yaml',
-    'domains/agents/greenfield-wu.yaml',
-    'domains/agents/brownfield-wu.yaml',
-    'domains/agents/brief.yaml',
-    'domains/agents/detail.yaml',
-    'domains/agents/architect.yaml',
-    'domains/agents/ux.yaml',
-    'domains/agents/phases.yaml',
-    'domains/agents/tasks.yaml',
-    'domains/agents/qa-planning.yaml',
-    'domains/agents/qa-implementation.yaml',
-    'domains/agents/dev.yaml',
-    'domains/agents/devops.yaml',
-    'domains/workflows/greenfield-fullstack.yaml',
-    'domains/workflows/brownfield-fullstack.yaml',
-    'domains/workflows/brownfield-discovery.yaml',
-    'domains/workflows/brownfield-service.yaml',
-    'domains/workflows/brownfield-ui.yaml',
-    'domains/workflows/quick-flow.yaml',
-    'domains/workflows/standard-flow.yaml',
-    // i18n
-    'i18n/en.yaml',
-    'i18n/pt.yaml',
-    'i18n/es.yaml',
-    'i18n/fr.yaml',
-    // Migrations
-    'migrations/v1.0-to-v1.1.yaml',
-    // Data
-    'data/entity-registry.yaml',
-    // Context (@ import chain for CLAUDE.md)
-    'context/root.md',
-    'context/governance.md',
-    'context/protocols.md',
-    'context/quality.md',
-  ];
-
-  for (const file of filesToCopy) {
-    const src = join(FRAMEWORK_SOURCE, file);
-    const dest = join(destDir, file);
+const FRAMEWORK_DIRS_TO_COPY = [
+  'orchestrator',
+  'agents',
+  'templates',
+  'workflows',
+  'quality-gates',
+  'schemas',
+  'frameworks',
+  'intelligence',
+  'patterns',
+  'hooks',
+  'domains',
+  'i18n',
+  'migrations',
+  'data',
+  'context',
+  'tasks',
+  'presets',
+];
 
-    if (existsSync(src)) {
-      createDir(dirname(dest));
+/**
+ * Loose files at the root of chati.dev/ that get copied directly.
+ */
+const FRAMEWORK_ROOT_FILES = [
+  'constitution.md',
+];
 
-      if (provider !== 'claude' && ADAPTABLE_FILES.has(file)) {
+/**
+ * Recursively copy a directory from source to destination, applying provider
+ * adaptation for files listed in ADAPTABLE_FILES when the provider is not Claude.
+ */
+function copyDirRecursive(srcDir, destDir, provider, relBase = '') {
+  if (!existsSync(srcDir)) return;
+  createDir(destDir);
+
+  const entries = readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const destPath = join(destDir, entry.name);
+    const relPath = relBase ? join(relBase, entry.name) : entry.name;
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath, provider, relPath);
+    } else if (entry.isFile()) {
+      if (provider !== 'claude' && ADAPTABLE_FILES.has(relPath)) {
         // Non-Claude provider: read, adapt, write
-        const content = readFileSync(src, 'utf-8');
-        writeFileSync(dest, adaptFrameworkFile(content, file, provider), 'utf-8');
+        const content = readFileSync(srcPath, 'utf-8');
+        writeFileSync(destPath, adaptFrameworkFile(content, relPath, provider), 'utf-8');
       } else {
         // Claude or non-adaptable: direct copy
-        copyFileSync(src, dest);
+        copyFileSync(srcPath, destPath);
       }
     }
   }
 }
 
+/**
+ * Copy framework files from the Chati.dev source directory.
+ *
+ * Uses recursive directory copy instead of a hardcoded file list, so that
+ * new files added to the framework source are automatically picked up.
+ *
+ * @param {string} destDir - Target framework directory (e.g., {project}/chati.dev/)
+ * @param {string} provider - Primary provider for text adaptation ('claude' | 'gemini' | 'codex')
+ */
+export function copyFrameworkFiles(destDir, provider = 'claude') {
+  if (!existsSync(FRAMEWORK_SOURCE)) return;
+
+  // Copy loose root files
+  for (const file of FRAMEWORK_ROOT_FILES) {
+    const src = join(FRAMEWORK_SOURCE, file);
+    if (!existsSync(src)) continue;
+    const dest = join(destDir, file);
+    createDir(dirname(dest));
+    if (provider !== 'claude' && ADAPTABLE_FILES.has(file)) {
+      const content = readFileSync(src, 'utf-8');
+      writeFileSync(dest, adaptFrameworkFile(content, file, provider), 'utf-8');
+    } else {
+      copyFileSync(src, dest);
+    }
+  }
+
+  // Copy each framework directory recursively
+  for (const dir of FRAMEWORK_DIRS_TO_COPY) {
+    const srcDir = join(FRAMEWORK_SOURCE, dir);
+    const destSubDir = join(destDir, dir);
+    copyDirRecursive(srcDir, destSubDir, provider, dir);
+  }
+}
+
 /**
  * Configure a specific IDE
  */
@@ -331,6 +291,12 @@ Pass through all context: session state, handoffs, artifacts, and user input.
 `;
     writeFileSync(join(targetDir, '.claude', 'commands', 'chati.md'), routerContent, 'utf-8');
 
+    // .claude/settings.json — wires the 10 chati.dev hooks into Claude Code's
+    // hook system and applies a baseline permission policy. THIS IS THE FILE
+    // CLAUDE CODE READS — without it, every hook in chati.dev/hooks/ is dormant.
+    // (Pre-v4.2.2 bug: this file was never written, hooks never ran.)
+    writeClaudeSettingsWithMerge(join(targetDir, '.claude', 'settings.json'));
+
     // MCP config
     if (selectedMCPs.length > 0) {
       const mcpConfig = generateClaudeMCPConfig(selectedMCPs);
@@ -348,10 +314,35 @@ Pass through all context: session state, handoffs, artifacts, and user input.
     // 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)
+    // Starlark execution policies (Codex sandboxed rule engine)
     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');
+
+    // .codex/hooks.json — license-guard wired to UserPromptSubmit (per-turn enforcement).
+    // Codex hooks.json is experimental (requires [features] codex_hooks = true in
+    // codex config). Without it, license enforcement only happens at slash command
+    // entry — a long-running terminal session would not be re-validated.
+    writeFileSync(
+      join(targetDir, '.codex', 'hooks.json'),
+      JSON.stringify({
+        $comment: 'chati.dev v4.2.2 — experimental Codex hooks. Requires [features] codex_hooks = true.',
+        hooks: {
+          UserPromptSubmit: [
+            {
+              matcher: '.*',
+              hooks: [
+                {
+                  type: 'command',
+                  command: 'node chati.dev/hooks/license-guard.js',
+                },
+              ],
+            },
+          ],
+        },
+      }, null, 2) + '\n',
+      '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({ orchestratorPath }), 'utf-8');
@@ -471,3 +462,106 @@ function createDir(dir) {
     mkdirSync(dir, { recursive: true });
   }
 }
+
+/**
+ * Write .claude/settings.json with safe merge against existing user content.
+ *
+ * If the file does not exist: write fresh chati settings.
+ * If the file exists and is valid JSON: merge — chati hooks/permissions are
+ * UNIONED into existing values rather than replacing them. User customizations
+ * (env, statusLine, plugins, language, alwaysThinkingEnabled, etc.) are preserved.
+ * If the file exists but is malformed: leave it alone, log a warning. We will
+ * not silently destroy user data.
+ */
+function writeClaudeSettingsWithMerge(settingsPath) {
+  createDir(dirname(settingsPath));
+  const fresh = JSON.parse(generateClaudeSettings());
+
+  if (!existsSync(settingsPath)) {
+    writeFileSync(settingsPath, JSON.stringify(fresh, null, 2) + '\n', 'utf-8');
+    return;
+  }
+
+  let existing;
+  try {
+    existing = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+  } catch (err) {
+    process.stderr.write(`[chati] WARNING: .claude/settings.json exists but is not valid JSON (${err.message}). Skipping merge — chati hooks will NOT be wired. Fix the file and re-run install.\n`);
+    return;
+  }
+
+  const merged = mergeClaudeSettings(existing, fresh);
+  writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+}
+
+/**
+ * Merge two Claude Code settings.json objects.
+ *
+ * - permissions.allow / permissions.deny: array union (de-duplicated)
+ * - permissions.defaultMode: keep existing if set, else use fresh
+ * - hooks: per-event union — chati hook commands are appended to existing
+ *   matcher groups; user's hooks for the same events are preserved
+ * - $schema: prefer fresh (always our canonical URL)
+ * - all other top-level keys (env, statusLine, plugins, language, etc.):
+ *   keep existing untouched
+ */
+export function mergeClaudeSettings(existing, fresh) {
+  const merged = { ...existing };
+
+  // $schema — chati's canonical URL wins
+  if (fresh.$schema) merged.$schema = fresh.$schema;
+
+  // permissions
+  const existingPerms = existing.permissions || {};
+  const freshPerms = fresh.permissions || {};
+  merged.permissions = {
+    ...existingPerms,
+    allow: unionArrays(existingPerms.allow, freshPerms.allow),
+    deny: unionArrays(existingPerms.deny, freshPerms.deny),
+    defaultMode: existingPerms.defaultMode || freshPerms.defaultMode || 'default',
+  };
+
+  // hooks — per-event merge
+  const existingHooks = existing.hooks || {};
+  const freshHooks = fresh.hooks || {};
+  merged.hooks = { ...existingHooks };
+
+  for (const [eventName, freshGroups] of Object.entries(freshHooks)) {
+    const existingGroups = existingHooks[eventName] || [];
+    // Append fresh groups; we don't dedup at the group level (different
+    // matchers are different groups). Within a single fresh group, the
+    // hook commands are unique to chati so duplication risk is minimal.
+    // To be safe, dedup by command string across the merged event.
+    const seen = new Set();
+    const collected = [];
+    for (const group of [...existingGroups, ...freshGroups]) {
+      const dedupedHooks = (group.hooks || []).filter(h => {
+        const key = `${group.matcher || ''}|${h.command}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
+      if (dedupedHooks.length > 0) {
+        collected.push({
+          ...(group.matcher !== undefined ? { matcher: group.matcher } : {}),
+          hooks: dedupedHooks,
+        });
+      }
+    }
+    merged.hooks[eventName] = collected;
+  }
+
+  return merged;
+}
+
+function unionArrays(a, b) {
+  const out = [];
+  const seen = new Set();
+  for (const item of [...(a || []), ...(b || [])]) {
+    if (!seen.has(item)) {
+      seen.add(item);
+      out.push(item);
+    }
+  }
+  return out;
+}

package/src/installer/templates.js

@@ -108,6 +108,44 @@ export function generateConfigYaml(config) {
     },
   };
 
+  // Feature flags (Intelligence Upgrade + Article XXI Agent Teams)
+  // Must match source chati.dev/config.yaml features block.
+  configData.features = {
+    hybrid_budget: true,
+    anti_dash: true,
+    rate_limiter_integration: true,
+    l5_keywords: true,
+    prompt_size_guard: true,
+    ids_decision_engine: true,
+    surface_criteria: true,
+    parallel_fallback: true,
+    tool_mesh: true,
+    tech_presets: true,
+    doctor_autofix: true,
+    brandbook: true,
+    // Intelligence Upgrade (v4.0.5 — Claude Code patterns)
+    undercover_mode: true,
+    memory_extraction: true,
+    memory_consolidation: true,
+    daily_digest: true,
+    structured_session_memory: true,
+    static_prism_boundary: true,
+    token_bracket_estimation: true,
+    model_fallback: true,
+    frustration_detection: true,
+    bash_security_checks: true,
+    // Agent Teams (Article XXI) — default ON in v4.2.2.
+    // Only effective when provider === 'claude' (gated in cli.js
+    // isAgentTeamsEnabled). Gemini and Codex always fall back to sequential
+    // pipeline silently. See plan: was previously false for "safe rollout"
+    // but the v4.2.0 launch never actually shipped, so this is a fresh start.
+    agent_teams: true,
+    team_planning_size: 3,
+    team_build_size: 2,
+    team_echo_threshold: 0.92,
+    team_correction_cycles_max: 2,
+  };
+
   // Add telemetry config
   configData.telemetry = {
     enabled: config.telemetryEnabled !== false,

package/src/orchestrator/cli.js

@@ -381,24 +381,33 @@ async function handleNext(projectDir) {
   // Check for parallel group — with Agent Teams override (Article XXI)
   let action, spawnCommand = null, parallelSpawnCommand = null, parallelAgents = [];
   let teamData = null;
+  const teamsEnabled = isAgentTeamsEnabled(projectDir);
+
   if (nextInfo.isParallel && nextInfo.group.length > 1) {
-    // When agent_teams is enabled, substitute spawn_parallel with spawn_team
-    if (isAgentTeamsEnabled(projectDir)) {
-      const teamType = nextInfo.group.includes('dev') ? 'build' : 'planning';
-      const teamConfig = TEAM_CONFIGS[teamType];
+    // Planning Team auto-spawn: detail + architect + ux are marked parallel: true
+    // in agent-selector. When agent_teams enabled, swap spawn_parallel for spawn_team.
+    if (teamsEnabled) {
+      const teamConfig = TEAM_CONFIGS.planning;
       const teamId = generateTeamId(teamConfig.slug);
       action = 'spawn_team';
       parallelAgents = teamConfig.members;
-      teamData = {
-        team_id: teamId,
-        team_type: teamType,
-        members: teamConfig.members,
-      };
+      teamData = { team_id: teamId, team_type: 'planning', members: teamConfig.members };
     } else {
       action = 'spawn_parallel';
       parallelAgents = nextInfo.group;
       parallelSpawnCommand = buildParallelSpawnCommand(nextInfo.group, projectDir, lastAgent, modelInfo.provider, 900000);
     }
+  } else if (nextAgent === 'dev' && teamsEnabled) {
+    // Build Team auto-spawn: dev + qa-implementation are NOT parallel in the
+    // classic sense (dev writes, qa reviews per-task), so they're not in a
+    // parallel group. But under Agent Teams, they coordinate via mailbox + shared
+    // task list, which IS the team mechanism. Spawn Build Team here when dev
+    // would otherwise spawn solo.
+    const teamConfig = TEAM_CONFIGS.build;
+    const teamId = generateTeamId(teamConfig.slug);
+    action = 'spawn_team';
+    parallelAgents = teamConfig.members;
+    teamData = { team_id: teamId, team_type: 'build', members: teamConfig.members };
   } else if (isInteractive) {
     action = 'activate_interactive';
   } else {
@@ -978,12 +987,33 @@ function generateTeamId(slug) {
   return `TM-${date}-${slug}`;
 }
 
+/**
+ * Agent Teams require BOTH the feature flag AND a Claude provider.
+ *
+ * Why provider gate: Agent Teams uses Claude Code's native Task tool / subagent
+ * spawn API. Gemini and Codex have no equivalent — calling spawn_team for those
+ * providers would fail. We always fall back silently to spawn_parallel
+ * (Gemini) or spawn_autonomous (Codex) when the active provider is not claude.
+ */
 function isAgentTeamsEnabled(projectDir) {
   const configPath = join(projectDir, 'chati.dev', 'config.yaml');
   if (!existsSync(configPath)) return false;
   const raw = readFileSync(configPath, 'utf-8');
-  const match = raw.match(/agent_teams:\s*(true|false)/);
-  return match ? match[1] === 'true' : false;
+
+  // Feature flag check
+  const flagMatch = raw.match(/agent_teams:\s*(true|false)/);
+  const flagOn = flagMatch ? flagMatch[1] === 'true' : false;
+  if (!flagOn) return false;
+
+  // Provider gate — Agent Teams is Claude-only.
+  // Read primary_provider from session.yaml (preferred) or active_provider
+  // field. Default to 'claude' if neither exists (early bootstrap).
+  const sessionPath = join(projectDir, '.chati', 'session.yaml');
+  if (!existsSync(sessionPath)) return true; // No session yet — assume claude
+  const sessionRaw = readFileSync(sessionPath, 'utf-8');
+  const providerMatch = sessionRaw.match(/^\s*(?:active_provider|primary_provider):\s*["']?(\w+)/m);
+  const provider = providerMatch ? providerMatch[1] : 'claude';
+  return provider === 'claude';
 }
 
 async function handleSpawnTeam(projectDir, args) {