up-cc 0.14.0 → 0.16.0

package/{bin → up/bin}/up-tools.cjs

@@ -12,7 +12,7 @@
  *   state load|get|update|advance-plan|update-progress|add-decision|record-session|record-metric|snapshot|save-session
  *   roadmap get-phase|analyze|update-plan-progress
  *   phase add|remove|find|complete|generate-from-report
- *   config get|set
+ *   config get|set|resolve-model|list-presets
  *   requirements mark-complete
  *   commit <msg> --files
  *   progress [json|table|bar]
@@ -26,7 +26,9 @@
 const fs = require('fs');
 const path = require('path');
 const {
-  output, error, loadConfig, isGitIgnored, execGit,
+  output, error, loadConfig, resolveAgentModel,
+  MODEL_PRESETS, AGENT_ROLE_MAP,
+  isGitIgnored, execGit,
   escapeRegex, normalizePhaseName, comparePhaseNum,
   findPhaseInternal, getRoadmapPhaseInternal,
   pathExistsInternal, generateSlugInternal, toPosixPath,
@@ -314,8 +316,12 @@ function main() {
         cmdConfigGet(cwd, args[2], raw);
       } else if (sub === 'set') {
         cmdConfigSet(cwd, args[2], args[3], raw);
+      } else if (sub === 'resolve-model') {
+        cmdConfigResolveModel(cwd, args[2], raw);
+      } else if (sub === 'list-presets') {
+        cmdConfigListPresets(raw);
       } else {
-        error('Unknown config subcommand. Available: get, set');
+        error('Unknown config subcommand. Available: get, set, resolve-model, list-presets');
       }
       break;
     }
@@ -348,6 +354,78 @@ function main() {
       break;
     }
 
+    // ==================== BUDGET ====================
+    case 'budget': {
+      cmdBudget(cwd, raw);
+      break;
+    }
+
+    // ==================== STATUS (headless aggregator) ====================
+    case 'status': {
+      cmdStatus(cwd, raw);
+      break;
+    }
+
+    // ==================== CONTEXT (pre-inline helper) ====================
+    case 'context': {
+      cmdContext(cwd, args.slice(1), raw);
+      break;
+    }
+
+    // ==================== TIMEOUT (Wave 3) ====================
+    case 'timeout': {
+      cmdTimeout(args.slice(1), raw);
+      break;
+    }
+
+    // ==================== STUCK CHECK (Wave 3) ====================
+    case 'stuck-check': {
+      cmdStuckCheck(cwd, args.slice(1), raw);
+      break;
+    }
+
+    // ==================== VERIFY-STATIC (Wave 4) ====================
+    case 'verify-static': {
+      cmdVerifyStatic(cwd, args.slice(1), raw);
+      break;
+    }
+
+    // ==================== CLASSIFY-TASK (Wave 5) ====================
+    case 'classify-task': {
+      cmdClassifyTask(cwd, args.slice(1), raw);
+      break;
+    }
+
+    // ==================== RESOLVE-MODEL-FOR-PLAN (Wave 5) ====================
+    case 'resolve-model-for-plan': {
+      cmdResolveModelForPlan(cwd, args.slice(1), raw);
+      break;
+    }
+
+    // ==================== ROUTING-LOG (Wave 5) ====================
+    case 'routing-log': {
+      cmdRoutingLog(cwd, args.slice(1), raw);
+      break;
+    }
+
+    // ==================== ANALYZE-ROUTING (Wave 5) ====================
+    case 'analyze-routing': {
+      cmdAnalyzeRouting(cwd, raw);
+      break;
+    }
+
+    // ==================== VALIDATE-PLAN (Wave 6) ====================
+    case 'validate-plan': {
+      cmdValidatePlan(cwd, args.slice(1), raw);
+      break;
+    }
+
+    // ==================== SKILL-MANIFEST (Wave 6) ====================
+    case 'skill-manifest': {
+      cmdSkillManifest(args.slice(1), raw);
+      break;
+    }
+
     // ==================== TIMESTAMP ====================
     case 'timestamp': {
       cmdTimestamp(args[1] || 'full', raw);
@@ -2303,6 +2381,7 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
   let parsedValue = value;
   if (value === 'true') parsedValue = true;
   else if (value === 'false') parsedValue = false;
+  else if (value === 'null') parsedValue = null;
   else if (!isNaN(value) && value !== '') parsedValue = Number(value);
 
   let config = {};
@@ -2334,6 +2413,16 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
   }
 }
 
+function cmdConfigResolveModel(cwd, agentName, raw) {
+  if (!agentName) error('Usage: config resolve-model <agent-name>');
+  const model = resolveAgentModel(cwd, agentName);
+  output({ agent: agentName, model: model, role: AGENT_ROLE_MAP[agentName] || 'unknown' }, raw, model || 'default');
+}
+
+function cmdConfigListPresets(raw) {
+  output(MODEL_PRESETS, raw, JSON.stringify(MODEL_PRESETS, null, 2));
+}
+
 // =====================================================================
 // REQUIREMENTS COMMANDS
 // =====================================================================
@@ -2407,6 +2496,1255 @@ function cmdCommit(cwd, message, files, raw) {
   output({ committed: true, hash, reason: 'committed' }, raw, hash || 'committed');
 }
 
+// =====================================================================
+// BUDGET COMMAND
+// =====================================================================
+
+function cmdBudget(cwd, raw) {
+  const config = loadConfig(cwd);
+  const ceiling = config.budget_ceiling;
+
+  // Spawn up-instrument.cjs report --json to get current spend
+  const { execSync } = require('child_process');
+  const instrumentPath = path.join(__dirname, 'up-instrument.cjs');
+
+  let spend = 0;
+  let agentCount = 0;
+  let report = null;
+
+  try {
+    const out = execSync(`node "${instrumentPath}" report --json --all-sessions`, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 30000, // 30s cap — fail open if jsonl scan is slow
+    });
+    report = JSON.parse(out);
+    spend = report.total_cost_usd ?? 0;
+    agentCount = (report.agents ?? []).reduce((sum, a) => sum + (a.invocations || 0), 0);
+  } catch (err) {
+    // instrumentation may fail on non-Claude Code runtimes or timeout — return zero spend
+    spend = 0;
+  }
+
+  const result = {
+    spend_usd: Number(spend.toFixed(4)),
+    ceiling_usd: ceiling,
+    agent_invocations: agentCount,
+    status: 'unknown',
+    percent_used: null,
+  };
+
+  if (ceiling === null || ceiling === undefined) {
+    result.status = 'no_ceiling';
+  } else if (ceiling <= 0) {
+    result.status = 'no_ceiling';
+  } else {
+    const pct = (spend / ceiling) * 100;
+    result.percent_used = Number(pct.toFixed(1));
+    if (pct >= 100) result.status = 'over_budget';
+    else if (pct >= 90) result.status = 'critical_90';
+    else if (pct >= 75) result.status = 'warning_75';
+    else if (pct >= 50) result.status = 'warning_50';
+    else result.status = 'under_budget';
+  }
+
+  output(
+    result,
+    raw,
+    ceiling
+      ? `Spent: $${result.spend_usd} / $${ceiling} (${result.percent_used}%) [${result.status}]`
+      : `Spent: $${result.spend_usd} (no ceiling configured)`
+  );
+}
+
+// =====================================================================
+// TIMEOUT COMMAND (Wave 3 — soft/idle/hard timeouts)
+// =====================================================================
+
+/**
+ * Compute timeout status given a start time and limits.
+ *
+ * Usage:
+ *   up-tools.cjs timeout --start <epoch> --soft <secs> --hard <secs>
+ *                        [--idle-since <epoch>] [--idle <secs>]
+ *
+ * Returns JSON:
+ *   { elapsed_secs, status, remaining_soft, remaining_hard,
+ *     idle_secs, idle_status }
+ *
+ * Status values:
+ *   ok           — under all limits
+ *   soft_warning — past soft, warn but continue
+ *   idle_warning — idle for too long, may be stuck
+ *   hard_abort   — past hard, abort immediately
+ *
+ * Defaults match gsd-2:
+ *   soft=1200 (20m), hard=1800 (30m), idle=600 (10m)
+ */
+function cmdTimeout(args, raw) {
+  const flags = { start: null, soft: 1200, hard: 1800, idleSince: null, idle: 600 };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--start') flags.start = parseInt(args[++i], 10);
+    else if (a === '--soft') flags.soft = parseInt(args[++i], 10);
+    else if (a === '--hard') flags.hard = parseInt(args[++i], 10);
+    else if (a === '--idle-since') flags.idleSince = parseInt(args[++i], 10);
+    else if (a === '--idle') flags.idle = parseInt(args[++i], 10);
+  }
+
+  if (!flags.start) error('Usage: timeout --start <epoch> [--soft N] [--hard N] [--idle-since E] [--idle N]');
+
+  const now = Math.floor(Date.now() / 1000);
+  const elapsed = now - flags.start;
+  const remainingSoft = Math.max(0, flags.soft - elapsed);
+  const remainingHard = Math.max(0, flags.hard - elapsed);
+
+  let status = 'ok';
+  if (elapsed >= flags.hard) status = 'hard_abort';
+  else if (elapsed >= flags.soft) status = 'soft_warning';
+
+  const result = {
+    elapsed_secs: elapsed,
+    status,
+    remaining_soft: remainingSoft,
+    remaining_hard: remainingHard,
+  };
+
+  if (flags.idleSince) {
+    const idleSecs = now - flags.idleSince;
+    result.idle_secs = idleSecs;
+    if (idleSecs >= flags.idle) {
+      result.idle_status = 'idle_warning';
+      // Idle warning escalates to hard_abort if also past soft
+      if (status === 'soft_warning') {
+        result.status = 'hard_abort';
+      } else if (status === 'ok') {
+        result.status = 'idle_warning';
+      }
+    } else {
+      result.idle_status = 'ok';
+    }
+  }
+
+  output(result, raw, `${result.status} | elapsed=${elapsed}s soft_remaining=${remainingSoft}s hard_remaining=${remainingHard}s`);
+}
+
+// =====================================================================
+// STUCK CHECK COMMAND (Wave 3 — sliding window pattern detector)
+// =====================================================================
+
+/**
+ * Detect repeated tool-call patterns by reading an activity log.
+ *
+ * Agents append events to .plano/runtime/agent-activity-<id>.log via
+ * Bash echo. Each line: "<timestamp>|<tool>|<target>". This command
+ * scans the last N lines and flags repetition.
+ *
+ * Usage:
+ *   up-tools.cjs stuck-check --log <path> [--window 10] [--threshold 3]
+ *
+ * Returns:
+ *   { stuck: bool, reason, repeated_pattern, count, window_size }
+ *
+ * Stuck = same (tool|target) appears `threshold` times within
+ * `window` last entries.
+ */
+function cmdStuckCheck(cwd, args, raw) {
+  const flags = { log: null, window: 10, threshold: 3 };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--log') flags.log = args[++i];
+    else if (a === '--window') flags.window = parseInt(args[++i], 10);
+    else if (a === '--threshold') flags.threshold = parseInt(args[++i], 10);
+  }
+
+  if (!flags.log) error('Usage: stuck-check --log <path> [--window N] [--threshold N]');
+
+  const logPath = path.isAbsolute(flags.log) ? flags.log : path.join(cwd, flags.log);
+
+  let lines = [];
+  try {
+    const content = fs.readFileSync(logPath, 'utf-8');
+    lines = content.split('\n').filter(l => l.trim() && l.includes('|'));
+  } catch {
+    output({ stuck: false, reason: 'no_log', repeated_pattern: null, count: 0, window_size: 0 }, raw, 'no_log');
+    return;
+  }
+
+  const window = lines.slice(-flags.window);
+  const counts = new Map();
+
+  for (const line of window) {
+    const parts = line.split('|').map(s => s.trim());
+    // Treat tool|target as the pattern (skip timestamp)
+    const key = parts.slice(1, 3).join('|');
+    counts.set(key, (counts.get(key) || 0) + 1);
+  }
+
+  let topPattern = null;
+  let topCount = 0;
+  for (const [key, count] of counts) {
+    if (count > topCount) {
+      topPattern = key;
+      topCount = count;
+    }
+  }
+
+  const stuck = topCount >= flags.threshold;
+
+  output(
+    {
+      stuck,
+      reason: stuck ? `pattern_repeated_${topCount}x` : 'ok',
+      repeated_pattern: stuck ? topPattern : null,
+      count: topCount,
+      window_size: window.length,
+      threshold: flags.threshold,
+    },
+    raw,
+    stuck ? `STUCK: "${topPattern}" repeated ${topCount}x in last ${window.length} entries` : `ok (top pattern: ${topCount}x in ${window.length})`
+  );
+}
+
+// =====================================================================
+// VALIDATE-PLAN COMMAND (Wave 6 — iron rule)
+// =====================================================================
+
+/**
+ * Iron rule: a plan must fit in one context window. Validate that a
+ * PLAN.md is decomposable enough to be executed by a single agent
+ * call without losing context. Fails when:
+ *   - File > 25kB (default; configurable via --max-bytes)
+ *   - Task count > 12 (default; configurable via --max-tasks)
+ *   - No frontmatter (must declare type at minimum)
+ *   - No verification criteria (no <verification>, no must_haves)
+ *
+ * Usage:
+ *   up-tools.cjs validate-plan <plan-path> [--max-bytes N] [--max-tasks N]
+ *
+ * Returns:
+ *   { pass, plan_path, bytes, tasks, frontmatter_keys, issues[],
+ *     suggestions[] }
+ */
+function cmdValidatePlan(cwd, args, raw) {
+  const flags = { maxBytes: 25 * 1024, maxTasks: 12 };
+  let planPath = null;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--max-bytes') flags.maxBytes = parseInt(args[++i], 10) || flags.maxBytes;
+    else if (a === '--max-tasks') flags.maxTasks = parseInt(args[++i], 10) || flags.maxTasks;
+    else if (!a.startsWith('--')) planPath = a;
+  }
+  if (!planPath) error('Usage: validate-plan <plan-path> [--max-bytes N] [--max-tasks N]');
+
+  const fullPath = path.isAbsolute(planPath) ? planPath : path.join(cwd, planPath);
+  let content;
+  try {
+    content = fs.readFileSync(fullPath, 'utf-8');
+  } catch {
+    error(`Cannot read plan: ${fullPath}`);
+  }
+
+  const issues = [];
+  const suggestions = [];
+  const bytes = Buffer.byteLength(content, 'utf-8');
+
+  // Frontmatter parsing
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  const fmKeys = [];
+  if (fmMatch) {
+    for (const line of fmMatch[1].split('\n')) {
+      const m = line.match(/^(\w+)\s*:/);
+      if (m) fmKeys.push(m[1]);
+    }
+  } else {
+    issues.push('no_frontmatter');
+    suggestions.push('Add YAML frontmatter with at least: phase, plan, type');
+  }
+
+  // Task count
+  // Detect tasks via multiple shapes — <task> XML tags (preferred), or
+  // numbered/bulleted markdown headings/items at start of line.
+  const taskMatches = (content.match(/<task\b/gi) || []).length;
+  const numberedHeadings = (content.match(/^#{2,4}\s+(?:Task\s+)?\d+[.:)]?\s/gmi) || []).length;
+  const numberedBullets = (content.match(/^[-*]\s+\d+[.:)]\s/gm) || []).length;
+  const tasks = Math.max(taskMatches, numberedHeadings, numberedBullets);
+
+  // Verification criteria
+  const hasVerification = /<verification|must_haves|criterios|criteria/i.test(content);
+
+  if (bytes > flags.maxBytes) {
+    issues.push(`size_exceeds_${flags.maxBytes}_bytes`);
+    suggestions.push(`Plan is ${(bytes/1024).toFixed(1)}kB (limit ${(flags.maxBytes/1024).toFixed(0)}kB). Split into 2 plans by task group.`);
+  }
+
+  if (tasks > flags.maxTasks) {
+    issues.push(`task_count_exceeds_${flags.maxTasks}`);
+    suggestions.push(`Plan has ${tasks} tasks (limit ${flags.maxTasks}). Split by domain (e.g., schema separate from API separate from UI).`);
+  }
+
+  if (tasks === 0) {
+    issues.push('no_tasks_detected');
+    suggestions.push('No <task> tags or numbered sections found. Use <task type="auto"> or "### 1. <action>" markers.');
+  }
+
+  if (!hasVerification) {
+    issues.push('no_verification_criteria');
+    suggestions.push('Add a <verification> block or must_haves frontmatter so the verifier can check completion.');
+  }
+
+  const pass = issues.length === 0;
+
+  output(
+    {
+      pass,
+      plan_path: path.relative(cwd, fullPath),
+      bytes,
+      tasks,
+      frontmatter_keys: fmKeys,
+      has_verification: hasVerification,
+      issues,
+      suggestions,
+      limits: { max_bytes: flags.maxBytes, max_tasks: flags.maxTasks },
+    },
+    raw,
+    pass
+      ? `validate-plan: PASS (${(bytes/1024).toFixed(1)}kB, ${tasks} tasks)`
+      : `validate-plan: FAIL (${issues.length} issues) — ${issues.join(', ')}`
+  );
+}
+
+// =====================================================================
+// SKILL-MANIFEST COMMAND (Wave 6 — per unit-type refs)
+// =====================================================================
+
+const SKILL_MANIFEST = {
+  // Execution agents — fokus em principles + production reqs
+  'up-executor': ['engineering-principles-compressed'],
+  'up-frontend-specialist': ['engineering-principles-compressed', 'ui-brand', 'production-requirements-compressed'],
+  'up-backend-specialist': ['engineering-principles-compressed', 'production-requirements-compressed'],
+  'up-database-specialist': ['engineering-principles-compressed', 'production-requirements-compressed'],
+  'up-devops-agent': ['production-requirements-compressed'],
+  'up-technical-writer': [],
+  'up-depurador': ['engineering-principles-compressed'],
+
+  // Planning agents — fokus em arquitetura + reqs
+  'up-planejador': ['engineering-principles-compressed'],
+  'up-arquiteto': ['engineering-principles-compressed', 'production-requirements-compressed'],
+  'up-product-analyst': [],
+  'up-system-designer': ['engineering-principles-compressed', 'production-requirements-compressed'],
+  'up-roteirista': [],
+  'up-pesquisador-projeto': [],
+  'up-sintetizador': [],
+  'up-mapeador-codigo': [],
+  'up-requirements-validator': ['production-requirements-compressed'],
+
+  // Governance — fokus em rules + rework
+  'up-execution-supervisor': ['governance-rules-compressed', 'engineering-principles-compressed', 'rework-limits-compressed'],
+  'up-verification-supervisor': ['governance-rules-compressed', 'rework-limits-compressed'],
+  'up-planning-supervisor': ['governance-rules-compressed', 'rework-limits-compressed'],
+  'up-quality-supervisor': ['governance-rules-compressed'],
+  'up-audit-supervisor': ['governance-rules-compressed'],
+  'up-product-supervisor': ['governance-rules-compressed'],
+  'up-architecture-supervisor': ['governance-rules-compressed'],
+  'up-operations-supervisor': ['governance-rules-compressed'],
+  'up-chief-engineer': ['governance-rules-compressed', 'rework-limits-compressed'],
+  'up-chief-architect': ['governance-rules-compressed'],
+  'up-chief-quality': ['governance-rules-compressed'],
+  'up-chief-operations': ['governance-rules-compressed'],
+  'up-chief-product': ['governance-rules-compressed'],
+  'up-project-ceo': ['governance-rules-compressed'],
+  'up-delivery-auditor': ['governance-rules-compressed', 'production-requirements-compressed'],
+  'up-planning-auditor': ['governance-rules-compressed'],
+
+  // Review & Testing — fokus em quality
+  'up-verificador': ['production-requirements-compressed'],
+  'up-blind-validator': [],
+  'up-code-reviewer': ['engineering-principles-compressed'],
+  'up-security-reviewer': ['production-requirements-compressed'],
+  'up-visual-critic': ['ui-brand'],
+  'up-exhaustive-tester': [],
+  'up-api-tester': [],
+  'up-qa-agent': [],
+  'up-auditor-ux': ['audit-ux'],
+  'up-auditor-performance': ['audit-performance'],
+  'up-auditor-modernidade': ['audit-modernidade'],
+  'up-sintetizador-melhorias': [],
+  'up-analista-codigo': ['engineering-principles-compressed'],
+  'up-pesquisador-mercado': [],
+  'up-consolidador-ideias': [],
+};
+
+/**
+ * Return the list of relevant reference files for a given agent.
+ * Used by workflows + the context command to inject only the refs
+ * relevant to the agent's role, instead of dumping all references
+ * in every prompt.
+ *
+ * Usage:
+ *   up-tools.cjs skill-manifest <agent-name>
+ *
+ * Output: { agent, refs: ["engineering-principles-compressed", ...] }
+ *
+ * Use --paths to get full paths instead of names.
+ */
+function cmdSkillManifest(args, raw) {
+  const agent = args[0];
+  if (!agent) error('Usage: skill-manifest <agent-name> [--paths]');
+  const wantPaths = args.includes('--paths');
+
+  const refs = SKILL_MANIFEST[agent] || [];
+
+  if (!wantPaths) {
+    output({ agent, refs, count: refs.length }, raw, refs.join('\n'));
+    return;
+  }
+
+  const homeRefDir = path.join(require('os').homedir(), '.claude', 'up', 'references');
+  const localRefDir = path.join(__dirname, '..', 'references');
+  const paths = refs.map(name => {
+    const installed = path.join(homeRefDir, name + '.md');
+    const local = path.join(localRefDir, name + '.md');
+    return fs.existsSync(installed) ? installed : local;
+  });
+
+  output({ agent, refs, paths, count: refs.length }, raw, paths.join('\n'));
+}
+
+// =====================================================================
+// CLASSIFY-TASK COMMAND (Wave 5 — complexity-based routing)
+// =====================================================================
+
+/**
+ * Classify a plan file by complexity. Returns complexity tier
+ * (simple|standard|complex) and suggested model.
+ *
+ * Usage:
+ *   up-tools.cjs classify-task <plan-path>
+ *
+ * Heuristics:
+ *   - Frontmatter: type, tasks count, brownfield flag
+ *   - Content patterns: integration, refactor, schema, etc.
+ *   - File size
+ *
+ * Score buckets:
+ *   0-2 -> simple   -> haiku
+ *   3-5 -> standard -> sonnet
+ *   6+  -> complex  -> opus
+ */
+function cmdClassifyTask(cwd, args, raw) {
+  const planPath = args[0];
+  if (!planPath) error('Usage: classify-task <plan-path>');
+  const fullPath = path.isAbsolute(planPath) ? planPath : path.join(cwd, planPath);
+
+  let content;
+  try {
+    content = fs.readFileSync(fullPath, 'utf-8');
+  } catch (err) {
+    error(`Cannot read plan: ${fullPath}`);
+  }
+
+  const result = classifyContent(content);
+  result.plan_path = path.relative(cwd, fullPath);
+  output(result, raw, `${result.complexity} | ${result.suggested_model} | score=${result.score} | reasons=${result.reasons.join(',')}`);
+}
+
+function classifyContent(content) {
+  let score = 0;
+  const reasons = [];
+
+  // Parse frontmatter
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  const fm = {};
+  if (fmMatch) {
+    for (const line of fmMatch[1].split('\n')) {
+      const m = line.match(/^(\w+)\s*:\s*(.+)$/);
+      if (m) fm[m[1]] = m[2].trim().replace(/^["']|["']$/g, '');
+    }
+  }
+
+  const type = (fm.type || '').toLowerCase();
+  const brownfield = String(fm.brownfield || '').toLowerCase() === 'true';
+  const lower = content.toLowerCase();
+
+  // Type-based scoring
+  if (type === 'refactor' || type === 'migration') {
+    score += 4;
+    reasons.push('type=refactor/migration');
+  } else if (type === 'integration') {
+    score += 3;
+    reasons.push('type=integration');
+  } else if (type === 'frontend' || type === 'backend') {
+    score += 1;
+    reasons.push(`type=${type}`);
+  } else if (type === 'database') {
+    score += 1;
+    reasons.push('type=database');
+  } else if (type === 'docs' || type === 'config') {
+    // simple, no points
+    reasons.push(`type=${type}-simple`);
+  }
+
+  // Brownfield = touching existing code = harder
+  if (brownfield) {
+    score += 2;
+    reasons.push('brownfield');
+  }
+
+  // Content patterns
+  const patterns = [
+    { rx: /\b(oauth|webhook|external api|third.?party|api integration)\b/i, weight: 2, name: 'external_integration' },
+    { rx: /\b(refactor|rewrite|migrate|deprecate)\b/i, weight: 2, name: 'refactor_signal' },
+    { rx: /\b(transaction|distributed|race condition|concurrency|locking)\b/i, weight: 2, name: 'concurrency' },
+    { rx: /\b(security|auth|authentication|authorization|csrf|xss|injection)\b/i, weight: 1, name: 'security' },
+    { rx: /\b(stripe|payment|billing|invoice)\b/i, weight: 2, name: 'payment' },
+    { rx: /\b(real.?time|websocket|streaming|sse)\b/i, weight: 2, name: 'realtime' },
+    { rx: /\b(performance|optimi[sz]e|cache|lazy|debounce)\b/i, weight: 1, name: 'performance' },
+    { rx: /\b(simple|trivial|basic|crud)\b/i, weight: -1, name: 'explicitly_simple' },
+  ];
+
+  for (const p of patterns) {
+    if (p.rx.test(content)) {
+      score += p.weight;
+      reasons.push(p.name + (p.weight > 0 ? `+${p.weight}` : `${p.weight}`));
+    }
+  }
+
+  // Size-based
+  const bytes = Buffer.byteLength(content, 'utf-8');
+  if (bytes > 20000) {
+    score += 2;
+    reasons.push(`size>20kB(+2)`);
+  } else if (bytes > 10000) {
+    score += 1;
+    reasons.push(`size>10kB(+1)`);
+  }
+
+  // Task count (count <task> tags or numbered sections)
+  // Detect tasks via multiple shapes — <task> XML tags (preferred), or
+  // numbered/bulleted markdown headings/items at start of line.
+  const taskMatches = (content.match(/<task\b/gi) || []).length;
+  const numberedHeadings = (content.match(/^#{2,4}\s+(?:Task\s+)?\d+[.:)]?\s/gmi) || []).length;
+  const numberedBullets = (content.match(/^[-*]\s+\d+[.:)]\s/gm) || []).length;
+  const tasks = Math.max(taskMatches, numberedHeadings, numberedBullets);
+  if (tasks > 10) {
+    score += 2;
+    reasons.push(`tasks>10(+2)`);
+  } else if (tasks > 6) {
+    score += 1;
+    reasons.push(`tasks>6(+1)`);
+  }
+
+  // Clamp to 0+
+  if (score < 0) score = 0;
+
+  let complexity, model;
+  if (score <= 2) {
+    complexity = 'simple';
+    model = 'haiku';
+  } else if (score <= 5) {
+    complexity = 'standard';
+    model = 'sonnet';
+  } else {
+    complexity = 'complex';
+    model = 'opus';
+  }
+
+  return {
+    complexity,
+    suggested_model: model,
+    score,
+    reasons,
+    frontmatter_type: type || null,
+    brownfield,
+    bytes,
+    tasks_detected: tasks,
+  };
+}
+
+// =====================================================================
+// RESOLVE-MODEL-FOR-PLAN (Wave 5 — combined router)
+// =====================================================================
+
+/**
+ * Resolve which model to use for an agent given a plan context.
+ * Combines per-role routing (existing) with complexity routing (new).
+ *
+ * Routing modes (config.modelos.routing):
+ *   per-role (default)   -> use existing resolveAgentModel
+ *   complexity           -> use classify-task suggestion
+ *   complexity-with-cap  -> use classify-task BUT cap by per-role
+ *                           (e.g., per-role says haiku, complexity says
+ *                            opus -> use haiku since user budget says so)
+ *
+ * Usage:
+ *   up-tools.cjs resolve-model-for-plan <plan-path> <agent-name>
+ */
+function cmdResolveModelForPlan(cwd, args, raw) {
+  const [planPath, agentName] = args;
+  if (!planPath || !agentName) error('Usage: resolve-model-for-plan <plan-path> <agent-name>');
+
+  const config = loadConfig(cwd);
+  const routingMode = (config.modelos && config.modelos.routing) || 'per-role';
+  const perRoleModel = resolveAgentModel(cwd, agentName);
+
+  if (routingMode === 'per-role') {
+    output({ model: perRoleModel || 'default', source: 'per-role' }, raw, perRoleModel || 'default');
+    return;
+  }
+
+  // Need to classify the plan
+  const fullPath = path.isAbsolute(planPath) ? planPath : path.join(cwd, planPath);
+  let content;
+  try {
+    content = fs.readFileSync(fullPath, 'utf-8');
+  } catch {
+    output({ model: perRoleModel || 'default', source: 'per-role-fallback' }, raw, perRoleModel || 'default');
+    return;
+  }
+
+  const cls = classifyContent(content);
+  const complexityModel = cls.suggested_model;
+
+  if (routingMode === 'complexity') {
+    output(
+      { model: complexityModel, source: 'complexity', complexity: cls.complexity, score: cls.score },
+      raw,
+      complexityModel
+    );
+    return;
+  }
+
+  if (routingMode === 'complexity-with-cap') {
+    // Order: haiku < sonnet < opus
+    const order = { haiku: 1, sonnet: 2, opus: 3 };
+    const finalModel =
+      perRoleModel && order[perRoleModel]
+        ? (order[complexityModel] <= order[perRoleModel] ? complexityModel : perRoleModel)
+        : complexityModel;
+    output(
+      { model: finalModel, source: 'complexity-with-cap', complexity: cls.complexity, capped_by: perRoleModel },
+      raw,
+      finalModel
+    );
+    return;
+  }
+
+  output({ model: perRoleModel || 'default', source: 'unknown-mode-fallback' }, raw, perRoleModel || 'default');
+}
+
+// =====================================================================
+// ROUTING-LOG (Wave 5 — append routing decision + outcome)
+// =====================================================================
+
+/**
+ * Append a routing decision to .plano/governance/routing-history.log
+ * for later analysis.
+ *
+ * Usage:
+ *   up-tools.cjs routing-log --plan <path> --agent <name> --model <m>
+ *                            --complexity <c> [--score N]
+ *                            [--outcome success|rework|abort]
+ *                            [--rework-cycles N]
+ */
+function cmdRoutingLog(cwd, args, raw) {
+  const flags = { update: false };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--update') {
+      flags.update = true;
+    } else if (args[i].startsWith('--')) {
+      flags[args[i].replace(/^--/, '')] = args[i + 1];
+      i++;
+    }
+  }
+
+  const govDir = path.join(cwd, '.plano', 'governance');
+  try { fs.mkdirSync(govDir, { recursive: true }); } catch {}
+  const logPath = path.join(govDir, 'routing-history.log');
+
+  const ts = new Date().toISOString();
+  const line = [
+    ts,
+    flags.plan || '',
+    flags.agent || '',
+    flags.model || '',
+    flags.complexity || '',
+    flags.score || '',
+    flags.outcome || 'pending',
+    flags['rework-cycles'] || '0',
+  ].join(' | ');
+
+  // --update: find last entry for (plan, agent) and rewrite it instead of appending.
+  // Used to patch outcome from "pending" to success/rework/abort once a phase finishes.
+  if (flags.update && flags.plan && flags.agent) {
+    let existing = '';
+    try {
+      existing = fs.readFileSync(logPath, 'utf-8');
+    } catch {
+      existing = '';
+    }
+    const lines = existing.split('\n').filter(Boolean);
+    let lastMatchIdx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const parts = lines[i].split('|').map(s => s.trim());
+      if (parts[1] === flags.plan && parts[2] === flags.agent) {
+        lastMatchIdx = i;
+        break;
+      }
+    }
+    if (lastMatchIdx >= 0) {
+      lines[lastMatchIdx] = line;
+      fs.writeFileSync(logPath, lines.join('\n') + '\n');
+      output({ updated: true, path: path.relative(cwd, logPath), line }, raw, line);
+      return;
+    }
+    // No match found — fall through to append
+  }
+
+  fs.appendFileSync(logPath, line + '\n');
+  output({ logged: true, path: path.relative(cwd, logPath), line }, raw, line);
+}
+
+// =====================================================================
+// ANALYZE-ROUTING (Wave 5 — post-mortem of routing decisions)
+// =====================================================================
+
+/**
+ * Aggregate routing-history.log to suggest classifier adjustments.
+ *
+ * Usage:
+ *   up-tools.cjs analyze-routing
+ *
+ * Output:
+ *   - per-complexity success rate
+ *   - which complexity buckets had high rework
+ *   - suggestions: bump up to bigger model, or downgrade
+ */
+function cmdAnalyzeRouting(cwd, raw) {
+  const logPath = path.join(cwd, '.plano', 'governance', 'routing-history.log');
+  let lines = [];
+  try {
+    lines = fs.readFileSync(logPath, 'utf-8').split('\n').filter(l => l.includes('|'));
+  } catch {
+    output({ entries: 0, message: 'no_history' }, raw, 'no routing history yet');
+    return;
+  }
+
+  // Dedupe by (plan, agent) — keep latest entry. Without this, --update vs
+  // append confusion or duplicate logs would inflate counts.
+  const latestByKey = new Map();
+  for (const line of lines) {
+    const parts = line.split('|').map(s => s.trim());
+    const [ts, plan, agent] = parts;
+    const dedupeKey = `${plan}|${agent}`;
+    latestByKey.set(dedupeKey, parts); // last-write-wins
+  }
+
+  const stats = {};
+  for (const parts of latestByKey.values()) {
+    const [ts, plan, agent, model, complexity, score, outcome, rework] = parts;
+    const key = `${complexity}|${model}`;
+    if (!stats[key]) stats[key] = { total: 0, success: 0, rework: 0, abort: 0, pending: 0, rework_cycles_total: 0 };
+    stats[key].total++;
+    if (outcome === 'success') stats[key].success++;
+    else if (outcome === 'rework') stats[key].rework++;
+    else if (outcome === 'abort') stats[key].abort++;
+    else if (outcome === 'pending') stats[key].pending++;
+    stats[key].rework_cycles_total += parseInt(rework || '0', 10);
+  }
+
+  const summary = [];
+  const suggestions = [];
+  for (const [key, s] of Object.entries(stats)) {
+    const [complexity, model] = key.split('|');
+    const successRate = s.total ? (s.success / s.total * 100).toFixed(1) : '0.0';
+    const avgRework = s.total ? (s.rework_cycles_total / s.total).toFixed(2) : '0';
+    summary.push({ complexity, model, total: s.total, success_rate: Number(successRate), avg_rework_cycles: Number(avgRework), aborts: s.abort });
+
+    if (Number(successRate) < 60 && s.total >= 3) {
+      suggestions.push(`${complexity}+${model}: success rate ${successRate}% (${s.total} runs) — consider bumping to bigger model`);
+    }
+    if (Number(avgRework) >= 1.5 && s.total >= 3) {
+      suggestions.push(`${complexity}+${model}: avg ${avgRework} rework cycles — model may be undersized for this complexity`);
+    }
+    if (s.abort > 0 && s.total >= 3 && (s.abort / s.total) > 0.2) {
+      suggestions.push(`${complexity}+${model}: ${s.abort}/${s.total} aborts — review timeout config or upgrade model`);
+    }
+  }
+
+  output(
+    { entries: lines.length, summary, suggestions },
+    raw,
+    `analyzed ${lines.length} entries — ${summary.length} buckets, ${suggestions.length} suggestions`
+  );
+}
+
+// =====================================================================
+// VERIFY-STATIC COMMAND (Wave 4 — deterministic verification ladder)
+// =====================================================================
+
+/**
+ * Run deterministic project checks (lint, typecheck, test, audit)
+ * BEFORE invoking an LLM verifier. If everything passes, the workflow
+ * can skip the LLM verification step entirely. If something fails,
+ * the captured output is fed into the LLM verifier as context so it
+ * can focus on what actually broke instead of running the same checks.
+ *
+ * Usage:
+ *   up-tools.cjs verify-static [--lint] [--typecheck] [--test] [--audit]
+ *                              [--all] [--skip-missing]
+ *
+ * If no flags given, defaults to --all (--skip-missing).
+ *
+ * Returns JSON:
+ *   {
+ *     overall: "pass" | "fail" | "skip",
+ *     checks: [
+ *       { name, status: "pass"|"fail"|"skip", exit_code, summary, output_path }
+ *     ],
+ *     duration_secs
+ *   }
+ *
+ * Each check's full output is written to .plano/runtime/verify-static-<check>.log
+ */
+function cmdVerifyStatic(cwd, args, raw) {
+  const flags = {
+    lint: false,
+    typecheck: false,
+    test: false,
+    audit: false,
+    all: false,
+    skipMissing: false,
+  };
+  for (const a of args) {
+    if (a === '--lint') flags.lint = true;
+    else if (a === '--typecheck') flags.typecheck = true;
+    else if (a === '--test') flags.test = true;
+    else if (a === '--audit') flags.audit = true;
+    else if (a === '--all') flags.all = true;
+    else if (a === '--skip-missing') flags.skipMissing = true;
+  }
+  // Default: run all, skip if script missing
+  if (!flags.lint && !flags.typecheck && !flags.test && !flags.audit && !flags.all) {
+    flags.all = true;
+    flags.skipMissing = true;
+  }
+
+  const { execSync } = require('child_process');
+  const runtimeDir = path.join(cwd, '.plano', 'runtime');
+  try { fs.mkdirSync(runtimeDir, { recursive: true }); } catch {}
+
+  // Read package.json scripts to know what's available
+  let scripts = {};
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf-8'));
+    scripts = pkg.scripts || {};
+  } catch {}
+
+  const checks = [];
+  const start = Date.now();
+
+  function runCheck(name, cmd, condition) {
+    if (!condition) return null;
+    const logPath = path.join(runtimeDir, `verify-static-${name}.log`);
+    try {
+      const out = execSync(cmd, {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 300000, // 5min cap per check
+      });
+      fs.writeFileSync(logPath, out);
+      return {
+        name,
+        status: 'pass',
+        exit_code: 0,
+        summary: `${name} passed`,
+        output_path: path.relative(cwd, logPath),
+      };
+    } catch (err) {
+      const out = (err.stdout || '') + (err.stderr || '');
+      fs.writeFileSync(logPath, out);
+      // Extract short summary: last few non-empty lines or error counts
+      const lines = out.split('\n').filter(l => l.trim());
+      const tail = lines.slice(-5).join(' | ').slice(0, 300);
+      return {
+        name,
+        status: 'fail',
+        exit_code: err.status || 1,
+        summary: tail || err.message,
+        output_path: path.relative(cwd, logPath),
+      };
+    }
+  }
+
+  function maybeSkip(name) {
+    if (flags.skipMissing) {
+      return { name, status: 'skip', exit_code: null, summary: 'script not found in package.json', output_path: null };
+    }
+    return null;
+  }
+
+  // Lint
+  if (flags.all || flags.lint) {
+    if (scripts.lint) {
+      checks.push(runCheck('lint', 'npm run lint --silent', true));
+    } else {
+      const skip = maybeSkip('lint');
+      if (skip) checks.push(skip);
+    }
+  }
+
+  // Typecheck
+  if (flags.all || flags.typecheck) {
+    const cmd = scripts.typecheck ? 'npm run typecheck --silent' :
+                scripts['type-check'] ? 'npm run type-check --silent' :
+                fs.existsSync(path.join(cwd, 'tsconfig.json')) ? 'npx tsc --noEmit' : null;
+    if (cmd) {
+      checks.push(runCheck('typecheck', cmd, true));
+    } else {
+      const skip = maybeSkip('typecheck');
+      if (skip) checks.push(skip);
+    }
+  }
+
+  // Test — detect runner and pick the right non-interactive flag
+  if (flags.all || flags.test) {
+    if (scripts.test) {
+      // Read deps to detect vitest (default watch mode needs --run to exit)
+      let testCmd = 'npm test --silent';
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf-8'));
+        const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+        if (allDeps.vitest) testCmd = 'npm test --silent -- --run';
+        // jest, mocha, jasmine, ava, tap, etc. exit on completion by default
+      } catch {}
+      // Allow override via env: UP_VERIFY_TEST_CMD
+      if (process.env.UP_VERIFY_TEST_CMD) testCmd = process.env.UP_VERIFY_TEST_CMD;
+      checks.push(runCheck('test', testCmd, true));
+    } else {
+      const skip = maybeSkip('test');
+      if (skip) checks.push(skip);
+    }
+  }
+
+  // Audit
+  if (flags.all || flags.audit) {
+    // npm audit always runs if package.json exists
+    if (Object.keys(scripts).length > 0 || fs.existsSync(path.join(cwd, 'package.json'))) {
+      checks.push(runCheck('audit', 'npm audit --audit-level=high --silent', true));
+    } else {
+      const skip = maybeSkip('audit');
+      if (skip) checks.push(skip);
+    }
+  }
+
+  const duration = Math.round((Date.now() - start) / 1000);
+
+  const failed = checks.filter(c => c.status === 'fail');
+  const passed = checks.filter(c => c.status === 'pass');
+  const skipped = checks.filter(c => c.status === 'skip');
+
+  let overall;
+  if (failed.length > 0) overall = 'fail';
+  else if (passed.length > 0) overall = 'pass';
+  else overall = 'skip';
+
+  const result = {
+    overall,
+    checks,
+    duration_secs: duration,
+    counts: { passed: passed.length, failed: failed.length, skipped: skipped.length },
+  };
+
+  output(
+    result,
+    raw,
+    `verify-static: ${overall} (${passed.length} passed, ${failed.length} failed, ${skipped.length} skipped, ${duration}s)`
+  );
+}
+
+// =====================================================================
+// CONTEXT COMMAND (pre-inline helper — Wave 2)
+// =====================================================================
+
+/**
+ * Build a pre-inlined prompt fragment containing the contents of
+ * requested files wrapped in XML tags. Used by workflows to avoid
+ * forcing agents to make Read tool calls for content the orchestrator
+ * already has on disk.
+ *
+ * Usage:
+ *   up-tools.cjs context --plan <path> [--state] [--config]
+ *                        [--requirements] [--governance]
+ *                        [--engineering-principles] [--max-bytes N]
+ *
+ * Outputs a single string of XML blocks to stdout. Designed to be
+ * captured into a bash variable and injected into a Task/Agent prompt.
+ *
+ * Example:
+ *   CTX=$(up-tools.cjs context --plan $PLAN --state --config)
+ *   # then in spawn prompt:
+ *   #   <prompt_context>
+ *   #   {CTX}
+ *   #   </prompt_context>
+ */
+function cmdContext(cwd, args, raw) {
+  const flags = {
+    plan: null,
+    state: false,
+    config: false,
+    requirements: null,
+    governance: false,
+    engineeringPrinciples: false,
+    manifest: null,
+    maxBytes: 50 * 1024, // 50kB hard cap per file by default
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--plan') flags.plan = args[++i];
+    else if (a === '--state') flags.state = true;
+    else if (a === '--config') flags.config = true;
+    else if (a === '--requirements') flags.requirements = args[++i] || true;
+    else if (a === '--governance') flags.governance = true;
+    else if (a === '--engineering-principles' || a === '--principles') flags.engineeringPrinciples = true;
+    else if (a === '--manifest') flags.manifest = args[++i];
+    else if (a === '--max-bytes') flags.maxBytes = parseInt(args[++i], 10) || flags.maxBytes;
+  }
+
+  function readCapped(filePath, maxBytes) {
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.size <= maxBytes) {
+        return fs.readFileSync(filePath, 'utf-8');
+      }
+      const fd = fs.openSync(filePath, 'r');
+      const buf = Buffer.alloc(maxBytes);
+      fs.readSync(fd, buf, 0, maxBytes, 0);
+      fs.closeSync(fd);
+      return buf.toString('utf-8') + `\n\n[TRUNCATED at ${maxBytes} bytes — full file at ${filePath}]\n`;
+    } catch {
+      return null;
+    }
+  }
+
+  const blocks = [];
+
+  if (flags.plan) {
+    const planPath = path.isAbsolute(flags.plan) ? flags.plan : path.join(cwd, flags.plan);
+    const content = readCapped(planPath, flags.maxBytes);
+    if (content !== null) {
+      blocks.push(`<plan_inlined path="${flags.plan}">\n${content}\n</plan_inlined>`);
+    }
+  }
+
+  if (flags.state) {
+    const statePath = path.join(cwd, '.plano', 'STATE.md');
+    const content = readCapped(statePath, flags.maxBytes);
+    if (content !== null) {
+      blocks.push(`<state_inlined path=".plano/STATE.md">\n${content}\n</state_inlined>`);
+    }
+  }
+
+  if (flags.config) {
+    const configPath = path.join(cwd, '.plano', 'config.json');
+    const content = readCapped(configPath, flags.maxBytes);
+    if (content !== null) {
+      blocks.push(`<config_inlined path=".plano/config.json">\n${content}\n</config_inlined>`);
+    }
+  }
+
+  if (flags.requirements) {
+    // If a phase number was passed as value, look for REQUIREMENTS-SLICE in that phase dir
+    if (typeof flags.requirements === 'string') {
+      const phasesDir = path.join(cwd, '.plano', 'fases');
+      try {
+        const dir = fs.readdirSync(phasesDir).find(d => d.startsWith(flags.requirements));
+        if (dir) {
+          const slicePath = path.join(phasesDir, dir, 'REQUIREMENTS-SLICE.md');
+          const content = readCapped(slicePath, flags.maxBytes);
+          if (content !== null) {
+            blocks.push(`<requirements_slice_inlined path="${path.relative(cwd, slicePath)}">\n${content}\n</requirements_slice_inlined>`);
+          }
+        }
+      } catch {}
+    } else {
+      // --requirements alone -> full REQUIREMENTS.md
+      const reqPath = path.join(cwd, '.plano', 'REQUIREMENTS.md');
+      const content = readCapped(reqPath, flags.maxBytes);
+      if (content !== null) {
+        blocks.push(`<requirements_inlined path=".plano/REQUIREMENTS.md">\n${content}\n</requirements_inlined>`);
+      }
+    }
+  }
+
+  if (flags.governance) {
+    const govPath = path.join(__dirname, '..', 'references', 'governance-rules-compressed.md');
+    // also try the runtime-installed location
+    const installedGovPath = path.join(require('os').homedir(), '.claude', 'up', 'references', 'governance-rules-compressed.md');
+    let govContent = readCapped(govPath, flags.maxBytes) || readCapped(installedGovPath, flags.maxBytes);
+    if (govContent !== null) {
+      blocks.push(`<governance_compressed>\n${govContent}\n</governance_compressed>`);
+    }
+  }
+
+  if (flags.engineeringPrinciples) {
+    const epPath = path.join(__dirname, '..', 'references', 'engineering-principles-compressed.md');
+    const installedEpPath = path.join(require('os').homedir(), '.claude', 'up', 'references', 'engineering-principles-compressed.md');
+    let epContent = readCapped(epPath, flags.maxBytes) || readCapped(installedEpPath, flags.maxBytes);
+    if (epContent !== null) {
+      blocks.push(`<engineering_principles_compressed>\n${epContent}\n</engineering_principles_compressed>`);
+    }
+  }
+
+  // Wave 6 — skill manifest: include only refs relevant to the agent's role
+  if (flags.manifest) {
+    const refs = SKILL_MANIFEST[flags.manifest] || [];
+    const homeRefDir = path.join(require('os').homedir(), '.claude', 'up', 'references');
+    const localRefDir = path.join(__dirname, '..', 'references');
+    for (const refName of refs) {
+      // Skip if the ref was already added via a dedicated flag
+      if (refName === 'engineering-principles-compressed' && flags.engineeringPrinciples) continue;
+      if (refName === 'governance-rules-compressed' && flags.governance) continue;
+
+      const installed = path.join(homeRefDir, refName + '.md');
+      const local = path.join(localRefDir, refName + '.md');
+      const refPath = fs.existsSync(installed) ? installed : local;
+      const refContent = readCapped(refPath, flags.maxBytes);
+      if (refContent !== null) {
+        // XML-safe tag name from the file name
+        const tagName = refName.replace(/-/g, '_');
+        blocks.push(`<manifest_${tagName}>\n${refContent}\n</manifest_${tagName}>`);
+      }
+    }
+  }
+
+  const out = blocks.join('\n\n');
+  if (raw) {
+    process.stdout.write(out);
+  } else {
+    output({ context_blocks: blocks.length, bytes: Buffer.byteLength(out, 'utf-8'), content: out }, raw, out);
+  }
+}
+
+// =====================================================================
+// STATUS COMMAND (headless aggregator — no LLM needed)
+// =====================================================================
+
+function cmdStatus(cwd, raw) {
+  // Aggregates progress + budget + current phase + governance counts in one shot.
+  // Designed for /up:progresso, /up:saude, dashboards, or external monitoring.
+  const phasesDir = path.join(cwd, '.plano', 'fases');
+  const phases = [];
+  let totalPlans = 0;
+  let totalSummaries = 0;
+  let currentPhase = null;
+
+  try {
+    const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).sort((a, b) => comparePhaseNum(a, b));
+    for (const dir of dirs) {
+      const dm = dir.match(/^(\d+(?:\.\d+)*)-?(.*)/);
+      const phaseNum = dm ? dm[1] : dir;
+      const phaseName = dm && dm[2] ? dm[2].replace(/-/g, ' ') : '';
+      const phaseFiles = fs.readdirSync(path.join(phasesDir, dir));
+      const plans = phaseFiles.filter(f => f.endsWith('-PLAN.md') || f === 'PLAN.md').length;
+      const summaries = phaseFiles.filter(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md').length;
+      const verifications = phaseFiles.filter(f => f.endsWith('-VERIFICATION.md') || f === 'VERIFICATION.md').length;
+      totalPlans += plans;
+      totalSummaries += summaries;
+      let status;
+      if (plans === 0) status = 'pending';
+      else if (summaries >= plans) status = 'complete';
+      else if (summaries > 0) status = 'in_progress';
+      else status = 'planned';
+      const phaseEntry = { number: phaseNum, name: phaseName, plans, summaries, verifications, status };
+      phases.push(phaseEntry);
+      if (!currentPhase && (status === 'in_progress' || status === 'planned')) {
+        currentPhase = phaseEntry;
+      }
+    }
+  } catch {}
+
+  const percent = totalPlans > 0 ? Math.min(100, Math.round((totalSummaries / totalPlans) * 100)) : 0;
+
+  // Governance counts
+  const approvalsLog = path.join(cwd, '.plano', 'governance', 'approvals.log');
+  const technicalDebtLog = path.join(cwd, '.plano', 'governance', 'technical-debt.log');
+  let approvalCount = 0;
+  let technicalDebtCount = 0;
+  try {
+    if (fs.existsSync(approvalsLog)) {
+      approvalCount = fs.readFileSync(approvalsLog, 'utf-8').split('\n').filter(l => l.includes('|')).length;
+    }
+    if (fs.existsSync(technicalDebtLog)) {
+      technicalDebtCount = fs.readFileSync(technicalDebtLog, 'utf-8').split('\n').filter(l => l.includes('|')).length;
+    }
+  } catch {}
+
+  // Budget (best-effort; never blocks status)
+  let budget = { spend_usd: 0, ceiling_usd: null, status: 'no_data' };
+  try {
+    const { execSync } = require('child_process');
+    const instrumentPath = path.join(__dirname, 'up-instrument.cjs');
+    const out = execSync(`node "${instrumentPath}" report --json --all-sessions`, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 30000,
+    });
+    const report = JSON.parse(out);
+    const config = loadConfig(cwd);
+    const ceiling = config.budget_ceiling;
+    const spend = report.total_cost_usd ?? 0;
+    let bStatus = 'no_ceiling';
+    let pct = null;
+    if (ceiling && ceiling > 0) {
+      pct = Number(((spend / ceiling) * 100).toFixed(1));
+      if (pct >= 100) bStatus = 'over_budget';
+      else if (pct >= 90) bStatus = 'critical_90';
+      else if (pct >= 75) bStatus = 'warning_75';
+      else if (pct >= 50) bStatus = 'warning_50';
+      else bStatus = 'under_budget';
+    }
+    budget = {
+      spend_usd: Number(spend.toFixed(4)),
+      ceiling_usd: ceiling,
+      percent_used: pct,
+      status: bStatus,
+    };
+  } catch {}
+
+  const config = loadConfig(cwd);
+  const result = {
+    cwd,
+    phases,
+    progress: {
+      total_plans: totalPlans,
+      total_summaries: totalSummaries,
+      percent,
+    },
+    current_phase: currentPhase,
+    governance: {
+      approvals_logged: approvalCount,
+      technical_debt_entries: technicalDebtCount,
+    },
+    budget,
+    config: {
+      modo: config.modo,
+      paralelizacao: config.paralelizacao,
+      auto_advance: config.auto_advance,
+      modelos_preset: config.modelos?.preset ?? 'runtime',
+      instrumentation_enabled: config.instrumentation?.enabled ?? false,
+    },
+    timestamp: new Date().toISOString(),
+  };
+
+  output(result, raw, JSON.stringify(result, null, 2));
+}
+
 // =====================================================================
 // PROGRESS COMMAND
 // =====================================================================