company-skill 2.2.2 → 3.0.0

package/README.md

@@ -10,7 +10,6 @@ A Claude Code skill that reads your team structure from `COMPANY.md`, runs every
 
 ## Install
 
-npm:
 ```bash
 npx company-skill install
 ```
@@ -27,73 +26,79 @@ Edit `COMPANY.md` with your team. Or skip it, the skill creates a minimal compan
 ```
 GOAL: "Build the auth system"
 
-  THINK     Leads break the goal into tasks
-  EXECUTE   Employees do the work
-  VERIFY    Built-in Reviewer + Critic check if the goal is met
+  THINK     CEO picks relevant employees, leads assign tasks
+  EXECUTE   Employees do the work, use installed skills
+  VERIFY    Reviewer checks criteria.json, Advocate attacks results
 
-  Not done? Loop back with feedback on what's missing.
-  Done? Write STATUS.md, report to user.
+  Not done? Loop back with feedback.
+  Done? Update playbook, write STATUS.md.
 ```
 
-No arbitrary limit. The loop runs until ALL criteria in `criteria.json` pass. A Stop Hook blocks Claude from exiting early. To cancel: `touch .company/CANCEL`.
+The loop runs until ALL criteria in `criteria.json` pass. A Stop Hook blocks Claude from exiting early. To cancel: `touch .company/CANCEL`.
+
+## Goal Enforcement
+
+The skill creates `criteria.json` with checkable success criteria:
+
+```json
+{"goal":"Build auth","criteria":[
+  {"id":1,"description":"OAuth2 login works with Google","passes":false,"evidence":null},
+  {"id":2,"description":"All tests pass","passes":false,"evidence":null}
+]}
+```
+
+The reviewer updates `passes` to `true` with evidence as work completes. The stop hook reads this file and blocks exit until everything passes.
+
+## Self-Improvement
+
+One file: `.company/playbook.md`. Accumulates across sessions.
+
+After each session, the CEO writes:
+- WORKED: what succeeded (with evidence)
+- FAILED: what failed, USE INSTEAD: what works, WHY: the difference
+- INEFFICIENT: what was slow, FASTER: better approach
+- TOP: best employees for priority activation next time
+- HIRE/FIRE: roles added or deactivated
+
+Leads read the playbook before every THINK phase. Employees check failed approaches before proposing new ones. The company that starts session 5 is smarter than session 1.
+
+The CEO also updates COMPANY.md: tags `[inactive]` on zero-contribution roles, `[priority]` on top performers, adds hired roles, evolves employee descriptions based on what they're good at.
 
 ## Built-In Roles
 
-Every company gets these employees automatically, even if your COMPANY.md is empty:
+Every company gets these automatically:
 
 | Role | Phase | What they do |
 |------|-------|-------------|
-| CEO | THINK | Sets priorities, resolves conflicts |
+| CEO | THINK | Picks relevant employees for the goal, resolves conflicts |
 | CTO | THINK | Technical decisions, architecture |
-| Internal Reviewer | VERIFY | Checks work against goal criteria |
+| Internal Reviewer | VERIFY | Checks criteria.json, rejects findings without sources |
 | User Advocate | VERIFY | Represents the end user |
 | Devil's Advocate | VERIFY | Attacks results, finds holes |
 | Elegance Enforcer | VERIFY | Prevents over-engineering |
 
-If you define these roles in COMPANY.md, the skill uses your description instead. No duplicates.
-
-A minimal `/company "fix the login bug"` with no COMPANY.md runs: CEO + CTO + 2 auto-created engineers + 4 built-in reviewers = 8 employees.
+Deduplicated if you define them in COMPANY.md.
 
-## Write Your Company
+## Source Citations
 
-`COMPANY.md` adds your own employees on top of the built-ins:
+Every finding needs a source:
+- Existing claims: file path, URL, or command output
+- Novel ideas: "NOVEL - needs validation" (reviewer adds a validation criterion)
 
-```markdown
-# My Team
-
-## Executive (Lead: CEO)
-- CEO, product vision, customer focus
-- CTO, architecture, technical standards
-
-## Engineering (Lead: CTO)
-- Backend Developer, API, database
-- Frontend Developer, UI, components
-- DevOps Engineer, CI/CD, monitoring
-
-## Priorities
-1. [URGENT] Fix payment processing
-2. [IMPORTANT] Add user dashboard
-
-## Rules
-- No deploy without review
-```
+No source = rejected by reviewer.
 
 ## Commands
 
 ```
-/company "Build X"      Run the company until X is done
-/company                Run using priorities from COMPANY.md
-/company:run "Build X"  Same as /company "Build X"
-/company:status         Show last status without running
-/company:resume         Continue from where last session stopped
+/company "Build X"      Run until X is done
+/company                Run using COMPANY.md priorities
+/company:run "Build X"  Same as above
+/company:status         Show last status
+/company:resume         Continue from last session
 ```
 
-Installs globally. Works from any directory.
-
 ## Visual Indicators
 
-When the skill runs, you see:
-
 ```
 ════════════════════════════════════════════════
              🏢 COMPANY SKILL ACTIVE
@@ -105,35 +110,28 @@ When the skill runs, you see:
 
 📋 CYCLE 1 VERDICT: NOT DONE
 Missing validation of compression ratios
-
-════════════════════════════════════════════════
-🏢 CYCLE 2 - THINK > EXECUTE > VERIFY
-════════════════════════════════════════════════
-
-📋 CYCLE 2 VERDICT: DONE
-All success criteria met
 ```
 
-Employees show with colors: leads (cyan), workers (green), reviewers (yellow), digest (gray). Skills are mandatory when installed.
+Employees show with colors: leads (cyan), workers (green), reviewers (yellow), digest (gray).
 
 ## Agents
 
-| Agent | Phase | Color | Role |
-|-------|-------|-------|------|
-| company-lead | THINK | Cyan | Department leads, deciding what to do |
-| company-worker | EXECUTE | Green | Employees doing the actual work |
-| company-reviewer | VERIFY | Yellow | Internal Reviewer, checking quality |
-| company-critic | VERIFY | Yellow | Devil's Advocate, finding holes |
-| company-digest | COMPRESS | Gray | Compresses output between cycles |
+| Agent | Phase | Color |
+|-------|-------|-------|
+| company-lead | THINK | Cyan |
+| company-worker | EXECUTE | Green |
+| company-reviewer | VERIFY | Yellow |
+| company-critic | VERIFY | Yellow |
+| company-digest | COMPRESS | Gray |
 
 ## Model Assignment
 
 | Phase | Model | Who |
 |-------|-------|-----|
-| THINK | Opus | CEO, CTO, department leads |
-| EXECUTE | Sonnet | Engineers, researchers, scouts |
-| VERIFY | Opus | Reviewer, Advocate, Enforcer, User Advocate |
-| COMPRESS | Haiku | Digest writer between cycles |
+| THINK | Opus | CEO, CTO, leads |
+| EXECUTE | Sonnet | Workers |
+| VERIFY | Opus | Reviewers |
+| COMPRESS | Haiku | Digest writer |
 
 Override per employee: `- ML Scientist, experiments [opus]`
 
@@ -153,27 +151,22 @@ Install manually for more:
 /plugin marketplace add obra/superpowers-marketplace
 /plugin marketplace add wshobson/agents
 /plugin marketplace add alirezarezvani/claude-skills
-npm i -g claude-mem
-npm i -g oh-my-claude-sisyphus
 ```
 
-When installed, employees MUST use them. Raw tools only when no skill matches the task.
+When installed, employees MUST use them.
 
 ## What Gets Created
 
 ```
 .company/
-  GOAL.md
-  STATUS.md
-  memory/{dept}.json
-  messages/{dept}.jsonl
-  cycles/
-    cycle-0-briefing.md
-    cycle-1-think-{dept}.md
-    cycle-1-review.md
-    cycle-1-advocate.md
-    cycle-1-briefing.md
-  {dept}/{employee}.md
+  criteria.json        Machine-checkable goal state
+  playbook.md          Accumulated lessons (self-improvement)
+  active-roster.md     Employees activated for this goal
+  active-tasks.md      Deduplicated task list
+  STATUS.md            Final report
+  cycles/              Per-cycle briefings and reviews
+  messages/            Typed findings per department
+  {dept}/              Per-employee findings (persist across sessions)
 ```
 
 ## Examples

package/bin/install.js

@@ -31,59 +31,66 @@ for (const agent of ['lead', 'worker', 'reviewer', 'critic', 'digest']) {
   if (fs.existsSync(src)) copyFile(src, path.join(agentsDir, `company-${agent}.md`));
 }
 
-// Install stop hook
-const hookSrc = path.join(srcDir, 'hooks', 'stop-guard.js');
-if (fs.existsSync(hookSrc)) {
-  copyFile(hookSrc, path.join(hooksDir, 'company-stop-guard.js'));
-
-  // Add to settings.json Stop hooks
-  const settingsPath = path.join(home, '.claude', 'settings.json');
-  try {
-    const settings = fs.existsSync(settingsPath)
-      ? JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
-      : {};
-
-    if (!settings.hooks) settings.hooks = {};
-    if (!settings.hooks.Stop) settings.hooks.Stop = [];
-
-    const hookCmd = `node "${path.join(hooksDir, 'company-stop-guard.js')}"`;
-    const exists = settings.hooks.Stop.some(h =>
-      h.hooks && h.hooks.some(hh => hh.command && hh.command.includes('company-stop-guard'))
-    );
-
-    if (!exists) {
-      settings.hooks.Stop.push({
-        hooks: [{
-          type: 'command',
-          command: hookCmd,
-          timeout: 5
-        }]
-      });
-      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-      console.log('Stop hook installed: company will not stop until goal is achieved.');
-    }
-  } catch (e) {
-    console.log('Could not install stop hook (optional). Add manually to settings.json.');
+// Install all hooks
+const hookFiles = {
+  'stop-guard.js': 'company-stop-guard.js',
+  'precompact.js': 'company-precompact.js',
+  'session-restore.js': 'company-session-restore.js'
+};
+
+for (const [src, dest] of Object.entries(hookFiles)) {
+  const srcPath = path.join(srcDir, 'hooks', src);
+  if (fs.existsSync(srcPath)) copyFile(srcPath, path.join(hooksDir, dest));
+}
+
+// Register hooks in settings.json
+const settingsPath = path.join(home, '.claude', 'settings.json');
+try {
+  const settings = fs.existsSync(settingsPath)
+    ? JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+    : {};
+
+  if (!settings.hooks) settings.hooks = {};
+
+  // Stop hook
+  if (!settings.hooks.Stop) settings.hooks.Stop = [];
+  if (!settings.hooks.Stop.some(h => h.hooks?.some(hh => hh.command?.includes('company-stop-guard')))) {
+    settings.hooks.Stop.push({ hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'company-stop-guard.js')}"`, timeout: 5 }] });
   }
+
+  // PreCompact hook
+  if (!settings.hooks.PreCompact) settings.hooks.PreCompact = [];
+  if (!settings.hooks.PreCompact.some(h => h.hooks?.some(hh => hh.command?.includes('company-precompact')))) {
+    settings.hooks.PreCompact.push({ hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'company-precompact.js')}"`, timeout: 5 }] });
+  }
+
+  // SessionStart hook (compact restore)
+  if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
+  if (!settings.hooks.SessionStart.some(h => h.hooks?.some(hh => hh.command?.includes('company-session-restore')))) {
+    settings.hooks.SessionStart.push({ matcher: 'compact', hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'company-session-restore.js')}"`, timeout: 5 }] });
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  console.log('Hooks installed: Stop guard + PreCompact + SessionStart restore');
+} catch (e) {
+  console.log('Could not register hooks. Add manually to settings.json.');
 }
 
-// Create COMPANY.md template in cwd if missing
+// Create COMPANY.md template
 const companyMd = path.join(process.cwd(), 'COMPANY.md');
 const template = path.join(srcDir, 'COMPANY.md.template');
 if (!fs.existsSync(companyMd) && fs.existsSync(template)) {
   fs.copyFileSync(template, companyMd);
-  console.log('Created COMPANY.md template. Edit it with your team.');
+  console.log('Created COMPANY.md template.');
 }
 
-// Add .company/ to .gitignore
-const gitignore = path.join(process.cwd(), '.gitignore');
+// Gitignore
 try {
-  const content = fs.existsSync(gitignore) ? fs.readFileSync(gitignore, 'utf8') : '';
-  if (!content.includes('.company/')) {
-    fs.appendFileSync(gitignore, '\n.company/\n');
-  }
+  const gi = path.join(process.cwd(), '.gitignore');
+  const content = fs.existsSync(gi) ? fs.readFileSync(gi, 'utf8') : '';
+  if (!content.includes('.company/')) fs.appendFileSync(gi, '\n.company/\n');
 } catch (e) {}
 
-console.log('company-skill installed globally.');
+console.log('company-skill installed.');
 console.log('Commands: /company, /company:run, /company:status, /company:resume');
-console.log('To cancel a running company: touch .company/CANCEL');
+console.log('Cancel: touch .company/CANCEL');

package/hooks/precompact.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+// Save company state before context compaction so nothing is lost.
+
+const fs = require('fs');
+const path = require('path');
+
+const companyDir = path.join(process.cwd(), '.company');
+if (!fs.existsSync(companyDir)) process.exit(0);
+
+const checkpoint = {};
+
+// Save current cycle number
+const cyclesDir = path.join(companyDir, 'cycles');
+if (fs.existsSync(cyclesDir)) {
+  const files = fs.readdirSync(cyclesDir).filter(f => f.startsWith('cycle-'));
+  const nums = files.map(f => parseInt(f.match(/cycle-(\d+)/)?.[1] || '0'));
+  checkpoint.cycle = Math.max(0, ...nums);
+}
+
+// Save criteria status
+const criteriaPath = path.join(companyDir, 'criteria.json');
+if (fs.existsSync(criteriaPath)) {
+  try {
+    const data = JSON.parse(fs.readFileSync(criteriaPath, 'utf8'));
+    const all = data.criteria || [];
+    checkpoint.goal = data.goal;
+    checkpoint.passing = all.filter(c => c.passes).length;
+    checkpoint.total = all.length;
+    checkpoint.failing = all.filter(c => !c.passes).map(c => c.description);
+  } catch (e) {}
+}
+
+// Save active roster
+const rosterPath = path.join(companyDir, 'active-roster.md');
+if (fs.existsSync(rosterPath)) {
+  checkpoint.roster = fs.readFileSync(rosterPath, 'utf8').substring(0, 500);
+}
+
+// Write checkpoint
+fs.writeFileSync(
+  path.join(companyDir, '.checkpoint.json'),
+  JSON.stringify(checkpoint, null, 2)
+);
+
+process.exit(0);

package/hooks/session-restore.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// Restore company state after compaction/resume. Injects context via systemMessage.
+
+const fs = require('fs');
+const path = require('path');
+
+const companyDir = path.join(process.cwd(), '.company');
+if (!fs.existsSync(companyDir)) process.exit(0);
+
+const checkpointPath = path.join(companyDir, '.checkpoint.json');
+if (!fs.existsSync(checkpointPath)) process.exit(0);
+
+try {
+  const cp = JSON.parse(fs.readFileSync(checkpointPath, 'utf8'));
+  const msg = [
+    "[COMPANY RESTORED] Session was compacted. Resuming.",
+    "Goal: " + (cp.goal || "unknown"),
+    "Cycle: " + (cp.cycle || 0),
+    "Criteria: " + (cp.passing || 0) + "/" + (cp.total || 0) + " passing",
+  ];
+
+  if (cp.failing && cp.failing.length > 0) {
+    msg.push("Failing: " + cp.failing.join(", "));
+  }
+
+  msg.push("Read .company/criteria.json and continue THINK > EXECUTE > VERIFY.");
+
+  console.log(JSON.stringify({
+    systemMessage: msg.join("\n")
+  }));
+} catch (e) {
+  process.exit(0);
+}

package/hooks/stop-guard.js

@@ -3,19 +3,35 @@
 const fs = require('fs');
 const path = require('path');
 
-const criteriaPath = path.join(process.cwd(), '.company', 'criteria.json');
-const goalPath = path.join(process.cwd(), '.company', 'GOAL.md');
-const cancelPath = path.join(process.cwd(), '.company', 'CANCEL');
-
+const cwd = process.cwd();
+const companyDir = path.join(cwd, '.company');
+const criteriaPath = path.join(companyDir, 'criteria.json');
+const goalPath = path.join(companyDir, 'GOAL.md');
+const cancelPath = path.join(companyDir, 'CANCEL');
+const counterPath = path.join(companyDir, '.stop-counter');
+
+// No company running
 if (!fs.existsSync(goalPath) && !fs.existsSync(criteriaPath)) {
   process.exit(0);
 }
 
+// Cancel signal
 if (fs.existsSync(cancelPath)) {
   try { fs.unlinkSync(cancelPath); } catch (e) {}
   process.exit(0);
 }
 
+// Circuit breaker: max 10 blocks then allow stop
+let count = 0;
+try { count = parseInt(fs.readFileSync(counterPath, 'utf8')) || 0; } catch (e) {}
+count++;
+try { fs.writeFileSync(counterPath, String(count)); } catch (e) {}
+if (count > 10) {
+  try { fs.unlinkSync(counterPath); } catch (e) {}
+  process.exit(0); // Allow stop, prevent infinite loop
+}
+
+// Check criteria
 if (fs.existsSync(criteriaPath)) {
   try {
     const data = JSON.parse(fs.readFileSync(criteriaPath, 'utf8'));
@@ -23,31 +39,23 @@ if (fs.existsSync(criteriaPath)) {
     const failing = all.filter(c => !c.passes || !c.evidence);
 
     if (all.length > 0 && failing.length === 0) {
-      process.exit(0);
+      try { fs.unlinkSync(counterPath); } catch (e) {}
+      process.exit(0); // All pass, allow stop
     }
 
     const failList = failing.map(c => c.description).join(', ');
     console.log(JSON.stringify({
       continue: false,
-      stopReason: failing.length + "/" + all.length + " criteria not met. Continue working.",
-      systemMessage: "COMPANY GOAL NOT ACHIEVED. " + failing.length + " criteria still failing: " + failList + ". Read .company/criteria.json and start the next THINK > EXECUTE > VERIFY cycle."
+      message: "[COMPANY CYCLE] " + failing.length + "/" + all.length + " criteria not met: " + failList + ". Continue THINK > EXECUTE > VERIFY. Read .company/criteria.json."
     }));
     process.exit(0);
   } catch (e) {
-    process.exit(0);
-  }
-}
-
-const statusPath = path.join(process.cwd(), '.company', 'STATUS.md');
-if (fs.existsSync(statusPath)) {
-  const status = fs.readFileSync(statusPath, 'utf8');
-  if (status.includes('ACHIEVED')) {
-    process.exit(0);
+    process.exit(0); // Malformed, allow stop
   }
 }
 
+// No criteria but goal exists
 console.log(JSON.stringify({
   continue: false,
-  stopReason: "Company goal not yet achieved.",
-  systemMessage: "COMPANY GOAL NOT ACHIEVED. Read .company/criteria.json and .company/GOAL.md. Start the next THINK > EXECUTE > VERIFY cycle."
+  message: "[COMPANY] Goal not achieved. Read .company/GOAL.md and create criteria.json, then start THINK > EXECUTE > VERIFY."
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "company-skill",
-  "version": "2.2.2",
+  "version": "3.0.0",
   "description": "Goal-driven multi-employee company for Claude Code. Give it a goal, it runs until done.",
   "bin": {
     "company-skill": "./bin/install.js"

package/skill/SKILL.md

@@ -72,8 +72,10 @@ Every finding MUST have:
 ```
 FINDING: what
 SOURCE: file/URL/command that proves it
+       OR "NOVEL - needs validation" for new ideas/techniques that don't exist yet
 ```
-No source = rejected by reviewer.
+Existing claims (numbers, papers, competitor data) need real sources.
+Novel ideas (new techniques, hypotheses, untested approaches) use "NOVEL - needs validation" and MUST be tested in the same or next cycle. The reviewer accepts novel sources but adds a criterion to criteria.json: "Validate novel technique X with experiment."
 
 ### VERIFY (Opus)