@haposoft/cafekit 0.16.0-rc.8 → 0.16.1

package/src/claude/scripts/generate-skill-catalog.cjs

@@ -1,184 +1,218 @@
 #!/usr/bin/env node
-/**
- * CafeKit skill catalog scanner.
- *
- * This mirrors the Research/.claude approach: expose the installed skill set as
- * a readable catalog so the model can choose skills from rules, not from an
- * automatic prompt-scoring hook.
- */
+/** Generate a fail-closed catalog from the current runtime's installed skills. */
+
+'use strict';
 
 const fs = require('fs');
 const path = require('path');
 
+// Keep synchronized with migration-manifest.json obsolete.skills. Modified
+// retired directories may remain on disk, but they are never automatic routes.
+const RETIRED_DIRECTORIES = new Set([
+  'backend-development',
+  'frontend-development',
+  'frontend-design',
+  'mobile-development',
+  'devops',
+  'react-best-practices',
+]);
+const PUBLIC_SUFFIX_BY_DIRECTORY = {
+  hotfix: 'fix',
+  inspect: 'scout',
+  question: 'ask',
+};
+
 function usage() {
   console.log(`Usage:
-  node .claude/scripts/generate-skill-catalog.cjs [--skills] [--json] [--root <skills-dir>]
+  node <runtime>/scripts/generate-skill-catalog.cjs [--skills] [--json] [--root <skills-dir>]
 
-Examples:
-  node .claude/scripts/generate-skill-catalog.cjs --skills
-  node .claude/scripts/generate-skill-catalog.cjs --json --root .claude/skills`);
+The default root is bound to the script runtime: .claude/skills for Claude,
+.agents/skills for Codex, and ../skills for the source tree.`);
 }
 
 function parseArgs(argv) {
   const args = { json: false, help: false, root: null };
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
     if (arg === '--help' || arg === '-h') args.help = true;
     else if (arg === '--json') args.json = true;
     else if (arg === '--skills') continue;
     else if (arg === '--root') {
-      args.root = argv[i + 1] || null;
-      i += 1;
-    } else {
-      args.root = args.root || arg;
-    }
+      if (!argv[index + 1] || argv[index + 1].startsWith('--')) {
+        throw new Error('--root requires a skills directory');
+      }
+      args.root = argv[++index];
+    } else throw new Error(`unknown option: ${arg}`);
   }
   return args;
 }
 
 function defaultSkillsRoot() {
-  const candidates = [
-    path.resolve(__dirname, '..', 'skills'),
-    path.resolve(process.cwd(), '.claude', 'skills'),
-    path.resolve(process.cwd(), '.agents', 'skills'),
-    path.resolve(__dirname, '..', '..', '.agents', 'skills')
-  ];
-  return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[0];
-}
-
-function readText(filePath) {
-  return fs.readFileSync(filePath, 'utf8');
+  const runtimeRoot = path.dirname(__dirname);
+  const runtimeName = path.basename(runtimeRoot);
+  if (runtimeName === '.codex') return path.join(path.dirname(runtimeRoot), '.agents', 'skills');
+  const claudeRuntimeName = `.${['cla', 'ude'].join('')}`;
+  if (runtimeName === claudeRuntimeName) return path.join(runtimeRoot, 'skills');
+  return path.resolve(__dirname, '..', 'skills');
 }
 
 function extractFrontmatter(content) {
-  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
-  if (!match) return {};
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match) return null;
   const frontmatter = {};
   const lines = match[1].split(/\r?\n/);
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i];
-    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
-    if (!kv) continue;
-    const key = kv[1];
-    let value = kv[2].trim();
-    if (value === '>' || value === '>-' || value === '|' || value === '|-') {
+  const seen = new Set();
+  let nestedKey = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.trim() === '') continue;
+    if (/^\s+/.test(line)) {
+      const nested = line.match(/^  ([A-Za-z0-9_-]+):\s*(\S.*)$/);
+      if (!nestedKey || !nested) return null;
+      const identity = `${nestedKey}.${nested[1]}`;
+      if (seen.has(identity) || quotedValue(nested[2]) === null) return null;
+      seen.add(identity);
+      continue;
+    }
+    nestedKey = null;
+    const parsed = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!parsed || seen.has(parsed[1])) return null;
+    seen.add(parsed[1]);
+    let value = parsed[2].trim();
+    if (['>', '>-', '|', '|-'].includes(value)) {
       const block = [];
-      i += 1;
-      while (i < lines.length && /^\s+/.test(lines[i])) {
-        block.push(lines[i].trim());
-        i += 1;
+      while (index + 1 < lines.length && /^\s+/.test(lines[index + 1])) {
+        block.push(lines[++index].trim());
       }
-      i -= 1;
+      if (block.length === 0) return null;
       value = block.join(' ');
     }
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
-      value = value.slice(1, -1);
+    if (value === '') {
+      nestedKey = parsed[1];
+      frontmatter[parsed[1]] = '';
+      continue;
     }
-    frontmatter[key] = value;
+    value = quotedValue(value);
+    if (value === null) return null;
+    frontmatter[parsed[1]] = value;
   }
   return frontmatter;
 }
 
-function firstParagraph(content) {
-  const body = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, '');
-  const paragraph = [];
-  for (const rawLine of body.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith('#')) {
-      if (paragraph.length > 0) break;
-      continue;
-    }
-    paragraph.push(line);
-    if (paragraph.join(' ').length > 160) break;
+function quotedValue(value) {
+  const startsQuote = value.startsWith('"') || value.startsWith("'");
+  const endsQuote = value.endsWith('"') || value.endsWith("'");
+  const startsFlow = value.startsWith('[') || value.startsWith('{');
+  const endsFlow = value.endsWith(']') || value.endsWith('}');
+  if (startsFlow || endsFlow) {
+    const expected = value.startsWith('[') ? ']' : value.startsWith('{') ? '}' : null;
+    if (!expected || !value.endsWith(expected)) return null;
   }
-  return paragraph.join(' ').slice(0, 360);
+  if (!startsQuote && !endsQuote) return value;
+  if (value.length < 2 || value[0] !== value[value.length - 1]) return null;
+  return value.slice(1, -1);
 }
 
-function categorize(name, description) {
-  const text = `${name} ${description}`.toLowerCase();
-  if (/spec|brainstorm|develop|sync/.test(text)) return 'workflow';
-  if (/debug|hotfix|inspect|impact|review|test|agent-browser|chrome/.test(text)) return 'quality';
-  if (/frontend|react|ui|ux|mobile/.test(text)) return 'frontend-mobile';
-  if (/pdf|docx|pptx|xlsx|multimodal/.test(text)) return 'artifacts-tools';
-  if (/backend|devops|api|database|deploy/.test(text)) return 'backend-infra';
-  if (/docs|research|graph/.test(text)) return 'knowledge';
-  if (/git/.test(text)) return 'git';
-  return 'other';
+function parseKeywords(value) {
+  if (!value || !/^\[[^\]]*\]$/.test(value)) return [];
+  return value.slice(1, -1).split(',').map((item) => item.trim()).filter(Boolean);
 }
 
-function scanSkills(root) {
-  if (!fs.existsSync(root)) {
-    throw new Error(`skills root not found: ${root}`);
-  }
-  const entries = fs.readdirSync(root, { withFileTypes: true });
-  const skills = [];
+function publicIdentity(name) {
+  const match = String(name).match(/^cf(?::|-)([a-z0-9]+(?:-[a-z0-9]+)*)$/);
+  return match ? `cf:${match[1]}` : null;
+}
+
+function expectedIdentity(directory) {
+  return `cf:${PUBLIC_SUFFIX_BY_DIRECTORY[directory] || directory}`;
+}
+
+function diagnostic(code, directory, message) {
+  return { code, directory, message };
+}
+
+function scanSkills(requestedRoot) {
+  if (!fs.existsSync(requestedRoot)) throw new Error(`skills root not found: ${requestedRoot}`);
+  const root = fs.realpathSync(requestedRoot);
+  const diagnostics = [];
+  const candidates = [];
+  const entries = fs.readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+    .sort((left, right) => left.name.localeCompare(right.name));
+
   for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
     const skillPath = path.join(root, entry.name, 'SKILL.md');
     if (!fs.existsSync(skillPath)) continue;
-    const content = readText(skillPath);
-    const frontmatter = extractFrontmatter(content);
-    const name = frontmatter.name || entry.name;
-    const description = frontmatter.description || firstParagraph(content);
-    skills.push({
-      name,
+    if (RETIRED_DIRECTORIES.has(entry.name)) {
+      diagnostics.push(diagnostic('retired_skill', entry.name, 'excluded from automatic routing'));
+      continue;
+    }
+    const frontmatter = extractFrontmatter(fs.readFileSync(skillPath, 'utf8'));
+    if (!frontmatter) {
+      diagnostics.push(diagnostic('malformed_frontmatter', entry.name, 'missing frontmatter block'));
+      continue;
+    }
+    const identity = publicIdentity(frontmatter.name);
+    if (!identity || !frontmatter.description || frontmatter.description.trim() === '') {
+      diagnostics.push(diagnostic('missing_routing_metadata', entry.name, 'requires valid name and description'));
+      continue;
+    }
+    if (identity !== expectedIdentity(entry.name)) {
+      diagnostics.push(diagnostic('folder_name_mismatch', entry.name, `${identity} does not match directory`));
+      continue;
+    }
+    candidates.push({
+      name: frontmatter.name,
+      public_id: identity,
       directory: entry.name,
-      description,
-      category: categorize(name, description),
+      description: frontmatter.description,
+      when_to_use: frontmatter.when_to_use || '',
+      category: frontmatter.category || 'other',
+      keywords: parseKeywords(frontmatter.keywords),
+      user_invocable: frontmatter['user-invocable'] !== 'false',
       has_references: fs.existsSync(path.join(root, entry.name, 'references')),
       has_scripts: fs.existsSync(path.join(root, entry.name, 'scripts')),
     });
   }
-  return skills.sort((a, b) => a.name.localeCompare(b.name));
+
+  const counts = new Map();
+  for (const skill of candidates) counts.set(skill.public_id, (counts.get(skill.public_id) || 0) + 1);
+  const skills = candidates.filter((skill) => {
+    if (counts.get(skill.public_id) === 1) return true;
+    diagnostics.push(diagnostic('duplicate_public_name', skill.directory, `${skill.public_id} requires explicit user disambiguation`));
+    return false;
+  }).sort((left, right) => left.public_id.localeCompare(right.public_id));
+
+  return { root, skills, diagnostics: diagnostics.sort((left, right) =>
+    `${left.directory}:${left.code}`.localeCompare(`${right.directory}:${right.code}`)) };
 }
 
-function renderMarkdown(skills, root) {
-  const lines = [
-    '# CafeKit Skills Catalog',
-    '',
-    `Skills root: \`${root}\``,
-    `Total skills: ${skills.length}`,
-    '',
-  ];
-  const categories = [...new Set(skills.map((skill) => skill.category))].sort();
-  for (const category of categories) {
-    lines.push(`## ${category}`, '');
-    for (const skill of skills.filter((item) => item.category === category)) {
-      const badges = [
-        skill.has_references ? 'refs' : null,
-        skill.has_scripts ? 'scripts' : null,
-      ].filter(Boolean);
-      lines.push(
-        `- \`${skill.name}\` (${skill.directory})${badges.length ? ` [${badges.join(', ')}]` : ''}: ${skill.description}`
-      );
-    }
-    lines.push('');
+function renderMarkdown(catalog) {
+  const lines = ['# CafeKit Skills Catalog', '', `Skills root: \`${catalog.root}\``,
+    `Routable skills: ${catalog.skills.length}`, ''];
+  for (const skill of catalog.skills) {
+    const intent = skill.when_to_use ? ` Use: ${skill.when_to_use}` : '';
+    lines.push(`- \`${skill.name}\` (${skill.directory}, ${skill.category}): ${skill.description}${intent}`);
   }
-  return lines.join('\n').trim() + '\n';
+  if (catalog.diagnostics.length > 0) {
+    lines.push('', '## Diagnostics', '');
+    for (const item of catalog.diagnostics) lines.push(`- ${item.code} (${item.directory}): ${item.message}`);
+  }
+  return `${lines.join('\n').trim()}\n`;
 }
 
 function main() {
   const args = parseArgs(process.argv.slice(2));
-  if (args.help) {
-    usage();
-    return;
-  }
-
-  const root = path.resolve(process.cwd(), args.root || defaultSkillsRoot());
-  const skills = scanSkills(root);
-  if (args.json) {
-    console.log(JSON.stringify({ root, total: skills.length, skills }, null, 2));
-    return;
-  }
-  console.log(renderMarkdown(skills, root));
+  if (args.help) return usage();
+  const requestedRoot = path.resolve(process.cwd(), args.root || defaultSkillsRoot());
+  const catalog = scanSkills(requestedRoot);
+  if (args.json) console.log(JSON.stringify({ ...catalog, total: catalog.skills.length }, null, 2));
+  else console.log(renderMarkdown(catalog));
 }
 
 try {
   main();
 } catch (error) {
   console.error(`[skill-catalog] ${error.message}`);
-  process.exit(1);
+  process.exitCode = 1;
 }

package/src/claude/scripts/provenance.cjs

@@ -83,9 +83,22 @@ function oneLine(value, label) {
   return output.replace(/\n$/, '');
 }
 
-function gitBase(root) {
-  const output = oneLine(runGit(root, ['rev-parse', 'HEAD'], 'git rev-parse HEAD')).toLowerCase();
-  if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/.test(output)) fail('malformed_git_output', 'git rev-parse HEAD did not return a commit id');
+function gitBase(root, specsRoot) {
+  const specsRelative = path.relative(root, specsRoot).split(path.sep).join('/');
+  const sourceHistory = decode(runGit(
+    root,
+    ['log', '-1', '--format=%H', '--', '.', `:(exclude,literal)${specsRelative}`],
+    'git log source base',
+  )).trim();
+  const roots = sourceHistory ? [] : decode(
+    runGit(root, ['rev-list', '--max-parents=0', '--reverse', 'HEAD'], 'git rev-list root'),
+    'git rev-list root',
+  ).trim().split('\n');
+  if (!sourceHistory && (roots.length === 0 || roots.some((rootId) => !/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/i.test(rootId)))) {
+    fail('malformed_git_output', 'git rev-list root did not return commit ids');
+  }
+  const output = (sourceHistory || roots[0]).toLowerCase();
+  if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/.test(output)) fail('malformed_git_output', 'git source base did not return a commit id');
   return output;
 }
 
@@ -136,15 +149,21 @@ function parseStatus(bytes) {
   return entries;
 }
 
+// Generated runtime state, not source evidence. Shared with the receipt binding
+// selector so the gate's own cache writes cannot be read as a dirty worktree.
+const RUNTIME_STATE_ROOTS = Object.freeze([
+  '.git', 'node_modules',
+  '.claude/hooks/.logs', '.codex/hooks/.logs', '.omp/hooks/.logs',
+  '.claude/.logs', '.codex/.logs', '.omp/.logs',
+  '.claude/runtime.json', '.codex/runtime.json', '.omp/runtime.json',
+]);
+
 function excluded(root, absolute, specsRoot) {
   const relative = path.relative(root, absolute).split(path.sep).join('/');
   const specsRelative = path.relative(root, specsRoot);
   // These roots are generated runtime state, not source evidence. The selected
   // canonical specs root is excluded above to avoid receipt/state recursion.
-  const roots = [
-    '.git', 'node_modules', '.claude/hooks/.logs', '.codex/hooks/.logs',
-    '.claude/.logs', '.codex/.logs', '.claude/runtime.json', '.codex/runtime.json',
-  ];
+  const roots = RUNTIME_STATE_ROOTS;
   if (relative === specsRelative || relative.startsWith(`${specsRelative}/`)) return true;
   return roots.some((entry) => relative === entry || relative.startsWith(`${entry}/`));
 }
@@ -211,11 +230,11 @@ function identity(input) {
 
 function deriveRuntimeProvenance(input) {
   const current = identity(input);
-  const base = gitBase(current.root);
+  const base = gitBase(current.root, current.specsRoot);
   const first = manifest(current.root, current.specsRoot);
   const head = manifestDigest(first);
   const second = manifest(current.root, current.specsRoot);
-  if (JSON.stringify(first) !== JSON.stringify(second) || gitBase(current.root) !== base) fail('worktree_race', 'checkout changed during provenance capture');
+  if (JSON.stringify(first) !== JSON.stringify(second) || gitBase(current.root, current.specsRoot) !== base) fail('worktree_race', 'checkout changed during provenance capture');
   const stable = {
     schema_version: CONTEXT_SCHEMA_VERSION,
     project_root: current.root,
@@ -302,6 +321,7 @@ function runCli(argv = process.argv.slice(2)) {
 if (require.main === module) process.exitCode = runCli();
 
 module.exports = {
+  RUNTIME_STATE_ROOTS,
   CONTEXT_SCHEMA_VERSION,
   PROVENANCE_MODE,
   ProvenanceError,

package/src/claude/scripts/spec-receipt.cjs

@@ -3,7 +3,9 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 const { annotatedMarkdownLines } = require('./spec-resolver.cjs');
+const { RUNTIME_STATE_ROOTS } = require('./provenance.cjs');
 
 const EVIDENCE_HEADINGS = new Set([
   'Evidence',
@@ -177,11 +179,67 @@ function identity(body) {
   return crypto.createHash('sha256').update(JSON.stringify({ fields, artifacts })).digest('hex');
 }
 
-function canonicalFailures(body, task, runtimeContext, policy) {
+function tryGitBytes(root, args) {
+  const result = spawnSync('git', ['-C', root, ...args], { encoding: 'buffer', maxBuffer: 64 * 1024 * 1024 });
+  if (result.error || result.status !== 0) return null;
+  return result.stdout;
+}
+
+// A receipt is bound to live Base/Head while it is being written or altered.
+// Once its task file matches the committed bytes and nothing outside the specs
+// root is uncommitted, later commits must not reopen it: rebinding every done
+// receipt on every Stop made each unrelated commit a refresh of all of them.
+// Every state that cannot be read as committed-and-clean keeps the binding,
+// including an unborn HEAD, a staged-only file, and any git failure. The git
+// calls pin the project root; a working-directory-relative status query run
+// from inside the specs root reports a dirty tree as clean.
+function receiptBindingMode(featureDir, taskPath, taskBytes, runtimeContext) {
+  const root = runtimeContext && typeof runtimeContext.project_root === 'string' ? runtimeContext.project_root : null;
+  const specsRoot = runtimeContext && typeof runtimeContext.specs_root === 'string' ? runtimeContext.specs_root : null;
+  if (!root || !specsRoot || !Buffer.isBuffer(taskBytes)) return 'binding';
+  let canonicalFeature;
+  try { canonicalFeature = fs.realpathSync(featureDir); } catch { return 'binding'; }
+  const toPosix = (value) => value.split(path.sep).join('/');
+  const taskRelative = toPosix(path.relative(root, path.join(canonicalFeature, taskPath)));
+  const specsRelative = toPosix(path.relative(root, specsRoot));
+  const escapes = (value) => !value || value === '..' || value.startsWith('../') || path.isAbsolute(value);
+  if (escapes(taskRelative) || escapes(specsRelative)) return 'binding';
+  // `--filters` applies the same smudge/eol conversion the worktree copy has,
+  // so a checkout that converts line endings can still reach structure mode.
+  const committed = tryGitBytes(root, ['cat-file', '--filters', `HEAD:${taskRelative}`]);
+  if (committed === null || !committed.equals(taskBytes)) return 'binding';
+  // The same roots the provenance manifest calls generated runtime state rather
+  // than source evidence. Without them the gate defeats itself: writing its own
+  // cache dirties the tree, so a project that tracks its runtime directory could
+  // never reach structure mode.
+  const outsideSpecs = ['--', '.', `:(exclude,literal)${specsRelative}`,
+    ...RUNTIME_STATE_ROOTS.map((entry) => `:(exclude,literal)${entry}`)];
+  const status = tryGitBytes(root, ['status', '--porcelain', '--untracked-files=all', ...outsideSpecs]);
+  if (status === null || status.length !== 0) return 'binding';
+  // `git status` obeys skip-worktree and assume-unchanged, so a tracked file can
+  // be modified while the tree reports clean. Require every index entry outside
+  // the specs root to carry the plain cached tag `H`; any other tag, including
+  // `S` and the lowercase assume-unchanged tags, keeps the binding.
+  const indexTags = tryGitBytes(root, ['ls-files', '-v', ...outsideSpecs]);
+  if (indexTags === null) return 'binding';
+  const hidden = indexTags.toString('utf8').split('\n')
+    .filter((line) => line.trim() !== '')
+    .some((line) => line[0] !== 'H');
+  if (hidden) return 'binding';
+  return 'structure';
+}
+
+function canonicalFailures(body, task, runtimeContext, policy, { bindProvenance = true } = {}) {
   if (!policy || typeof policy.validateCanonicalReceipt !== 'function') return ['validator_unavailable'];
   const options = typeof policy.receiptValidatorOptions === 'function'
     ? policy.receiptValidatorOptions(task || {}, { runtimeContext, requireProvenanceBinding: true })
     : { requireProvenanceBinding: true };
+  // Structure-only mode drops the live Base/Head comparison and nothing else.
+  // It is granted only while a trusted artifact root survived, because
+  // withholding the runtime context would also silence artifact byte checks.
+  if (!bindProvenance && typeof options.artifactRoot === 'string' && options.artifactRoot.trim() !== '') {
+    return policy.validateCanonicalReceipt(body, { ...options, expectedProvenance: null, requireProvenanceBinding: false });
+  }
   return policy.validateCanonicalReceipt(body, options);
 }
 
@@ -261,12 +319,15 @@ function checkWorkflowTaskReceipt(featureDir, taskPath, runtimeContext, policy)
     const options = typeof policy?.receiptValidatorOptions === 'function'
       ? policy.receiptValidatorOptions({}, { runtimeContext, requireProvenanceBinding: true })
       : { requireProvenanceBinding: true };
-    failures.push(...canonicalFailures(canonicalBody, {}, runtimeContext, policy));
-    failures.push(...canonicalFailures(body, {}, runtimeContext, policy)
+    const requested = receiptBindingMode(featureDir, taskPath, taskFile.bytes, runtimeContext);
+    const artifactRootAvailable = typeof options.artifactRoot === 'string' && options.artifactRoot.trim() !== '';
+    const bindProvenance = !(requested === 'structure' && artifactRootAvailable);
+    failures.push(...canonicalFailures(canonicalBody, {}, runtimeContext, policy, { bindProvenance }));
+    failures.push(...canonicalFailures(body, {}, runtimeContext, policy, { bindProvenance })
       .filter((failure) => ['placeholder', 'verification_state', 'exit_result'].includes(failure)));
     failures.push(...workflowCommandFailures(taskText, canonicalBody));
     if (!hasNonEmptyFencedBlock(body)) failures.push('command_output');
-    if (!options.expectedProvenance) failures.push('provenance');
+    if (bindProvenance && !options.expectedProvenance) failures.push('provenance');
   }
   return {
     status: failures.length === 0 ? 'ok' : 'invalid',

package/src/claude/scripts/workflow-policy.cjs

@@ -1733,7 +1733,7 @@ function evaluateFlashPromotion(task, verdict, proof = 'Verification: PASS', cap
       status: 'in_progress',
       receipt: 'FLASH_UNVERIFIED',
       blocker: normalized.diagnostic === 'NO_TESTS'
-        ? 'awaiting test proof from /hapo:test <feature>'
+        ? 'awaiting test proof from /cf:test <feature>'
         : normalized.diagnostic === 'PARTIAL'
           ? 'verification is partial; awaiting complete test proof'
           : `verification returned ${normalized.verdict}`,

package/src/claude/settings/settings.json

@@ -4,6 +4,7 @@
     "command": "node \"$CLAUDE_PROJECT_DIR/.claude/status.cjs\"",
     "padding": 0
   },
+  "outputStyle": "Junior Developer Mode (Level 1)",
   "hooks": {
     "SessionStart": [
       {
@@ -35,9 +36,24 @@
         ]
       }
     ],
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/precompact.cjs\""
+          }
+        ]
+      }
+    ],
     "UserPromptSubmit": [
       {
         "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/secret-output-guardrail.cjs\""
+          },
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/rules.cjs\""

package/src/claude/skills/agent-browser/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: hapo:agent-browser
+name: cf:agent-browser
 description: AI-optimized browser automation CLI with context-efficient snapshots. Use for long autonomous sessions, self-verifying workflows, video recording, and cloud browser testing (Browserbase).
 license: Apache-2.0
 user-invocable: true

package/src/claude/skills/ai-multimodal/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: hapo:ai-multimodal
+name: cf:ai-multimodal
 description: Analyze images/audio/video/documentation with Gemini API. Use for vision analysis, transcription, OCR, design extraction, and deep multimodal understanding.
 license: MIT
 user-invocable: true