pan-wizard 2.8.1 → 2.9.1

package/pan-wizard-core/bin/lib/core.cjs

@@ -25,21 +25,41 @@ const {
   MILESTONE_VERSION_RE,
 } = require('./constants.cjs');
 
+// ─── Multi-Model Routing ─────────────────────────────────────────────────────
+
+/**
+ * Provider-specific model name mapping for each tier alias.
+ * Each provider maps reasoning/mid/fast to its native model identifiers.
+ * "inherit" means the host runtime uses its own top-tier model selection.
+ */
+const PROVIDER_MODELS = {
+  anthropic: { reasoning: 'inherit', mid: 'sonnet', fast: 'haiku' },
+  openai:    { reasoning: 'inherit', mid: 'mid',    fast: 'fast'  },
+  google:    { reasoning: 'inherit', mid: 'mid',    fast: 'fast'  },
+  default:   { reasoning: 'inherit', mid: 'sonnet', fast: 'haiku' },
+};
+
+/** Maps legacy Anthropic model names to provider-agnostic tier aliases. */
+const LEGACY_ALIASES = { opus: 'reasoning', sonnet: 'mid', haiku: 'fast' };
+
+/** Relative cost multipliers per tier (fast = 1× baseline). */
+const COST_MULTIPLIERS = { reasoning: 15, mid: 3, fast: 1 };
+
 // ─── Model Profile Table ─────────────────────────────────────────────────────
 
 const MODEL_PROFILES = {
-  'pan-planner':              { quality: 'opus', balanced: 'opus',   budget: 'sonnet' },
-  'pan-roadmapper':           { quality: 'opus', balanced: 'sonnet', budget: 'sonnet' },
-  'pan-executor':             { quality: 'opus', balanced: 'sonnet', budget: 'sonnet' },
-  'pan-phase-researcher':     { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'pan-project-researcher':   { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'pan-research-synthesizer': { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'pan-debugger':             { quality: 'opus', balanced: 'sonnet', budget: 'sonnet' },
-  'pan-document_code':        { quality: 'opus', balanced: 'haiku', budget: 'haiku' },
-  'pan-verifier':             { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'pan-plan-checker':         { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'pan-integration-checker':  { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'pan-reviewer':             { quality: 'opus', balanced: 'haiku',  budget: 'haiku' },
+  'pan-planner':              { quality: 'reasoning', balanced: 'reasoning', budget: 'mid' },
+  'pan-roadmapper':           { quality: 'reasoning', balanced: 'mid',      budget: 'mid' },
+  'pan-executor':             { quality: 'reasoning', balanced: 'mid',      budget: 'mid' },
+  'pan-phase-researcher':     { quality: 'reasoning', balanced: 'mid',      budget: 'fast' },
+  'pan-project-researcher':   { quality: 'reasoning', balanced: 'mid',      budget: 'fast' },
+  'pan-research-synthesizer': { quality: 'reasoning', balanced: 'mid',      budget: 'fast' },
+  'pan-debugger':             { quality: 'reasoning', balanced: 'mid',      budget: 'mid' },
+  'pan-document_code':        { quality: 'reasoning', balanced: 'fast',     budget: 'fast' },
+  'pan-verifier':             { quality: 'reasoning', balanced: 'mid',      budget: 'fast' },
+  'pan-plan-checker':         { quality: 'reasoning', balanced: 'mid',      budget: 'fast' },
+  'pan-integration-checker':  { quality: 'reasoning', balanced: 'mid',      budget: 'fast' },
+  'pan-reviewer':             { quality: 'reasoning', balanced: 'fast',     budget: 'fast' },
 };
 
 // ─── Output helpers ───────────────────────────────────────────────────────────
@@ -179,6 +199,8 @@ function loadConfig(cwd) {
       commit: parsed.commit || { safety_checks: true, conventional_types: true, sensitive_patterns: ['\\.env$', '\\.pem$', '\\.key$', 'credentials', 'secret', 'password', 'token'] },
       execution: parsed.execution || { default_mode: 'wave_order', rollback_snapshots: true, error_pattern_learning: true },
       focus: parsed.focus || { auto_commit: true },
+      model_overrides: parsed.model_overrides || {},
+      routing: parsed.routing || { strategy: 'static', provider: 'auto' },
     };
   } catch { // Config missing or malformed — use defaults
     return {
@@ -187,6 +209,8 @@ function loadConfig(cwd) {
       commit: { safety_checks: true, conventional_types: true, sensitive_patterns: ['\\.env$', '\\.pem$', '\\.key$', 'credentials', 'secret', 'password', 'token'] },
       execution: { default_mode: 'wave_order', rollback_snapshots: true, error_pattern_learning: true },
       focus: { auto_commit: true },
+      model_overrides: {},
+      routing: { strategy: 'static', provider: 'auto' },
     };
   }
 }
@@ -485,27 +509,142 @@ function getRoadmapPhaseInternal(cwd, phaseNum) {
 }
 
 /**
- * Resolve the model for a given agent type based on profile and overrides.
- * Returns "inherit" for opus-tier to let Claude Code use its configured opus version.
+ * Extract a model tier override from a roadmap phase section.
+ * Looks for `<!-- model_tier: <tier> -->` in the phase section text.
+ * @param {string} cwd - Project root directory
+ * @param {string|number} phaseNum - Phase number to look up
+ * @returns {string|null} Tier alias if found, null otherwise
+ */
+function getPhaseModelTier(cwd, phaseNum) {
+  const phaseData = getRoadmapPhaseInternal(cwd, phaseNum);
+  if (!phaseData?.section) return null;
+  const match = phaseData.section.match(/<!--\s*model_tier:\s*(\S+)\s*-->/i);
+  return match ? match[1] : null;
+}
+
+/**
+ * Resolve the model for a given agent type based on profile, provider, and routing strategy.
+ * Returns "inherit" for reasoning-tier to let the host runtime use its top-tier model.
  * @param {string} cwd - Project root directory
  * @param {string} agentType - Agent name (e.g., "pan-planner", "pan-executor")
- * @returns {string} Model identifier: "inherit" (opus), "sonnet", or "haiku"
+ * @param {Object} [taskMetadata] - Optional metadata for complexity routing
+ * @returns {string} Model identifier: "inherit", "sonnet", "haiku", "mid", "fast", etc.
  */
-function resolveModelInternal(cwd, agentType) {
+function resolveModelInternal(cwd, agentType, taskMetadata) {
   const config = loadConfig(cwd);
+  const provider = detectProvider(cwd, config);
 
-  // Check per-agent override first
+  // Check per-agent override first (highest priority)
   const override = config.model_overrides?.[agentType];
   if (override) {
-    return override === 'opus' ? 'inherit' : override;
+    return resolveTierToModel(override, provider);
+  }
+
+  // Check per-phase override from roadmap (second priority)
+  if (taskMetadata?.phaseNum) {
+    const phaseTier = getPhaseModelTier(cwd, taskMetadata.phaseNum);
+    if (phaseTier) {
+      return resolveTierToModel(phaseTier, provider);
+    }
   }
 
   // Fall back to profile lookup
   const profile = config.model_profile || 'balanced';
   const agentModels = MODEL_PROFILES[agentType];
-  if (!agentModels) return 'sonnet';
-  const resolved = agentModels[profile] || agentModels['balanced'] || 'sonnet';
-  return resolved === 'opus' ? 'inherit' : resolved;
+  if (!agentModels) return resolveTierToModel('mid', provider);
+
+  let tier = agentModels[profile] || agentModels['balanced'] || 'mid';
+
+  // Apply routing strategy
+  const strategy = config.routing?.strategy || 'static';
+  if (strategy === 'complexity' && taskMetadata) {
+    const thresholds = config.routing?.complexity_thresholds;
+    tier = resolveComplexityTier(tier, { ...taskMetadata, thresholds });
+  }
+
+  return resolveTierToModel(tier, provider);
+}
+
+/**
+ * Detect the LLM provider from config, environment, or runtime directory presence.
+ * @param {string} cwd - Project root directory
+ * @param {Object} config - Loaded config object
+ * @returns {string} Provider name: "anthropic", "openai", "google", or "default"
+ */
+function detectProvider(cwd, config) {
+  // 1. Explicit config
+  if (config.routing?.provider && config.routing.provider !== 'auto') {
+    const p = config.routing.provider;
+    return PROVIDER_MODELS[p] ? p : 'default';
+  }
+  // 2. Environment variable
+  const envProvider = process.env.PAN_PROVIDER;
+  if (envProvider) {
+    return PROVIDER_MODELS[envProvider] ? envProvider : 'default';
+  }
+  // 3. Runtime directory detection
+  const checks = [
+    ['.claude', 'anthropic'], ['.codex', 'openai'],
+    ['.gemini', 'google'], ['.opencode', 'openai'], ['.github', 'default'],
+  ];
+  for (const [dir, provider] of checks) {
+    try { if (fs.statSync(path.join(cwd, dir)).isDirectory()) return provider; }
+    catch { /* continue */ }
+  }
+  return 'default';
+}
+
+/**
+ * Resolve a tier alias (or legacy model name) to a provider-specific model name.
+ * @param {string} tier - Tier alias ("reasoning", "mid", "fast") or legacy name ("opus", "sonnet", "haiku")
+ * @param {string} provider - Provider key from detectProvider()
+ * @returns {string} Provider-specific model name
+ */
+function resolveTierToModel(tier, provider) {
+  const normalizedTier = LEGACY_ALIASES[tier] || tier;
+  const providerMap = PROVIDER_MODELS[provider] || PROVIDER_MODELS['default'];
+  return providerMap[normalizedTier] || providerMap['mid'];
+}
+
+/**
+ * Adjust model tier based on task complexity metadata.
+ * @param {string} baseTier - Starting tier ("reasoning", "mid", "fast")
+ * @param {Object} [taskMetadata] - Complexity indicators
+ * @returns {string} Adjusted tier
+ */
+function resolveComplexityTier(baseTier, taskMetadata) {
+  if (!taskMetadata) return baseTier;
+  const { fileCount = 0, waveCount = 0, requirementCount = 0, isArchitectural = false } = taskMetadata;
+
+  const score =
+    (fileCount > 15 ? 2 : fileCount > 5 ? 1 : 0) +
+    (waveCount > 3 ? 2 : waveCount > 1 ? 1 : 0) +
+    (requirementCount > 5 ? 2 : requirementCount > 2 ? 1 : 0) +
+    (isArchitectural ? 3 : 0);
+
+  const thresholds = taskMetadata.thresholds || { downgrade_max: 2, upgrade_min: 6 };
+  const tiers = ['fast', 'mid', 'reasoning'];
+  const idx = tiers.indexOf(baseTier);
+  if (idx === -1) return baseTier;
+
+  if (score <= thresholds.downgrade_max && idx > 0) return tiers[idx - 1];
+  if (score >= thresholds.upgrade_min && idx < 2) return tiers[idx + 1];
+  return baseTier;
+}
+
+/**
+ * Estimate relative cost multiplier for a given profile.
+ * @param {string} profile - "quality", "balanced", or "budget"
+ * @returns {Object} Cost estimation with total, average, agentCount
+ */
+function estimateCostMultiplier(profile) {
+  let total = 0;
+  const agents = Object.keys(MODEL_PROFILES);
+  for (const agent of agents) {
+    const tier = MODEL_PROFILES[agent][profile] || 'mid';
+    total += COST_MULTIPLIERS[tier] || 3;
+  }
+  return { profile, total, average: +(total / agents.length).toFixed(1), agentCount: agents.length };
 }
 
 // ─── Misc utilities ───────────────────────────────────────────────────────────
@@ -625,6 +764,9 @@ function scanSourceTodos(cwd) {
 
 module.exports = {
   MODEL_PROFILES,
+  PROVIDER_MODELS,
+  LEGACY_ALIASES,
+  COST_MULTIPLIERS,
   output,
   error,
   verbose,
@@ -641,6 +783,11 @@ module.exports = {
   getArchivedPhaseDirs,
   getRoadmapPhaseInternal,
   resolveModelInternal,
+  detectProvider,
+  resolveTierToModel,
+  resolveComplexityTier,
+  estimateCostMultiplier,
+  getPhaseModelTier,
   pathExistsInternal,
   generateSlugInternal,
   getMilestoneInfo,

package/pan-wizard-core/bin/lib/focus.cjs

@@ -783,6 +783,11 @@ function determineStopReason(cycle, run) {
   if (run.totals.cycles_completed >= run.max_cycles) return 'max_cycles';
   if (cycle.items_completed === 0) return 'zero_completed';
 
+  // Prompts category: stop when all prompts are completed
+  if (run.category === 'prompts' && cycle.prompts_remaining === 0) {
+    return 'prompts_complete';
+  }
+
   // Optimize category: stop when efficiency drops below threshold of previous cycle
   if (run.category === 'optimize' && run.cycles.length >= 2) {
     const prev = run.cycles[run.cycles.length - 2];

package/pan-wizard-core/bin/lib/verify.cjs

@@ -826,6 +826,16 @@ function repairIssues(cwd, repairs) {
           repairActions.push({ action: repair, success: true, path: CONFIG_FILE });
           break;
         }
+        case 'syncRequirements': {
+          const syncResult = syncRequirementCheckboxes(cwd);
+          repairActions.push({ action: repair, success: !syncResult.error, fixed: syncResult.fixed, error: syncResult.error || undefined });
+          break;
+        }
+        case 'syncRoadmap': {
+          const syncResult = syncRoadmapPlanCheckboxes(cwd);
+          repairActions.push({ action: repair, success: !syncResult.error, fixed: syncResult.fixed, error: syncResult.error || undefined });
+          break;
+        }
         case 'regenerateState': {
           // Create timestamped backup before overwriting to prevent data loss
           try {
@@ -950,13 +960,112 @@ function checkVerificationGate(cwd, addIssue) {
   }
 }
 
+/**
+ * Sync REQUIREMENTS.md checkboxes — mark requirements as complete if their
+ * linked phases are completed in roadmap.md. Returns count of boxes fixed.
+ * @param {string} cwd
+ * @returns {{ fixed: number, error?: string }}
+ */
+function syncRequirementCheckboxes(cwd) {
+  const planDir = planningPath(cwd);
+  const reqPath = path.join(planDir, REQUIREMENTS_FILE);
+  const roadmapPath = path.join(planDir, ROADMAP_FILE);
+
+  let reqContent, roadmapContent;
+  try { reqContent = fs.readFileSync(reqPath, 'utf-8'); } catch { return { fixed: 0, error: 'requirements.md not found' }; }
+  try { roadmapContent = fs.readFileSync(roadmapPath, 'utf-8'); } catch { return { fixed: 0, error: 'roadmap.md not found' }; }
+
+  // Find completed phases (checkbox marked [x] in roadmap)
+  const completedPhases = [];
+  const phaseRe = /- \[x\]\s*.*Phase\s+(\d+(?:\.\d+)?)/gi;
+  let m;
+  while ((m = phaseRe.exec(roadmapContent)) !== null) {
+    completedPhases.push(m[1]);
+  }
+
+  if (completedPhases.length === 0) return { fixed: 0 };
+
+  // For each completed phase, find linked requirement IDs and check their boxes
+  let fixed = 0;
+  for (const phaseNum of completedPhases) {
+    const reqMatch = roadmapContent.match(
+      new RegExp(`Phase\\s+${phaseNum.replace(/\./g, '\\.')}[\\s\\S]*?\\*\\*Requirements:\\*\\*\\s*([^\\n]+)`, 'i')
+    );
+    if (!reqMatch) continue;
+    const reqIds = reqMatch[1].replace(/[\[\]]/g, '').split(/[,\s]+/).map(id => id.trim()).filter(Boolean);
+    for (const reqId of reqIds) {
+      const escaped = reqId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const re = new RegExp(`(- \\[) (\\]\\s*\\*\\*${escaped}\\*\\*)`, 'gi');
+      const before = reqContent;
+      reqContent = reqContent.replace(re, '$1x$2');
+      if (reqContent !== before) fixed++;
+    }
+  }
+
+  if (fixed > 0) {
+    try { fs.writeFileSync(reqPath, reqContent, 'utf-8'); } catch (e) { return { fixed: 0, error: e.message }; }
+  }
+  return { fixed };
+}
+
+/**
+ * Sync ROADMAP.md plan checkboxes — mark plans as checked if corresponding
+ * summary files exist on disk (indicating execution completed).
+ * @param {string} cwd
+ * @returns {{ fixed: number, error?: string }}
+ */
+function syncRoadmapPlanCheckboxes(cwd) {
+  const planDir = planningPath(cwd);
+  const roadmapPath = path.join(planDir, ROADMAP_FILE);
+
+  let roadmapContent;
+  try { roadmapContent = fs.readFileSync(roadmapPath, 'utf-8'); } catch { return { fixed: 0, error: 'roadmap.md not found' }; }
+
+  // Collect all summary files on disk (indicates plan was executed)
+  const phasesDir = path.join(planDir, PHASES_DIR);
+  const summaryFiles = new Set();
+  try {
+    const dirs = fs.readdirSync(phasesDir, { withFileTypes: true }).filter(d => d.isDirectory());
+    for (const dir of dirs) {
+      try {
+        const files = fs.readdirSync(path.join(phasesDir, dir.name));
+        for (const f of files) {
+          if (isSummaryFile(f)) {
+            // Extract plan stem: "01-02-summary.md" → "01-02"
+            const stem = f.replace(/-summary\.md$/i, '');
+            summaryFiles.add(stem);
+          }
+        }
+      } catch { /* unreadable phase dir */ }
+    }
+  } catch { return { fixed: 0 }; }
+
+  if (summaryFiles.size === 0) return { fixed: 0 };
+
+  // Mark plan checkboxes: "- [ ] 01-02-plan.md" → "- [x] 01-02-plan.md"
+  let fixed = 0;
+  for (const stem of summaryFiles) {
+    const escaped = stem.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`(- \\[) (\\]\\s*${escaped}-plan)`, 'gi');
+    const before = roadmapContent;
+    roadmapContent = roadmapContent.replace(re, '$1x$2');
+    if (roadmapContent !== before) fixed++;
+  }
+
+  if (fixed > 0) {
+    try { fs.writeFileSync(roadmapPath, roadmapContent, 'utf-8'); } catch (e) { return { fixed: 0, error: e.message }; }
+  }
+  return { fixed };
+}
+
 /**
  * Cross-check STATE.md progress counts against REQUIREMENTS.md checkboxes and ROADMAP.md plan checkboxes.
  * Reports mismatches as warnings so users can run --repair or investigate.
  * @param {string} cwd - Working directory path
  * @param {Function} addIssue - Issue recording callback
+ * @param {string[]} [repairs] - Repair action list (pushed to when repairable)
  */
-function checkStateConsistency(cwd, addIssue) {
+function checkStateConsistency(cwd, addIssue, repairs) {
   const planDir = planningPath(cwd);
   const statePath = path.join(planDir, STATE_FILE);
   const reqPath = path.join(planDir, REQUIREMENTS_FILE);
@@ -983,7 +1092,8 @@ function checkStateConsistency(cwd, addIssue) {
       if (completedPlans > 0 && completedPlans >= totalPlans && uncheckedBoxes > 0) {
         addIssue('warning', 'STATE_REQ_DRIFT',
           `STATE.md shows all plans complete but REQUIREMENTS.md has ${uncheckedBoxes}/${totalBoxes} unchecked checkboxes`,
-          'Run syncRequirementCheckboxes or manually check completed requirement boxes');
+          'Run /pan:health --repair to auto-check completed requirement boxes', true);
+        if (repairs) repairs.push('syncRequirements');
       }
     }
   } catch { /* no REQUIREMENTS.md — not required */ }
@@ -1001,7 +1111,8 @@ function checkStateConsistency(cwd, addIssue) {
       if (completedPlans > 0 && completedPlans >= totalPlans && uncheckedPlans > 0) {
         addIssue('warning', 'STATE_ROADMAP_DRIFT',
           `STATE.md shows all plans complete but ROADMAP.md has ${uncheckedPlans} unchecked plan checkboxes`,
-          'Run cmdRoadmapUpdatePlanProgress for each phase or manually check completed plan boxes');
+          'Run /pan:health --repair to auto-check completed plan boxes', true);
+        if (repairs) repairs.push('syncRoadmap');
       }
     }
   } catch { /* no ROADMAP.md — other checks handle this */ }
@@ -1050,7 +1161,7 @@ function cmdValidateHealth(cwd, options, raw) {
   checkPhaseContents(cwd, addIssue);
 
   // Check 8b: cross-document state consistency
-  checkStateConsistency(cwd, addIssue);
+  checkStateConsistency(cwd, addIssue, repairs);
 
   // Check 8c: verification gate (phases with verifier enabled need verification.md)
   checkVerificationGate(cwd, addIssue);
@@ -1783,6 +1894,169 @@ function cmdRetro(cwd, raw) {
   output(result, raw, rawLines.join('\n'));
 }
 
+// ─── Deployment Validation ──────────────────────────────────────────────────
+
+/**
+ * Detect which PAN runtimes are installed in cwd.
+ * @param {string} cwd
+ * @returns {Array<{runtime: string, configDir: string}>}
+ */
+function detectInstalledRuntimes(cwd) {
+  const RUNTIME_DIRS = [
+    { runtime: 'claude', configDir: '.claude' },
+    { runtime: 'opencode', configDir: '.opencode' },
+    { runtime: 'gemini', configDir: '.gemini' },
+    { runtime: 'codex', configDir: '.codex' },
+    { runtime: 'copilot', configDir: '.github' },
+  ];
+  const found = [];
+  for (const rt of RUNTIME_DIRS) {
+    const manifestPath = path.join(cwd, rt.configDir, 'pan-file-manifest.json');
+    try {
+      fs.accessSync(manifestPath);
+      found.push(rt);
+    } catch (_) { /* not installed */ }
+  }
+  return found;
+}
+
+/**
+ * Validate a single PAN runtime installation.
+ * Checks: manifest files exist, hashes match, settings integrity.
+ * @param {string} cwd
+ * @param {string} configDir - e.g. '.claude'
+ * @param {string} runtime - e.g. 'claude'
+ * @returns {{ status: string, version: string, total_files: number, missing: string[], modified: string[], orphaned: string[], settings_ok: boolean, settings_issues: string[] }}
+ */
+function validateRuntimeInstall(cwd, configDir, runtime) {
+  const crypto = require('crypto');
+  const baseDir = path.join(cwd, configDir);
+  const manifestPath = path.join(baseDir, 'pan-file-manifest.json');
+
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (e) {
+    return { status: 'broken', version: null, error: `Cannot read manifest: ${e.message}`, total_files: 0, missing: [], modified: [], orphaned: [], settings_ok: false, settings_issues: ['manifest unreadable'] };
+  }
+
+  const missing = [];
+  const modified = [];
+  const files = manifest.files || {};
+  const totalFiles = Object.keys(files).length;
+
+  for (const [relPath, expectedHash] of Object.entries(files)) {
+    const absPath = path.join(baseDir, relPath);
+    try {
+      const content = fs.readFileSync(absPath);
+      const actualHash = crypto.createHash('sha256').update(content).digest('hex');
+      if (actualHash !== expectedHash) {
+        modified.push(relPath);
+      }
+    } catch (_) {
+      missing.push(relPath);
+    }
+  }
+
+  // Check settings integrity (hook paths resolve to real files)
+  const settingsIssues = [];
+  const settingsFile = runtime === 'copilot' ? 'config.json' : 'settings.json';
+  const settingsPath = path.join(baseDir, settingsFile);
+  let settingsOk = true;
+  try {
+    const settingsContent = fs.readFileSync(settingsPath, 'utf8');
+    const settings = JSON.parse(settingsContent);
+    // Check hook paths in settings
+    // Collect all hook command strings from settings
+    const hookCommands = [];
+    const hooks = settings.hooks;
+    if (hooks && typeof hooks === 'object') {
+      for (const hookArr of Object.values(hooks)) {
+        if (!Array.isArray(hookArr)) continue;
+        for (const hook of hookArr) {
+          if (hook.command) hookCommands.push(hook.command);
+        }
+      }
+    }
+    // Copilot/Gemini statusLine
+    if (settings.statusLine && settings.statusLine.command) {
+      hookCommands.push(settings.statusLine.command);
+    }
+    // Claude statusline
+    if (settings.statusline && settings.statusline.command) {
+      hookCommands.push(settings.statusline.command);
+    }
+    for (const cmd of hookCommands) {
+      const parts = cmd.split(/\s+/);
+      const hookFile = parts.find(p => p.endsWith('.js'));
+      if (hookFile) {
+        // Hook paths are relative to cwd, not to config dir
+        const resolvedPath = path.isAbsolute(hookFile) ? hookFile : path.join(cwd, hookFile);
+        try { fs.accessSync(resolvedPath); } catch (_) {
+          settingsIssues.push(`Hook path not found: ${hookFile}`);
+          settingsOk = false;
+        }
+      }
+    }
+  } catch (_) {
+    // No settings file is OK for some runtimes (codex, opencode)
+    if (runtime !== 'codex' && runtime !== 'opencode') {
+      settingsIssues.push(`${settingsFile} missing or unreadable`);
+      settingsOk = false;
+    }
+  }
+
+  const status = missing.length > 0 ? 'broken' : modified.length > 0 ? 'modified' : 'clean';
+
+  return {
+    status,
+    version: manifest.version || null,
+    total_files: totalFiles,
+    missing,
+    modified,
+    orphaned: [],
+    settings_ok: settingsOk,
+    settings_issues: settingsIssues,
+  };
+}
+
+/**
+ * CLI command: validate deployment
+ * Validates PAN installations in the current directory.
+ * @param {string} cwd
+ * @param {boolean} raw
+ */
+function cmdValidateDeployment(cwd, raw) {
+  const runtimes = detectInstalledRuntimes(cwd);
+  if (runtimes.length === 0) {
+    output({ error: 'No PAN installations found in this directory' }, raw);
+    return;
+  }
+
+  const results = {};
+  let overallStatus = 'clean';
+
+  for (const { runtime, configDir } of runtimes) {
+    const result = validateRuntimeInstall(cwd, configDir, runtime);
+    results[runtime] = result;
+    if (result.status === 'broken') overallStatus = 'broken';
+    else if (result.status === 'modified' && overallStatus !== 'broken') overallStatus = 'modified';
+  }
+
+  const summary = {
+    status: overallStatus,
+    runtimes_found: runtimes.length,
+    runtimes: results,
+  };
+
+  const rawLines = [`Deployment status: ${overallStatus} (${runtimes.length} runtimes)`];
+  for (const [rt, r] of Object.entries(results)) {
+    rawLines.push(`  ${rt}: ${r.status} (${r.total_files} files, ${r.missing.length} missing, ${r.modified.length} modified)`);
+  }
+
+  output(summary, raw, rawLines.join('\n'));
+}
+
 module.exports = {
   cmdVerifySummary,
   cmdVerifyPlanStructure,
@@ -1805,4 +2079,9 @@ module.exports = {
   countRoadmapPhases,
   groupGapPatterns,
   checkVerificationGate,
+  cmdValidateDeployment,
+  validateRuntimeInstall,
+  detectInstalledRuntimes,
+  syncRequirementCheckboxes,
+  syncRoadmapPlanCheckboxes,
 };

package/pan-wizard-core/bin/pan-tools.cjs

@@ -309,7 +309,14 @@ async function main() {
     }
 
     case 'resolve-model': {
-      commands.cmdResolveModel(cwd, args[1], raw);
+      const metadataIdx = args.indexOf('--metadata');
+      const metadataJson = metadataIdx !== -1 ? args[metadataIdx + 1] : undefined;
+      commands.cmdResolveModel(cwd, args[1], raw, metadataJson);
+      break;
+    }
+
+    case 'estimate-cost': {
+      commands.cmdEstimateCost(cwd, raw);
       break;
     }
 
@@ -534,8 +541,10 @@ async function main() {
         const fullFlag = args.includes('--full');
         const driftFlag = args.includes('--drift');
         verify.cmdValidateHealth(cwd, { repair: repairFlag, standards: standardsFlag, full: fullFlag, drift: driftFlag }, raw);
+      } else if (subcommand === 'deployment') {
+        verify.cmdValidateDeployment(cwd, raw);
       } else {
-        error('Unknown validate subcommand. Available: consistency, health');
+        error('Unknown validate subcommand. Available: consistency, health, deployment');
       }
       break;
     }