chati-dev 4.2.1 → 4.3.0

package/src/config/agent-customizer.js

@@ -10,13 +10,21 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import yaml from 'js-yaml';
+import { resolveFrameworkDir } from '../utils/framework-dir.js';
 
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 
-/** Directory relative to project root where customization files are stored. */
-const CUSTOMIZE_DIR = 'chati.dev/customize';
+/**
+ * Get the customize directory for a given project.
+ * Supports both .chati.dev/ and chati.dev/ structures.
+ * @param {string} projectDir
+ * @returns {string} Relative path from project root
+ */
+function getCustomizeDir(projectDir) {
+  return `${resolveFrameworkDir(projectDir)}/customize`;
+}
 
 /** Valid override fields that customizations can set. */
 export const VALID_OVERRIDE_FIELDS = [
@@ -57,7 +65,7 @@ export function loadCustomization(projectDir, agentName) {
     return { found: false, overrides: {} };
   }
 
-  const customizePath = join(projectDir, CUSTOMIZE_DIR, `${agentName}.yaml`);
+  const customizePath = join(projectDir, getCustomizeDir(projectDir), `${agentName}.yaml`);
 
   if (!existsSync(customizePath)) {
     return { found: false, overrides: {} };

package/src/config/claude-settings-generator.js

@@ -0,0 +1,226 @@
+/**
+ * Claude Code settings.json generator.
+ *
+ * Produces .claude/settings.json content that wires the 14 chati.dev hooks
+ * into Claude Code's hook system and applies a baseline permission policy.
+ *
+ * Background: prior to v4.2.2, the installer wrote hooks to
+ * .chati.dev/hooks/settings.json — but Claude Code reads .claude/settings.json,
+ * not the framework's bundled file. As a result, every hook was dormant for
+ * every Claude Code user since the project started. This generator is the fix:
+ * it produces the file Claude Code actually loads, registers all 14 hooks at
+ * the canonical events, and applies a generic permission policy modeled on
+ * production Claude Code setups.
+ *
+ * Hook output schema (v4.2.2): all PreToolUse hooks now use the canonical
+ * `hookSpecificOutput.permissionDecision` field per Anthropic docs at
+ * https://code.claude.com/docs/en/hooks.md. The previous `decision` field
+ * was silently no-op'd by Claude Code.
+ */
+
+/**
+ * Hook registration map. Each entry is one hook script and the events it
+ * should fire on. Source of truth lives in .chati.dev/hooks/.
+ */
+const HOOK_REGISTRY = [
+  // UserPromptSubmit — fires on every user message turn.
+  // NOTE: license-guard is NOT here. UserPromptSubmit blocks are SILENT (prompt
+  // is dropped, no message shown to user). License enforcement is done via:
+  //   1. Slash command STEP 0 (visible — Claude runs checkLicense() via Bash)
+  //   2. PreToolUse catch-all below (backup — Claude sees deny reason, reports it)
+  { name: 'prism-engine',      event: 'UserPromptSubmit', matcher: '.*' },
+  { name: 'model-governance',  event: 'UserPromptSubmit', matcher: '.*' },
+
+  // PreToolUse — fires before each tool call. Matcher targets specific tools.
+  // license-guard is first on catch-all ".*" — blocks ALL tool calls when
+  // license is expired. Claude sees the deny reason and can report it to user.
+  // This is the backup defense: even if someone bypasses the slash command,
+  // no tool call succeeds with an expired license.
+  { name: 'license-guard',     event: 'PreToolUse', matcher: '.*' },
+  { name: 'read-protection',   event: 'PreToolUse', matcher: 'Read' },
+  { name: 'constitution-guard',event: 'PreToolUse', matcher: 'Bash|Write|Edit' },
+  { name: 'mode-governance',   event: 'PreToolUse', matcher: 'Write|Edit' },
+  { name: 'style-guard',       event: 'PreToolUse', matcher: 'Write|Edit|Bash' },
+  { name: 'undercover-guard',  event: 'PreToolUse', matcher: 'Write|Edit|Bash' },
+  { name: 'team-quality-gate', event: 'PreToolUse', matcher: 'Write|Edit' },
+
+  // PostToolUse — fires after each tool call. Used to auto-advance the pipeline
+  // when an agent finishes writing its handoff. Hook inspects the written path
+  // and triggers `chati-router.js advance` if it matches an agent handoff file.
+  { name: 'advance-trigger',   event: 'PostToolUse', matcher: 'Write' },
+  { name: 'reference-trigger', event: 'PostToolUse', matcher: 'Write' },
+  { name: 'brief-validator',   event: 'PostToolUse', matcher: 'Write' },
+  // Autonomous-completion v1 (ADR-AUTO-06): spawns visual-qa.js on
+  // dev-handoff write so the next /chati turn already has report.json.
+  { name: 'post-dev',          event: 'PostToolUse', matcher: 'Write' },
+
+  // PreCompact — fires before context compaction (observational).
+  { name: 'session-digest',    event: 'PreCompact', matcher: '' },
+];
+
+/**
+ * Baseline permission allow list.
+ * Modeled on production Claude Code setups: lets the assistant work freely
+ * inside the project without prompting for every tool call. Personal MCP
+ * permissions are intentionally NOT included — those are user-specific.
+ */
+const PERMISSIONS_ALLOW = [
+  'Read(**/*)',
+  'Write(**/*)',
+  'Edit(**/*)',
+  'Bash',
+  'WebFetch',
+  'WebSearch',
+  'Task',
+  'Glob',
+  'Grep',
+  'NotebookEdit',
+  'Skill(*)',
+  'TodoWrite',
+  'AskUserQuestion',
+  'EnterPlanMode',
+  'ExitPlanMode',
+  'KillShell',
+  'Bash(npx playwright:*)',
+  'Bash(node .chati.dev/scripts/*)',
+  'Bash(node chati.dev/scripts/*)',
+];
+
+/**
+ * Baseline permission deny list.
+ *
+ * Categories:
+ * - Catastrophic filesystem: deletes that hit root, mass-format, recursive chmod
+ * - Git destructive: force push, hard reset, .git removal, hook bypass
+ * - System path writes: /etc, /usr, /System, /bin, /sbin (note `//` prefix
+ *   means absolute filesystem path, not project-relative)
+ * - Secret reads: SSH keys, AWS/GCP credentials, npm tokens, GitHub tokens
+ * - Accidental publish: npm/yarn/pnpm/pip/cargo publish commands
+ *
+ * Path syntax (from Claude Code docs):
+ * - `Bash(cmd:*)`  matches "cmd" with any args
+ * - `~/path/**`    expands ~ to home dir, ** matches recursive
+ * - `//etc/**`     double-slash means absolute filesystem path
+ * - `/path/**`     single-slash is project-root-relative (NOT absolute)
+ */
+const PERMISSIONS_DENY = [
+  // Catastrophic filesystem
+  'Bash(rm -rf /)',
+  'Bash(rm -rf /*)',
+  'Bash(rm -rf ~)',
+  'Bash(rm -rf ~/*)',
+  'Bash(rm -rf $HOME)',
+  'Bash(rm -rf $HOME/*)',
+  'Bash(sudo rm -rf:*)',
+  'Bash(mkfs:*)',
+  'Bash(dd if=/dev/zero:*)',
+  'Bash(dd if=/dev/random:*)',
+  'Bash(chmod -R 777 /)',
+  'Bash(chown -R:*  /)',
+
+  // Git destructive
+  'Bash(git push --force:*)',
+  'Bash(git push -f:*)',
+  'Bash(git push --force-with-lease:*)',
+  'Bash(git reset --hard:*)',
+  'Bash(git clean -fd:*)',
+  'Bash(git clean -fdx:*)',
+  'Bash(git clean -fx:*)',
+  'Bash(rm -rf .git)',
+  'Bash(rm -rf .git/*)',
+
+  // Bypass hooks (always suspect)
+  'Bash(git commit --no-verify:*)',
+  'Bash(git commit -n:*)',
+  'Bash(git commit --no-gpg-sign:*)',
+  'Bash(git rebase --no-verify:*)',
+
+  // System path writes — `//` prefix = absolute filesystem
+  'Write(//etc/**)',
+  'Write(//usr/**)',
+  'Write(//System/**)',
+  'Write(//bin/**)',
+  'Write(//sbin/**)',
+  'Write(//Library/**)',
+  'Edit(//etc/**)',
+  'Edit(//usr/**)',
+  'Edit(//System/**)',
+  'Edit(//bin/**)',
+  'Edit(//sbin/**)',
+  'Edit(//Library/**)',
+
+  // Credentials and secrets
+  'Read(~/.ssh/**)',
+  'Read(~/.aws/credentials)',
+  'Read(~/.aws/config)',
+  'Read(~/.gnupg/**)',
+  'Read(~/.config/gh/hosts.yml)',
+  'Read(~/.docker/config.json)',
+  'Read(~/.npmrc)',
+  'Read(~/.pypirc)',
+  'Read(~/.netrc)',
+
+  // Accidental publish
+  'Bash(npm publish:*)',
+  'Bash(yarn publish:*)',
+  'Bash(pnpm publish:*)',
+  'Bash(pip upload:*)',
+  'Bash(twine upload:*)',
+  'Bash(cargo publish:*)',
+];
+
+/**
+ * Group HOOK_REGISTRY entries by event, then by matcher within each event.
+ * Returns the shape Claude Code expects under the top-level "hooks" key.
+ */
+function buildHooksObject() {
+  const events = {};
+
+  for (const entry of HOOK_REGISTRY) {
+    if (!events[entry.event]) events[entry.event] = new Map();
+    const matcherGroups = events[entry.event];
+    if (!matcherGroups.has(entry.matcher)) {
+      matcherGroups.set(entry.matcher, []);
+    }
+    matcherGroups.get(entry.matcher).push({
+      type: 'command',
+      command: `node .chati.dev/hooks/${entry.name}.js`,
+    });
+  }
+
+  const result = {};
+  for (const [event, matcherGroups] of Object.entries(events)) {
+    result[event] = [];
+    for (const [matcher, hooks] of matcherGroups.entries()) {
+      const group = { hooks };
+      if (matcher) group.matcher = matcher;
+      result[event].push(group);
+    }
+  }
+  return result;
+}
+
+/**
+ * Generate the full settings.json content.
+ *
+ * @returns {string} JSON string with trailing newline, ready to write to disk.
+ */
+export function generateClaudeSettings() {
+  const settings = {
+    $schema: 'https://json.schemastore.org/claude-code-settings.json',
+    permissions: {
+      allow: PERMISSIONS_ALLOW,
+      deny: PERMISSIONS_DENY,
+      defaultMode: 'default',
+    },
+    hooks: buildHooksObject(),
+  };
+
+  return JSON.stringify(settings, null, 2) + '\n';
+}
+
+export {
+  HOOK_REGISTRY,
+  PERMISSIONS_ALLOW,
+  PERMISSIONS_DENY,
+};

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

@@ -13,6 +13,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { getEnabledNonClaudeProviders } from '../utils/config-parser.js';
+import { resolveFrameworkDir } from '../utils/framework-dir.js';
 
 // ---------------------------------------------------------------------------
 // Replacement Maps
@@ -48,23 +49,34 @@ const CODEX_STRIP_PATTERNS = [
 ];
 
 /**
- * Text replacements for Codex CLI context file.
- * Note: Codex has no commands/ or rules/ directories — references point to chati.dev/.
+ * 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
  */
-const CODEX_REPLACEMENTS = [
-  ['Claude Code', 'Codex CLI'],
-  ['claude code', 'Codex CLI'],
-  ['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.override.md'],
-  ['/chati', '$chati'],
-];
+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/`],
+    ['.claude/mcp.json', '.codex/config.toml'],
+    ['claude --print', 'codex exec'],
+    ['claude -p', 'codex exec'],
+    ['CLAUDE.local.md', 'AGENTS.override.md'],
+    ['/chati', '$chati'],
+  ];
+}
+
+/**
+ * Text replacements for Codex CLI context file (legacy constant using default 'chati.dev/' prefix).
+ * @deprecated Use buildCodexReplacements(frameworkDir) for correct path resolution.
+ */
+const CODEX_REPLACEMENTS = buildCodexReplacements();
 
 // ---------------------------------------------------------------------------
 // Generators
@@ -122,10 +134,12 @@ export function generateGeminiMd(content) {
  *
  * @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
  */
-export function generateAgentsMd(content, contextFiles = null) {
+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) {
@@ -133,7 +147,7 @@ export function generateAgentsMd(content, contextFiles = null) {
   }
 
   // Apply text replacements
-  for (const [search, replace] of CODEX_REPLACEMENTS) {
+  for (const [search, replace] of replacements) {
     result = result.replaceAll(search, replace);
   }
 
@@ -155,7 +169,7 @@ export function generateAgentsMd(content, contextFiles = null) {
       if (fileContent) {
         // Adapt context for Codex (replace Claude-specific refs)
         let adapted = fileContent;
-        for (const [search, replace] of CODEX_REPLACEMENTS) {
+        for (const [search, replace] of replacements) {
           adapted = adapted.replaceAll(search, replace);
         }
         sections.push(adapted.trim());
@@ -213,6 +227,9 @@ export function generateContextFiles(projectDir, baseContent = null) {
   // Read context files for inline injection (Codex)
   const contextFiles = readContextFilesFromDisk(projectDir);
 
+  // Resolve framework directory for dynamic path generation
+  const fwDir = resolveFrameworkDir(projectDir);
+
   // Provider-to-generator mapping
   const generators = {
     gemini: {
@@ -221,7 +238,7 @@ export function generateContextFiles(projectDir, baseContent = null) {
     },
     codex: {
       filename: 'AGENTS.md',
-      generate: (content) => generateAgentsMd(content, contextFiles),
+      generate: (content) => generateAgentsMd(content, contextFiles, fwDir),
     },
   };
 
@@ -247,7 +264,10 @@ export function generateContextFiles(projectDir, baseContent = null) {
  * @returns {object|null} { root, governance, protocols, quality } or null
  */
 function readContextFilesFromDisk(projectDir) {
-  const contextDir = join(projectDir, 'chati.dev', 'context');
+  // 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;
   if (!existsSync(contextDir)) return null;
 
   const files = {};

package/src/config/framework-adapter.js

@@ -31,6 +31,7 @@ export const ADAPTABLE_FILES = new Set([
   'agents/plan/tasks.md',
   'agents/quality/qa-planning.md',
   'agents/quality/qa-implementation.md',
+  'agents/quality/qa-visual.md',
   'agents/build/dev.md',
   'agents/deploy/devops.md',
   'context/governance.md',

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' },
@@ -30,6 +34,7 @@ export const HOOK_MAP = {
   'session-digest': { event: 'PreCompress', description: 'Save session state before context compression' },
   'undercover-guard': { event: 'BeforeTool', description: 'Advisory: sanitize internal framework references from deliverables' },
   'style-guard': { event: 'BeforeTool', description: 'Advisory: enforce em-dash and emoji standards' },
+  'team-quality-gate': { event: 'BeforeTool', description: 'Validate team task completion and quality scores before handoff (Article XXI)' },
 };
 
 // ---------------------------------------------------------------------------
@@ -53,6 +58,16 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = join(__filename, '..');
 const projectRoot = join(__dirname, '..', '..');
+
+/**
+ * Resolve framework directory (supports .chati.dev/ and legacy chati.dev/).
+ * @param {string} cwd - Project root directory
+ */
+function resolveFrameworkDir(cwd) {
+  const newPath = join(cwd, '.chati.dev');
+  if (existsSync(newPath)) return '.chati.dev';
+  return 'chati.dev';
+}
 `;
 
 /**
@@ -82,7 +97,7 @@ async function main() {
     }
 
     // Delegate to shared PRISM engine logic
-    const hookPath = join(cwd, 'chati.dev', 'hooks', 'prism-engine.js');
+    const hookPath = join(cwd, resolveFrameworkDir(cwd), 'hooks', 'prism-engine.js');
     if (existsSync(hookPath)) {
       const mod = await import(hookPath);
       if (typeof mod.buildPrismContext === 'function') {
@@ -137,7 +152,7 @@ async function main() {
 
     if (agent) {
       // Delegate to shared model governance logic
-      const hookPath = join(cwd, 'chati.dev', 'hooks', 'model-governance.js');
+      const hookPath = join(cwd, resolveFrameworkDir(cwd), 'hooks', 'model-governance.js');
       if (existsSync(hookPath)) {
         const mod = await import(hookPath);
         if (typeof mod.getRecommendedModel === 'function') {
@@ -171,8 +186,9 @@ function generateModeGovernance() {
  * Blocks write operations outside current mode scope.
  * Constitution Article XI enforcement.
  */
+const fwDir = existsSync(join(process.cwd(), '.chati.dev')) ? '.chati.dev' : 'chati.dev';
 const MODE_SCOPES = {
-  planning: { allowed: ['chati.dev/', '.chati/', 'chati.dev/artifacts/'] },
+  planning: { allowed: [fwDir + '/', '.chati/', 'artifacts/'] },
   build: { allowed: ['*'] },
   deploy: { allowed: ['*'] },
 };
@@ -443,7 +459,7 @@ async function main() {
     const cwd = event.cwd || process.cwd();
 
     // Delegate to shared session digest logic
-    const hookPath = join(cwd, 'chati.dev', 'hooks', 'session-digest.js');
+    const hookPath = join(cwd, resolveFrameworkDir(cwd), 'hooks', 'session-digest.js');
     if (existsSync(hookPath)) {
       const mod = await import(hookPath);
       if (typeof mod.saveDigest === 'function') {
@@ -491,7 +507,7 @@ async function main() {
     }
 
     // Delegate to shared undercover guard logic
-    const hookPath = join(cwd, 'chati.dev', 'hooks', 'undercover-guard.js');
+    const hookPath = join(cwd, resolveFrameworkDir(cwd), 'hooks', 'undercover-guard.js');
     if (!existsSync(hookPath)) {
       console.log(JSON.stringify({}));
       return;
@@ -561,7 +577,7 @@ async function main() {
     }
 
     // Delegate to shared style guard logic
-    const hookPath = join(cwd, 'chati.dev', 'hooks', 'style-guard.js');
+    const hookPath = join(cwd, resolveFrameworkDir(cwd), 'hooks', 'style-guard.js');
     if (!existsSync(hookPath)) {
       console.log(JSON.stringify({}));
       return;
@@ -611,6 +627,7 @@ main();
  */
 export function generateAllGeminiHooks() {
   return {
+    'license-guard.js': generateLicenseGuard(),
     'prism-engine.js': generatePrismEngine(),
     'model-governance.js': generateModelGovernance(),
     'mode-governance.js': generateModeGovernance(),
@@ -622,6 +639,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, resolveFrameworkDir(cwd), '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/config/mcp-configs.js

@@ -42,6 +42,7 @@ export const AGENT_MCP_DEPS = {
   'qa-planning':       { required: [],            optional: [] },
   dev:                 { required: ['context7'],  optional: ['browser'] },
   'qa-implementation': { required: [],            optional: ['browser'] },
+  'qa-visual':         { required: [],            optional: ['browser'] },
   devops:              { required: [],            optional: [] },
 };
 

package/src/context/layers/l1-global.js

@@ -6,6 +6,7 @@
  */
 
 import { loadGlobalDomain, extractRules } from '../domain-loader.js';
+import { resolveFrameworkDir } from '../../utils/framework-dir.js';
 
 // Maps session states to governance modes for domain lookup
 const STATE_TO_GOVERNANCE_MODE = {
@@ -40,7 +41,7 @@ export function processL1(ctx) {
     rules,
     mode: sessionMode,
     modeRules: {
-      writeScope: modeRules.writeScope || 'chati.dev/',
+      writeScope: modeRules.writeScope || resolveFrameworkDir(ctx.projectDir || process.cwd()) + '/',
       allowedActions: modeRules.allowedActions || [],
       blockedActions: modeRules.blockedActions || [],
     },

package/src/dashboard/data-reader.js

@@ -1,6 +1,7 @@
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join } from 'path';
 import yaml from 'js-yaml';
+import { resolveFrameworkDir } from '../utils/framework-dir.js';
 
 /**
  * Read all dashboard data from project directory
@@ -31,7 +32,7 @@ export async function readDashboardData(targetDir) {
   }
 
   // Read config.yaml
-  const configPath = join(targetDir, 'chati.dev', 'config.yaml');
+  const configPath = join(targetDir, resolveFrameworkDir(targetDir), 'config.yaml');
   if (existsSync(configPath)) {
     try {
       data.config = yaml.load(readFileSync(configPath, 'utf-8'));
@@ -59,7 +60,7 @@ export async function readDashboardData(targetDir) {
   }
 
   // Read task progress from artifacts
-  const tasksDir = join(targetDir, 'chati.dev', 'artifacts', '6-Tasks');
+  const tasksDir = join(targetDir, 'artifacts', '6-Tasks');
   if (existsSync(tasksDir)) {
     try {
       const files = readdirSync(tasksDir).filter(f => f.endsWith('.yaml') || f.endsWith('.md'));
@@ -70,7 +71,7 @@ export async function readDashboardData(targetDir) {
   }
 
   // Read gotchas
-  const gotchasPath = join(targetDir, 'chati.dev', 'intelligence', 'gotchas.yaml');
+  const gotchasPath = join(targetDir, resolveFrameworkDir(targetDir), 'intelligence', 'gotchas.yaml');
   if (existsSync(gotchasPath)) {
     try {
       const gotchasData = yaml.load(readFileSync(gotchasPath, 'utf-8'));

package/src/dashboard/layout.js

@@ -62,7 +62,8 @@ export function buildProjectInfo(data) {
   const name = project.name || 'unknown';
   const type = project.type === 'brownfield' ? 'Brownfield' : 'Greenfield';
   const state = formatState(project.state);
-  const mode = formatMode(session.execution_mode);
+  const rawMode = session.execution_mode;
+  const mode = formatMode(rawMode && typeof rawMode === 'object' ? rawMode.mode : rawMode);
   const lang = session.language || 'en';
   // Show the provider-specific IDE (last in the list) rather than always claude-code
   const ides = session.ides || [];