opencastle 0.31.6 → 0.32.0

package/src/cli/package.ts

@@ -0,0 +1,329 @@
+import { readFileSync, existsSync, mkdirSync, readdirSync, cpSync, writeFileSync } from 'node:fs'
+import { resolve, join } from 'node:path'
+import { c } from './prompt.js'
+import type { CliContext } from './types.js'
+import { PLATFORM_CONFIGS, getSkillsForPlatform } from './package-config.js'
+
+const HELP = `
+  opencastle package [options]
+
+  Package OpenCastle orchestrator as a plugin for IDE marketplaces.
+
+  Options:
+    --platform, -p <name>   Target platform (claude-code, cursor, opencode, gemini)
+    --all                   Generate packages for all platforms
+    --output, -o <dir>      Output directory (default: dist/plugins)
+    --dry-run               Preview what would be built without writing files
+    --help, -h              Show this help
+`
+
+export interface PackageArgs {
+  platform: string | null
+  all: boolean
+  output: string
+  dryRun: boolean
+  help: boolean
+}
+
+export function parseArgs(args: string[]): PackageArgs {
+  const opts: PackageArgs = { platform: null, all: false, output: 'dist/plugins', dryRun: false, help: false }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === '--help' || arg === '-h') {
+      opts.help = true
+    } else if (arg === '--all') {
+      opts.all = true
+    } else if (arg === '--dry-run' || arg === '--dryRun') {
+      opts.dryRun = true
+    } else if ((arg === '--platform' || arg === '-p') && args[i + 1]) {
+      opts.platform = args[++i]
+    } else if ((arg === '--output' || arg === '-o') && args[i + 1]) {
+      opts.output = args[++i]
+    }
+  }
+  return opts
+}
+
+export function readVersion(pkgRoot: string): string {
+  const pkgPath = resolve(pkgRoot, 'package.json')
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { version: string }
+  return pkg.version
+}
+
+export function listSkillDirs(pkgRoot: string): string[] {
+  const skillsPath = resolve(pkgRoot, 'src/orchestrator/skills')
+  if (!existsSync(skillsPath)) return []
+  return readdirSync(skillsPath, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name)
+    .sort()
+}
+
+export function generateManifest(
+  platform: string,
+  version: string,
+  skills: string[],
+  agents: string[],
+): object {
+  const base = {
+    name: 'opencastle',
+    version,
+    description: 'OpenCastle multi-agent orchestration framework',
+    skills,
+    agents,
+  }
+  if (platform === 'claude-code') {
+    return { ...base, hooks: ['SessionStart'] }
+  }
+  if (platform === 'gemini') {
+    return { ...base, type: 'extension' }
+  }
+  return base
+}
+
+export function generateEntryPoint(platform: string, version: string, skills: string[]): string {
+  const skillList = skills.map(s => '- ' + s).join('\n')
+  switch (platform) {
+    case 'claude-code':
+      return [
+        '# OpenCastle v' + version,
+        '',
+        'Multi-agent orchestration framework for Claude Code.',
+        '',
+        '## Available Skills',
+        '',
+        skillList,
+        '',
+        '## Usage',
+        '',
+        'Skills are available in the `skills/` directory. Reference them in your agent instructions.',
+        '',
+      ].join('\n')
+    case 'cursor':
+      return [
+        '# OpenCastle v' + version + ' -- Cursor Rules',
+        '',
+        'Multi-agent orchestration framework for Cursor.',
+        '',
+        '## Skills',
+        '',
+        skillList,
+        '',
+        '## Instructions',
+        '',
+        'Reference skill files using the `skills/` directory in your workspace.',
+        '',
+      ].join('\n')
+    case 'opencode':
+      return [
+        '# OpenCastle v' + version,
+        '',
+        'Multi-agent orchestration framework for OpenCode.',
+        '',
+        '## Setup',
+        '',
+        'Copy this package to your project and reference skill files as needed.',
+        '',
+        '## Available Skills',
+        '',
+        skillList,
+        '',
+      ].join('\n')
+    case 'gemini':
+      return [
+        '# OpenCastle v' + version,
+        '',
+        'Multi-agent orchestration framework for Gemini CLI.',
+        '',
+        '## Tool Mapping',
+        '',
+        'Each skill maps to a specialized tool capability.',
+        '',
+        '## Available Skills',
+        '',
+        skillList,
+        '',
+      ].join('\n')
+    default:
+      return '# OpenCastle v' + version + '\n'
+  }
+}
+
+export function generateReadme(platform: string, version: string): string {
+  const config = PLATFORM_CONFIGS[platform]
+  const displayName = config?.displayName ?? platform
+  return [
+    '# OpenCastle Plugin for ' + displayName,
+    '',
+    'Version: ' + version,
+    '',
+    '## Installation',
+    '',
+    'Copy the contents of this directory to your ' + displayName + ' workspace or plugin directory.',
+    '',
+    '## Usage',
+    '',
+    'Reference the `' + (config?.entryPoint ?? 'README.md') + '` file in your ' + displayName + ' configuration.',
+    '',
+    '## Skills',
+    '',
+    'See the `skills/` directory for available skills.',
+    '',
+    '## Agents',
+    '',
+    'See the `agents/` directory for available agent definitions.',
+    '',
+    '## More Info',
+    '',
+    'Visit https://www.opencastle.dev/ for documentation.',
+    '',
+  ].join('\n')
+}
+
+export interface BuildResult {
+  platform: string
+  outputDir: string
+  skillCount: number
+  agentCount: number
+}
+
+export function buildPluginPackage(
+  pkgRoot: string,
+  platform: string,
+  outputBase: string,
+): BuildResult {
+  const config = PLATFORM_CONFIGS[platform]
+  if (!config) {
+    throw new Error('Unknown platform: ' + platform + '. Valid: ' + Object.keys(PLATFORM_CONFIGS).join(', '))
+  }
+  const outputDir = resolve(outputBase, config.outputDir)
+  mkdirSync(outputDir, { recursive: true })
+
+  const version = readVersion(pkgRoot)
+  const allSkills = listSkillDirs(pkgRoot)
+  const filteredSkills = getSkillsForPlatform(platform, allSkills)
+
+  if (config.includedDirs.includes('skills')) {
+    const skillsOut = join(outputDir, 'skills')
+    mkdirSync(skillsOut, { recursive: true })
+    const skillsSrc = resolve(pkgRoot, 'src/orchestrator/skills')
+    for (const skill of filteredSkills) {
+      const src = join(skillsSrc, skill)
+      if (existsSync(src)) {
+        cpSync(src, join(skillsOut, skill), { recursive: true })
+      }
+    }
+  }
+
+  const agentsSrc = resolve(pkgRoot, 'src/orchestrator/agents')
+  const agentFiles = existsSync(agentsSrc)
+    ? readdirSync(agentsSrc).filter(f => f.endsWith('.agent.md'))
+    : []
+  if (config.includedDirs.includes('agents')) {
+    const agentsOut = join(outputDir, 'agents')
+    mkdirSync(agentsOut, { recursive: true })
+    for (const f of agentFiles) {
+      cpSync(join(agentsSrc, f), join(agentsOut, f))
+    }
+  }
+
+  if (config.includedDirs.includes('instructions')) {
+    const instrSrc = resolve(pkgRoot, 'src/orchestrator/instructions')
+    if (existsSync(instrSrc)) {
+      const instrOut = join(outputDir, 'instructions')
+      mkdirSync(instrOut, { recursive: true })
+      const files = readdirSync(instrSrc).filter(f => f.endsWith('.instructions.md'))
+      for (const f of files) {
+        cpSync(join(instrSrc, f), join(instrOut, f))
+      }
+    }
+  }
+
+  if (config.includedDirs.includes('prompts')) {
+    const promptsSrc = resolve(pkgRoot, 'src/orchestrator/prompts')
+    if (existsSync(promptsSrc)) {
+      const promptsOut = join(outputDir, 'prompts')
+      mkdirSync(promptsOut, { recursive: true })
+      const files = readdirSync(promptsSrc).filter(f => f.endsWith('.prompt.md'))
+      for (const f of files) {
+        cpSync(join(promptsSrc, f), join(promptsOut, f))
+      }
+    }
+  }
+
+  if (config.includedDirs.includes('agent-workflows')) {
+    const wfSrc = resolve(pkgRoot, 'src/orchestrator/agent-workflows')
+    if (existsSync(wfSrc)) {
+      const wfOut = join(outputDir, 'agent-workflows')
+      mkdirSync(wfOut, { recursive: true })
+      const files = readdirSync(wfSrc).filter(f => f.endsWith('.md'))
+      for (const f of files) {
+        cpSync(join(wfSrc, f), join(wfOut, f))
+      }
+    }
+  }
+
+  const agentNames = agentFiles.map(f => f.replace('.agent.md', ''))
+  const manifest = generateManifest(platform, version, filteredSkills, agentNames)
+  writeFileSync(join(outputDir, config.manifestFile), JSON.stringify(manifest, null, 2) + '\n', 'utf8')
+
+  const entryContent = generateEntryPoint(platform, version, filteredSkills)
+  writeFileSync(join(outputDir, config.entryPoint), entryContent, 'utf8')
+
+  const readmeContent = generateReadme(platform, version)
+  writeFileSync(join(outputDir, 'README.md'), readmeContent, 'utf8')
+
+  return { platform, outputDir, skillCount: filteredSkills.length, agentCount: agentFiles.length }
+}
+
+export default async function packageCmd({ args, pkgRoot }: CliContext): Promise<void> {
+  const opts = parseArgs(args)
+  if (opts.help) {
+    console.log(HELP)
+    return
+  }
+
+  const platforms = opts.all
+    ? Object.keys(PLATFORM_CONFIGS)
+    : opts.platform
+    ? [opts.platform]
+    : null
+  if (!platforms) {
+    console.error('  ' + c.red('✗') + ' Specify --platform <name> or --all')
+    console.log(HELP)
+    process.exit(1)
+  }
+
+  if (opts.dryRun) {
+    console.log(`  [dry-run] Would build packages for: ${platforms.join(', ')}`)
+    console.log(`  [dry-run] Output directory: ${resolve(process.cwd(), opts.output)}`)
+    return
+  }
+
+  const outputBase = resolve(process.cwd(), opts.output)
+  const results: BuildResult[] = []
+  const errors: string[] = []
+
+  for (const platform of platforms) {
+    try {
+      console.log('  ' + c.dim('→') + ' Building ' + platform + '...')
+      const result = buildPluginPackage(pkgRoot, platform, outputBase)
+      results.push(result)
+      console.log(
+        '  ' + c.green('✓') + ' ' + platform + ': ' +
+        result.skillCount + ' skills, ' + result.agentCount + ' agents → ' + result.outputDir
+      )
+    } catch (err) {
+      const msg = (err as Error).message
+      errors.push(platform + ': ' + msg)
+      console.error('  ' + c.red('✗') + ' ' + platform + ': ' + msg)
+    }
+  }
+
+  console.log()
+  if (errors.length > 0) {
+    console.error('  ' + c.red('✗') + ' ' + errors.length + ' platform(s) failed')
+    process.exit(1)
+  }
+  console.log('  ' + c.green('✔') + ' ' + results.length + ' package(s) built in ' + outputBase)
+}

package/src/cli/pipeline.ts

@@ -18,6 +18,17 @@ export interface ConvoyGroup {
   depends_on: string[]
 }
 
+function appendTaskComplexity(base: string, taskComplexity: ComplexityAssessment['task_complexity']): string {
+  if (!taskComplexity?.length) return base
+  let result = base + '\n\n## Pre-Computed Task Complexity\n\n'
+  result += '| Workstream | Phase | Complexity | Rationale |\n'
+  result += '|-----------|-------|-----------|----------|\n'
+  for (const tc of taskComplexity) {
+    result += `| ${tc.workstream} | ${tc.phase} | ${tc.complexity} | ${tc.rationale} |\n`
+  }
+  return result
+}
+
 export interface ComplexityAssessment {
   original_prompt: string
   total_tasks: number
@@ -28,6 +39,12 @@ export interface ComplexityAssessment {
   recommended_strategy: 'single' | 'chain'
   chain_rationale?: string
   convoy_groups: ConvoyGroup[]
+  task_complexity?: Array<{
+    workstream: string
+    phase: number
+    complexity: 1 | 2 | 3 | 5 | 8 | 13
+    rationale: string
+  }>
 }
 
 export function parseComplexityAssessment(jsonText: string): ComplexityAssessment | null {
@@ -572,12 +589,13 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
           ].filter(Boolean).join('\n')
 
           const prdContent = await readFile(prdPath, 'utf8')
+          const contextForSpec = appendTaskComplexity(prdContent, complexity?.task_complexity)
           const groupSpecPath = resolve(convoyDir, `${group.name}.convoy.yml`)
 
           const { specPath: resolvedGroupSpecPath } = await generateAndValidateSpec({
             sharedOpts,
             goalText: chainGoal,
-            contextText: prdContent,
+            contextText: contextForSpec,
             specPath: groupSpecPath,
             skipValidation: opts.skipValidation,
             groupName: group.name,
@@ -643,12 +661,13 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
 
   // ── Generate convoy spec ──────────────────────────────────────────────────
   const singlePrdContent = await readFile(prdPath, 'utf8')
+  const singleContextForSpec = appendTaskComplexity(singlePrdContent, complexity?.task_complexity)
   const singleGoal = complexity?.original_prompt ?? opts.text ?? ''
 
   const specResult = await generateAndValidateSpec({
     sharedOpts,
     goalText: singleGoal,
-    contextText: singlePrdContent,
+    contextText: singleContextForSpec,
     specPath: opts.outputSpec ? resolve(process.cwd(), opts.outputSpec) : undefined,
     skipValidation: opts.skipValidation,
     enrichment: complexity ? deriveSpecEnrichment(complexity) : undefined,

package/src/cli/run/schema.test.ts

@@ -1830,6 +1830,64 @@ describe('validateSpec — built_in_gates config', () => {
     expect(result.valid).toBe(false)
     expect(result.errors).toContainEqual(expect.stringContaining('gate_timeout'))
   })
+
+  it('accepts tdd_check as boolean', () => {
+    const result = validateSpec({
+      ...validSpec,
+      defaults: { built_in_gates: { tdd_check: true } },
+    })
+    expect(result.valid).toBe(true)
+  })
+
+  it('accepts tdd_check as object', () => {
+    const result = validateSpec({
+      ...validSpec,
+      defaults: { built_in_gates: { tdd_check: { enabled: true, mode: 'block' } } },
+    })
+    expect(result.valid).toBe(true)
+  })
+
+  it('rejects tdd_check with invalid value', () => {
+    const result = validateSpec({
+      ...validSpec,
+      defaults: { built_in_gates: { tdd_check: 'yes' } },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('tdd_check'))
+  })
+})
+
+describe('validateSpec — review_stages', () => {
+  const validSpec = {
+    name: 'test-run',
+    version: 1,
+    tasks: [{ id: 'task-1', prompt: 'Do something' }],
+  }
+
+  it('accepts review_stages as true', () => {
+    const result = validateSpec({
+      ...validSpec,
+      defaults: { review_stages: true },
+    })
+    expect(result.valid).toBe(true)
+  })
+
+  it('accepts review_stages as false', () => {
+    const result = validateSpec({
+      ...validSpec,
+      defaults: { review_stages: false },
+    })
+    expect(result.valid).toBe(true)
+  })
+
+  it('rejects review_stages with non-boolean value', () => {
+    const result = validateSpec({
+      ...validSpec,
+      defaults: { review_stages: 'yes' },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('review_stages'))
+  })
 })
 
 describe('validateSpec — browser_test config', () => {

package/src/cli/run/schema.ts

@@ -268,6 +268,10 @@ export function validateSpec(spec: unknown): ValidationResult {
         } else {
           const bg = d.built_in_gates as Record<string, unknown>
           const boolOrAutoFields = ['secret_scan', 'blast_radius', 'dependency_audit', 'regression_test', 'browser_test'] as const
+          // tdd_check can be boolean or object (TDDGateConfig)
+          if (bg.tdd_check !== undefined && typeof bg.tdd_check !== 'boolean' && (typeof bg.tdd_check !== 'object' || Array.isArray(bg.tdd_check) || bg.tdd_check === null)) {
+            errors.push('`defaults.built_in_gates.tdd_check` must be a boolean or an object')
+          }
           for (const field of boolOrAutoFields) {
             if (bg[field] !== undefined && typeof bg[field] !== 'boolean' && bg[field] !== 'auto') {
               errors.push(`\`defaults.built_in_gates.${field}\` must be a boolean or "auto"`)
@@ -287,6 +291,35 @@ export function validateSpec(spec: unknown): ValidationResult {
         validateBrowserTestConfig(d.browser_test, 'defaults.browser_test', errors)
       }
 
+      // compaction config validation (Phase 44)
+      if (d.compaction !== undefined) {
+        if (!d.compaction || typeof d.compaction !== 'object' || Array.isArray(d.compaction)) {
+          errors.push('`defaults.compaction` must be an object')
+        } else {
+          const comp = d.compaction as Record<string, unknown>
+          if (comp.enabled !== undefined && typeof comp.enabled !== 'boolean') {
+            errors.push('`defaults.compaction.enabled` must be a boolean')
+          }
+          if (comp.token_threshold_pct !== undefined) {
+            const pct = Number(comp.token_threshold_pct)
+            if (!Number.isFinite(pct) || pct < 1 || pct > 100) {
+              errors.push('`defaults.compaction.token_threshold_pct` must be a number between 1 and 100')
+            }
+          }
+          if (comp.summary_max_tokens !== undefined) {
+            const smt = Number(comp.summary_max_tokens)
+            if (!Number.isInteger(smt) || smt < 1) {
+              errors.push('`defaults.compaction.summary_max_tokens` must be a positive integer')
+            }
+          }
+        }
+      }
+
+      // review_stages validation (Phase 40 — two-stage review toggle)
+      if (d.review_stages !== undefined && typeof d.review_stages !== 'boolean') {
+        errors.push('`defaults.review_stages` must be a boolean')
+      }
+
       // review validation
       const VALID_REVIEW = ['auto', 'fast', 'panel', 'none']
       if (d.review !== undefined && !VALID_REVIEW.includes(d.review as string)) {

package/src/cli/run.ts

@@ -532,7 +532,9 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
     const { createConvoyStore } = await import('./convoy/store.js')
     const store = createConvoyStore(dbPath)
     const latestPipeline = store.getLatestPipeline()
-    if (latestPipeline && (latestPipeline.status === 'pending' || latestPipeline.status === 'running')) {
+
+    // ── Pipeline resume (pending / running / failed) ────────────
+    if (latestPipeline && latestPipeline.status !== 'done') {
       store.close()
       const resumePipelineSpec = parseTaskSpecText(latestPipeline.spec_yaml)
       if (opts.concurrency !== null) resumePipelineSpec.concurrency = opts.concurrency
@@ -572,6 +574,17 @@ export default async function run({ args, pkgRoot }: CliContext): Promise<void>
       process.exit(resumePipelineResult.status !== 'done' ? 1 : 0)
     }
 
+    // ── Pipeline done — don't fall through to convoy check ──────
+    if (latestPipeline && latestPipeline.status === 'done') {
+      store.close()
+      console.error(
+        `  ✗ Last pipeline "${latestPipeline.name}" already finished with status: done`
+      )
+      console.error(`    Only interrupted (running/pending/failed) pipelines can be resumed.`)
+      process.exit(1)
+    }
+
+    // ── Standalone convoy resume ────────────────────────────────
     const convoy = store.getLatestConvoy()
     store.close()
     if (!convoy) {

package/src/cli/skills.ts

@@ -0,0 +1,121 @@
+import type { CliContext } from './types.js'
+import { c } from './prompt.js'
+
+const HELP = `
+  opencastle skills [subcommand]
+
+  Skill refinement and failure tracking.
+
+  Subcommands:
+    refine              Scan for failure patterns and generate refinement proposals
+    failures            Show failure stats per skill
+
+  Options:
+    --dry-run           Preview what proposals would be generated without saving
+    --help, -h          Show this help
+`
+
+function parseSkillsArgs(args: string[]): { subcommand: string | null; help: boolean; dryRun: boolean } {
+  const opts = { subcommand: null as string | null, help: false, dryRun: false }
+  for (const arg of args) {
+    if (arg === '--help' || arg === '-h') {
+      opts.help = true
+    } else if (arg === '--dry-run' || arg === '--dryRun') {
+      opts.dryRun = true
+    } else if (!arg.startsWith('--')) {
+      opts.subcommand ??= arg
+    }
+  }
+  return opts
+}
+
+export default async function skills({ args }: CliContext): Promise<void> {
+  const opts = parseSkillsArgs(args)
+
+  if (opts.help || !opts.subcommand) {
+    console.log(HELP)
+    return
+  }
+
+  const {
+    getFailureStats,
+    getSkillFailures,
+    detectFailurePatterns,
+    generateRefinementProposal,
+    saveProposal,
+  } = await import('./convoy/skill-refinement.js')
+
+  switch (opts.subcommand) {
+    case 'refine': {
+      const stats = getFailureStats()
+      const uniqueSkills = stats.map(s => s.skill_name)
+
+      if (uniqueSkills.length === 0) {
+        console.log('  No skill failures recorded yet.')
+        return
+      }
+
+      const generated: Array<{ skill: string; path: string }> = []
+      for (const skillName of uniqueSkills) {
+        const failures = getSkillFailures(skillName)
+        const { threshold_met } = detectFailurePatterns(failures)
+        if (!threshold_met) continue
+        const proposal = generateRefinementProposal(skillName, failures)
+        const proposalPath = opts.dryRun
+          ? `.opencastle/proposals/${skillName}-refinement.md`
+          : saveProposal(proposal, undefined, failures)
+        generated.push({ skill: skillName, path: proposalPath })
+      }
+
+      if (generated.length === 0) {
+        console.log('  No skills currently meet the refinement threshold.')
+      } else if (opts.dryRun) {
+        console.log(`  [dry-run] Would generate ${generated.length} refinement proposal${generated.length === 1 ? '' : 's'}:`)
+        for (const g of generated) {
+          console.log(`    ${c.dim('◆')} ${g.skill}: ${g.path}`)
+        }
+      } else {
+        console.log(`  ${c.green('✔')} ${generated.length} skill${generated.length === 1 ? '' : 's'} have refinement proposals. Review in .opencastle/proposals/`)
+        for (const g of generated) {
+          console.log(`    ${c.dim('◆')} ${g.skill}: ${g.path}`)
+        }
+      }
+      break
+    }
+
+    case 'failures': {
+      const stats = getFailureStats()
+      if (stats.length === 0) {
+        console.log('  No skill failures recorded yet.')
+        return
+      }
+
+      const colW = [30, 10, 30, 26]
+      const header = [
+        'Skill'.padEnd(colW[0]),
+        'Failures'.padEnd(colW[1]),
+        'Agents'.padEnd(colW[2]),
+        'Latest',
+      ].join('  ')
+      console.log(`\n  ${c.bold(header)}`)
+      console.log('  ' + '-'.repeat(header.length))
+
+      for (const s of stats) {
+        const row = [
+          s.skill_name.slice(0, colW[0] - 1).padEnd(colW[0]),
+          String(s.count).padEnd(colW[1]),
+          s.agents.join(', ').slice(0, colW[2] - 1).padEnd(colW[2]),
+          s.latest.slice(0, 10),
+        ].join('  ')
+        console.log(`  ${row}`)
+      }
+      console.log('')
+      break
+    }
+
+    default:
+      console.error(`  ${c.red('✗')} Unknown subcommand: ${opts.subcommand}`)
+      console.log(HELP)
+      process.exit(1)
+  }
+}

package/src/cli/types.ts

@@ -1,5 +1,5 @@
 import type { ChildProcess } from 'node:child_process';
-import type { BuiltInGatesConfig, BrowserTestConfig, GuardConfig, CircuitBreakerConfig, TaskStep, Hook, TaskOutput, TaskInput, WatchConfig, MCPServerConfig } from './convoy/types.js';
+import type { BuiltInGatesConfig, BrowserTestConfig, GuardConfig, CircuitBreakerConfig, CompactionConfig, TaskStep, Hook, TaskOutput, TaskInput, WatchConfig, MCPServerConfig } from './convoy/types.js';
 
 // ── Stack selection types ──────────────────────────────────────
 
@@ -165,6 +165,7 @@ export interface TaskDefaults {
   escalate_to?: string;
   circuit_breaker?: CircuitBreakerConfig;
   review?: 'auto' | 'fast' | 'panel' | 'none';
+  review_stages?: boolean;
   reviewer_model?: string;
   review_budget?: number;
   on_review_budget_exceeded?: 'skip' | 'downgrade' | 'stop';
@@ -188,6 +189,8 @@ export interface TaskDefaults {
   mcp_server_approval_timeout?: number;
   /** Browser test gate configuration for default built-in gates. */
   browser_test?: BrowserTestConfig;
+  /** Auto-context compaction configuration (Phase 44). */
+  compaction?: CompactionConfig;
 }
 
 /** Validated task spec from YAML. */

package/src/cli/update.ts

@@ -19,8 +19,8 @@ const UPDATE_HELP = `
 
   Options:
     --dry-run         Preview what would be changed without writing files
-    --force           Overwrite customized files (default: skip)
-    --reconfigure     Re-run IDE selection and reconfigure adapters
+    --force           Force update even if versions match
+    --reconfigure     Re-run IDE and stack selection
     --help, -h        Show this help
 `