create-claude-rails 0.1.2 → 0.2.0

package/lib/cli.js

@@ -1,10 +1,12 @@
 const prompts = require('prompts');
 const path = require('path');
 const fs = require('fs');
+const crypto = require('crypto');
 const { copyTemplates } = require('./copy');
 const { mergeSettings } = require('./settings-merge');
 const { create: createMetadata, read: readMetadata } = require('./metadata');
 const { setupDb } = require('./db-setup');
+const { reset } = require('./reset');
 
 const VERSION = require('../package.json').version;
 
@@ -23,8 +25,8 @@ const MODULES = {
     templates: ['hooks/git-guardrails.sh', 'hooks/skill-telemetry.sh', 'hooks/skill-tool-telemetry.sh'],
   },
   'work-tracking': {
-    name: 'Work Tracking (pib-db)',
-    description: 'Lightweight SQLite task/project tracker. Gives orient something to scan, debrief something to close.',
+    name: 'Work Tracking (pib-db or markdown)',
+    description: 'Track work items for orient/debrief. Default: SQLite (pib-db). Also supports markdown (tasks.md) or external systems. Choice made during /onboard.',
     mandatory: false,
     default: true,
     templates: ['scripts/pib-db.js', 'scripts/pib-db-schema.sql'],
@@ -101,6 +103,8 @@ function parseArgs(argv) {
     noDb: false,
     dryRun: false,
     help: false,
+    reset: false,
+    force: false,
     targetDir: '.',
   };
 
@@ -109,6 +113,8 @@ function parseArgs(argv) {
     else if (arg === '--no-db') flags.noDb = true;
     else if (arg === '--dry-run') flags.dryRun = true;
     else if (arg === '--help' || arg === '-h') flags.help = true;
+    else if (arg === '--reset') flags.reset = true;
+    else if (arg === '--force') flags.force = true;
     else if (!arg.startsWith('-')) flags.targetDir = arg;
   }
 
@@ -123,6 +129,8 @@ function printHelp() {
     --yes, -y     Accept all defaults, no prompts
     --no-db       Skip work tracking database setup
     --dry-run     Show what would be copied without writing
+    --reset       Remove CoR files (uses manifest for safety)
+    --force       With --reset: remove even customized files
     --help, -h    Show this help
 
   Examples:
@@ -131,6 +139,8 @@ function printHelp() {
     npx create-claude-rails --yes           Install everything, no questions
     npx create-claude-rails --yes --no-db   Install everything except DB
     npx create-claude-rails --dry-run       Preview what would be installed
+    npx create-claude-rails --reset         Remove CoR files safely
+    npx create-claude-rails --reset --dry-run  Preview what --reset would do
 `);
 }
 
@@ -142,6 +152,12 @@ async function run() {
     return;
   }
 
+  if (flags.reset) {
+    const projectDir = path.resolve(flags.targetDir);
+    await reset(projectDir, { dryRun: flags.dryRun, force: flags.force });
+    return;
+  }
+
   console.log('');
   console.log('  🚂 Claude on Rails v' + VERSION);
   console.log('  Opinionated process scaffolding for Claude Code projects');
@@ -290,6 +306,21 @@ async function run() {
   let totalCopied = 0;
   let totalSkipped = 0;
   let totalOverwritten = 0;
+  const allManifest = {}; // relPath -> hash for all written files
+
+  function hashContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+  }
+
+  // Compute the relative path from projectDir for manifest entries
+  function manifestPath(tmpl) {
+    if (tmpl.startsWith('skills/') || tmpl.startsWith('hooks/') || tmpl.startsWith('rules/')) {
+      return '.claude/' + tmpl;
+    } else if (tmpl.startsWith('scripts/')) {
+      return tmpl;
+    }
+    return '.claude/' + tmpl;
+  }
 
   for (const modKey of selectedModules) {
     const mod = MODULES[modKey];
@@ -323,23 +354,33 @@ async function run() {
         totalCopied += results.copied.length;
         totalSkipped += results.skipped.length;
         totalOverwritten += results.overwritten.length;
+        // Collect manifest entries — prefix with the dest-relative path
+        const prefix = manifestPath(tmpl);
+        for (const [relFile, hash] of Object.entries(results.manifest)) {
+          allManifest[prefix + '/' + relFile] = hash;
+        }
       } else {
         const destDir = path.dirname(destPath);
         if (!flags.dryRun && !fs.existsSync(destDir)) {
           fs.mkdirSync(destDir, { recursive: true });
         }
 
+        const incoming = fs.readFileSync(srcPath, 'utf8');
+        const incomingHash = hashContent(incoming);
+        const mPath = manifestPath(tmpl);
+
         if (fs.existsSync(destPath)) {
           const existingContent = fs.readFileSync(destPath, 'utf8');
-          const incoming = fs.readFileSync(srcPath, 'utf8');
           if (existingContent === incoming) {
             totalSkipped++;
+            allManifest[mPath] = incomingHash;
             continue;
           }
 
           if (flags.yes) {
             // --yes: keep existing files (safe default)
             totalSkipped++;
+            allManifest[mPath] = incomingHash;
           } else {
             const response = await prompts({
               type: 'select',
@@ -357,10 +398,12 @@ async function run() {
             } else {
               totalSkipped++;
             }
+            allManifest[mPath] = incomingHash;
           }
         } else {
           if (!flags.dryRun) fs.copyFileSync(srcPath, destPath);
           totalCopied++;
+          allManifest[mPath] = incomingHash;
         }
       }
     }
@@ -403,6 +446,7 @@ async function run() {
       modules: selectedModules,
       skipped: skippedModules,
       version: VERSION,
+      manifest: allManifest,
     });
     console.log('  📝 Created .pibrc.json');
   }

package/lib/copy.js

@@ -1,13 +1,18 @@
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const prompts = require('prompts');
 
+function hashContent(content) {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
 /**
  * Recursively copy files from src to dest, surfacing conflicts.
  * Returns { copied: string[], skipped: string[], overwritten: string[] }
  */
 async function copyTemplates(src, dest, { dryRun = false, skipConflicts = false, skipPhases = false } = {}) {
-  const results = { copied: [], skipped: [], overwritten: [] };
+  const results = { copied: [], skipped: [], overwritten: [], manifest: {} };
   await walkAndCopy(src, dest, src, results, dryRun, skipConflicts, skipPhases);
   return results;
 }
@@ -32,17 +37,21 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
       }
       await walkAndCopy(srcRoot, destRoot, srcPath, results, dryRun, skipConflicts, skipPhases);
     } else {
+      const incoming = fs.readFileSync(srcPath, 'utf8');
+      const incomingHash = hashContent(incoming);
+
       if (fs.existsSync(destPath)) {
         const existing = fs.readFileSync(destPath, 'utf8');
-        const incoming = fs.readFileSync(srcPath, 'utf8');
 
         if (existing === incoming) {
           results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
           continue;
         }
 
         if (skipConflicts) {
           results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
           continue;
         }
 
@@ -60,6 +69,7 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
         if (!response.action) {
           // User cancelled
           results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
           continue;
         }
 
@@ -77,11 +87,14 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
           } else {
             results.skipped.push(relPath);
           }
+          results.manifest[relPath] = incomingHash;
         } else if (response.action === 'overwrite') {
           if (!dryRun) fs.copyFileSync(srcPath, destPath);
           results.overwritten.push(relPath);
+          results.manifest[relPath] = incomingHash;
         } else {
           results.skipped.push(relPath);
+          results.manifest[relPath] = incomingHash;
         }
       } else {
         if (!dryRun) {
@@ -90,6 +103,7 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
           fs.copyFileSync(srcPath, destPath);
         }
         results.copied.push(relPath);
+        results.manifest[relPath] = incomingHash;
       }
     }
   }

package/lib/metadata.js

@@ -18,13 +18,14 @@ function write(projectDir, data) {
   fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
 }
 
-function create(projectDir, { modules, skipped, version }) {
+function create(projectDir, { modules, skipped, version, manifest = {} }) {
   const data = {
     version,
     installedAt: new Date().toISOString(),
     upstreamPackage: 'create-claude-rails',
     modules: {},
     skipped: {},
+    manifest,
   };
 
   for (const mod of modules) {

package/lib/reset.js

@@ -0,0 +1,193 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { read: readMetadata, METADATA_FILE } = require('./metadata');
+const { DEFAULT_HOOKS } = require('./settings-merge');
+
+// CoR-managed hook command patterns — used to identify hooks to remove
+const COR_HOOK_PATTERNS = [
+  '.claude/hooks/git-guardrails.sh',
+  '.claude/hooks/skill-telemetry.sh',
+  '.claude/hooks/skill-tool-telemetry.sh',
+];
+
+function hashContent(content) {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+/**
+ * Reconstruct manifest from module list for 0.1.x installs that lack one.
+ * Maps module names to their expected template paths using the MODULES
+ * definition from cli.js. Returns a best-effort manifest with no hashes.
+ */
+function reconstructManifest(metadata) {
+  // We don't import MODULES to avoid circular deps — use a static mapping
+  // that covers the known 0.1.x template structure.
+  console.log('  ⚠ No manifest found (0.1.x install). Reconstructing from modules...');
+  console.log('    All files will be treated as unmodified (no hash data).\n');
+  return {};
+}
+
+/**
+ * Remove CoR files from a project using the manifest for safety.
+ *
+ * For each manifest entry:
+ * - Hash matches → remove (unmodified CoR file)
+ * - Hash differs → skip with [CUSTOMIZED] warning (unless --force)
+ * - File missing → skip (already removed)
+ *
+ * Files NOT in the manifest are left alone (user-created, onboard-generated).
+ */
+async function reset(projectDir, { dryRun = false, force = false } = {}) {
+  console.log('');
+  console.log('  🚂 Claude on Rails — Reset');
+  console.log('');
+
+  if (dryRun) {
+    console.log('  [dry run — no files will be removed]\n');
+  }
+
+  const metadata = readMetadata(projectDir);
+  if (!metadata) {
+    console.log('  No .pibrc.json found — nothing to reset.');
+    return;
+  }
+
+  console.log(`  Found installation (v${metadata.version}, installed ${metadata.installedAt.split('T')[0]})`);
+  console.log('');
+
+  let manifest = metadata.manifest;
+  if (!manifest || Object.keys(manifest).length === 0) {
+    manifest = reconstructManifest(metadata);
+    if (Object.keys(manifest).length === 0) {
+      console.log('  Could not reconstruct manifest. Use --force to remove all CoR directories.\n');
+      if (!force) return;
+    }
+  }
+
+  const removed = [];
+  const customized = [];
+  const missing = [];
+  const forced = [];
+
+  // Process each manifest entry
+  for (const [relPath, installedHash] of Object.entries(manifest)) {
+    const fullPath = path.join(projectDir, relPath);
+
+    if (!fs.existsSync(fullPath)) {
+      missing.push(relPath);
+      continue;
+    }
+
+    const currentContent = fs.readFileSync(fullPath, 'utf8');
+    const currentHash = hashContent(currentContent);
+
+    if (currentHash === installedHash) {
+      // Unmodified — safe to remove
+      if (!dryRun) {
+        fs.unlinkSync(fullPath);
+        cleanEmptyDirs(path.dirname(fullPath), projectDir);
+      }
+      removed.push(relPath);
+    } else if (force) {
+      // Modified but --force used
+      if (!dryRun) {
+        fs.unlinkSync(fullPath);
+        cleanEmptyDirs(path.dirname(fullPath), projectDir);
+      }
+      forced.push(relPath);
+    } else {
+      customized.push(relPath);
+    }
+  }
+
+  // Clean CoR hooks from settings.json
+  const settingsPath = path.join(projectDir, '.claude', 'settings.json');
+  let hooksRemoved = 0;
+  if (fs.existsSync(settingsPath)) {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    if (settings.hooks) {
+      for (const [event, hookGroups] of Object.entries(settings.hooks)) {
+        const filtered = hookGroups.filter(group => {
+          const commands = group.hooks.map(h => h.command);
+          return !commands.some(cmd => COR_HOOK_PATTERNS.includes(cmd));
+        });
+        const removedCount = hookGroups.length - filtered.length;
+        hooksRemoved += removedCount;
+        if (filtered.length === 0) {
+          delete settings.hooks[event];
+        } else {
+          settings.hooks[event] = filtered;
+        }
+      }
+      if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+      }
+      if (!dryRun) {
+        if (Object.keys(settings).length === 0) {
+          fs.unlinkSync(settingsPath);
+        } else {
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+        }
+      }
+    }
+  }
+
+  // Remove .pibrc.json last
+  const pibrcPath = path.join(projectDir, METADATA_FILE);
+  if (!dryRun && fs.existsSync(pibrcPath)) {
+    fs.unlinkSync(pibrcPath);
+  }
+
+  // Print summary
+  if (removed.length > 0) {
+    console.log(`  ✅ Removed ${removed.length} unmodified file${removed.length === 1 ? '' : 's'}`);
+    for (const f of removed) console.log(`     [REMOVED] ${f}`);
+  }
+
+  if (forced.length > 0) {
+    console.log(`  ⚠ Force-removed ${forced.length} customized file${forced.length === 1 ? '' : 's'}`);
+    for (const f of forced) console.log(`     [FORCED]  ${f}`);
+  }
+
+  if (customized.length > 0) {
+    console.log(`  ⏭ Skipped ${customized.length} customized file${customized.length === 1 ? '' : 's'} (use --force to remove)`);
+    for (const f of customized) console.log(`     [CUSTOMIZED] ${f}`);
+  }
+
+  if (missing.length > 0) {
+    console.log(`  ℹ ${missing.length} manifest file${missing.length === 1 ? '' : 's'} already removed`);
+  }
+
+  if (hooksRemoved > 0) {
+    console.log(`  🔧 Removed ${hooksRemoved} CoR hook${hooksRemoved === 1 ? '' : 's'} from settings.json`);
+  }
+
+  if (!dryRun) {
+    console.log(`  📝 Removed ${METADATA_FILE}`);
+  }
+
+  console.log('\n  Reset complete.\n');
+}
+
+/**
+ * Remove empty directories up to (but not including) the stop directory.
+ */
+function cleanEmptyDirs(dir, stopDir) {
+  const resolved = path.resolve(dir);
+  const stop = path.resolve(stopDir);
+
+  if (resolved === stop || !resolved.startsWith(stop)) return;
+
+  try {
+    const entries = fs.readdirSync(resolved);
+    if (entries.length === 0) {
+      fs.rmdirSync(resolved);
+      cleanEmptyDirs(path.dirname(resolved), stopDir);
+    }
+  } catch {
+    // Directory doesn't exist or not empty — stop
+  }
+}
+
+module.exports = { reset };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-rails",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Claude on Rails — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-rails": "bin/create-claude-rails.js"

package/templates/EXTENSIONS.md

@@ -1,15 +1,15 @@
-# Extension Examples: How Flow Uses Process-in-a-Box
+# Extension Examples: How Flow Uses Claude on Rails
 
-PIB gives you skeletons. Your project fills them in via phase files —
+Claude on Rails (CoR) gives you skeletons. Your project fills them in via phase files —
 replacing defaults with project-specific behavior, adding custom phases
 the skeleton doesn't define. This document shows what that looks like
-in practice, using Flow (PIB's reference implementation) as the example.
+in practice, using Flow (CoR's reference implementation) as the example.
 
 Flow is a cognitive workspace built on Claude Code — a GTD system,
 research thread manager, and course management tool. It has a deployed
 web app (Railway), a local SQLite cache, research threads, an inbox
 pipeline, and 25+ skills. It's what happens when a project grows past
-PIB's defaults while staying on PIB's rails.
+CoR's defaults while staying on CoR's rails.
 
 You and Claude will make different choices for your project. These
 examples show what choices Flow made and why — not what you should do,
@@ -18,22 +18,22 @@ but what's possible.
 
 ## Flow's Phase File Overrides by Skill
 
-For each skeleton skill, the tables show: which PIB phase files Flow
+For each skeleton skill, the tables show: which CoR phase files Flow
 overrides (replacing default behavior with Flow-specific content), and
-which custom phase files Flow adds (concerns PIB doesn't define).
+which custom phase files Flow adds (concerns CoR doesn't define).
 
-Phase file states: **default** = PIB's behavior is fine, no override
+Phase file states: **default** = CoR's behavior is fine, no override
 needed. **override** = Flow writes its own content. **custom** = Flow
-adds a phase PIB doesn't have. **skip** = Flow actively opts out.
+adds a phase CoR doesn't have. **skip** = Flow actively opts out.
 
 ### orient
 
-PIB's orient skeleton loads context, syncs data, scans work, checks
+CoR's orient skeleton loads context, syncs data, scans work, checks
 health, and presents a briefing. Flow's orient is its most complex
 skill — 47 steps managing a deployed app, research threads, an inbox
 pipeline, and multiple always-on perspectives.
 
-| Phase | PIB Default | Flow Override |
+| Phase | CoR Default | Flow Override |
 |---|---|---|
 | `context.md` | Read status files | `system-status.md`, 7 research threads (`thread.yaml` + `CLAUDE.md`), `MEMORY.md` index, active course syllabi |
 | `data-sync.md` | Skip | DB pull from Railway (`sync-db-to-railway.sh --pull`). Report failure but don't block. |
@@ -60,12 +60,12 @@ custom phases as concerns emerge.
 
 ### debrief
 
-PIB's debrief skeleton inventories work, closes items, updates state,
+CoR's debrief skeleton inventories work, closes items, updates state,
 records lessons, and captures loose ends. Flow's debrief is the second
 most complex skill — it resolves feedback comments, runs prep scout and
 articulation sweeps, checks machine-level drift, and enforces QA gates.
 
-| Phase | PIB Default | Flow Override |
+| Phase | CoR Default | Flow Override |
 |---|---|---|
 | `inventory.md` | Scan git log + conversation | Same approach, plus check for uncommitted work, unresolved preview tool sessions |
 | `close-work.md` | Match session work against pib-db actions | Match against Railway API actions. QA perspective gate: actions can't be marked complete if QA report shows failures. Project auto-completion scan. |
@@ -86,16 +86,16 @@ articulation sweeps, checks machine-level drift, and enforces QA gates.
 | `project-completion.md` | Check if any projects have all actions completed, prompt for project close |
 
 **Key pattern:** Flow's debrief has *mandatory perspectives* — historian
-and life-tracker always activate. In PIB's skeleton, perspectives are
+and life-tracker always activate. In CoR's skeleton, perspectives are
 optional (the `perspectives.md` phase can be empty). Flow overrides this
 by listing required perspectives in its close-work and loose-ends phases.
 
 ### validate
 
-PIB's validate skeleton runs validators from a single phase file. Flow
+CoR's validate skeleton runs validators from a single phase file. Flow
 overrides with 8 specific validators.
 
-| Phase | PIB Default | Flow Override |
+| Phase | CoR Default | Flow Override |
 |---|---|---|
 | `validators.md` | Commented-out examples | 8 validators: fid coverage (`validate-fids.sh`), thread structure (`validate-threads.sh`), folder integrity (`validate-folders.sh`), MEMORY.md references, TypeScript (`npx tsc --noEmit`), Vite build (`npx vite build`), ESLint (`npx eslint`), Mantine import check |
 
@@ -104,11 +104,11 @@ does the job. Flow just fills in its specific checks.
 
 ### plan
 
-PIB's plan skeleton researches, checks overlap, drafts with template,
+CoR's plan skeleton researches, checks overlap, drafts with template,
 runs perspective critique, checks completeness, presents, and files work.
 Flow's plan adds a design committee pattern and specific work tracking.
 
-| Phase | PIB Default | Flow Override |
+| Phase | CoR Default | Flow Override |
 |---|---|---|
 | `research.md` | Explore codebase | Same, plus check ecosystem memory (`reference-skill-ecosystem.md`) for prior art |
 | `overlap-check.md` | Query pib-db | Query Railway DB via sqlite3 on local cache. Check open actions + recent completed. |
@@ -126,11 +126,11 @@ Flow's plan adds a design committee pattern and specific work tracking.
 
 ### execute
 
-PIB's execute skeleton loads the plan, activates perspectives, implements
+CoR's execute skeleton loads the plan, activates perspectives, implements
 with checkpoints, validates, and commits. Flow adds QA enforcement and
 design mock verification.
 
-| Phase | PIB Default | Flow Override |
+| Phase | CoR Default | Flow Override |
 |---|---|---|
 | `load-plan.md` | Read plan from conversation or file | Same, plus check for design mocks in action notes (`mock_path`) and `.claude/mocks/` |
 | `perspectives.md` | Activate relevant perspectives | QA always-on. Boundary-conditions always-on. Others per plan's surface area. |
@@ -141,15 +141,15 @@ design mock verification.
 **Key pattern:** Flow's execute enforces a QA gate — the QA perspective
 produces a verification report at checkpoint 3, and debrief won't mark
 actions complete if QA shows failures. This is the "mandatory perspective"
-pattern: a perspective that's advisory in PIB becomes load-bearing in Flow.
+pattern: a perspective that's advisory in CoR becomes load-bearing in Flow.
 
 ### audit
 
-PIB's audit skeleton selects perspectives, runs structural checks, loads
+CoR's audit skeleton selects perspectives, runs structural checks, loads
 triage suppression, spawns perspective agents, and persists findings.
 Flow overrides the data layer and execution model.
 
-| Phase | PIB Default | Flow Override |
+| Phase | CoR Default | Flow Override |
 |---|---|---|
 | `perspective-selection.md` | Discover from SKILL.md files, use groups | Same discovery, but 21 additional domain perspectives available |
 | `structural-checks.md` | Run fast structural scripts | Same validators as `/validate`, run before LLM analysis |
@@ -164,19 +164,19 @@ Flow overrides the data layer and execution model.
 | `triage.md` | Programmatic triage of findings via Railway API PATCH endpoint (approve/reject/defer) |
 | `next-steps.md` | Offer quick-fix, /plan, or bulk triage based on findings after output |
 
-**Why nested agents instead of subprocesses:** PIB's default uses
+**Why nested agents instead of subprocesses:** CoR's default uses
 `claude --print` for parallel perspective execution. Flow found that
 subprocess spawning creates API concurrency errors during active
 sessions. Nested Agent tool calls avoid this. A project without this
-constraint can use PIB's subprocess default.
+constraint can use CoR's subprocess default.
 
 ### pulse
 
-PIB's pulse skeleton checks self-description accuracy, spots dead
+CoR's pulse skeleton checks self-description accuracy, spots dead
 references, and detects staleness. Flow overrides with extensive
 count verification and principle practice checks.
 
-| Phase | PIB Default | Flow Override |
+| Phase | CoR Default | Flow Override |
 |---|---|---|
 | `checks.md` | Count freshness, dead references | Count freshness across 3 files (`project-skills-infrastructure.md`, `system-status.md`, `_context.md`). Dead reference spot-check with rotation tracking (`pulse-state.json`). Skill staleness (last-verified > 30d). Rules enforcement health. Session drift detection. Principle spot-check (samples different principle each run). Memory index auto-fix. |
 | `auto-fix-scope.md` | Closed list of safe fixes | Same closed list: numeric counts, MEMORY.md filenames, system-status moves, `_context.md` perspective lists, last-verified dates |
@@ -190,10 +190,10 @@ project could adopt.
 
 ### triage-audit
 
-PIB's triage skeleton loads findings, presents via UI, and applies
+CoR's triage skeleton loads findings, presents via UI, and applies
 verdicts. Flow overrides the data source and verdict application.
 
-| Phase | PIB Default | Flow Override |
+| Phase | CoR Default | Flow Override |
 |---|---|---|
 | `load-findings.md` | Query pib-db or read JSON files | Fetch from Railway DB via API with severity + perspective ordering |
 | `triage-ui.md` | Start local `triage-server.mjs`, open browser | Same local server, but opened via Chrome MCP tool for reading verdicts |
@@ -218,7 +218,7 @@ project could implement for its own domain.
 | Change-type deployment | `/deploy` | Classifies changes (markdown-only, code, mixed), takes appropriate deploy path (git push vs git push + platform deploy), verifies | Any project with multiple deployment paths depending on what changed. The classify-deploy-verify loop is the pattern. |
 | Area health review | `/quarterly-review` | SQL-driven area-by-area walkthrough: stale actions, recurring cadence health, person context freshness, open loops, supply patterns | Any project with areas of responsibility benefits from periodic health queries. The SQL query templates are reusable. |
 
-These are future extraction candidates. If PIB grows beyond Wave 6, the
+These are future extraction candidates. If CoR grows beyond Wave 6, the
 highest-value patterns to skeleton would be: entity scaffolding (widely
 applicable), prompt refinement (universal for Claude Code projects), and
 command queue processing (needed by any project with an async work queue).
@@ -226,7 +226,7 @@ command queue processing (needed by any project with an async work queue).
 
 ## Writing Domain-Specific Perspectives
 
-PIB ships 14 generic perspectives. Flow has 19 additional domain-specific
+CoR ships 14 generic perspectives. Flow has 19 additional domain-specific
 perspectives. Here are three examples showing how to write your own.
 
 ### Example 1: GTD (encoding domain expertise)
@@ -305,7 +305,7 @@ Eight skills contained reusable patterns (documented in the table above).
 The full analysis is in the methodology essay's Wave 6 findings section.
 
 These are patterns, not extraction candidates — yet. The patterns are
-documented here so PIB users know what's possible. If your project needs
+documented here so CoR users know what's possible. If your project needs
 entity scaffolding or prompt refinement, you'll write your own version.
-If PIB grows a Wave 7, the strongest candidates for skeleton extraction
+If CoR grows a Wave 7, the strongest candidates for skeleton extraction
 are scaffold, refine-prompts, and handle-findings.

package/templates/README.md

@@ -59,7 +59,7 @@ adoption is straightforward: copy what you need into your project's
 | `skills/triage-audit/SKILL.md` | 5 | **Triage skeleton.** Load findings, prepare commentary, present via local web UI or CLI, apply verdicts (fix/defer/reject), create actions for approved findings. 3 phase files. |
 | `skills/onboard/SKILL.md` | 7 | **Onboarding skeleton.** Conversational interview that generates the initial context layer. Re-runnable: first run generates, subsequent runs refine. 6 phase files. |
 | `skills/seed/SKILL.md` | 7 | **Capability seeding skeleton.** Detects technology adoption signals, proposes expertise conversations, builds and maintains perspectives collaboratively. 4 phase files. |
-| `skills/upgrade/SKILL.md` | 7 | **Upgrade skeleton.** Conversational merge when new PIB skeletons arrive. Intelligence is the merge strategy — conversation, not mechanical copy. 4 phase files. |
+| `skills/upgrade/SKILL.md` | 7 | **Upgrade skeleton.** Conversational merge when new CoR skeletons arrive. Intelligence is the merge strategy — conversation, not mechanical copy. 4 phase files. |
 
 ### Scripts (6)
 
@@ -106,7 +106,7 @@ execution, audit). Each is a named domain expert encoded in markdown.
 
 | Perspective | Domain | Activation |
 |------------|--------|-----------|
-| `box-health` | PIB adoption health, phase file coverage, configuration drift, anti-bloat | Always-on during audit |
+| `box-health` | CoR adoption health, phase file coverage, configuration drift, anti-bloat | Always-on during audit |
 
 **Infrastructure files (7):**