create-claude-cabinet 0.11.0 → 0.11.2

package/README.md

@@ -1,7 +1,7 @@
 # Claude Cabinet
 
 A cabinet of expert advisors for your Claude Code project. One command
-gives Claude a memory, 20 domain experts, a planning process, and the
+gives Claude a memory, 27 domain experts, a planning process, and the
 habit of starting sessions informed and ending them properly.
 
 Built by a guy who'd rather talk to Claude than write code. Most of it
@@ -12,7 +12,7 @@ was built by Claude. I just complained until it worked.
 Your project gets a cabinet — specialist advisors who each own a domain
 and weigh in when their expertise matters:
 
-- **Cabinet members** — 20 domain experts (security, accessibility,
+- **Cabinet members** — 27 domain experts (security, accessibility,
   architecture, QA, etc.) who review your project and surface what
   you'd miss alone
 - **Briefings** — project context members read before weighing in
@@ -37,7 +37,9 @@ say `/onboard`. It'll interview you about your project and set everything
 up based on your answers.
 
 **New to this?** See [GETTING-STARTED.md](GETTING-STARTED.md) for a
-step-by-step walkthrough.
+step-by-step walkthrough. Then [WORKFLOW-GUIDE.md](WORKFLOW-GUIDE.md)
+for how to use everything — when to plan, when to audit, what the
+cabinet does for you, and how the system grows with your project.
 
 ### For developers
 

package/lib/cli.js

@@ -27,6 +27,9 @@ function parseFrontmatter(content) {
   let nestedMap = null;    // The nested map being built
   let nestedSubKey = null; // Current sub-key within the nested map
   let nestedSubValue = '';
+  let blockScalarKey = null;  // Key when parsing a block scalar (description: >)
+  let blockScalarValue = '';
+  let blockScalarStyle = null; // '>' for folded, '|' for literal
 
   function flushNested() {
     if (nestedSubKey && nestedMap) {
@@ -50,6 +53,26 @@ function parseFrontmatter(content) {
   }
 
   for (const line of match[1].split('\n')) {
+    // Inside a block scalar (description: > or description: |)?
+    if (blockScalarKey) {
+      if (/^[\s]/.test(line) && line.trim() !== '') {
+        const sep = blockScalarStyle === '|' ? '\n' : ' ';
+        blockScalarValue += (blockScalarValue ? sep : '') + line.trim();
+        continue;
+      }
+      // Blank line inside block scalar — for '|' style, preserve as newline
+      if (line.trim() === '' && blockScalarStyle === '|') {
+        blockScalarValue += '\n';
+        continue;
+      }
+      // Not indented or blank line in '>' mode — end of block scalar
+      fm[blockScalarKey] = blockScalarValue.trim();
+      blockScalarKey = null;
+      blockScalarValue = '';
+      blockScalarStyle = null;
+      // Fall through to parse this line
+    }
+
     // Inside a nested map?
     if (nestedKey) {
       // Nested sub-key (indented key: value)
@@ -63,6 +86,16 @@ function parseFrontmatter(content) {
         nestedSubValue = subKv[2].replace(/^[>|]\s*$/, '');
         continue;
       }
+      // First indented line doesn't look like a sub-key — this is a block scalar, not a map
+      if (!nestedSubKey && /^[\s]/.test(line) && line.trim() !== '') {
+        // Convert from nested map mode to block scalar mode
+        blockScalarKey = nestedKey;
+        blockScalarStyle = '>';  // Default to folded
+        blockScalarValue = line.trim();
+        nestedKey = null;
+        nestedMap = null;
+        continue;
+      }
       // Continuation of nested sub-value (deeply indented)
       if (nestedSubKey && /^    /.test(line)) {
         nestedSubValue += ' ' + line.trim();
@@ -94,11 +127,12 @@ function parseFrontmatter(content) {
       const val = kvMatch[2].trim();
       // Empty value after colon = start of nested map or block scalar
       if (val === '' || val === '>' || val === '|') {
-        // Peek: could be a nested map or a block scalar.
-        // We'll treat it as a nested map if the next indented line has a colon.
-        // For now, start as nested and fall back if no sub-keys found.
+        // Could be a nested map (directives:) or a block scalar (description: >).
+        // Start as nested map; if first indented line has no sub-key, fall back
+        // to block scalar mode.
         nestedKey = kvMatch[1];
         nestedMap = {};
+        blockScalarStyle = (val === '|') ? '|' : '>';  // Remember style hint
         currentKey = null;
       } else {
         currentKey = kvMatch[1];
@@ -107,6 +141,9 @@ function parseFrontmatter(content) {
     }
   }
   // Flush remaining
+  if (blockScalarKey) {
+    fm[blockScalarKey] = blockScalarValue.trim();
+  }
   if (nestedSubKey && nestedMap) {
     nestedMap[nestedSubKey] = nestedSubValue.trim();
   }
@@ -126,6 +163,70 @@ function generateSkillIndex(projectDir) {
   const skillsDir = path.join(projectDir, '.claude', 'skills');
   if (!fs.existsSync(skillsDir)) return 0;
 
+  // Read project directive overlay if it exists
+  const projectDirectives = {};
+  const directivesFile = path.join(projectDir, '.claude', 'cabinet', 'directives-project.yaml');
+  if (fs.existsSync(directivesFile)) {
+    const dContent = fs.readFileSync(directivesFile, 'utf8');
+    // Parse simple YAML: top-level keys are member names, nested keys are
+    // standing-mandate (list) and directives (map)
+    let currentMember = null;
+    let inDirectives = false;
+    let currentDirectiveKey = null;
+    let currentDirectiveValue = '';
+    for (const line of dContent.split('\n')) {
+      if (/^\s*#/.test(line) || line.trim() === '') continue;
+      const indent = line.length - line.trimStart().length;
+      const content = line.trim();
+
+      // Flush previous directive value
+      if (currentDirectiveKey && indent <= 4 && !/^\s/.test(line.charAt(0)) || (indent <= 4 && currentDirectiveKey)) {
+        if (currentMember && currentDirectiveKey) {
+          if (!projectDirectives[currentMember]) projectDirectives[currentMember] = {};
+          if (!projectDirectives[currentMember].directives) projectDirectives[currentMember].directives = {};
+          projectDirectives[currentMember].directives[currentDirectiveKey] = currentDirectiveValue.trim();
+        }
+        currentDirectiveKey = null;
+        currentDirectiveValue = '';
+      }
+
+      if (indent === 0) {
+        // Top-level: member name
+        const m = content.match(/^(cabinet-[\w-]+):\s*$/);
+        if (m) {
+          currentMember = m[1];
+          projectDirectives[currentMember] = projectDirectives[currentMember] || {};
+          inDirectives = false;
+        }
+      } else if (indent === 2 && currentMember) {
+        const kv = content.match(/^([\w-]+):\s*(.*)$/);
+        if (kv) {
+          if (kv[1] === 'standing-mandate') {
+            // Parse [item1, item2] or item1, item2
+            const val = kv[2].replace(/^\[|\]$/g, '');
+            projectDirectives[currentMember].standingMandate = val.split(/,\s*/).map(s => s.trim()).filter(Boolean);
+            inDirectives = false;
+          } else if (kv[1] === 'directives') {
+            inDirectives = true;
+          }
+        }
+      } else if (indent === 4 && inDirectives && currentMember) {
+        const kv = content.match(/^([\w-]+):\s*(.*)$/);
+        if (kv) {
+          currentDirectiveKey = kv[1];
+          currentDirectiveValue = kv[2].replace(/^[>|]\s*$/, '');
+        }
+      } else if (indent >= 6 && currentDirectiveKey) {
+        currentDirectiveValue += ' ' + content;
+      }
+    }
+    // Flush last directive
+    if (currentMember && currentDirectiveKey) {
+      if (!projectDirectives[currentMember].directives) projectDirectives[currentMember].directives = {};
+      projectDirectives[currentMember].directives[currentDirectiveKey] = currentDirectiveValue.trim();
+    }
+  }
+
   const entries = [];
   const dirs = fs.readdirSync(skillsDir, { withFileTypes: true });
   for (const dir of dirs) {
@@ -165,6 +266,21 @@ function generateSkillIndex(projectDir) {
       entry.directives = fm.directives;
     }
 
+    // Merge project directive overlay (if any)
+    const overlay = projectDirectives[dir.name];
+    if (overlay) {
+      // Append project standing mandates (union, no duplicates)
+      if (overlay.standingMandate) {
+        const existing = entry.standingMandate || [];
+        const merged = [...new Set([...existing, ...overlay.standingMandate])];
+        entry.standingMandate = merged;
+      }
+      // Merge project directives (project wins on conflict)
+      if (overlay.directives) {
+        entry.directives = { ...(entry.directives || {}), ...overlay.directives };
+      }
+    }
+
     entries.push(entry);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-cabinet": "bin/create-claude-cabinet.js"

package/templates/EXTENSIONS.md

@@ -226,8 +226,8 @@ command queue processing (needed by any project with an async work queue).
 
 ## Writing Domain-Specific Cabinet Members
 
-CC ships 14 generic cabinet members. Flow has 19 additional domain-specific
-cabinet members. Here are three examples showing how to write your own.
+CC ships 27 generic cabinet members. Your project can add domain-specific
+cabinet members on top of these. Here are three examples showing how to write your own.
 
 ### Example 1: GTD (encoding domain expertise)