opencastle 0.10.7 → 0.11.0

package/src/cli/run/loop-reporter.ts

@@ -0,0 +1,125 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { formatDuration } from './executor.js'
+import { c } from '../prompt.js'
+import { appendEvent } from '../log.js'
+import { appendLesson } from '../lesson.js'
+import type {
+  LoopRunReport,
+  LoopIterationResult,
+  BackpressureResult,
+  LoopReporter,
+} from '../types.js'
+
+const STOPPED_LABELS: Record<LoopRunReport['stoppedReason'], string> = {
+  'max-iterations': 'reached max iterations',
+  'plan-empty': 'plan exhausted',
+  'backpressure-fail': 'backpressure check failed',
+  'user-abort': 'aborted by user',
+  error: 'agent error',
+}
+
+export function createLoopReporter(
+  specName: string,
+  options: { reportDir?: string; verbose?: boolean } = {},
+): LoopReporter {
+  const reportDir = options.reportDir ?? resolve(process.cwd(), '.opencastle', 'runs')
+  const verbose = options.verbose ?? false
+
+  return {
+    onIterationStart(i: number, max: number): void {
+      console.log(`\n  \u21bb Iteration ${i}/${max}`)
+    },
+
+    onIterationDone(_i: number, result: LoopIterationResult): void {
+      const dur = formatDuration(result.duration)
+      if (result.status === 'done') {
+        console.log(`  ${c.green('\u2713')} Completed (${dur})`)
+      } else if (result.status === 'backpressure-fail') {
+        console.log(`  ${c.yellow('\u26a0')} Backpressure failed (${dur})`)
+      } else {
+        console.log(`  ${c.red('\u2717')} Failed (${dur})`)
+        if (result.output) {
+          const lines = result.output.split('\n').slice(0, 5)
+          for (const line of lines) console.log(`    ${line}`)
+          if (result.output.split('\n').length > 5) console.log(`    ... (truncated)`)
+        }
+      }
+      if (verbose && result.output && result.status === 'done') {
+        console.log(`    Output: ${result.output.slice(0, 500)}`)
+      }
+
+      appendEvent({
+        type: 'delegation',
+        timestamp: new Date().toISOString(),
+        session_id: specName,
+        agent: 'autonomous',
+        task: `Loop iteration ${_i}`,
+        mechanism: 'run-loop',
+        outcome: result.status === 'done' ? 'success' : result.status,
+        duration_sec: Math.round(result.duration / 1000),
+      }).catch(() => {})
+    },
+
+    onBackpressureStart(cmd: string): void {
+      console.log(`  \u23ce Running: ${cmd}`)
+    },
+
+    onBackpressureResult(result: BackpressureResult): void {
+      if (result.passed) {
+        console.log(`  ${c.green('\u2713')} Exit ${result.exitCode}`)
+      } else {
+        console.log(`  ${c.red('\u2717')} Exit ${result.exitCode}`)
+        if (result.output) {
+          const lines = result.output.split('\n').slice(0, 5)
+          for (const line of lines) console.log(`    ${line}`)
+        }
+      }
+    },
+
+    async onComplete(report: LoopRunReport): Promise<void> {
+      console.log(`\n  ${c.dim('\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500')}`)
+      console.log(`  ${c.bold('Loop complete:')} ${report.name}`)
+      console.log(`  Duration: ${report.duration}`)
+      console.log()
+      console.log(
+        `  Iterations: ${report.totalIterations} total \u2014 ` +
+          `${c.green(String(report.completedIterations))} completed`,
+      )
+      console.log(`  Stopped: ${STOPPED_LABELS[report.stoppedReason]}`)
+
+      try {
+        await mkdir(reportDir, { recursive: true })
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+        const reportPath = resolve(reportDir, `loop-${specName}-${timestamp}.json`)
+        await writeFile(reportPath, JSON.stringify(report, null, 2), 'utf8')
+        console.log(`  Report: ${reportPath}`)
+      } catch (err: unknown) {
+        console.log(`  \u2717 Could not write report: ${(err as Error).message}`)
+      }
+      await appendEvent({
+        type: 'session',
+        timestamp: new Date().toISOString(),
+        agent: 'opencastle-run',
+        task: `Loop: ${report.name}`,
+        outcome: report.stoppedReason === 'max-iterations' || report.stoppedReason === 'plan-empty' ? 'success' : 'failure',
+        duration_min: Math.round((new Date(report.completedAt).getTime() - new Date(report.startedAt).getTime()) / 60000),
+        mode: 'loop',
+        total_iterations: report.totalIterations,
+        completed_iterations: report.completedIterations,
+        stopped_reason: report.stoppedReason,
+      }).catch(() => {})
+
+      if (report.stoppedReason === 'error' || report.stoppedReason === 'backpressure-fail') {
+        const lastIter = report.iterations[report.iterations.length - 1]
+        await appendLesson({
+          title: `Run loop "${report.name}" stopped: ${report.stoppedReason}`,
+          category: 'general',
+          severity: 'medium',
+          problem: `Loop stopped after ${report.totalIterations} iterations due to ${report.stoppedReason}.${lastIter?.output ? ` Last output: ${lastIter.output.slice(0, 200)}` : ''}`,
+        }).catch(() => {})
+      }
+      console.log()
+    },
+  }
+}

package/src/cli/run/reporter.ts

@@ -2,6 +2,7 @@ import { mkdir, writeFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
 import { formatDuration } from './executor.js'
 import { c } from '../prompt.js'
+import { appendEvent } from '../log.js'
 import type {
   TaskSpec,
   Task,
@@ -56,6 +57,17 @@ export function createReporter(spec: TaskSpec, options: ReporterOptions = {}): R
       if (verbose && result.output && result.status === 'done') {
         console.log(`    Output: ${result.output.slice(0, 500)}`)
       }
+
+      appendEvent({
+        type: 'delegation',
+        timestamp: new Date().toISOString(),
+        session_id: spec.name,
+        agent: task.agent,
+        task: `${task.id}: ${task.description}`,
+        mechanism: 'run-task',
+        outcome: result.status === 'done' ? 'success' : result.status,
+        duration_sec: Math.round(result.duration / 1000),
+      }).catch(() => {})
     },
 
     onTaskSkipped(task: Task, reason: string): void {
@@ -95,6 +107,23 @@ export function createReporter(spec: TaskSpec, options: ReporterOptions = {}): R
         console.log(`  ${ICONS.failed} Could not write report: ${(err as Error).message}`)
       }
 
+      await appendEvent({
+        type: 'session',
+        timestamp: new Date().toISOString(),
+        agent: 'opencastle-run',
+        model: spec.adapter,
+        task: `Run: ${report.name}`,
+        outcome: report.summary.failed > 0 || report.summary['timed-out'] > 0 ? 'failure' : 'success',
+        duration_min: Math.round((new Date(report.completedAt).getTime() - new Date(report.startedAt).getTime()) / 60000),
+        files_changed: 0,
+        retries: 0,
+        mode: 'tasks',
+        tasks_total: report.summary.total,
+        tasks_done: report.summary.done,
+        tasks_failed: report.summary.failed,
+        tasks_skipped: report.summary.skipped,
+      }).catch(() => {})
+
       console.log()
     },
   }
@@ -108,7 +137,7 @@ export function printExecutionPlan(spec: TaskSpec, phases: Task[][]): void {
   console.log(`  ${c.dim('Adapter:')}     ${c.cyan(spec.adapter)}`)
   console.log(`  ${c.dim('Concurrency:')} ${c.yellow(String(spec.concurrency))}`)
   console.log(`  ${c.dim('On failure:')}  ${c.yellow(spec.on_failure)}`)
-  console.log(`  ${c.dim('Tasks:')}       ${c.yellow(String(spec.tasks.length))}`)
+  console.log(`  ${c.dim('Tasks:')}       ${c.yellow(String(spec.tasks?.length ?? 0))}`)
   console.log(`  ${c.dim('──────────────────────────────────')}`)
 
   for (let i = 0; i < phases.length; i++) {

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

@@ -324,7 +324,7 @@ describe('applyDefaults', () => {
       name: 'test',
       tasks: [{ id: 'a', prompt: 'x' }],
     })
-    const task = spec.tasks[0]
+    const task = spec.tasks![0]
     expect(task.agent).toBe('developer')
     expect(task.timeout).toBe('30m')
     expect(task.depends_on).toEqual([])
@@ -343,10 +343,250 @@ describe('applyDefaults', () => {
         files: ['src/'],
       }],
     })
-    const task = spec.tasks[0]
+    const task = spec.tasks![0]
     expect(task.agent).toBe('ui-ux-expert')
     expect(task.timeout).toBe('15m')
     expect(task.depends_on).toEqual(['b'])
     expect(task.files).toEqual(['src/'])
   })
 })
+
+// ── loop mode — validateSpec ───────────────────────────────────
+
+describe('validateSpec — loop mode', () => {
+  const validLoopSpec = {
+    name: 'build-auth',
+    mode: 'loop',
+    adapter: 'copilot',
+    loop: {
+      prompt: 'PROMPT_build.md',
+      plan_file: 'IMPLEMENTATION_PLAN.md',
+      max_iterations: 20,
+      timeout: '10m',
+      model: 'gpt-5.1',
+      backpressure: ['npm test', 'npx tsc --noEmit'],
+    },
+  }
+
+  it('accepts a valid minimal loop spec (only prompt required)', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT_build.md' },
+    })
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('accepts a full loop spec', () => {
+    const result = validateSpec(validLoopSpec)
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('does not require tasks array in loop mode', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT_build.md' },
+    })
+    expect(result.valid).toBe(true)
+  })
+
+  it('fails when loop object is missing', () => {
+    const result = validateSpec({ name: 'build-auth', mode: 'loop' })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('`loop` is required'))
+  })
+
+  it('fails when loop.prompt is missing', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { max_iterations: 10 },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.prompt'))
+  })
+
+  it('fails when loop.prompt is not a string', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 123 },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.prompt'))
+  })
+
+  it('fails when loop.max_iterations is 0', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md', max_iterations: 0 },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.max_iterations'))
+  })
+
+  it('fails when loop.max_iterations is a float', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md', max_iterations: 1.5 },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.max_iterations'))
+  })
+
+  it('fails when loop.timeout has invalid format', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md', timeout: 'bad' },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.timeout'))
+  })
+
+  it('accepts valid loop.timeout formats', () => {
+    for (const t of ['5s', '10m', '2h']) {
+      const result = validateSpec({
+        name: 'build-auth',
+        mode: 'loop',
+        loop: { prompt: 'PROMPT.md', timeout: t },
+      })
+      expect(result.valid).toBe(true)
+    }
+  })
+
+  it('fails when loop.backpressure is not an array', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md', backpressure: 'npm test' },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.backpressure'))
+  })
+
+  it('fails when loop.backpressure contains non-strings', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md', backpressure: ['npm test', 42] },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.backpressure'))
+  })
+
+  it('fails when loop.plan_file is not a string', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md', plan_file: true },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.plan_file'))
+  })
+
+  it('fails when loop.model is not a string', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md', model: 99 },
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('loop.model'))
+  })
+
+  it('rejects unknown mode value', () => {
+    const result = validateSpec({
+      name: 'build-auth',
+      mode: 'parallel',
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('mode'))
+  })
+
+  it('mode: tasks still requires tasks array', () => {
+    const result = validateSpec({ name: 'build-auth', mode: 'tasks' })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('tasks'))
+  })
+
+  it('spec without mode field defaults to tasks behavior (requires tasks)', () => {
+    const result = validateSpec({ name: 'build-auth' })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('tasks'))
+  })
+})
+
+// ── loop mode — applyDefaults ──────────────────────────────────
+
+describe('applyDefaults — loop mode', () => {
+  it('applies default max_iterations', () => {
+    const spec = applyDefaults({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md' },
+    })
+    expect(spec.loop?.max_iterations).toBe(20)
+  })
+
+  it('applies default plan_file', () => {
+    const spec = applyDefaults({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md' },
+    })
+    expect(spec.loop?.plan_file).toBe('IMPLEMENTATION_PLAN.md')
+  })
+
+  it('applies default timeout', () => {
+    const spec = applyDefaults({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md' },
+    })
+    expect(spec.loop?.timeout).toBe('10m')
+  })
+
+  it('preserves user-specified loop values', () => {
+    const spec = applyDefaults({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: {
+        prompt: 'PROMPT.md',
+        max_iterations: 5,
+        plan_file: 'MY_PLAN.md',
+        timeout: '30m',
+        model: 'gpt-5.1',
+        backpressure: ['npm test'],
+      },
+    })
+    expect(spec.loop?.max_iterations).toBe(5)
+    expect(spec.loop?.plan_file).toBe('MY_PLAN.md')
+    expect(spec.loop?.timeout).toBe('30m')
+    expect(spec.loop?.model).toBe('gpt-5.1')
+    expect(spec.loop?.backpressure).toEqual(['npm test'])
+  })
+
+  it('sets mode to tasks when not specified', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(spec.mode).toBe('tasks')
+  })
+
+  it('preserves mode: loop', () => {
+    const spec = applyDefaults({
+      name: 'build-auth',
+      mode: 'loop',
+      loop: { prompt: 'PROMPT.md' },
+    })
+    expect(spec.mode).toBe('loop')
+  })
+})

package/src/cli/run/schema.ts

@@ -39,6 +39,8 @@ interface RawSpec {
   on_failure?: unknown
   adapter?: unknown
   tasks?: unknown
+  mode?: unknown
+  loop?: unknown
 }
 
 interface RawTask {
@@ -90,72 +92,117 @@ export function validateSpec(spec: unknown): ValidationResult {
     errors.push('`adapter` must be a string')
   }
 
-  // Tasks
-  if (!s.tasks || !Array.isArray(s.tasks) || s.tasks.length === 0) {
-    errors.push('`tasks` is required and must be a non-empty array')
-    return { valid: false, errors }
+  // mode
+  const mode = s.mode !== undefined ? s.mode : 'tasks'
+  if (mode !== 'tasks' && mode !== 'loop') {
+    errors.push('`mode` must be one of: tasks, loop')
   }
 
-  const taskIds = new Set<string>()
-  const tasks = s.tasks as RawTask[]
-
-  for (let i = 0; i < tasks.length; i++) {
-    const task = tasks[i]
-    const prefix = `tasks[${i}]`
-
-    if (!task || typeof task !== 'object') {
-      errors.push(`${prefix}: must be an object`)
-      continue
-    }
-
-    // id
-    if (!task.id || typeof task.id !== 'string') {
-      errors.push(`${prefix}: \`id\` is required and must be a string`)
-    } else if (taskIds.has(task.id)) {
-      errors.push(`${prefix}: duplicate task id "${task.id}"`)
+  if (mode === 'loop') {
+    // Loop validation — tasks array is NOT required
+    const loop = s.loop as Record<string, unknown> | undefined
+    if (!loop || typeof loop !== 'object') {
+      errors.push('`loop` is required when mode is "loop"')
     } else {
-      taskIds.add(task.id)
+      if (!loop.prompt || typeof loop.prompt !== 'string') {
+        errors.push('`loop.prompt` is required and must be a string')
+      }
+      if (loop.max_iterations !== undefined) {
+        const mi = Number(loop.max_iterations)
+        if (!Number.isInteger(mi) || mi < 1) {
+          errors.push('`loop.max_iterations` must be an integer >= 1')
+        }
+      }
+      if (loop.timeout !== undefined) {
+        if (isNaN(parseTimeout(loop.timeout as string))) {
+          errors.push(
+            '`loop.timeout` must be in format: <number><s|m|h> (e.g. "10m")'
+          )
+        }
+      }
+      if (loop.backpressure !== undefined) {
+        if (
+          !Array.isArray(loop.backpressure) ||
+          !(loop.backpressure as unknown[]).every((b) => typeof b === 'string')
+        ) {
+          errors.push('`loop.backpressure` must be an array of strings')
+        }
+      }
+      if (loop.plan_file !== undefined && typeof loop.plan_file !== 'string') {
+        errors.push('`loop.plan_file` must be a string')
+      }
+      if (loop.model !== undefined && typeof loop.model !== 'string') {
+        errors.push('`loop.model` must be a string')
+      }
     }
-
-    // prompt
-    if (!task.prompt || typeof task.prompt !== 'string') {
-      errors.push(`${prefix}: \`prompt\` is required and must be a string`)
+  } else {
+    // Tasks mode — tasks array is required
+    if (!s.tasks || !Array.isArray(s.tasks) || s.tasks.length === 0) {
+      errors.push('`tasks` is required and must be a non-empty array')
+      return { valid: false, errors }
     }
 
-    // timeout
-    if (task.timeout !== undefined) {
-      if (isNaN(parseTimeout(task.timeout as string))) {
-        errors.push(
-          `${prefix}: \`timeout\` must be in format: <number><s|m|h> (e.g. "10m")`
-        )
+    const taskIds = new Set<string>()
+    const tasks = s.tasks as RawTask[]
+
+    for (let i = 0; i < tasks.length; i++) {
+      const task = tasks[i]
+      const prefix = `tasks[${i}]`
+
+      if (!task || typeof task !== 'object') {
+        errors.push(`${prefix}: must be an object`)
+        continue
       }
-    }
 
-    // depends_on
-    if (task.depends_on !== undefined) {
-      if (!Array.isArray(task.depends_on)) {
-        errors.push(`${prefix}: \`depends_on\` must be an array`)
+      // id
+      if (!task.id || typeof task.id !== 'string') {
+        errors.push(`${prefix}: \`id\` is required and must be a string`)
+      } else if (taskIds.has(task.id)) {
+        errors.push(`${prefix}: duplicate task id "${task.id}"`)
       } else {
-        for (const dep of task.depends_on as string[]) {
-          if (!taskIds.has(dep) && !tasks.some((t) => t && t.id === dep)) {
-            errors.push(
-              `${prefix}: \`depends_on\` references unknown task "${dep}"`
-            )
+        taskIds.add(task.id)
+      }
+
+      // prompt
+      if (!task.prompt || typeof task.prompt !== 'string') {
+        errors.push(`${prefix}: \`prompt\` is required and must be a string`)
+      }
+
+      // timeout
+      if (task.timeout !== undefined) {
+        if (isNaN(parseTimeout(task.timeout as string))) {
+          errors.push(
+            `${prefix}: \`timeout\` must be in format: <number><s|m|h> (e.g. "10m")`
+          )
+        }
+      }
+
+      // depends_on
+      if (task.depends_on !== undefined) {
+        if (!Array.isArray(task.depends_on)) {
+          errors.push(`${prefix}: \`depends_on\` must be an array`)
+        } else {
+          for (const dep of task.depends_on as string[]) {
+            if (!taskIds.has(dep) && !tasks.some((t) => t && t.id === dep)) {
+              errors.push(
+                `${prefix}: \`depends_on\` references unknown task "${dep}"`
+              )
+            }
           }
         }
       }
-    }
 
-    // files
-    if (task.files !== undefined && !Array.isArray(task.files)) {
-      errors.push(`${prefix}: \`files\` must be an array`)
+      // files
+      if (task.files !== undefined && !Array.isArray(task.files)) {
+        errors.push(`${prefix}: \`files\` must be an array`)
+      }
     }
-  }
 
-  // DAG cycle detection
-  if (errors.length === 0) {
-    const cycleErr = detectCycles(tasks as Array<{ id: string; depends_on?: string[] }>)
-    if (cycleErr) errors.push(cycleErr)
+    // DAG cycle detection
+    if (errors.length === 0) {
+      const cycleErr = detectCycles(tasks as Array<{ id: string; depends_on?: string[] }>)
+      if (cycleErr) errors.push(cycleErr)
+    }
   }
 
   return { valid: errors.length === 0, errors }
@@ -214,14 +261,23 @@ export function applyDefaults(spec: Record<string, unknown>): TaskSpec {
   s.on_failure = (s.on_failure as string) || 'continue'
   // Leave adapter empty so run.ts can auto-detect the best available CLI
   s.adapter = (s.adapter as string) || ''
-
-  const tasks = s.tasks as Array<Record<string, unknown>>
-  for (const task of tasks) {
-    task.agent = (task.agent as string) || 'developer'
-    task.timeout = (task.timeout as string) || '30m'
-    task.depends_on = (task.depends_on as string[]) || []
-    task.files = (task.files as string[]) || []
-    task.description = (task.description as string) || (task.id as string)
+  s.mode = (s.mode as string) || 'tasks'
+
+  if (s.mode === 'loop') {
+    const loop = ((s.loop ?? {}) as Record<string, unknown>)
+    loop.max_iterations = loop.max_iterations !== undefined ? Number(loop.max_iterations) : 20
+    loop.plan_file = (loop.plan_file as string) || 'IMPLEMENTATION_PLAN.md'
+    loop.timeout = (loop.timeout as string) || '10m'
+    s.loop = loop
+  } else {
+    const tasks = s.tasks as Array<Record<string, unknown>>
+    for (const task of tasks) {
+      task.agent = (task.agent as string) || 'developer'
+      task.timeout = (task.timeout as string) || '30m'
+      task.depends_on = (task.depends_on as string[]) || []
+      task.files = (task.files as string[]) || []
+      task.description = (task.description as string) || (task.id as string)
+    }
   }
 
   return s as unknown as TaskSpec