chati-dev 4.2.0 → 4.2.2

package/framework/orchestrator/chati.md

@@ -83,13 +83,20 @@ Parse the JSON output. The `action` field tells you what to do:
 | `complete` | Action: Complete |
 | `error` | Display error, suggest `/chati status` |
 
-**After every action**, display context bracket from JSON `context_bracket`:
-```
-FRESH    → "Context: FRESH ({remaining}%) — Proceeding to {agent}"
-MODERATE → "Context: MODERATE ({remaining}%) — Proceeding (context layers reduced)"
-DEPLETED → "Context: DEPLETED ({remaining}%) — Warning: context running low"
-CRITICAL → "Context: CRITICAL ({remaining}%) — Initiating handoff protocol"
-```
+**Internal: track context bracket from JSON `context_bracket` but DO NOT display it to the user.** The bracket is internal telemetry — users should never see "Context: FRESH (90%)" or framework jargon like "Initiating handoff protocol". Speak in natural language about what you are doing, not the internal state.
+
+Only mention the bracket when it reaches CRITICAL, and only in plain language. Example: "I'm running low on memory — let me wrap up the current step before continuing." Never say "CRITICAL bracket", "PRISM", "L0-L5", "deviation protocol", or other internal framework terms.
+
+**Never reveal agent technical names** to the user. Refer to phases naturally:
+- `greenfield-wu` / `brownfield-wu` → "let's understand your goals"
+- `brief` → "let's confirm what we're building"
+- `detail` → "let's expand the requirements"
+- `architect` → "let's design the architecture"
+- `ux` → "let's design the user experience"
+- `phases` / `tasks` → "let's break this down into phases"
+- `qa-planning` / `qa-implementation` → "let's review what we have"
+- `dev` → "let's build it"
+- `devops` → "let's deploy it"
 
 ---
 
@@ -135,11 +142,7 @@ The user should experience a smooth start: they describe their project, the orch
 
 These agents (greenfield-wu, brownfield-wu, brief) run in the same conversation.
 
-1. Display model recommendation from JSON `model_info`:
-   ```
-   Model recommendation for {agent}: {model} ({upgrade condition})
-   To switch: /model {model}
-   ```
+1. Track model recommendation from JSON `model_info` internally. Do NOT display "Model recommendation for {agent}" or expose internal agent names. If the recommended model is materially different from the current one and the difference will affect quality, mention it briefly in plain language: e.g., "This step works best on Opus — switch with /model opus if you want stronger reasoning." Otherwise stay silent.
 2. Read the agent file from `agent_file` in the JSON response
 3. Load its full content and **become** that agent
 4. Follow the agent's instructions — the user interacts with you directly
@@ -206,17 +209,17 @@ Quality gate passed: {score}%.
 
 These agents run in separate Claude Code processes.
 
-1. Display context bracket status from JSON
+1. Track context bracket internally — do NOT display it.
 2. Check `handoff_status.valid` from JSON:
-   - If `false` with missing fields:
+   - If `false` with missing fields, present user-facing options in plain language:
      ```
-     Context check: FAILED — missing: {missing_fields}
-     1. Re-run previous agent to regenerate handoff (Recommended)
-     2. Continue anyway (risk: missing context)
-     3. Manual context injection (provide missing info)
+     I noticed some context from the previous step is missing. How should I proceed?
+     1. Redo the previous step to regenerate the missing information (Recommended)
+     2. Continue anyway, with the missing context
+     3. Provide the missing details manually
      ```
-   - If warnings only: display warnings, proceed
-   - If `true`: display "Context check: OK — handoff verified"
+   - If warnings only: proceed silently. Only mention the warning if it directly affects what the user just asked for.
+   - If `true`: proceed silently. Do NOT announce "Context check: OK".
 3. Execute `spawn_command` via Bash tool (the full command is in the JSON)
 4. Wait for JSON output from the spawned process. Handle `status`:
    - `"complete"` → Present **Completion Options** (see above) → on approval, run `orchestrate advance --agent {name} --score {score}`
@@ -240,7 +243,7 @@ Planning phase agents (detail, architect, ux) run simultaneously.
 
 **NOTE (Article XXI):** When `features.agent_teams: true` in config.yaml, the orchestrator MUST attempt `spawn_team` FIRST for GROUP 1 agents (detail, architect, ux) and BUILD pair (dev, qa-implementation). Only fall back to `spawn_parallel` if team spawning is unavailable or fails. The CLI `orchestrate next` command handles this automatically — when teams are enabled, it returns `spawn_team` instead of `spawn_parallel`.
 
-1. Display: "Spawning parallel group: {agents}"
+1. Display naturally what is happening using user-facing language. Examples (pick one that fits the phase): "Working on the planning phase now." / "Reviewing the architecture and UX in parallel." NEVER say "spawning parallel group", "spawn_parallel", or list internal agent names like "detail, architect, ux".
 2. Execute `parallel_spawn_command` via Bash tool
 3. Parse consolidated JSON output
 4. Present **Completion Options** (Parallel Group variant) — wait for user choice
@@ -271,7 +274,7 @@ node packages/chati-dev/bin/chati.js orchestrate spawn-team --team-type {plannin
 ```
 Parse JSON. If `fallback_required: true` → fall back silently to `spawn_parallel`. Do NOT display error messages.
 
-Display: "Forming {team_type} team: {members}"
+Display naturally what the team is doing using user-facing language. For Planning Team: "Working on the planning — designing the requirements, architecture, and user experience together." For Build Team: "Building this with continuous quality review." NEVER say "team", "spawn_team", "Article XXI", "mailbox", "Planning Team", or list internal agent names.
 
 ### Step 2: Spawn Teammates via Agent Tool
 
@@ -413,13 +416,13 @@ If the Agent tool is unavailable or any sub-agent spawn fails:
 
 The user is returning to an active session.
 
-1. Present `status_summary` from JSON in the user's language
-2. Display context bracket
-3. Offer options:
+1. Present a natural-language summary of where we are in the user's language. Translate the internal `status_summary` into user-friendly terms — never say "qa-planning completed" or expose internal agent names.
+2. Track context bracket internally — do NOT display.
+3. Offer options in plain language (translate internal agent names to user-facing phase descriptions):
    ```
-   1. Continue with {next_agent} (Recommended)
-   2. Review last output
-   3. View full status (/chati status)
+   1. Continue (Recommended)
+   2. Review what we just produced
+   3. Show me the full project status
    ```
 
 ---

package/package.json

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

package/scripts/validate-package.js

@@ -166,6 +166,114 @@ function checkBinExists(packageRoot, results) {
   }
 }
 
+/**
+ * Validate that every hook referenced in hooks/settings.json exists on disk.
+ * Prevents shipping a bundle where settings.json references a hook file that
+ * was never copied.
+ */
+function checkHooksParity(packageRoot, results) {
+  results.checks++;
+  const settingsPath = join(packageRoot, 'framework', 'hooks', 'settings.json');
+  if (!existsSync(settingsPath)) {
+    results.warnings.push('framework/hooks/settings.json not found — skipping hooks parity check.');
+    results.passed++;
+    return;
+  }
+
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    const missing = new Set();
+    const hooksDir = join(packageRoot, 'framework', 'hooks');
+
+    // Walk all hook events and collect referenced .js files
+    for (const event of Object.keys(settings.hooks || {})) {
+      for (const matcher of settings.hooks[event] || []) {
+        for (const hook of matcher.hooks || []) {
+          if (hook.type === 'command' && typeof hook.command === 'string') {
+            // command format: "node chati.dev/hooks/foo.js"
+            const match = hook.command.match(/hooks\/([^\s]+\.js)/);
+            if (match) {
+              const hookFile = match[1];
+              if (!existsSync(join(hooksDir, hookFile))) {
+                missing.add(hookFile);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (missing.size === 0) {
+      results.passed++;
+    } else {
+      results.errors.push(`Hooks referenced in settings.json but missing from framework/hooks/: ${[...missing].join(', ')}`);
+    }
+  } catch (err) {
+    results.errors.push(`Failed to parse hooks/settings.json: ${err.message}`);
+  }
+}
+
+/**
+ * Parity check: every file in source chati.dev/ (that belongs to a copied
+ * directory) must exist in framework/. Catches bundling bugs where new files
+ * are added to the source but not included in the bundle.
+ *
+ * Only runs when the monorepo source is available (skipped inside the
+ * published package since the source is not shipped).
+ */
+function checkSourceBundleParity(packageRoot, results) {
+  results.checks++;
+  const monorepoSource = join(packageRoot, '..', '..', 'chati.dev');
+  const bundleDir = join(packageRoot, 'framework');
+
+  if (!existsSync(monorepoSource)) {
+    // Running inside the published package — skip (nothing to compare against)
+    results.passed++;
+    return;
+  }
+
+  // Collect all files in source, grouped by the top-level directory
+  const missing = [];
+  const COPIED_DIRS = [
+    'orchestrator', 'agents', 'templates', 'workflows', 'quality-gates',
+    'schemas', 'frameworks', 'intelligence', 'patterns', 'hooks',
+    'domains', 'i18n', 'migrations', 'data', 'context', 'tasks', 'presets',
+  ];
+  const COPIED_ROOT_FILES = ['constitution.md'];
+
+  function walk(srcDir, relBase) {
+    if (!existsSync(srcDir)) return;
+    for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+      const srcPath = join(srcDir, entry.name);
+      const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(srcPath, relPath);
+      } else if (entry.isFile()) {
+        const bundlePath = join(bundleDir, relPath);
+        if (!existsSync(bundlePath)) missing.push(relPath);
+      }
+    }
+  }
+
+  for (const file of COPIED_ROOT_FILES) {
+    const src = join(monorepoSource, file);
+    const bundled = join(bundleDir, file);
+    if (existsSync(src) && !existsSync(bundled)) missing.push(file);
+  }
+
+  for (const dir of COPIED_DIRS) {
+    walk(join(monorepoSource, dir), dir);
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    const sample = missing.slice(0, 10).join(', ');
+    const more = missing.length > 10 ? ` (+ ${missing.length - 10} more)` : '';
+    results.errors.push(`Files in source chati.dev/ missing from framework/ bundle: ${sample}${more}`);
+  }
+}
+
 /**
  * Compare entity count in registry vs actual files in framework/.
  */
@@ -201,12 +309,146 @@ function checkEntityCount(packageRoot, results) {
   }
 }
 
+/**
+ * v4.2.2: Validate that generateClaudeSettings() produces a settings.json
+ * that wires all 10 chati hooks via the canonical hookSpecificOutput schema
+ * — at the right events and with paths that resolve to existing files.
+ *
+ * This catches the v4.2.0/v4.2.1 catastrophe (hooks dormant because the
+ * installer never wrote .claude/settings.json) at validation time.
+ */
+async function checkClaudeHooksWired(packageRoot, results) {
+  results.checks++;
+  try {
+    const genPath = join(packageRoot, 'src', 'config', 'claude-settings-generator.js');
+    if (!existsSync(genPath)) {
+      results.errors.push('claude-settings-generator.js missing — Claude hooks would not be wired in installs.');
+      return;
+    }
+
+    const mod = await import(genPath);
+    if (typeof mod.generateClaudeSettings !== 'function') {
+      results.errors.push('claude-settings-generator.js does not export generateClaudeSettings.');
+      return;
+    }
+
+    const settings = JSON.parse(mod.generateClaudeSettings());
+
+    // Verify required events
+    const requiredEvents = ['UserPromptSubmit', 'PreToolUse', 'PreCompact'];
+    const missingEvents = requiredEvents.filter(e => !settings.hooks?.[e]);
+    if (missingEvents.length > 0) {
+      results.errors.push(`generateClaudeSettings missing events: ${missingEvents.join(', ')}`);
+      return;
+    }
+
+    // Collect all referenced hook commands
+    const allCommands = [];
+    for (const event of Object.values(settings.hooks)) {
+      for (const group of event) {
+        for (const hook of group.hooks || []) {
+          allCommands.push(hook.command || '');
+        }
+      }
+    }
+
+    // Verify all 10 chati hooks are referenced
+    const requiredHooks = [
+      'license-guard', 'prism-engine', 'model-governance',
+      'read-protection', 'constitution-guard', 'mode-governance',
+      'style-guard', 'undercover-guard', 'team-quality-gate', 'session-digest',
+    ];
+    const missingHooks = requiredHooks.filter(h => !allCommands.some(c => c.includes(h)));
+    if (missingHooks.length > 0) {
+      results.errors.push(`generateClaudeSettings missing hook references: ${missingHooks.join(', ')}`);
+      return;
+    }
+
+    // Verify each referenced hook file exists in framework/hooks/
+    const hooksDir = join(packageRoot, 'framework', 'hooks');
+    if (existsSync(hooksDir)) {
+      const missingFiles = [];
+      for (const cmd of allCommands) {
+        const match = cmd.match(/hooks\/([^\s]+\.js)/);
+        if (match && !existsSync(join(hooksDir, match[1]))) {
+          missingFiles.push(match[1]);
+        }
+      }
+      if (missingFiles.length > 0) {
+        results.errors.push(`Claude settings reference hook files missing from bundle: ${missingFiles.join(', ')}`);
+        return;
+      }
+    }
+
+    results.passed++;
+  } catch (err) {
+    results.errors.push(`checkClaudeHooksWired failed: ${err.message}`);
+  }
+}
+
+/**
+ * v4.2.2: Verify license-guard is wired for ALL three providers.
+ * Without this, an expired trial keeps working forever — exactly the bug
+ * the user flagged in v4.2.1 (they could see chati.dev with no license check).
+ */
+async function checkLicenseEntryPointAcrossProviders(packageRoot, results) {
+  results.checks++;
+  try {
+    const missing = [];
+
+    // Claude — settings.json must include license-guard in UserPromptSubmit
+    const genPath = join(packageRoot, 'src', 'config', 'claude-settings-generator.js');
+    if (existsSync(genPath)) {
+      const mod = await import(genPath);
+      const settings = JSON.parse(mod.generateClaudeSettings());
+      const ups = settings.hooks?.UserPromptSubmit || [];
+      const claudeCmds = ups.flatMap(g => (g.hooks || []).map(h => h.command || ''));
+      if (!claudeCmds.some(c => c.includes('license-guard'))) {
+        missing.push('Claude (UserPromptSubmit)');
+      }
+    } else {
+      missing.push('Claude (generator file missing)');
+    }
+
+    // Gemini — HOOK_MAP must include license-guard at BeforeModel
+    const geminiPath = join(packageRoot, 'src', 'config', 'gemini-hooks-generator.js');
+    if (existsSync(geminiPath)) {
+      const mod = await import(geminiPath);
+      if (!mod.HOOK_MAP?.['license-guard'] || mod.HOOK_MAP['license-guard'].event !== 'BeforeModel') {
+        missing.push('Gemini (HOOK_MAP missing license-guard at BeforeModel)');
+      }
+    } else {
+      missing.push('Gemini (generator file missing)');
+    }
+
+    // Codex — installer/core.js must write .codex/hooks.json with license-guard
+    const corePath = join(packageRoot, 'src', 'installer', 'core.js');
+    if (existsSync(corePath)) {
+      const coreContent = readFileSync(corePath, 'utf-8');
+      if (!coreContent.includes('.codex/hooks.json') || !coreContent.includes("license-guard")) {
+        missing.push('Codex (.codex/hooks.json not wired with license-guard in core.js)');
+      }
+    } else {
+      missing.push('Codex (core.js missing)');
+    }
+
+    if (missing.length > 0) {
+      results.errors.push(`License enforcement gaps: ${missing.join('; ')}`);
+      return;
+    }
+
+    results.passed++;
+  } catch (err) {
+    results.errors.push(`checkLicenseEntryPointAcrossProviders failed: ${err.message}`);
+  }
+}
+
 /**
  * Validate the npm package completeness.
  * @param {string} packageRoot - Root of the package (packages/chati-dev/)
- * @returns {{ errors: string[], warnings: string[], checks: number, passed: number }}
+ * @returns {Promise<{ errors: string[], warnings: string[], checks: number, passed: number }>}
  */
-export function validatePackage(packageRoot) {
+export async function validatePackage(packageRoot) {
   const results = { errors: [], warnings: [], checks: 0, passed: 0 };
 
   checkFrameworkExists(packageRoot, results);
@@ -216,6 +458,10 @@ export function validatePackage(packageRoot) {
   checkExportsResolve(packageRoot, results);
   checkBinExists(packageRoot, results);
   checkEntityCount(packageRoot, results);
+  checkHooksParity(packageRoot, results);
+  checkSourceBundleParity(packageRoot, results);
+  await checkClaudeHooksWired(packageRoot, results);
+  await checkLicenseEntryPointAcrossProviders(packageRoot, results);
 
   return results;
 }
@@ -247,11 +493,13 @@ function formatResults(results) {
 // CLI entry point
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
   const packageRoot = join(__dirname, '..');
-  const results = validatePackage(packageRoot);
-
-  console.log(formatResults(results));
-
-  if (results.errors.length > 0) {
+  validatePackage(packageRoot).then(results => {
+    console.log(formatResults(results));
+    if (results.errors.length > 0) {
+      process.exit(1);
+    }
+  }).catch(err => {
+    console.error('validate-package failed:', err);
     process.exit(1);
-  }
+  });
 }

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

@@ -0,0 +1,206 @@
+/**
+ * Claude Code settings.json generator.
+ *
+ * Produces .claude/settings.json content that wires the 10 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 10 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.
+  // license-guard MUST be first so license check runs before any other work.
+  { name: 'license-guard',     event: 'UserPromptSubmit', matcher: '.*' },
+  { name: 'prism-engine',      event: 'UserPromptSubmit', matcher: '.*' },
+  { name: 'model-governance',  event: 'UserPromptSubmit', matcher: '.*' },
+
+  // PreToolUse — fires before each tool call. Matcher targets specific tools.
+  { 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' },
+
+  // 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',
+];
+
+/**
+ * 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,
+};