@chrisai/base 2.3.0

package/README.md

@@ -0,0 +1,157 @@
+<div align="center">
+  <img src="terminal.svg" alt="BASE terminal" width="740"/>
+</div>
+
+<div align="center">
+
+[![npm](https://img.shields.io/npm/v/@chrisai/base?color=00d8ff&label=npm&style=flat-square)](https://www.npmjs.com/package/@chrisai/base)
+[![Node](https://img.shields.io/badge/node-%3E%3D16.7.0-brightgreen?style=flat-square)](https://nodejs.org)
+[![License](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](LICENSE)
+[![Claude Code](https://img.shields.io/badge/Claude%20Code-compatible-8b5cf6?style=flat-square)](https://claude.ai/code)
+
+</div>
+
+---
+
+## What is BASE?
+
+BASE keeps your Claude Code workspace from becoming a mess. It scaffolds structure, tracks workspace health, surfaces the right context automatically, and tells you when things go stale — so you spend time building, not maintaining.
+
+**The core pattern:** structured JSON files (data surfaces) + lightweight Python hooks that inject them into Claude's context every session. Claude always knows what's active, what's queued, and where satellites stand — without you having to say it.
+
+---
+
+## Install
+
+```bash
+npx @chrisai/base --global --workspace
+```
+
+| Flag | What it does |
+|------|-------------|
+| `--global` | Install commands + framework to `~/.claude` |
+| `--workspace` | Install workspace layer (`.base/`) in current directory |
+| `--local` | Install commands to `./.claude` instead of global |
+| `--config-dir <path>` | Custom Claude config directory |
+| `--workspace-dir <path>` | Target a specific workspace path |
+
+**Common flows:**
+
+```bash
+# Full install — global commands + current workspace
+npx @chrisai/base --global --workspace
+
+# Already have global? Just wire a new workspace
+npx @chrisai/base --workspace
+
+# Global only — set up each workspace later with /base:scaffold
+npx @chrisai/base --global
+```
+
+---
+
+## What Gets Installed
+
+```
+~/.claude/                          ← --global
+├── commands/base/                  11 slash commands
+├── skills/base/                    Entry point (base.md)
+└── base-framework/
+    ├── tasks/                      pulse, groom, audit, scaffold...
+    ├── templates/                  workspace.json, STATE.md, surfaces
+    ├── context/                    base-principles.md
+    ├── frameworks/                 audit-strategies.md
+    └── hooks/                      Session hooks (scaffold source)
+
+./.base/                            ← --workspace
+├── workspace.json                  Manifest: surfaces, satellites, groom config
+├── data/
+│   ├── active.json                 Active projects surface
+│   └── backlog.json                Backlog surface
+├── hooks/                          Surface injection hooks
+├── base-mcp/                       BASE MCP server
+└── carl-mcp/                       CARL MCP server
+
+./.claude/
+├── hooks/
+│   ├── base-pulse-check.py         Drift detection (every session)
+│   ├── psmm-injector.py            Per-session meta memory
+│   └── satellite-detection.py      PAUL project auto-registration
+└── settings.json                   Hook registrations (merged)
+```
+
+---
+
+## Commands
+
+After install, open Claude Code and run `/base:scaffold` to complete setup.
+
+| Command | Description |
+|---------|------------|
+| `/base:scaffold` | Set up BASE in a new or existing workspace |
+| `/base:pulse` | Daily workspace health briefing |
+| `/base:groom` | Weekly maintenance cycle |
+| `/base:audit` | Deep workspace optimization |
+| `/base:status` | Quick health check |
+| `/base:history` | Workspace evolution timeline |
+| `/base:audit-claude-md` | Audit CLAUDE.md, generate recommended version |
+| `/base:carl-hygiene` | CARL domain maintenance |
+| `/base:surface create` | Create a new data surface (guided) |
+| `/base:surface convert` | Convert a markdown file to a data surface |
+| `/base:surface list` | Show all registered data surfaces |
+
+---
+
+## Data Surfaces
+
+The core primitive. A data surface is a structured JSON file + a Python hook that injects it into Claude's context every session. Any persistent data you want Claude to passively know about becomes a surface.
+
+```
+workspace.json registers it → hook reads it → Claude knows it
+```
+
+**Built-in surfaces:**
+- `active.json` — Current projects, status, blockers, deadlines
+- `backlog.json` — Future work queue, ideas, deferred items
+
+**Create your own:**
+```
+/base:surface create
+```
+Guided schema builder. Point it at any data you want surfaced — contacts, clients, API keys, anything. BASE generates the JSON schema, the hook, and wires it automatically.
+
+---
+
+## PAUL Satellite Integration
+
+BASE auto-detects [PAUL](https://github.com/ChristopherKahler/paul) projects in your workspace. Every session, `satellite-detection.py` scans for `.paul/paul.json` files and registers any new projects in `workspace.json`. Weekly groom cycles check satellite health: stale loops, abandoned phases, overdue milestones.
+
+No manual registration. It just works.
+
+---
+
+## Ecosystem
+
+BASE is part of a three-layer workspace system:
+
+| System | Role |
+|--------|------|
+| **BASE** | Workspace lifecycle — surfaces, grooming, drift detection |
+| **CARL** | Dynamic rules engine — just-in-time rule injection |
+| **PAUL** | Project orchestration — Plan → Apply → Unify loop |
+
+Each is independent. Use one, some, or all.
+
+---
+
+## Requirements
+
+- Node.js ≥ 16.7.0
+- [Claude Code](https://claude.ai/code)
+- Python 3 (for hooks)
+
+---
+
+## License
+
+MIT — [Chris Kahler](https://github.com/ChristopherKahler)

package/bin/install.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { execSync } = require('child_process');
+
+// Colors
+const cyan = '\x1b[36m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+const banner = `
+${cyan}  ██████╗  █████╗ ███████╗███████╗
+  ██╔══██╗██╔══██╗██╔════╝██╔════╝
+  ██████╔╝███████║███████╗█████╗
+  ██╔══██╗██╔══██║╚════██║██╔══╝
+  ██████╔╝██║  ██║███████║███████╗
+  ╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝${reset}
+
+  BASE Framework ${dim}v${pkg.version}${reset}
+  Builder's Automated State Engine for Claude Code
+`;
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+const hasWorkspace = args.includes('--workspace') || args.includes('-w');
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const configDirIndex = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (configDirIndex !== -1) {
+    const nextArg = args[configDirIndex + 1];
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
+  if (configDirArg) {
+    return configDirArg.split('=')[1];
+  }
+  return null;
+}
+const explicitConfigDir = parseConfigDirArg();
+
+// Parse --workspace-dir argument
+function parseWorkspaceDirArg() {
+  const idx = args.findIndex(arg => arg === '--workspace-dir');
+  if (idx !== -1) {
+    const nextArg = args[idx + 1];
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--workspace-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  return null;
+}
+const explicitWorkspaceDir = parseWorkspaceDirArg();
+const hasHelp = args.includes('--help') || args.includes('-h');
+
+console.log(banner);
+
+// Show help if requested
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx base-framework [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-g, --global${reset}                 Install commands globally (to ~/.claude)
+    ${cyan}-l, --local${reset}                  Install commands locally (to ./.claude)
+    ${cyan}-w, --workspace${reset}              Install workspace layer (.base/ in current directory)
+    ${cyan}-c, --config-dir <path>${reset}      Specify custom Claude config directory
+    ${cyan}--workspace-dir <path>${reset}        Specify workspace root (default: cwd)
+    ${cyan}-h, --help${reset}                   Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Full install: global commands + workspace layer${reset}
+    npx base-framework --global --workspace
+
+    ${dim}# Global commands only (no workspace data)${reset}
+    npx base-framework --global
+
+    ${dim}# Workspace layer only (assumes commands already installed)${reset}
+    npx base-framework --workspace
+
+    ${dim}# Install to current project only${reset}
+    npx base-framework --local --workspace
+
+  ${yellow}What gets installed:${reset}
+    ${cyan}Commands (--global or --local):${reset}
+      commands/base/       - Slash commands (/base:surface-create, etc.)
+      skills/base/         - Skill framework (tasks, templates, context)
+
+    ${cyan}Workspace (--workspace):${reset}
+      .base/data/          - Data surface directory
+      .base/hooks/         - Surface injection hooks
+      .base/base-mcp/      - BASE MCP server (npm install auto-runs)
+      .base/carl-mcp/      - CARL MCP server (npm install auto-runs)
+      .mcp.json            - MCP server registration (merged)
+`);
+  process.exit(0);
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Recursively copy directory
+ */
+function copyDir(srcDir, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Install commands and skill framework
+ */
+function installCommands(isGlobal) {
+  const src = path.join(__dirname, '..');
+  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
+  const defaultGlobalDir = configDir || path.join(os.homedir(), '.claude');
+  const claudeDir = isGlobal ? defaultGlobalDir : path.join(process.cwd(), '.claude');
+
+  const locationLabel = isGlobal
+    ? claudeDir.replace(os.homedir(), '~')
+    : claudeDir.replace(process.cwd(), '.');
+
+  console.log(`  Installing commands to ${cyan}${locationLabel}${reset}\n`);
+
+  // Copy commands
+  const commandsSrc = path.join(src, 'src', 'commands');
+  const commandsDest = path.join(claudeDir, 'commands', 'base');
+  copyDir(commandsSrc, commandsDest);
+  console.log(`  ${green}+${reset} commands/base/ (3 slash commands)`);
+
+  // Copy skill entry point
+  const skillSrc = path.join(src, 'src', 'skill');
+  const skillDest = path.join(claudeDir, 'skills', 'base');
+  copyDir(skillSrc, skillDest);
+  console.log(`  ${green}+${reset} skills/base/ (entry point + MCP package sources)`);
+
+  // Copy MCP package sources into skill (for scaffold reference)
+  const packagesSrc = path.join(src, 'src', 'packages');
+  const packagesDest = path.join(claudeDir, 'skills', 'base', 'packages');
+  copyDir(packagesSrc, packagesDest);
+
+  // Copy BASE framework (tasks, templates, context, frameworks)
+  const frameworkSrc = path.join(src, 'src', 'framework');
+  const frameworkDest = path.join(claudeDir, 'base-framework');
+  copyDir(frameworkSrc, frameworkDest);
+  console.log(`  ${green}+${reset} base-framework/ (tasks, templates, context, frameworks)`);
+
+  // Copy session hooks to global base-framework/hooks/ (source for scaffold)
+  const sessionHookNames = ['base-pulse-check.py', 'psmm-injector.py', 'satellite-detection.py'];
+  const hooksFrameworkDest = path.join(claudeDir, 'base-framework', 'hooks');
+  fs.mkdirSync(hooksFrameworkDest, { recursive: true });
+  const hooksSrcDir = path.join(src, 'src', 'hooks');
+  for (const hookFile of sessionHookNames) {
+    const hookSrcPath = path.join(hooksSrcDir, hookFile);
+    if (fs.existsSync(hookSrcPath)) {
+      fs.copyFileSync(hookSrcPath, path.join(hooksFrameworkDest, hookFile));
+    }
+  }
+  console.log(`  ${green}+${reset} base-framework/hooks/ (session hooks for scaffold)`);
+
+  console.log(`\n  ${green}Commands installed.${reset}\n`);
+}
+
+/**
+ * Install workspace layer (.base/)
+ */
+function installWorkspace() {
+  const src = path.join(__dirname, '..');
+  const workspaceDir = expandTilde(explicitWorkspaceDir) || process.cwd();
+  const baseDir = path.join(workspaceDir, '.base');
+
+  console.log(`  Installing workspace layer to ${cyan}${baseDir.replace(os.homedir(), '~')}${reset}\n`);
+
+  // Create .base directories
+  fs.mkdirSync(path.join(baseDir, 'data'), { recursive: true });
+  fs.mkdirSync(path.join(baseDir, 'hooks'), { recursive: true });
+  console.log(`  ${green}+${reset} .base/data/`);
+  console.log(`  ${green}+${reset} .base/hooks/`);
+
+  // Copy MCP servers
+  const baseMcpSrc = path.join(src, 'src', 'packages', 'base-mcp');
+  const baseMcpDest = path.join(baseDir, 'base-mcp');
+  copyDir(baseMcpSrc, baseMcpDest);
+  console.log(`  ${green}+${reset} .base/base-mcp/`);
+
+  const carlMcpSrc = path.join(src, 'src', 'packages', 'carl-mcp');
+  const carlMcpDest = path.join(baseDir, 'carl-mcp');
+  copyDir(carlMcpSrc, carlMcpDest);
+  console.log(`  ${green}+${reset} .base/carl-mcp/`);
+
+  // Copy all hooks from single src/hooks/ directory
+  // Surface hooks (_template, active-hook, backlog-hook) → .base/hooks/
+  // Session hooks (base-pulse-check, psmm-injector) → .claude/hooks/
+  const allHooksSrc = path.join(src, 'src', 'hooks');
+  const surfaceHooks = ['_template.py', 'active-hook.py', 'backlog-hook.py'];
+  const sessionHooks = ['base-pulse-check.py', 'psmm-injector.py', 'satellite-detection.py'];
+
+  const entries = fs.readdirSync(allHooksSrc);
+  for (const file of entries) {
+    const srcPath = path.join(allHooksSrc, file);
+    if (surfaceHooks.includes(file)) {
+      fs.copyFileSync(srcPath, path.join(baseDir, 'hooks', file));
+    } else if (sessionHooks.includes(file)) {
+      const claudeHooksDir = path.join(workspaceDir, '.claude', 'hooks');
+      fs.mkdirSync(claudeHooksDir, { recursive: true });
+      fs.copyFileSync(srcPath, path.join(claudeHooksDir, file));
+    } else {
+      // Unknown hooks default to .base/hooks/
+      fs.copyFileSync(srcPath, path.join(baseDir, 'hooks', file));
+    }
+  }
+  console.log(`  ${green}+${reset} .base/hooks/ (${surfaceHooks.length} surface hooks)`);
+  console.log(`  ${green}+${reset} .claude/hooks/ (${sessionHooks.length} session hooks: pulse, PSMM, satellite)`);
+
+  // npm install for MCP servers
+  console.log(`\n  Installing MCP dependencies...`);
+  try {
+    execSync('npm install', { cwd: baseMcpDest, stdio: 'pipe' });
+    console.log(`  ${green}+${reset} base-mcp dependencies installed`);
+  } catch (e) {
+    console.log(`  ${yellow}!${reset} base-mcp npm install failed — run manually in .base/base-mcp/`);
+  }
+  try {
+    execSync('npm install', { cwd: carlMcpDest, stdio: 'pipe' });
+    console.log(`  ${green}+${reset} carl-mcp dependencies installed`);
+  } catch (e) {
+    console.log(`  ${yellow}!${reset} carl-mcp npm install failed — run manually in .base/carl-mcp/`);
+  }
+
+  // Merge MCP registrations into .mcp.json
+  const mcpJsonPath = path.join(workspaceDir, '.mcp.json');
+  let mcpConfig = { mcpServers: {} };
+  if (fs.existsSync(mcpJsonPath)) {
+    try {
+      mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8'));
+    } catch (e) { /* start fresh */ }
+  }
+  mcpConfig.mcpServers['carl-mcp'] = {
+    type: 'stdio',
+    command: 'node',
+    args: ['./.base/carl-mcp/index.js']
+  };
+  mcpConfig.mcpServers['base-mcp'] = {
+    type: 'stdio',
+    command: 'node',
+    args: ['./.base/base-mcp/index.js']
+  };
+  fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+  console.log(`  ${green}+${reset} .mcp.json (carl-mcp + base-mcp registered)`);
+
+  console.log(`\n  ${green}Workspace layer installed.${reset}`);
+  console.log(`  Run ${cyan}/base:scaffold${reset} to complete workspace setup.\n`);
+}
+
+/**
+ * Prompt for install location
+ */
+function promptLocation() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
+  const globalPath = configDir || path.join(os.homedir(), '.claude');
+  const globalLabel = globalPath.replace(os.homedir(), '~');
+
+  console.log(`  ${yellow}What would you like to install?${reset}
+
+  ${cyan}1${reset}) Full install  ${dim}(commands to ${globalLabel} + workspace layer to .base/)${reset}
+  ${cyan}2${reset}) Commands only  ${dim}(${globalLabel})${reset}
+  ${cyan}3${reset}) Workspace only ${dim}(.base/ in current directory)${reset}
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    rl.close();
+    const choice = answer.trim() || '1';
+    if (choice === '1' || choice === '2') {
+      installCommands(true);
+    }
+    if (choice === '1' || choice === '3') {
+      installWorkspace();
+    }
+    if (choice !== '1' && choice !== '2' && choice !== '3') {
+      installCommands(true);
+      installWorkspace();
+    }
+    console.log(`  ${green}Done!${reset} Launch Claude Code and run ${cyan}/base:surface-list${reset}.\n`);
+  });
+}
+
+// Main
+if (hasHelp) {
+  // Already handled above
+} else if (hasGlobal || hasLocal || hasWorkspace) {
+  if (hasGlobal && hasLocal) {
+    console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
+    process.exit(1);
+  }
+  if (hasGlobal || hasLocal) {
+    installCommands(hasGlobal);
+  }
+  if (hasWorkspace) {
+    installWorkspace();
+  }
+  console.log(`  ${green}Done!${reset} Launch Claude Code and run ${cyan}/base:surface-list${reset}.\n`);
+} else {
+  promptLocation();
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@chrisai/base",
+  "version": "2.3.0",
+  "description": "Builder's Automated State Engine — workspace orchestration framework for Claude Code",
+  "bin": {
+    "base-framework": "bin/install.js"
+  },
+  "files": [
+    "bin",
+    "src/commands",
+    "src/skill",
+    "src/framework",
+    "src/packages",
+    "src/hooks",
+    "README.md"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "workspace",
+    "orchestration",
+    "base",
+    "data-surfaces",
+    "mcp"
+  ],
+  "author": "Chris Kahler",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ChristopherKahler/base.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ChristopherKahler/base/issues"
+  },
+  "homepage": "https://github.com/ChristopherKahler/base#readme",
+  "engines": {
+    "node": ">=16.7.0"
+  }
+}

package/src/commands/audit-claude-md.md

@@ -0,0 +1,31 @@
+---
+name: base:audit-claude-md
+description: Audit CLAUDE.md and generate recommended version
+allowed-tools: [Read, Write, Edit, Glob, Grep, Bash]
+---
+
+<objective>
+Audit the project's CLAUDE.md for completeness, accuracy, and alignment with workspace state. Generate a recommended version.
+
+**When to use:** "audit claude md", "check my claude.md", after major workspace changes.
+</objective>
+
+<execution_context>
+@.claude/skills/base/tasks/audit-claude-md.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@CLAUDE.md
+</context>
+
+<process>
+Follow task: @.claude/skills/base/tasks/audit-claude-md.md
+</process>
+
+<success_criteria>
+- [ ] Current CLAUDE.md analyzed
+- [ ] Gaps and outdated sections identified
+- [ ] Recommended version generated or changes suggested
+</success_criteria>

package/src/commands/audit.md

@@ -0,0 +1,33 @@
+---
+name: base:audit
+description: Deep workspace optimization
+allowed-tools: [Read, Write, Edit, Glob, Grep, Bash, Agent, AskUserQuestion]
+---
+
+<objective>
+Deep workspace audit — comprehensive optimization across all areas with actionable recommendations.
+
+**When to use:** "audit my workspace", "deep clean", monthly optimization.
+</objective>
+
+<execution_context>
+@.claude/skills/base/tasks/audit.md
+@.claude/skills/base/context/base-principles.md
+@.claude/skills/base/frameworks/audit-strategies.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@.base/workspace.json
+</context>
+
+<process>
+Follow task: @.claude/skills/base/tasks/audit.md
+</process>
+
+<success_criteria>
+- [ ] All areas audited with strategy-specific checks
+- [ ] Findings categorized and prioritized
+- [ ] Actionable recommendations presented
+</success_criteria>

package/src/commands/carl-hygiene.md

@@ -0,0 +1,33 @@
+---
+name: base:carl-hygiene
+description: CARL domain maintenance and rule review
+allowed-tools: [Read, Write, Edit, Glob, Grep, Bash, AskUserQuestion]
+---
+
+<objective>
+CARL rule lifecycle management — review staleness, dedup, staging pipeline, domain health.
+
+**When to use:** "carl hygiene", "review carl rules", "clean up carl".
+</objective>
+
+<execution_context>
+@.claude/skills/base/tasks/carl-hygiene.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@.carl/manifest
+@.base/workspace.json
+</context>
+
+<process>
+Follow task: @.claude/skills/base/tasks/carl-hygiene.md
+</process>
+
+<success_criteria>
+- [ ] All domains reviewed for staleness
+- [ ] Duplicate/conflicting rules identified
+- [ ] Staging pipeline processed
+- [ ] carl_hygiene.last_run updated in workspace.json
+</success_criteria>

package/src/commands/groom.md

@@ -0,0 +1,35 @@
+---
+name: base:groom
+description: Weekly workspace maintenance cycle
+allowed-tools: [Read, Write, Edit, Glob, Grep, Bash, AskUserQuestion]
+---
+
+<objective>
+Structured weekly maintenance — review each workspace area, update statuses, archive stale items, reduce drift.
+
+**When to use:** Weekly maintenance, "groom my workspace", "run grooming".
+</objective>
+
+<execution_context>
+@.claude/skills/base/tasks/groom.md
+@.claude/skills/base/context/base-principles.md
+@.claude/skills/base/frameworks/audit-strategies.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@.base/workspace.json
+@.base/STATE.md
+</context>
+
+<process>
+Follow task: @.claude/skills/base/tasks/groom.md
+</process>
+
+<success_criteria>
+- [ ] All workspace areas reviewed
+- [ ] Stale items addressed
+- [ ] STATE.md updated with groom results
+- [ ] Drift score recalculated
+</success_criteria>