task-while 0.0.1 → 0.0.3

package/src/agents/event-log.ts

@@ -0,0 +1,195 @@
+import type { ClaudeAgentEvent, ClaudeAgentEventHandler } from './claude'
+import type { CodexThreadEvent, CodexThreadEventHandler } from './codex'
+
+function formatInline(value: string) {
+  return value.trim().replaceAll('\n', String.raw`\n`)
+}
+
+function formatJson(value: unknown) {
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return String(value)
+  }
+}
+
+function writeCodexEvent(event: CodexThreadEvent) {
+  if (
+    event.type === 'item.completed' ||
+    event.type === 'item.started' ||
+    event.type === 'item.updated'
+  ) {
+    const item = event.item
+
+    if (item.type === 'reasoning') {
+      const text = formatInline(item.text)
+      if (text) {
+        process.stderr.write(`[codex] thinking ${text}\n`)
+      }
+      return
+    }
+
+    if (item.type === 'command_execution') {
+      if (event.type === 'item.started') {
+        process.stderr.write(`[codex] exec ${formatInline(item.command)}\n`)
+        return
+      }
+      if (event.type === 'item.completed') {
+        process.stderr.write(
+          `[codex] exec ${item.status} exit=${item.exit_code ?? 'unknown'} ${formatInline(item.command)}\n`,
+        )
+        const output = formatInline(item.aggregated_output)
+        if (output) {
+          process.stderr.write(`[codex] output ${output}\n`)
+        }
+        return
+      }
+    }
+
+    if (item.type === 'mcp_tool_call') {
+      const target = `${item.server}.${item.tool}`
+      if (event.type === 'item.started') {
+        process.stderr.write(
+          `[codex] tool ${target} ${formatJson(item.arguments)}\n`,
+        )
+        return
+      }
+      if (event.type === 'item.completed') {
+        const detail =
+          item.status === 'failed'
+            ? ` error=${item.error?.message ?? 'unknown'}`
+            : ''
+        process.stderr.write(`[codex] tool ${item.status} ${target}${detail}\n`)
+        return
+      }
+    }
+
+    if (item.type === 'file_change' && event.type === 'item.completed') {
+      const files = item.changes.map((change) => change.path).join(', ')
+      process.stderr.write(`[codex] files ${item.status} ${files}\n`)
+      return
+    }
+
+    if (item.type === 'web_search') {
+      process.stderr.write(`[codex] search ${formatInline(item.query)}\n`)
+      return
+    }
+
+    if (item.type === 'todo_list') {
+      for (const todo of item.items) {
+        process.stderr.write(
+          `[codex] todo ${todo.completed ? '[x]' : '[ ]'} ${formatInline(todo.text)}\n`,
+        )
+      }
+      return
+    }
+
+    if (item.type === 'error') {
+      process.stderr.write(`[codex] error ${formatInline(item.message)}\n`)
+      return
+    }
+
+    if (item.type === 'agent_message' && event.type === 'item.completed') {
+      const text = formatInline(item.text)
+      if (text) {
+        process.stderr.write(`[codex] message ${text}\n`)
+      }
+      return
+    }
+  }
+
+  if (event.type === 'turn.completed') {
+    process.stderr.write(
+      `[codex] result tokens in=${event.usage.input_tokens} out=${event.usage.output_tokens} cached=${event.usage.cached_input_tokens}\n`,
+    )
+    return
+  }
+
+  if (event.type === 'error') {
+    process.stderr.write(`[codex] error ${formatInline(event.message)}\n`)
+    return
+  }
+
+  if (event.type === 'turn.failed') {
+    process.stderr.write(`[codex] error ${formatInline(event.error.message)}\n`)
+  }
+}
+
+function writeClaudeEvent(event: ClaudeAgentEvent) {
+  if (event.type === 'system.init') {
+    const tools = event.tools.length !== 0 ? event.tools.join(',') : '-'
+    const skills = event.skills.length !== 0 ? event.skills.join(',') : '-'
+    const mcp =
+      event.mcpServers.length !== 0
+        ? event.mcpServers
+            .map((server) => `${server.name}:${server.status}`)
+            .join(',')
+        : '-'
+    process.stderr.write(
+      `[claude] init model=${event.model} permission=${event.permissionMode} tools=${tools} skills=${skills} mcp=${mcp}\n`,
+    )
+    return
+  }
+
+  if (event.type === 'task.started') {
+    process.stderr.write(`[claude] task ${formatInline(event.description)}\n`)
+    return
+  }
+
+  if (event.type === 'tool.progress') {
+    process.stderr.write(
+      `[claude] tool ${event.toolName} ${event.elapsedTimeSeconds}s\n`,
+    )
+    return
+  }
+
+  if (event.type === 'tool.summary') {
+    process.stderr.write(
+      `[claude] tool-summary ${formatInline(event.summary)}\n`,
+    )
+    return
+  }
+
+  if (event.type === 'task.progress') {
+    const detail = event.summary ?? event.description
+    process.stderr.write(
+      `[claude] progress ${formatInline(event.lastToolName ?? '-')} ${formatInline(detail)}\n`,
+    )
+    return
+  }
+
+  if (event.type === 'text') {
+    const text = formatInline(event.delta)
+    if (text) {
+      process.stderr.write(`[claude] text ${text}\n`)
+    }
+    return
+  }
+
+  if (event.type === 'result') {
+    process.stderr.write(
+      `[claude] result ${event.subtype} turns=${event.numTurns} duration=${event.durationMs}ms\n`,
+    )
+    return
+  }
+
+  process.stderr.write(`[claude] error ${formatInline(event.message)}\n`)
+}
+
+export function createCodexEventHandler(
+  verbose: boolean | undefined,
+): CodexThreadEventHandler | undefined {
+  if (!verbose) {
+    return undefined
+  }
+  return writeCodexEvent
+}
+
+export function createClaudeEventHandler(
+  verbose: boolean | undefined,
+): ClaudeAgentEventHandler | undefined {
+  if (!verbose) {
+    return undefined
+  }
+  return writeClaudeEvent
+}

package/src/batch/discovery.ts

@@ -24,7 +24,7 @@ export async function discoverBatchFiles(
     absolute: false,
     cwd: input.baseDir,
     dot: true,
-    ignore: ['.git/**', 'node_modules/**'],
+    ignore: ['.git/**', '.while/**', 'node_modules/**'],
     nodir: true,
     posix: true,
   })

package/src/batch/provider.ts

@@ -1,5 +1,9 @@
 import { ClaudeAgentClient } from '../agents/claude'
 import { CodexAgentClient } from '../agents/codex'
+import {
+  createClaudeEventHandler,
+  createCodexEventHandler,
+} from '../agents/event-log'
 
 import type { WorkflowRoleProviderOptions } from '../agents/provider-options'
 
@@ -17,6 +21,7 @@ export interface BatchStructuredOutputProvider {
 
 export type CreateBatchStructuredOutputProviderInput =
   WorkflowRoleProviderOptions & {
+    verbose?: boolean
     workspaceRoot: string
   }
 
@@ -60,19 +65,23 @@ export function createBatchStructuredOutputProvider(
   input: CreateBatchStructuredOutputProviderInput,
 ): BatchStructuredOutputProvider {
   if (input.provider === 'codex') {
+    const onEvent = createCodexEventHandler(input.verbose)
     return new CodexBatchStructuredOutputProvider(
       new CodexAgentClient({
         ...(input.effort ? { effort: input.effort } : {}),
         ...(input.model ? { model: input.model } : {}),
+        ...(onEvent ? { onEvent } : {}),
         workspaceRoot: input.workspaceRoot,
       }),
     )
   }
 
+  const onEvent = createClaudeEventHandler(input.verbose)
   return new ClaudeBatchStructuredOutputProvider(
     new ClaudeAgentClient({
       ...(input.effort ? { effort: input.effort } : {}),
       ...(input.model ? { model: input.model } : {}),
+      ...(onEvent ? { onEvent } : {}),
       workspaceRoot: input.workspaceRoot,
     }),
   )

package/src/commands/batch.ts

@@ -5,23 +5,21 @@ import Ajv from 'ajv'
 import * as fsExtra from 'fs-extra'
 import { z } from 'zod'
 
+import { createFsHarnessStore } from '../adapters/fs/harness-store'
 import { loadBatchConfig, type BatchConfig } from '../batch/config'
 import { discoverBatchFiles } from '../batch/discovery'
 import {
   createBatchStructuredOutputProvider,
   type BatchStructuredOutputProvider,
 } from '../batch/provider'
-import { parseWithSchema, uniqueStringArray } from '../schema/shared'
+import { runKernel } from '../harness/kernel'
+import { createBatchProgram } from '../programs/batch'
+import { createRuntimePaths } from '../runtime/path-layout'
+import { createBatchRetryScheduler } from '../schedulers/scheduler'
+import { parseWithSchema } from '../schema/shared'
+import { runSession, SessionEventType } from '../session/session'
 import { writeJsonAtomic } from '../utils/fs'
 
-const batchStateSchema = z
-  .object({
-    failed: uniqueStringArray('failed'),
-    inProgress: uniqueStringArray('inProgress'),
-    pending: uniqueStringArray('pending'),
-  })
-  .strict()
-
 const batchResultsSchema = z.custom<Record<string, unknown>>(
   (value) =>
     typeof value === 'object' && value !== null && !Array.isArray(value),
@@ -30,12 +28,6 @@ const batchResultsSchema = z.custom<Record<string, unknown>>(
   },
 )
 
-export interface BatchState {
-  failed: string[]
-  inProgress: string[]
-  pending: string[]
-}
-
 export interface RunBatchCommandInput {
   configPath: string
   cwd?: string
@@ -47,19 +39,7 @@ export interface RunBatchCommandResult {
   failedFiles: string[]
   processedFiles: string[]
   results: Record<string, unknown>
-  state: BatchState
-}
-
-function createEmptyState(): BatchState {
-  return {
-    failed: [],
-    inProgress: [],
-    pending: [],
-  }
-}
-
-function unique(items: string[]) {
-  return [...new Set(items)]
+  resultsFilePath: string
 }
 
 async function readJsonFileIfExists(filePath: string) {
@@ -72,14 +52,6 @@ async function readJsonFileIfExists(filePath: string) {
   return value
 }
 
-async function loadBatchState(filePath: string) {
-  const value = await readJsonFileIfExists(filePath)
-  if (value === null) {
-    return createEmptyState()
-  }
-  return parseWithSchema(batchStateSchema, value)
-}
-
 async function loadBatchResults(filePath: string) {
   const value = await readJsonFileIfExists(filePath)
   if (value === null) {
@@ -88,82 +60,16 @@ async function loadBatchResults(filePath: string) {
   return parseWithSchema(batchResultsSchema, value)
 }
 
-function mergeBatchState(input: {
-  discoveredFiles: string[]
-  results: Record<string, unknown>
-  state: BatchState
-}): BatchState {
-  const discovered = new Set(input.discoveredFiles)
-  const completed = new Set(Object.keys(input.results))
-  const failed = unique(input.state.failed).filter(
-    (filePath) => discovered.has(filePath) && !completed.has(filePath),
-  )
-  const failedSet = new Set(failed)
-  const pending = unique([
-    ...input.state.inProgress,
-    ...input.state.pending,
-  ]).filter(
-    (filePath) =>
-      discovered.has(filePath) &&
-      !completed.has(filePath) &&
-      !failedSet.has(filePath),
-  )
-  const pendingSet = new Set(pending)
-
-  for (const filePath of input.discoveredFiles) {
-    if (
-      completed.has(filePath) ||
-      failedSet.has(filePath) ||
-      pendingSet.has(filePath)
-    ) {
-      continue
-    }
-    pending.push(filePath)
-    pendingSet.add(filePath)
-  }
-
-  return {
-    failed,
-    inProgress: [],
-    pending,
-  }
-}
-
-function removeFile(items: string[], filePath: string) {
-  return items.filter((item) => item !== filePath)
-}
-
-function writeBatchFailure(filePath: string, error: unknown) {
-  process.stderr.write(
-    `[batch] failed ${filePath}: ${
-      error instanceof Error ? error.message : String(error)
-    }\n`,
-  )
-}
-
-async function recycleFailedFiles(
-  statePath: string,
-  state: BatchState,
-): Promise<BatchState> {
-  if (state.pending.length !== 0 || state.failed.length === 0) {
-    return state
-  }
-
-  const nextState: BatchState = {
-    failed: [],
-    inProgress: [],
-    pending: [...state.failed],
-  }
-  await writeJsonAtomic(statePath, nextState)
-  return nextState
-}
-
-function createProvider(config: BatchConfig): BatchStructuredOutputProvider {
+function createProvider(
+  config: BatchConfig,
+  verbose: boolean | undefined,
+): BatchStructuredOutputProvider {
   if (config.provider === 'codex') {
     return createBatchStructuredOutputProvider({
       provider: 'codex',
       ...(config.effort ? { effort: config.effort } : {}),
       ...(config.model ? { model: config.model } : {}),
+      ...(verbose === undefined ? {} : { verbose }),
       workspaceRoot: config.configDir,
     })
   }
@@ -172,10 +78,22 @@ function createProvider(config: BatchConfig): BatchStructuredOutputProvider {
     provider: 'claude',
     ...(config.effort ? { effort: config.effort } : {}),
     ...(config.model ? { model: config.model } : {}),
+    ...(verbose === undefined ? {} : { verbose }),
     workspaceRoot: config.configDir,
   })
 }
 
+function createOutputValidator(schema: Record<string, unknown>) {
+  const ajv = new Ajv({ strict: false })
+  const validate = ajv.compile(schema)
+  return (value: unknown) => {
+    if (validate(value)) {
+      return
+    }
+    throw new Error(ajv.errorsText(validate.errors))
+  }
+}
+
 export async function runBatchCommand(
   input: RunBatchCommandInput,
 ): Promise<RunBatchCommandResult> {
@@ -185,82 +103,68 @@ export async function runBatchCommand(
     cwd,
   })
 
-  const statePath = path.join(config.configDir, 'state.json')
   const resultsPath = path.join(config.configDir, 'results.json')
-  const excludedFiles = new Set([config.configPath, statePath, resultsPath])
+  const excludedFiles = new Set([config.configPath, resultsPath])
   const discoveredFiles = await discoverBatchFiles({
     baseDir: config.configDir,
     excludedFiles,
     patterns: config.glob,
   })
   const results = await loadBatchResults(resultsPath)
-  let state: BatchState = mergeBatchState({
-    discoveredFiles,
+  await writeJsonAtomic(resultsPath, results)
+
+  const provider = createProvider(config, input.verbose)
+  const validateOutput = createOutputValidator(config.schema)
+  const harnessDir = createRuntimePaths(config.configDir).runtimeDir
+  const store = createFsHarnessStore(harnessDir)
+  const protocol = 'batch'
+
+  const program = createBatchProgram({
+    configDir: config.configDir,
+    maxRetries: 3,
+    outputSchema: config.schema,
+    prompt: config.prompt,
+    provider,
     results,
-    state: await loadBatchState(statePath),
+    resultsPath,
+    validateOutput,
   })
-  await writeJsonAtomic(statePath, state)
-  await writeJsonAtomic(resultsPath, results)
-  const ajv = new Ajv({
-    allErrors: true,
-    strict: false,
+
+  const scheduler = createBatchRetryScheduler({
+    files: discoveredFiles,
+    protocol,
+    results,
+    store,
   })
-  const validateOutput = ajv.compile(config.schema)
-  const processedFiles: string[] = []
-  let provider: BatchStructuredOutputProvider | null = null
 
-  while (state.pending.length !== 0 || state.failed.length !== 0) {
-    if (state.pending.length === 0) {
-      state = await recycleFailedFiles(statePath, state)
-      continue
-    }
-    const filePath = state.pending[0]!
-    state = {
-      ...state,
-      inProgress: unique([...state.inProgress, filePath]),
-      pending: state.pending.slice(1),
-    }
-    await writeJsonAtomic(statePath, state)
+  const processedFiles: string[] = []
 
-    try {
-      provider ??= createProvider(config)
-      const absoluteFilePath = path.join(config.configDir, filePath)
-      const content = await readFile(absoluteFilePath, 'utf8')
-      const output = await provider.runFile({
-        content,
-        filePath,
-        outputSchema: config.schema,
-        prompt: config.prompt,
-      })
-      if (!validateOutput(output)) {
-        throw new Error(ajv.errorsText(validateOutput.errors))
-      }
-      results[filePath] = output
-      await writeJsonAtomic(resultsPath, results)
-      state = {
-        ...state,
-        inProgress: removeFile(state.inProgress, filePath),
-      }
-      await writeJsonAtomic(statePath, state)
-      processedFiles.push(filePath)
-    } catch (error) {
-      if (input.verbose) {
-        writeBatchFailure(filePath, error)
-      }
-      state = {
-        failed: unique([...state.failed, filePath]),
-        inProgress: removeFile(state.inProgress, filePath),
-        pending: state.pending,
-      }
-      await writeJsonAtomic(statePath, state)
+  for await (const event of runSession({
+    config: {},
+    scheduler,
+    kernel: {
+      run: (subjectId) =>
+        runKernel({
+          config: { prompt: config.prompt, schema: config.schema },
+          program,
+          protocol,
+          store,
+          subjectId,
+        }),
+    },
+  })) {
+    if (event.type === SessionEventType.SubjectDone) {
+      processedFiles.push(event.subjectId)
     }
   }
 
+  const sets = await scheduler.rebuild()
+
   return {
     config,
-    failedFiles: state.failed,
+    failedFiles: [...sets.blocked],
     processedFiles,
     results,
-    state,
+    resultsFilePath: resultsPath,
   }
 }

package/src/commands/run-branch-helpers.ts

@@ -0,0 +1,81 @@
+import type { GitPort } from '../core/runtime'
+import type { CodeHostPort } from '../ports/code-host'
+import type { TaskSourceSession } from '../task-sources/types'
+
+export const sleep = (ms: number) =>
+  new Promise<void>((resolve) => setTimeout(resolve, ms))
+
+export function toTaskBranchName(commitSubject: string) {
+  const slug = commitSubject
+    .replace(/^Task\s+/i, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  return `task/${slug}`
+}
+
+export async function ensureTaskBranch(
+  git: GitPort,
+  branchName: string,
+  restoreFromRemote: boolean,
+) {
+  const currentBranch = await git.getCurrentBranch()
+  if (currentBranch === branchName) {
+    return
+  }
+  try {
+    await git.checkoutBranch(branchName)
+  } catch {
+    if (restoreFromRemote) {
+      await git.checkoutRemoteBranch(branchName)
+      return
+    }
+    await git.checkoutBranch(branchName, {
+      create: true,
+      startPoint: 'main',
+    })
+  }
+}
+
+export async function runPrCheckpoint(
+  ports: { codeHost: CodeHostPort; git: GitPort },
+  taskSource: TaskSourceSession,
+  input: { iteration: number; subjectId: string },
+): Promise<{ checkpointStartedAt: string; prNumber: number }> {
+  const commitSubject = taskSource.buildCommitSubject(input.subjectId)
+  const branchName = toTaskBranchName(commitSubject)
+  const existingPr = await ports.codeHost.findOpenPullRequestByHeadBranch({
+    headBranch: branchName,
+  })
+
+  await ensureTaskBranch(ports.git, branchName, existingPr !== null)
+
+  const checkpointMessage = `checkpoint: ${commitSubject} (attempt ${input.iteration})`
+  const headSubject = await ports.git.getHeadSubject()
+  if (headSubject !== checkpointMessage) {
+    await ports.git.commitTask({ message: checkpointMessage })
+  }
+
+  await ports.git.pushBranch(branchName)
+
+  let pullRequest = existingPr
+  if (!pullRequest) {
+    pullRequest = await ports.codeHost.createPullRequest({
+      baseBranch: 'main',
+      body: `Task: ${commitSubject}\nManaged by task-while.`,
+      headBranch: branchName,
+      title: commitSubject,
+    })
+  }
+
+  const checkpointStartedAt = await ports.git.getHeadTimestamp()
+  return { checkpointStartedAt, prNumber: pullRequest.number }
+}
+
+export async function cleanupBranch(git: GitPort, branchName: string) {
+  try {
+    await git.checkoutBranch('main')
+    await git.pullFastForward('main')
+    await git.deleteLocalBranch(branchName)
+  } catch {}
+}