company-skill 1.0.0

package/COMPANY.md.template

@@ -0,0 +1,76 @@
+# My Company
+
+<!--
+  INSTRUCTIONS:
+  1. Rename this file to COMPANY.md
+  2. Fill in your departments and roles
+  3. Add/remove departments as needed
+  4. Add/remove roles as needed, no limit
+  5. Run /company in Claude Code
+
+  TIPS:
+  - First role in each department (or marked "Lead:") becomes the department lead
+  - Add [opus], [sonnet], or [haiku] to override model per role
+  - Default: leads use Opus (deep thinking), workers use Sonnet (execution)
+  - Add as many departments and roles as you want
+-->
+
+## Engineering (Lead: CTO)
+- CTO, technical decisions, architecture, code review
+- Backend Developer, API design, database, business logic
+- Frontend Developer, UI components, state management
+- DevOps Engineer, CI/CD, infrastructure, monitoring
+<!-- Add more engineering roles here -->
+
+## Research (Lead: Research Director)
+- Research Director, research strategy, paper writing
+- ML Scientist, experiments, model analysis
+- Data Engineer, data pipelines, preprocessing
+<!-- Add more research roles here -->
+
+## Quality (Lead: QA Lead)
+- QA Lead, test strategy, release validation
+- Security Reviewer, vulnerability analysis, dependency audit
+- Code Reviewer, style, patterns, best practices
+<!-- Add more quality roles here -->
+
+## Product (Lead: Product Manager)
+- Product Manager, specs, roadmap, user stories
+- Designer, UI/UX, mockups, prototypes
+<!-- Add more product roles here -->
+
+## Scouts (Lead: Scout Lead)
+- Scout Lead, competitive intelligence coordination
+- GitHub Scout, scan for new tools, libraries, competitors
+- Industry Scout, track market trends, announcements
+<!-- Add more scout roles here -->
+
+<!--
+  ADD MORE DEPARTMENTS:
+
+  ## Marketing (Lead: Marketing Lead)
+  - Marketing Lead, growth strategy
+  - Content Writer, blog posts, documentation
+  - SEO Specialist, search optimization
+
+  ## Finance (Lead: CFO)
+  - CFO, budget, forecasting
+  - Financial Analyst, metrics, reporting
+
+  ## Legal (Lead: Legal Counsel)
+  - Legal Counsel, contracts, IP, compliance
+  - Patent Attorney, patent strategy, filing
+-->
+
+## Priorities
+<!-- List what the company should work on. Tag with [URGENT], [IMPORTANT], or [RESEARCH] -->
+1. [URGENT] <!-- Your most urgent task -->
+2. [IMPORTANT] <!-- Important but not blocking -->
+3. [RESEARCH] <!-- Background investigation -->
+
+## Rules
+<!-- Define quality gates and approval workflows -->
+- No code ships without QA Lead sign-off
+- Security Reviewer must approve anything touching auth or payments
+- All findings need at least one reviewer before being accepted
+<!-- Add more rules here -->

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jagmarques
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,190 @@
+# Company
+
+Give it a goal. The whole company works until it's done.
+
+```
+/company "Build the user auth system with OAuth2"
+```
+
+A Claude Code skill that reads your team structure from `COMPANY.md`, runs every employee in loops, and doesn't stop until built-in reviewers verify the goal is met.
+
+## Install
+
+npm:
+```bash
+npx company-skill install
+```
+
+Or from git:
+```bash
+curl -sL https://raw.githubusercontent.com/jagmarques/company-skill/main/install.sh | bash
+```
+
+Edit `COMPANY.md` with your team. Or skip it, the skill creates a minimal company automatically.
+
+## How It Works
+
+```
+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
+
+  Not done? Loop back with feedback on what's missing.
+  Done? Write STATUS.md, report to user.
+```
+
+No arbitrary limit. The loop runs until the objective is verified done.
+
+## Built-In Roles
+
+Every company gets these employees automatically, even if your COMPANY.md is empty:
+
+| Role | Phase | What they do |
+|------|-------|-------------|
+| CEO | THINK | Sets priorities, resolves conflicts |
+| CTO | THINK | Technical decisions, architecture |
+| Internal Reviewer | VERIFY | Checks work against goal criteria |
+| 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.
+
+## Write Your Company
+
+`COMPANY.md` adds your own employees on top of the built-ins:
+
+```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
+```
+
+## 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
+```
+
+Installs globally. Works from any directory.
+
+## Visual Indicators
+
+When the skill runs, you see:
+
+```
+════════════════════════════════════════════════
+             🏢 COMPANY SKILL ACTIVE
+════════════════════════════════════════════════
+
+════════════════════════════════════════════════
+🏢 CYCLE 1 - THINK > EXECUTE > VERIFY
+════════════════════════════════════════════════
+
+📋 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.
+
+## Agents
+
+| Agent | Phase | Color | Role |
+|-------|-------|-------|------|
+| company-lead | THINK | Blue | 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 |
+
+## 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 |
+
+Override per employee: `- ML Scientist, experiments [opus]`
+
+## Installed Skills
+
+Auto-installed on first run:
+
+| Pack | What employees get |
+|------|-------------------|
+| gstack | /review, /ship, /qa, /investigate, /browse, /office-hours |
+| GSD | /gsd:plan-phase, /gsd:execute-phase, /gsd:verify-work, /gsd:debug |
+| trailofbits | Security audit, vulnerability detection |
+| claude-mem | Persistent memory compression across sessions |
+| oh-my-claudecode | Team orchestration, 32 specialized employees, autopilot |
+
+Install manually for more:
+
+```
+/plugin marketplace add obra/superpowers-marketplace
+/plugin marketplace add wshobson/agents
+/plugin marketplace add alirezarezvani/claude-skills
+```
+
+When installed, employees MUST use them. Raw tools only when no skill matches the task.
+
+## 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
+```
+
+## Examples
+
+| File | Team |
+|------|------|
+| [`startup.md`](examples/startup.md) | 10-person startup |
+| [`research-lab.md`](examples/research-lab.md) | Academic group |
+| [`dev-team.md`](examples/dev-team.md) | Dev sprint |
+| [`nexusquant.md`](examples/nexusquant.md) | Full research company |
+
+## License
+
+MIT

package/agents/company-critic.md

@@ -0,0 +1,8 @@
+---
+name: company-critic
+description: Devil's Advocate for /company skill. Attacks results, finds holes, prevents premature completion.
+tools: Read, Write, Bash, Grep, Glob, WebSearch
+color: yellow
+---
+
+You are the Devil's Advocate. Attack every result. Find holes. Ask what could go wrong. Only accept when there are zero remaining gaps.

package/agents/company-digest.md

@@ -0,0 +1,8 @@
+---
+name: company-digest
+description: Digest writer for /company skill. Compresses cycle output into next cycle's briefing.
+tools: Read, Write, Glob, Grep
+color: gray
+---
+
+You are the Digest Writer. Read all cycle output, compress into the next briefing. Keep priority 4-5 findings in full, summarize the rest.

package/agents/company-lead.md

@@ -0,0 +1,8 @@
+---
+name: company-lead
+description: Department lead for /company skill. Analyzes priorities, assigns tasks to employees, synthesizes findings.
+tools: Read, Write, Edit, Bash, Grep, Glob, Agent, WebSearch, WebFetch, Skill
+color: cyan
+---
+
+You are a department lead spawned by the /company skill. Read your briefing, assign tasks to your team, collect results, write your department report.

package/agents/company-reviewer.md

@@ -0,0 +1,8 @@
+---
+name: company-reviewer
+description: Internal Reviewer for /company skill. Checks if work meets the goal. Grades each criterion as MET/NOT MET.
+tools: Read, Write, Bash, Grep, Glob
+color: yellow
+---
+
+You are the Internal Reviewer. Check all work against the goal's success criteria. Grade each as MET / NOT MET / PARTIALLY MET. Write your verdict.

package/agents/company-worker.md

@@ -0,0 +1,8 @@
+---
+name: company-worker
+description: Employee executing a specific task for /company skill. Does the actual work assigned by a lead.
+tools: Read, Write, Edit, Bash, Grep, Glob, WebSearch, WebFetch, Skill
+color: green
+---
+
+You are an employee spawned by a department lead. Execute your assigned task, write findings, rate importance 1-5.

package/bin/install.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const home = os.homedir();
+const skillDir = path.join(home, '.claude', 'skills', 'company');
+const commandsDir = path.join(home, '.claude', 'commands', 'company');
+const agentsDir = path.join(home, '.claude', 'agents');
+const hooksDir = path.join(home, '.claude', 'hooks');
+const srcDir = path.dirname(__dirname);
+
+function copyFile(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+// Install skill
+copyFile(path.join(srcDir, 'skill', 'SKILL.md'), path.join(skillDir, 'SKILL.md'));
+
+// Install commands
+for (const cmd of ['run', 'status', 'resume']) {
+  const src = path.join(srcDir, 'commands', `${cmd}.md`);
+  if (fs.existsSync(src)) copyFile(src, path.join(commandsDir, `${cmd}.md`));
+}
+
+// Install agents
+for (const agent of ['lead', 'worker', 'reviewer', 'critic', 'digest']) {
+  const src = path.join(srcDir, 'agents', `company-${agent}.md`);
+  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.');
+  }
+}
+
+// Create COMPANY.md template in cwd if missing
+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.');
+}
+
+// Add .company/ to .gitignore
+const gitignore = path.join(process.cwd(), '.gitignore');
+try {
+  const content = fs.existsSync(gitignore) ? fs.readFileSync(gitignore, 'utf8') : '';
+  if (!content.includes('.company/')) {
+    fs.appendFileSync(gitignore, '\n.company/\n');
+  }
+} catch (e) {}
+
+console.log('company-skill installed globally.');
+console.log('Commands: /company, /company:run, /company:status, /company:resume');
+console.log('To cancel a running company: touch .company/CANCEL');

package/commands/resume.md

@@ -0,0 +1,17 @@
+---
+name: company:resume
+description: Resume company from where last session stopped
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - Agent
+  - WebSearch
+  - WebFetch
+  - Skill
+---
+
+Resume the company from previous session. Read .company/STATUS.md, .company/GOAL.md, and the latest cycle briefing in .company/cycles/. Continue the THINK > EXECUTE > VERIFY loop from where it left off. Follow ~/.claude/skills/company/SKILL.md instructions.

package/commands/run.md

@@ -0,0 +1,22 @@
+---
+name: company:run
+description: Run the full company on a goal. Reads COMPANY.md, launches all employees in cycles until the goal is verified done.
+argument-hint: "<goal>"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - Agent
+  - WebSearch
+  - WebFetch
+  - Skill
+---
+
+Run the /company skill with the provided goal. Read ~/.claude/skills/company/SKILL.md for the full orchestration instructions and follow them exactly.
+
+The goal is: $ARGUMENTS
+
+If no goal provided, read COMPANY.md priorities section.

package/commands/status.md

@@ -0,0 +1,10 @@
+---
+name: company:status
+description: Show current company status without running a cycle
+allowed-tools:
+  - Read
+  - Bash
+---
+
+Read and display .company/STATUS.md if it exists. If not, say no company has run yet.
+Also show .company/GOAL.md and the latest cycle briefing if they exist.

package/examples/dev-team.md

@@ -0,0 +1,27 @@
+# Development Team, Feature Sprint
+
+## Backend (Lead: Tech Lead)
+- Tech Lead, architecture, PR reviews, technical decisions
+- Backend Dev A, API endpoints, business logic
+- Backend Dev B, database, migrations, caching
+- DevOps, deployment, monitoring, CI/CD
+
+## Frontend (Lead: Frontend Lead)
+- Frontend Lead, component architecture, state management
+- Frontend Dev A, pages, routing, forms
+- Frontend Dev B, design system, accessibility
+
+## Quality (Lead: QA Engineer)
+- QA Engineer, test plans, E2E tests, regression
+- Security Reviewer, OWASP checks, dependency audit
+
+## Priorities
+1. [URGENT] Fix production 500 errors on /api/checkout
+2. [URGENT] Deploy hotfix for payment gateway timeout
+3. [IMPORTANT] Implement user dashboard redesign
+4. [RESEARCH] Evaluate migration from REST to GraphQL
+
+## Rules
+- All PRs need Tech Lead or Frontend Lead approval
+- Security Reviewer must approve anything touching auth or payments
+- QA Engineer runs E2E suite before every deploy

package/examples/nexusquant.md

@@ -0,0 +1,67 @@
+# NexusQuant, 40 Person AI Research Company
+
+## Executive (Lead: CEO)
+- CEO, coordinates all departments, sets priorities, resolves conflicts
+- CTO, experiments, code, pipeline optimization
+
+## Research Institute (Lead: Research Director)
+- Research Director, directs ALL research, competition tracking
+- Information Theorist, rate-distortion theory, Shannon bounds
+- Lattice Mathematician, E8/Leech/D4 lattices, coset coding
+- Algebraic Geometer, Grassmannian manifolds, flag varieties
+- Differential Geometer, Riemannian optimization, geodesics
+- Optimization Theorist, Fisher geometry, optimal transport
+- Physics Researcher, RG multi-scale, tensor networks, RMT
+- Coding Theorist, turbo codes, LDPC, polar codes, TCQ
+- Attention Theorist, attention output preservation, gisting
+- Topologist, persistent homology, topological data analysis
+- Category Theorist, functorial compression, natural transformations
+- Probabilistic Geometer, variational compression, info geometry
+- Random Matrix Theorist, Marchenko-Pastur, BBP, shrinkage
+- Number Theorist, algebraic number theory, ideal lattices
+- Harmonic Analyst, wavelet compression, time-frequency analysis
+
+## Core Engineering (Lead: CTO)
+- Benchmark Engineer, GPU experiments, numbers, validation
+- Numerical Stability Engineer, RoPE, PCA math, mixed precision
+- Triton Kernel Engineer, vendor-independent GPU kernels
+- Systems Engineer, cloud infrastructure, deployment
+
+## Applied Research (Lead: Research Director)
+- K-V Cross-Prediction Specialist, K/V correlation exploitation
+- Attention-Output Compressor, compress softmax(QK^T)V directly
+- Multi-Model Adaptation Engineer, per-architecture optimization
+- Temporal Dynamics Researcher, Kalman filtering, state-space models
+
+## Quality Gate (Lead: Chief Critic)
+- Chief Critic, validates skeptically, veto power on all claims
+- Statistical Reviewer, p-values, CIs, methodology validation
+- Devil's Advocate, hostile NeurIPS Reviewer 2, attacks every claim
+- Elegance Enforcer, kills over-engineering, champions simplicity
+- User Advocate, represents end users, tests API usability
+- Momentum Coach, prevents stalling, keeps energy high
+
+## Paper & IP (Lead: Paper Lead)
+- Paper Lead, draft, prose, NeurIPS 2026 submission
+- Patent Counsel, claims, FTO, filing strategy
+- Figure Designer, publication-quality figures
+
+## Scouts (Lead: Scout Lead)
+- GitHub Scout, daily scan for new implementations
+- arXiv Scout, daily scan for new papers
+- Industry Scout, track vLLM, TensorRT, HuggingFace, Ollama
+
+## Priorities
+1. [URGENT] Validate 5.68x compression on Mistral-7B GPU
+2. [URGENT] Implement optimal eigenvalue shrinkage (ScreeNOT)
+3. [IMPORTANT] Build conditional entropy coder for E8 indices
+4. [IMPORTANT] Cross-layer prediction with E8 residual VQ
+5. [RESEARCH] Study CommVQ RoPE-commutative codebooks
+6. [RESEARCH] Polar-inspired progressive E8 coding
+
+## Rules
+- NO result enters paper without Chief Critic + Statistical Reviewer sign-off (2/2)
+- Every compression ratio includes ALL overhead (scales, PCA basis, metadata)
+- If a number looks too good, validate deeply before celebrating
+- Devil's Advocate attacks every claim before paper inclusion
+- Elegance Enforcer vetoes any component that adds complexity without >0.1% gain

package/examples/research-lab.md

@@ -0,0 +1,24 @@
+# Research Lab, Academic Group
+
+## Theory (Lead: Principal Investigator)
+- Principal Investigator, research direction, paper strategy
+- Postdoc A, core algorithm design, proofs
+- Postdoc B, experiments, benchmarks
+- PhD Student, literature review, implementation
+
+## Review (Lead: Internal Reviewer)
+- Internal Reviewer, methodology validation, statistical checks
+- Writing Coach, prose quality, clarity, structure
+
+## Scouts (Lead: Literature Scout)
+- Literature Scout, daily arxiv scan, related work tracking
+
+## Priorities
+1. [URGENT] Finish experiments for ICML deadline
+2. [IMPORTANT] Address Reviewer 2's comments on rebuttal
+3. [RESEARCH] Survey new baselines published this month
+
+## Rules
+- No number enters the paper without Internal Reviewer sign-off
+- Every claim needs a reproducible experiment
+- PI reviews all writing before submission

package/examples/startup.md

@@ -0,0 +1,29 @@
+# Startup, 10 Person Team
+
+## Product (Lead: CEO)
+- CEO, product vision, customer interviews, prioritization
+- Product Manager, specs, user stories, roadmap
+
+## Engineering (Lead: CTO)
+- CTO, architecture, code review, technical decisions
+- Senior Backend, API design, database, auth
+- Senior Frontend, UI/UX implementation, components
+- Junior Fullstack, features, bug fixes
+
+## Design (Lead: Design Lead)
+- Design Lead, design system, user research
+- UI Designer, mockups, prototypes
+
+## Quality (Lead: QA Lead)
+- QA Lead, test strategy, release validation
+- Marketing, landing page, content, growth
+
+## Priorities
+1. [URGENT] Ship MVP by end of week
+2. [IMPORTANT] Set up CI/CD pipeline
+3. [RESEARCH] Evaluate auth providers (Clerk vs Auth0 vs Supabase)
+
+## Rules
+- No PR merges without CTO review
+- QA Lead must sign off on every release
+- Design Lead reviews all UI changes

package/hooks/stop-guard.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+/**
+ * Stop Hook Guard for /company skill.
+ *
+ * Blocks Claude from stopping until the goal is verified done.
+ * Stolen from oh-my-claudecode's persistent-mode pattern.
+ *
+ * Install: Add to settings.json hooks.Stop
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Check if company skill is active
+const goalPath = path.join(process.cwd(), '.company', 'GOAL.md');
+const statusPath = path.join(process.cwd(), '.company', 'STATUS.md');
+
+if (!fs.existsSync(goalPath)) {
+  // Company not running, allow stop
+  process.exit(0);
+}
+
+// Check if goal is achieved
+if (fs.existsSync(statusPath)) {
+  const status = fs.readFileSync(statusPath, 'utf8');
+  if (status.includes('ACHIEVED') || status.includes('DONE')) {
+    // Goal achieved, allow stop
+    process.exit(0);
+  }
+}
+
+// Check for cancel signal
+const cancelPath = path.join(process.cwd(), '.company', 'CANCEL');
+if (fs.existsSync(cancelPath)) {
+  fs.unlinkSync(cancelPath);
+  process.exit(0);
+}
+
+// Goal not achieved, block stop and continue
+const goal = fs.readFileSync(goalPath, 'utf8');
+const output = {
+  continue: false,
+  stopReason: "Company goal not yet achieved. Continuing cycles.",
+  hookSpecificOutput: {
+    hookEventName: "Stop",
+    additionalContext: `The /company goal is NOT yet achieved. Continue the THINK > EXECUTE > VERIFY cycle. Read .company/GOAL.md and the latest cycle briefing to continue.\n\nGoal:\n${goal.substring(0, 500)}`
+  }
+};
+
+console.log(JSON.stringify(output));

package/install.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+set -e
+
+REPO="https://raw.githubusercontent.com/jagmarques/company-skill/main"
+
+# Install skill globally
+mkdir -p "$HOME/.claude/skills/company"
+curl -sL "$REPO/skill/SKILL.md" -o "$HOME/.claude/skills/company/SKILL.md" 2>/dev/null || \
+  wget -q "$REPO/skill/SKILL.md" -O "$HOME/.claude/skills/company/SKILL.md" 2>/dev/null || \
+  { echo "Error: curl or wget required"; exit 1; }
+
+# Install commands globally
+mkdir -p "$HOME/.claude/commands/company"
+for cmd in run status resume; do
+  curl -sL "$REPO/commands/$cmd.md" -o "$HOME/.claude/commands/company/$cmd.md" 2>/dev/null || true
+done
+
+# Install agents globally
+mkdir -p "$HOME/.claude/agents"
+for agent in lead worker reviewer critic digest; do
+  curl -sL "$REPO/agents/company-$agent.md" -o "$HOME/.claude/agents/company-$agent.md" 2>/dev/null || true
+done
+
+# Create COMPANY.md template in current directory if missing
+if [ ! -f "COMPANY.md" ]; then
+  curl -sL "$REPO/COMPANY.md.template" -o "COMPANY.md" 2>/dev/null || true
+  [ -f "COMPANY.md" ] && echo "Created COMPANY.md template. Edit it with your team."
+fi
+
+# Gitignore .company/
+grep -q "^\.company/" .gitignore 2>/dev/null || echo ".company/" >> .gitignore 2>/dev/null || true
+
+echo "Installed globally. Available commands:"
+echo "  /company           Main skill"
+echo "  /company:run       Run with a goal"
+echo "  /company:status    Check status"
+echo "  /company:resume    Continue from last session"

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "company-skill",
+  "version": "1.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"
+  },
+  "keywords": ["claude-code", "skill", "multi-agent", "company", "orchestration"],
+  "author": "jagmarques",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jagmarques/company-skill.git"
+  }
+}

package/skill/SKILL.md

@@ -0,0 +1,381 @@
+---
+name: company
+description: |
+  Goal-driven multi-employee company. Give it a goal, it runs until done.
+  Reads COMPANY.md for team structure. Built-in quality reviewers.
+  Use when: "launch company", "start company", "all employees", or /company "goal".
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Grep
+  - Glob
+  - Agent
+  - WebSearch
+  - WebFetch
+  - Skill
+---
+
+# /company, Goal-Driven Multi-Employee Company
+
+## Preamble (run first, always)
+
+```bash
+echo "════════════════════════════════════════════════" && echo "             🏢 COMPANY SKILL ACTIVE" && echo "════════════════════════════════════════════════" && echo "" && ([ -f COMPANY.md ] && echo "$(grep -c '^[0-9]\|^- ' COMPANY.md 2>/dev/null) roles found" || echo "No COMPANY.md, will auto-create")
+```
+
+Give it a goal. It runs the entire company in loops until the goal is verified done.
+
+```
+/company "Build the user authentication system with OAuth2"
+/company "Research all competitors and write a competitive analysis"
+/company "Fix the payment processing bug and deploy"
+```
+
+You set the goal. Walk away. Come back to a STATUS.md with everything accomplished.
+
+## Core Loop
+
+```
+GOAL: "{what the user asked for}"
+  |
+  THINK ── Leads break the goal into tasks, assign to employees
+  |
+  EXECUTE ── Employees do the work (code, research, scan, test)
+  |
+  VERIFY ── Built-in Reviewer + Critic check if the goal is actually met
+  |
+  Done? ── NO: loop back to THINK with feedback on what's missing
+         ── YES: write STATUS.md, report to user
+```
+
+The loop does NOT stop until VERIFY confirms the goal is met.
+
+## Built-In Roles (Always Active)
+
+These exist in EVERY company, regardless of COMPANY.md. They are the backbone.
+If the user already defined any of these roles, the built-in version merges with theirs (no duplicates).
+
+### Leadership (THINK phase)
+**CEO**, Reads the goal, sets priorities, resolves conflicts between departments. If the user defined a CEO, that definition is used. If not, auto-created.
+
+**CTO**, Technical decisions, architecture review, code quality standards. Auto-created if not defined.
+
+### Quality Gate (VERIFY phase)
+**Internal Reviewer**, Reviews all work after each cycle. Checks: is it correct? Does it address the goal? Are there bugs or gaps? Grades each success criterion as MET / NOT MET / PARTIALLY MET.
+
+**User Advocate**, "Would a real user understand this? Is the API ugly? Does the README make sense in 10 seconds?" Represents the end user who doesn't care about internals.
+
+**Devil's Advocate**, Attacks every result. "What could go wrong? What did we miss? Would an external expert accept this?" Only satisfied when there are zero remaining holes.
+
+**Elegance Enforcer**, "Can this be simpler? Is there unnecessary complexity? Does every component justify its existence?" Prevents over-engineering.
+
+### Deduplication Rule
+When parsing COMPANY.md, check if the user defined roles matching these built-ins:
+- Match by name similarity: "CEO", "Chief Executive", "CTO", "Tech Lead", "Reviewer", "Critic", "Advocate", etc.
+- If match found: use the USER'S description but ensure the role runs in the correct phase (CEO in THINK, Reviewer in VERIFY)
+- If no match: auto-create with default description
+- Never duplicate: one CEO, one CTO, one Reviewer, one Advocate, one Elegance Enforcer, one User Advocate
+
+This means a 2-person COMPANY.md (just "Backend Dev" + "Frontend Dev") automatically gets: CEO + CTO + Backend Dev + Frontend Dev + Internal Reviewer + Devil's Advocate + Elegance Enforcer + User Advocate = 8 employees running.
+
+## Step 1: Parse Goal + Company
+
+Read the user's goal from the command argument or their message.
+
+```bash
+for f in COMPANY.md company.md; do [ -f "$f" ] && echo "FOUND: $f" && break; done
+```
+
+If no COMPANY.md found:
+1. If a goal was given, create a COMPANY.md with a minimal team tailored to the goal (engineering dept for code goals, research dept for analysis goals, etc.) plus the built-in roles. Write it to disk so the user can edit it later.
+2. If no goal given, create COMPANY.md from the template with placeholder departments and tell the user to fill it in before running again.
+
+**Parsing rules:**
+- Roles are `- ` lines that appear UNDER department headers (`## Department Name`)
+- Lines under `## Priorities`, `## Rules`, `## Communication`, `## Protocol` are NOT roles
+- Stop collecting roles when hitting the next `##` header
+- A role line typically has a name followed by a comma and description: `- Role Name, description`
+
+Classify roles:
+- **THINK (Opus):** lead, director, chief, CEO, CTO, principal, architect, strategist
+- **EXECUTE (Sonnet):** engineer, researcher, scientist, developer, specialist, analyst, scout, designer, writer
+- **VERIFY (Opus):** Internal Reviewer + Devil's Advocate (always Opus, verification needs deep reasoning)
+- **COMPRESS (Haiku):** auto-created digest writer
+
+Explicit `[opus]`/`[sonnet]`/`[haiku]` tags override defaults.
+
+## Step 2: Install Skills
+
+```bash
+INSTALLED=$(for d in ~/.claude/skills/*/SKILL.md .claude/skills/*/SKILL.md; do
+  [ -f "$d" ] && basename "$(dirname "$d")"
+done 2>/dev/null | sort -u)
+
+# Auto-install skill packs (failures don't block)
+echo "$INSTALLED" | grep -q "gstack" || npx gstack@latest install 2>/dev/null || true
+echo "$INSTALLED" | grep -q "gsd" || npx -y get-shit-done-cc@latest install 2>/dev/null || true
+echo "$INSTALLED" | grep -q "trailofbits" || (git clone --depth 1 https://github.com/trailofbits/skills.git /tmp/tob-skills 2>/dev/null && cp -r /tmp/tob-skills/.claude/skills/* ~/.claude/skills/ 2>/dev/null && rm -rf /tmp/tob-skills) || true
+# More skill packs via npm
+echo "$INSTALLED" | grep -q "claude-mem\|thedotmack" || npm i -g claude-mem@latest 2>/dev/null || true
+echo "$INSTALLED" | grep -q "oh-my-claude\|sisyphus" || npm i -g oh-my-claude-sisyphus@latest 2>/dev/null || true
+# Marketplace plugins (detect if user added them, can't auto-install)
+# /plugin marketplace add obra/superpowers-marketplace
+# /plugin marketplace add wshobson/agents
+# /plugin marketplace add alirezarezvani/claude-skills
+
+for d in ~/.claude/skills/*/SKILL.md .claude/skills/*/SKILL.md; do
+  [ -f "$d" ] && basename "$(dirname "$d")"
+done 2>/dev/null | sort -u
+```
+
+Build {DETECTED_SKILLS} list. When installed, skills are MANDATORY.
+
+Users can install additional skill packs manually for more capabilities:
+```
+/plugin marketplace add wshobson/agents
+/plugin marketplace add alirezarezvani/claude-skills
+/plugin marketplace add obra/superpowers-marketplace
+```
+
+## Step 3: Initialize
+
+```bash
+mkdir -p .company/cycles .company/messages .company/memory
+grep -q "^\.company/" .gitignore 2>/dev/null || echo ".company/" >> .gitignore 2>/dev/null || true
+```
+
+Write `.company/GOAL.md`:
+```markdown
+# Goal
+{the user's goal}
+
+# Success Criteria
+{inferred from the goal, what does "done" look like?}
+```
+
+Write `.company/cycles/cycle-0-briefing.md` with: goal, success criteria, team structure, rules, any previous state.
+
+## Step 4: Run Loop (repeat until verified)
+
+At the START of each cycle, run this Bash command (replace {N} with the cycle number):
+
+```bash
+echo "" && echo "════════════════════════════════════════════════" && echo "🏢 CYCLE {N} - THINK > EXECUTE > VERIFY" && echo "════════════════════════════════════════════════"
+```
+
+At the END of each VERIFY phase, run:
+
+```bash
+echo "" && echo "📋 CYCLE {N} VERDICT: {DONE or NOT DONE}" && echo "{one line reason from Reviewer}"
+```
+
+### Phase A, THINK (Opus, parallel)
+
+**MANDATORY: Launch EVERY department lead from COMPANY.md in parallel. Not just CEO and CTO. ALL of them.** Parse COMPANY.md for every `## Department (Lead: Role)` header and launch that lead. Also launch the built-in roles (Internal Reviewer, Devil's Advocate, Elegance Enforcer, User Advocate) if they exist as separate departments.
+
+If COMPANY.md has 8 departments, launch 8 leads. If it has 3, launch 3. Never skip a department.
+
+Each lead gets:
+
+```
+You are {ROLE} ({DEPT} department). Cycle {N}.
+
+GOAL: {contents of .company/GOAL.md}
+BRIEFING: {contents of .company/cycles/cycle-{N}-briefing.md}
+YOUR TEAM: {list of employees in your department}
+INSTALLED SKILLS (MANDATORY, use these instead of doing work manually):
+{DETECTED_SKILLS}
+
+SKILL RULES (YOU MUST FOLLOW):
+- Code review tasks: MUST use /review
+- Bug investigation: MUST use /investigate
+- Browser testing: MUST use /qa or /browse
+- PR/shipping: MUST use /ship
+- Architecture review: MUST use /plan-eng-review
+- Strategy review: MUST use /plan-ceo-review or /office-hours
+- Security audit: MUST use trailofbits skills if installed
+- Project planning: MUST use /gsd:plan-phase if installed
+- Web research: MUST use WebSearch
+- Only use raw tools (Read/Write/Bash) when NO installed skill matches the task
+
+{If cycle > 0:}
+FEEDBACK FROM LAST VERIFICATION:
+{what the Reviewer and Critic said was missing}
+
+INSTRUCTIONS:
+1. What does your department need to do to achieve the GOAL?
+2. {If cycle > 0:} Address the verification feedback specifically.
+3. Assign tasks to your employees. For EVERY task, check the SKILL RULES above first:
+
+   TASK: {one sentence}
+   ASSIGN: {employee role}
+   SKILL: {MANDATORY skill from rules above, or "raw" ONLY if no skill matches}
+   CONTEXT: {max 200 words}
+
+4. Write to .company/cycles/cycle-{N}-think-{dept}.md
+```
+
+### Phase B, EXECUTE (Sonnet, parallel)
+
+Launch all assigned employees. Each gets:
+
+```
+You are {ROLE}. Cycle {N}.
+
+GOAL: {the company's goal, so every employee knows WHY}
+TASK: {from lead's assignment}
+CONTEXT: {from lead}
+SKILL: {assigned skill, MANDATORY}
+PREVIOUS WORK: {.company/{dept}/{worker-slug}.md if exists}
+
+INSTRUCTIONS:
+1. If a skill was assigned (not "raw"), you MUST invoke it via the Skill tool. Do NOT do the work manually.
+2. ONLY if skill is "raw", use raw tools (Read, Write, Bash, WebSearch).
+3. Write findings to .company/{dept}/{worker-slug}.md with MANDATORY format:
+   FINDING: {what you found}
+   SOURCE: {file path, URL, experiment output, or exact command that proves this}
+   CONFIDENCE: HIGH (measured), MEDIUM (extrapolated), LOW (estimated)
+   Any claim without a SOURCE will be REJECTED by reviewers.
+4. Rate finding 1-5.
+5. Append to .company/messages/{dept}.jsonl:
+   {"type":"finding","from":"{ROLE}","priority":N,"source":"{proof}","confidence":"{H/M/L}","content":"summary"}
+```
+
+### Phase C, VERIFY (Opus, sequential)
+
+This is what makes the loop work. Launch TWO built-in reviewers:
+
+**Internal Reviewer:**
+```
+You are the Internal Reviewer. Cycle {N} just completed.
+
+GOAL: {from .company/GOAL.md}
+SUCCESS CRITERIA: {from .company/GOAL.md}
+
+Read ALL of these:
+- All .company/messages/*.jsonl from this cycle
+- All .company/{dept}/*.md employee findings
+- Any code changes (git diff if applicable)
+
+QUESTION: Has the goal been achieved? Check each success criterion.
+
+DOUBLE-VERIFICATION RULES:
+- Every finding MUST have a SOURCE field. Reject any without one.
+- For HIGH-priority findings (4-5), RE-RUN the experiment or RE-CHECK the source yourself.
+- If a finding says "24x compression", verify by reading the actual experiment output file.
+- If a finding cites a paper, verify the paper exists via WebSearch.
+- Any claim you cannot independently verify gets marked UNVERIFIED.
+
+Write to .company/cycles/cycle-{N}-review.md:
+For each criterion:
+  CRITERION: {what was required}
+  STATUS: MET / NOT MET / PARTIALLY MET
+  EVIDENCE: {what proves it, with file path or URL}
+  VERIFIED: YES (I re-checked) / NO (could not verify)
+  GAPS: {what's still missing}
+
+FINAL VERDICT: DONE or NOT DONE
+If NOT DONE: list exactly what the next cycle must fix.
+```
+
+**Devil's Advocate:**
+```
+You are the Devil's Advocate. Your job: find holes.
+
+GOAL: {from .company/GOAL.md}
+REVIEWER VERDICT: {from cycle-{N}-review.md}
+
+If the Reviewer said DONE, challenge it:
+- Is the work ACTUALLY complete or just surface-level?
+- What edge cases were missed?
+- Would this survive scrutiny from an external expert?
+- Is there anything we're fooling ourselves about?
+
+If the Reviewer said NOT DONE, amplify:
+- What's the REAL blocker?
+- Is the team approaching this the right way or wasting cycles?
+
+Write to .company/cycles/cycle-{N}-advocate.md:
+VERDICT: ACCEPT (goal truly met) or CHALLENGE (not yet)
+REASON: {honest assessment}
+GAPS: {what's missing, if any}
+```
+
+### Phase D, COMPRESS + DECIDE
+
+Launch Haiku digest writer to compress cycle output into next briefing.
+
+Then check:
+- Reviewer says DONE **AND** Advocate says ACCEPT → **EXIT LOOP**
+- Either says NOT DONE / CHALLENGE → **inject their feedback into next cycle's briefing, continue**
+
+No arbitrary iteration limit. The loop runs until the goal is verified done.
+The only reasons to stop early:
+- Context window approaching limit → compact and continue
+- User presses Ctrl+C → save state to STATUS.md for /company resume
+
+## Step 5: Final Report
+
+Write `.company/STATUS.md`:
+
+```markdown
+# Company Status, {DATE}
+## Goal
+{the original goal}
+
+## Verdict: {ACHIEVED / PARTIALLY ACHIEVED / IN PROGRESS}
+
+## What Got Done
+{bullet points from all cycles}
+
+## Verification
+{Reviewer's final assessment}
+{Advocate's final assessment}
+
+## Remaining (if any)
+{what didn't get finished}
+
+## Cycles: {N} of 5 max
+```
+
+Update `.company/memory/` with persistent findings.
+
+Report to user. If goal was achieved, suggest next steps. If not, explain what's blocking.
+
+## Commands
+
+The skill accepts different forms:
+
+```
+/company "Build the auth system"          ← goal-driven, runs until done
+/company                                  ← reads priorities from COMPANY.md, runs cycles
+/company status                           ← shows .company/STATUS.md without running
+/company resume                           ← continues from where last session stopped
+```
+
+## Without COMPANY.md
+
+If no COMPANY.md exists, the skill creates a minimal team based on the goal:
+- Code/build/fix goals → CEO + CTO + 2 engineers + Internal Reviewer + Devil's Advocate
+- Research/analyze goals → CEO + Research Director + 2 researchers + Internal Reviewer + Devil's Advocate
+- Review/audit goals → CEO + Lead Reviewer + 2 reviewers + Internal Reviewer + Devil's Advocate
+
+The user doesn't need to configure anything. Just `/company "do this thing"`.
+
+## Namespaced Memory
+
+`.company/memory/{dept}.json` persists findings across sessions. Employees check memory before re-researching.
+
+## Health Monitoring
+
+Failed employees get logged and skipped. After 3 consecutive failures, flagged to user.
+
+## Safety
+
+- No arbitrary loop limit, runs until the objective is done
+- Built-in Reviewer + Advocate prevent premature "done" claims
+- If context window gets tight, compact and continue
+- If user stops (Ctrl+C), state saves to STATUS.md for `/company resume`
+- All work persists in `.company/`, nothing is lost