pan-wizard 3.8.0 → 3.10.0

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

@@ -3,11 +3,12 @@
  */
 const fs = require('fs');
 const path = require('path');
-const { safeReadFile, loadConfig, isGitIgnored, isGitRepo, execGit, normalizePhaseName, comparePhaseNum, getArchivedPhaseDirs, generateSlugInternal, getMilestoneInfo, resolveModelInternal, detectProvider, resolveTierToModel, estimateCostMultiplier, MODEL_PROFILES, output, error, findPhaseInternal, scanPendingTodos, toPosix } = require('./core.cjs');
+const { safeReadFile, loadConfig, isGitIgnored, isGitRepo, execGit, normalizePhaseName, comparePhaseNum, getArchivedPhaseDirs, generateSlugInternal, getMilestoneInfo, resolveModelInternal, resolveEffortInternal, detectProvider, resolveTierToModel, estimateCostMultiplier, MODEL_PROFILES, output, error, findPhaseInternal, scanPendingTodos, toPosix } = require('./core.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { PLANNING_DIR, PHASES_DIR, MILESTONES_DIR, QUICK_DIR, STATE_FILE, ROADMAP_FILE, PROJECT_FILE, PATTERNS_FILE, SESSION_HISTORY_FILE, LEARNINGS_FILE, CONTEXT_SUFFIX, UAT_SUFFIX, VERIFICATION_SUFFIX, isPlanFile, isSummaryFile, ARCHIVE_DIR_RE, PHASE_DIR_RE, CONTEXT_WINDOW, WARNING_THRESHOLD, CRITICAL_THRESHOLD, VALID_COMMIT_TYPES, DEFAULT_SENSITIVE_PATTERNS } = require('./constants.cjs');
 const { planningPath, phasesPath, filterPlanFiles, filterSummaryFiles } = require('./utils.cjs');
 const { estimateTokens } = require('./context-budget.cjs');
+const { collectPhaseSummaries, readErrorPatterns, appendErrorPattern, appendSessionSummary, parseLearnings, formatLearningEntry, cmdLearningsExtract, cmdLearningsList, cmdLearningsPrune } = require('./commands-learnings.cjs');
 
 /**
  * Generate a URL-safe slug from text by lowercasing and replacing non-alphanumeric chars.
@@ -93,64 +94,7 @@ function cmdVerifyPathExists(cwd, targetPath, raw) {
 
 // ---- History digest helper functions ----------------------------------------
 
-/**
- * Scan all phase directories (archived + current) and read summary frontmatter.
- * Returns an array of { phaseNum, dirName, frontmatter } objects for each summary found.
- *
- * Algorithm overview:
- * 1. Collect archived phase dirs from milestone archives (oldest milestones first)
- * 2. Collect current phase dirs from .planning/phases/
- * 3. For each directory, read all *-summary.md files and extract frontmatter
- *
- * @param {string} cwd - Working directory path
- * @returns {{ allPhaseDirs: Array, summaries: Array<{phaseNum: string, dirName: string, frontmatter: Object}> }}
- */
-function collectPhaseSummaries(cwd) {
-  const phasesDir = phasesPath(cwd);
-
-  // Collect all phase directories: archived + current
-  const allPhaseDirs = [];
-
-  // Add archived phases first (oldest milestones first)
-  const archived = getArchivedPhaseDirs(cwd);
-  for (const archiveEntry of archived) {
-    allPhaseDirs.push({ name: archiveEntry.name, fullPath: archiveEntry.fullPath, milestone: archiveEntry.milestone });
-  }
-
-  // Add current phases
-  try {
-    const currentDirs = fs.readdirSync(phasesDir, { withFileTypes: true })
-      .filter(entry => entry.isDirectory())
-      .map(entry => entry.name)
-      .sort();
-    for (const dirName of currentDirs) {
-      allPhaseDirs.push({ name: dirName, fullPath: path.join(phasesDir, dirName), milestone: null });
-    }
-  } catch { /* phases dir missing or unreadable */ }
-
-  const summaries = [];
-
-  for (const { name: dirName, fullPath: dirPath } of allPhaseDirs) {
-    let summaryFiles;
-    try {
-      summaryFiles = fs.readdirSync(dirPath).filter(filename => isSummaryFile(filename));
-    } catch { continue; }
-
-    for (const summaryFile of summaryFiles) {
-      try {
-        const content = fs.readFileSync(path.join(dirPath, summaryFile), 'utf-8');
-        const frontmatter = extractFrontmatter(content);
-        const phaseNum = frontmatter.phase || dirName.split('-')[0];
-
-        summaries.push({ phaseNum, dirName, frontmatter });
-      } catch {
-        // Skip malformed summary files (broken YAML, unreadable)
-      }
-    }
-  }
-
-  return { allPhaseDirs, summaries };
-}
+// collectPhaseSummaries — extracted to commands-learnings.cjs (imported above)
 
 /**
  * Aggregate tech stack entries from all summary frontmatters into a unified Set.
@@ -293,13 +237,14 @@ function cmdResolveModel(cwd, agentType, raw, metadataJson) {
   const agentModels = MODEL_PROFILES[agentType];
   if (!agentModels) {
     const model = resolveTierToModel('mid', detectProvider(cwd, config));
-    const result = { model, profile, strategy, unknown_agent: true };
+    const result = { model, profile, strategy, effort: resolveEffortInternal(cwd, agentType), unknown_agent: true };
     output(result, raw, model);
     return;
   }
 
   const model = resolveModelInternal(cwd, agentType, taskMetadata);
-  const result = { model, profile, strategy };
+  const effort = resolveEffortInternal(cwd, agentType);
+  const result = { model, profile, strategy, effort };
   output(result, raw, model);
 }
 
@@ -902,12 +847,14 @@ function cmdRollbackSnapshot(cwd, phase, raw) {
   }
   const hash = headResult.stdout;
 
-  // Create tag
-  let tagResult = execGit(cwd, ['tag', tagName]);
+  // Create tag. tag.gpgsign=true in user config turns plain `git tag` into a
+  // sign-or-fail operation ("fatal: no tag message?") in non-interactive runs —
+  // PAN snapshot tags are automation markers, so signing is explicitly disabled.
+  let tagResult = execGit(cwd, ['-c', 'tag.gpgsign=false', 'tag', tagName]);
   if (tagResult.exitCode !== 0) {
     // Tag might already exist — try with suffix
     tagName = tagName + '-1';
-    tagResult = execGit(cwd, ['tag', tagName]);
+    tagResult = execGit(cwd, ['-c', 'tag.gpgsign=false', 'tag', tagName]);
     if (tagResult.exitCode !== 0) {
       const result = { tag: null, hash, phase, warning: 'Failed to create tag: ' + tagResult.stderr };
       output(result, raw, '');
@@ -978,465 +925,7 @@ function shouldSkipTests(files) {
   return files.every(f => /\.md$/i.test(f));
 }
 
-/**
- * Read error patterns from .planning/patterns.md.
- * Parses PAT-NNN entries into structured objects.
- * @param {string} cwd - Working directory path
- * @returns {Array<{id: string, title: string, wrong: string, right: string, context: string|null, date: string|null}>}
- */
-function readErrorPatterns(cwd) {
-  const filePath = path.join(cwd, PLANNING_DIR, PATTERNS_FILE);
-  let content;
-  try {
-    content = fs.readFileSync(filePath, 'utf-8');
-  } catch {
-    return [];
-  }
-
-  if (!content || !content.trim()) {
-    return [];
-  }
-
-  const patterns = [];
-  // Split on PAT-NNN headers
-  const sections = content.split(/^### (PAT-\d+):\s*/m);
-  // sections[0] = preamble, then alternating [id, body, id, body, ...]
-  for (let i = 1; i < sections.length; i += 2) {
-    const id = sections[i];
-    const body = sections[i + 1] || '';
-
-    // Title is the first line of the body
-    const lines = body.split('\n');
-    const title = lines[0] ? lines[0].trim() : '';
-    const rest = lines.slice(1).join('\n');
-
-    const wrongMatch = rest.match(/\*\*Wrong:\*\*\s*(.+)/);
-    const rightMatch = rest.match(/\*\*Right:\*\*\s*(.+)/);
-    const contextMatch = rest.match(/\*\*Context:\*\*\s*(.+)/);
-    const dateMatch = rest.match(/\*\*Date:\*\*\s*(.+)/);
-
-    // Skip entries missing required fields
-    if (!wrongMatch || !rightMatch) continue;
-
-    patterns.push({
-      id,
-      title,
-      wrong: wrongMatch ? wrongMatch[1].trim() : null,
-      right: rightMatch ? rightMatch[1].trim() : null,
-      context: contextMatch ? contextMatch[1].trim() : null,
-      date: dateMatch ? dateMatch[1].trim() : null,
-    });
-  }
-
-  return patterns;
-}
-
-/**
- * Append a new error pattern entry to .planning/patterns.md.
- * Auto-increments the PAT-NNN ID. Creates file if missing.
- * @param {string} cwd - Working directory path
- * @param {Object} pattern - Pattern to append
- * @param {string} pattern.wrong - What went wrong
- * @param {string} pattern.right - What is correct
- * @param {string} [pattern.title] - Short title
- * @param {string} [pattern.context] - Additional context
- * @param {string} [pattern.date] - Date string (defaults to today)
- * @returns {{ id: string } | { error: string }}
- */
-function appendErrorPattern(cwd, pattern) {
-  if (!pattern || !pattern.wrong || !pattern.right) {
-    return { error: "Pattern requires 'wrong' and 'right' fields" };
-  }
-
-  const filePath = path.join(cwd, PLANNING_DIR, PATTERNS_FILE);
-  const existing = readErrorPatterns(cwd);
-
-  // Determine next ID
-  let maxNum = 0;
-  for (const p of existing) {
-    const m = p.id.match(/PAT-(\d+)/);
-    if (m) maxNum = Math.max(maxNum, parseInt(m[1], 10));
-  }
-  const nextId = `PAT-${String(maxNum + 1).padStart(3, '0')}`;
-
-  const date = pattern.date || new Date().toISOString().split('T')[0];
-  const title = pattern.title || 'Untitled';
-
-  const entry = [
-    '',
-    `### ${nextId}: ${title}`,
-    `**Wrong:** ${pattern.wrong}`,
-    `**Right:** ${pattern.right}`,
-    pattern.context ? `**Context:** ${pattern.context}` : null,
-    `**Date:** ${date}`,
-    '',
-  ].filter(line => line !== null).join('\n');
-
-  try {
-    let existingContent = '';
-    try {
-      existingContent = fs.readFileSync(filePath, 'utf-8');
-    } catch {
-      // File doesn't exist — create with header
-      existingContent = '# Error Patterns\n';
-    }
-    fs.writeFileSync(filePath, existingContent.trimEnd() + '\n' + entry, 'utf-8');
-    return { id: nextId };
-  } catch (e) {
-    return { error: `Failed to write pattern: ${e.message}` };
-  }
-}
-
-/**
- * Append a session summary to .planning/session-history.md.
- * Creates file with header if missing. Keeps last 20 entries.
- * @param {string} cwd - Working directory path
- * @param {Object} summary - Session summary
- * @param {string} summary.phase - Phase identifier
- * @param {number} [summary.plans_executed] - Plans executed
- * @param {number} [summary.tests_before] - Test count before
- * @param {number} [summary.tests_after] - Test count after
- * @param {string} [summary.key_decisions] - Key decisions made
- * @param {string} [summary.date] - Date string (defaults to today)
- * @returns {{ appended: boolean } | { error: string }}
- */
-function appendSessionSummary(cwd, summary) {
-  if (!summary || !summary.phase) {
-    return { error: "Summary requires 'phase' field" };
-  }
-
-  const filePath = path.join(cwd, PLANNING_DIR, SESSION_HISTORY_FILE);
-  const date = summary.date || new Date().toISOString().split('T')[0];
-
-  const entry = [
-    `### Session — ${date}`,
-    `- **Phase:** ${summary.phase}`,
-    summary.plans_executed != null ? `- **Plans Executed:** ${summary.plans_executed}` : null,
-    summary.tests_before != null ? `- **Tests Before:** ${summary.tests_before}` : null,
-    summary.tests_after != null ? `- **Tests After:** ${summary.tests_after}` : null,
-    summary.key_decisions ? `- **Key Decisions:** ${summary.key_decisions}` : null,
-    '',
-  ].filter(line => line !== null).join('\n');
-
-  try {
-    let content = '';
-    try {
-      content = fs.readFileSync(filePath, 'utf-8');
-    } catch {
-      content = '# Session History\n\n';
-    }
-
-    content = content.trimEnd() + '\n\n' + entry;
-
-    // Keep last 20 entries — split on session headers, trim oldest
-    const SESSION_HEADER_RE = /^### Session — /m;
-    const parts = content.split(SESSION_HEADER_RE);
-    // parts[0] = header, parts[1..N] = session entries
-    if (parts.length > 21) { // header + 20 entries
-      const header = parts[0];
-      const kept = parts.slice(parts.length - 20);
-      content = header.trimEnd() + '\n\n' + kept.map(p => '### Session — ' + p).join('');
-    }
-
-    fs.writeFileSync(filePath, content, 'utf-8');
-    return { appended: true };
-  } catch (e) {
-    return { error: `Failed to write session summary: ${e.message}` };
-  }
-}
-
-// ---- Session Learnings ---------------------------------------------------------
-
-/**
- * Parse learnings.md into structured entries.
- * Each learning has: id, type, title, detail, files (optional), date.
- * @param {string} content - Raw content of learnings.md
- * @returns {Array<{id: string, type: string, title: string, detail: string, files: string[], date: string|null}>}
- */
-function parseLearnings(content) {
-  if (!content || !content.trim()) return [];
-
-  const learnings = [];
-  const sections = content.split(/^### (LEARN-\d+):\s*/m);
-  // sections[0] = preamble, then alternating [id, body, ...]
-  for (let i = 1; i < sections.length; i += 2) {
-    const id = sections[i];
-    const body = sections[i + 1] || '';
-
-    const lines = body.split('\n');
-    const title = lines[0] ? lines[0].trim() : '';
-    const rest = lines.slice(1).join('\n');
-
-    const typeMatch = rest.match(/\*\*Type:\*\*\s*(.+)/);
-    const detailMatch = rest.match(/\*\*Detail:\*\*\s*(.+)/);
-    const filesMatch = rest.match(/\*\*Files:\*\*\s*(.+)/);
-    const dateMatch = rest.match(/\*\*Date:\*\*\s*(.+)/);
-
-    learnings.push({
-      id,
-      type: typeMatch ? typeMatch[1].trim() : 'unknown',
-      title,
-      detail: detailMatch ? detailMatch[1].trim() : '',
-      files: filesMatch ? filesMatch[1].trim().split(/,\s*/) : [],
-      date: dateMatch ? dateMatch[1].trim() : null,
-    });
-  }
-
-  return learnings;
-}
-
-/**
- * Format a learning entry as markdown text.
- * @param {Object} learning - Learning entry
- * @returns {string}
- */
-function formatLearningEntry(learning) {
-  const lines = [
-    `### ${learning.id}: ${learning.title}`,
-    `**Type:** ${learning.type}`,
-    `**Detail:** ${learning.detail}`,
-  ];
-  if (learning.files && learning.files.length > 0) {
-    lines.push(`**Files:** ${learning.files.join(', ')}`);
-  }
-  if (learning.date) {
-    lines.push(`**Date:** ${learning.date}`);
-  }
-  lines.push('');
-  return lines.join('\n');
-}
-
-/**
- * Extract learnings from session summaries and error patterns.
- * Reads session history + error patterns, extracts file co-change patterns
- * and error resolutions, writes to .planning/learnings.md.
- * @param {string} cwd - Working directory path
- * @param {boolean} raw - If true, output raw count instead of JSON
- * @returns {void}
- */
-function cmdLearningsExtract(cwd, raw) {
-  const learningsPath = path.join(cwd, PLANNING_DIR, LEARNINGS_FILE);
-  const newLearnings = [];
-  const today = new Date().toISOString().split('T')[0];
-
-  // Read existing learnings to get next ID and avoid duplicates
-  let existingContent = '';
-  try { existingContent = fs.readFileSync(learningsPath, 'utf-8'); } catch { /* new file */ }
-  const existing = parseLearnings(existingContent);
-  let maxNum = 0;
-  for (const l of existing) {
-    const m = l.id.match(/LEARN-(\d+)/);
-    if (m) maxNum = Math.max(maxNum, parseInt(m[1], 10));
-  }
-
-  // Existing detail strings for dedup
-  const existingDetails = new Set(existing.map(l => l.detail));
-
-  // 1. Extract error resolutions from patterns.md
-  const patterns = readErrorPatterns(cwd);
-  for (const pat of patterns) {
-    const detail = `${pat.wrong} -> ${pat.right}`;
-    if (existingDetails.has(detail)) continue;
-    existingDetails.add(detail);
-    maxNum++;
-    newLearnings.push({
-      id: `LEARN-${String(maxNum).padStart(3, '0')}`,
-      type: 'error-resolution',
-      title: pat.title || 'Error pattern',
-      detail,
-      files: [],
-      date: pat.date || today,
-    });
-  }
-
-  // 2. Extract file co-change patterns from summary frontmatters
-  const { summaries } = collectPhaseSummaries(cwd);
-  const fileCoChanges = new Map(); // file -> Set of co-changed files
-
-  for (const { frontmatter } of summaries) {
-    const keyFiles = Array.isArray(frontmatter['key-files']) ? frontmatter['key-files'] : [];
-    if (keyFiles.length < 2) continue;
-    for (const file of keyFiles) {
-      if (!fileCoChanges.has(file)) fileCoChanges.set(file, new Set());
-      for (const other of keyFiles) {
-        if (other !== file) fileCoChanges.get(file).add(other);
-      }
-    }
-  }
-
-  // Emit co-change learnings for files that appear together 2+ times
-  const emittedPairs = new Set();
-  for (const [file, coFiles] of fileCoChanges) {
-    for (const coFile of coFiles) {
-      const pair = [file, coFile].sort().join(' + ');
-      if (emittedPairs.has(pair)) continue;
-      emittedPairs.add(pair);
-
-      // Count co-occurrences
-      let count = 0;
-      for (const { frontmatter } of summaries) {
-        const kf = frontmatter['key-files'] || [];
-        if (kf.includes(file) && kf.includes(coFile)) count++;
-      }
-      if (count < 2) continue;
-
-      const detail = `${file} and ${coFile} changed together ${count} times`;
-      if (existingDetails.has(detail)) continue;
-      existingDetails.add(detail);
-      maxNum++;
-      newLearnings.push({
-        id: `LEARN-${String(maxNum).padStart(3, '0')}`,
-        type: 'co-change',
-        title: `Co-change: ${path.basename(file)} + ${path.basename(coFile)}`,
-        detail,
-        files: [file, coFile],
-        date: today,
-      });
-    }
-  }
-
-  // 3. Extract successful patterns from summaries
-  for (const { frontmatter } of summaries) {
-    const patterns_established = frontmatter['patterns-established'] || [];
-    for (const pattern of patterns_established) {
-      const detail = String(pattern);
-      if (existingDetails.has(detail)) continue;
-      existingDetails.add(detail);
-      maxNum++;
-      newLearnings.push({
-        id: `LEARN-${String(maxNum).padStart(3, '0')}`,
-        type: 'pattern',
-        title: detail.length > 60 ? detail.substring(0, 57) + '...' : detail,
-        detail,
-        files: [],
-        date: today,
-      });
-    }
-  }
-
-  // Write new learnings to file
-  if (newLearnings.length > 0) {
-    let content = existingContent;
-    if (!content || !content.trim()) {
-      content = '# Session Learnings\n\n';
-    }
-
-    for (const learning of newLearnings) {
-      content = content.trimEnd() + '\n\n' + formatLearningEntry(learning);
-    }
-
-    try {
-      fs.mkdirSync(path.dirname(learningsPath), { recursive: true });
-      fs.writeFileSync(learningsPath, content, 'utf-8');
-    } catch (e) {
-      error('Failed to write learnings: ' + e.message);
-    }
-  }
-
-  const result = {
-    extracted: newLearnings.length,
-    total: existing.length + newLearnings.length,
-    by_type: {
-      'error-resolution': newLearnings.filter(l => l.type === 'error-resolution').length,
-      'co-change': newLearnings.filter(l => l.type === 'co-change').length,
-      'pattern': newLearnings.filter(l => l.type === 'pattern').length,
-    },
-  };
-  output(result, raw, `Extracted ${newLearnings.length} new learnings (${result.total} total)`);
-}
-
-/**
- * List all learnings from .planning/learnings.md.
- * @param {string} cwd - Working directory path
- * @param {boolean} raw - If true, output raw formatted list instead of JSON
- * @returns {void}
- */
-function cmdLearningsList(cwd, raw) {
-  const learningsPath = path.join(cwd, PLANNING_DIR, LEARNINGS_FILE);
-
-  let content;
-  try {
-    content = fs.readFileSync(learningsPath, 'utf-8');
-  } catch {
-    output({ learnings: [], count: 0 }, raw, 'No learnings found');
-    return;
-  }
-
-  const learnings = parseLearnings(content);
-  const result = {
-    learnings,
-    count: learnings.length,
-    by_type: {},
-  };
-
-  for (const l of learnings) {
-    result.by_type[l.type] = (result.by_type[l.type] || 0) + 1;
-  }
-
-  if (raw) {
-    const lines = learnings.map(l => `${l.id} [${l.type}] ${l.title}`);
-    output(result, true, lines.join('\n') || 'No learnings found');
-  } else {
-    output(result, false);
-  }
-}
-
-/**
- * Prune learnings by age (--days) or by ID (--id).
- * @param {string} cwd - Working directory path
- * @param {Object} opts - Prune options
- * @param {number|null} opts.days - Remove entries older than N days
- * @param {string|null} opts.id - Remove specific entry by ID
- * @param {boolean} raw - If true, output raw count instead of JSON
- * @returns {void}
- */
-function cmdLearningsPrune(cwd, opts, raw) {
-  const learningsPath = path.join(cwd, PLANNING_DIR, LEARNINGS_FILE);
-
-  if (!opts || (opts.days == null && opts.id == null)) {
-    error('Prune requires --days N or --id LEARN-NNN');
-  }
-
-  let content;
-  try {
-    content = fs.readFileSync(learningsPath, 'utf-8');
-  } catch {
-    output({ pruned: 0, remaining: 0 }, raw, 'No learnings file found');
-    return;
-  }
-
-  const learnings = parseLearnings(content);
-  const before = learnings.length;
-  let kept;
-
-  if (opts.id) {
-    kept = learnings.filter(l => l.id !== opts.id);
-  } else if (opts.days != null) {
-    const cutoff = new Date();
-    cutoff.setDate(cutoff.getDate() - opts.days);
-    const cutoffStr = cutoff.toISOString().split('T')[0];
-    kept = learnings.filter(l => !l.date || l.date >= cutoffStr);
-  } else {
-    kept = learnings;
-  }
-
-  const pruned = before - kept.length;
-
-  // Rewrite file
-  let newContent = '# Session Learnings\n';
-  for (const learning of kept) {
-    newContent += '\n' + formatLearningEntry(learning);
-  }
-
-  try {
-    fs.writeFileSync(learningsPath, newContent, 'utf-8');
-  } catch (e) {
-    error('Failed to write learnings: ' + e.message);
-  }
-
-  const result = { pruned, remaining: kept.length };
-  output(result, raw, `Pruned ${pruned} learnings (${kept.length} remaining)`);
-}
+// ---- Error patterns, session history, learnings — extracted to commands-learnings.cjs (re-exported below)
 
 module.exports = {
   cmdGenerateSlug,

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

@@ -75,6 +75,70 @@ const MODEL_PROFILES = {
   'pan-experiment-runner':    { quality: 'reasoning', balanced: 'fast',     budget: 'fast' },
 };
 
+// ─── Effort Profiles (2026-06, adaptive-thinking era) ───────────────────────
+//
+// Per-agent base reasoning effort (low|medium|high|xhigh). `effort` is the
+// primary within-model cost/intelligence dial on current models — it replaced
+// fixed thinking budgets. The base values here mirror the `effort:`
+// frontmatter shipped in agents/*.md (a drift test keeps them in sync).
+//
+// Profile modulation: `budget` steps effort down one level (floor: low) as
+// its cost lever; `quality` and `balanced` keep the base. Per-agent override
+// via config.json → effort_overrides.
+
+const EFFORT_ORDER = ['low', 'medium', 'high', 'xhigh'];
+
+const AGENT_BASE_EFFORT = {
+  // Heavy planning/orchestration/debugging — deepest reasoning
+  'pan-planner':              'xhigh',
+  'pan-conductor':            'xhigh',
+  'pan-debugger':             'xhigh',
+  'pan-plan-checker':         'xhigh',
+  // Execution and verification — thorough but bounded
+  'pan-executor':             'high',
+  'pan-roadmapper':           'high',
+  'pan-verifier':             'high',
+  'pan-integration-checker':  'high',
+  'pan-hardener':             'high',
+  'pan-counterfactual':       'high',
+  'pan-previewer':            'high',
+  'pan-experiment-runner':    'high',
+  'pan-optimizer':            'high',
+  // Research/synthesis/review — moderate depth
+  'pan-phase-researcher':     'medium',
+  'pan-project-researcher':   'medium',
+  'pan-research-synthesizer': 'medium',
+  'pan-knowledge':            'medium',
+  'pan-distiller':            'medium',
+  'pan-meta-reviewer':        'medium',
+  'pan-reviewer':             'medium',
+  // Mechanical documentation pass — fast and scoped
+  'pan-document_code':        'low',
+};
+
+/**
+ * Resolve the reasoning effort level for an agent under the active profile.
+ * Priority: config.effort_overrides[agent] → base effort modulated by
+ * model_profile (budget steps down one level) → 'medium' for unknown agents.
+ *
+ * @param {string} cwd - Project root directory
+ * @param {string} agentType - e.g. "pan-planner"
+ * @returns {string} One of 'low' | 'medium' | 'high' | 'xhigh'
+ */
+function resolveEffortInternal(cwd, agentType) {
+  const config = loadConfig(cwd);
+  const override = config.effort_overrides?.[agentType];
+  if (typeof override === 'string' && EFFORT_ORDER.includes(override.toLowerCase().trim())) {
+    return override.toLowerCase().trim();
+  }
+  const base = AGENT_BASE_EFFORT[agentType] || 'medium';
+  const profile = config.model_profile || 'balanced';
+  if (profile === 'budget') {
+    return EFFORT_ORDER[Math.max(0, EFFORT_ORDER.indexOf(base) - 1)];
+  }
+  return base;
+}
+
 // ─── Output helpers ───────────────────────────────────────────────────────────
 
 /**
@@ -213,6 +277,7 @@ function loadConfig(cwd) {
       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 || {},
+      effort_overrides: parsed.effort_overrides || {},
       routing: parsed.routing || { strategy: 'static', provider: 'auto' },
     };
   } catch { // Config missing or malformed — use defaults
@@ -223,6 +288,7 @@ function loadConfig(cwd) {
       execution: { default_mode: 'wave_order', rollback_snapshots: true, error_pattern_learning: true },
       focus: { auto_commit: true },
       model_overrides: {},
+      effort_overrides: {},
       routing: { strategy: 'static', provider: 'auto' },
     };
   }
@@ -860,6 +926,9 @@ function scanSourceTodos(cwd) {
 
 module.exports = {
   MODEL_PROFILES,
+  AGENT_BASE_EFFORT,
+  EFFORT_ORDER,
+  resolveEffortInternal,
   PROVIDER_MODELS,
   LEGACY_ALIASES,
   COST_MULTIPLIERS,