task-while 0.0.2 → 0.0.3

package/src/agents/event-log.ts

@@ -1,34 +1,179 @@
 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) {
-  const itemType =
+  if (
     event.type === 'item.completed' ||
     event.type === 'item.started' ||
     event.type === 'item.updated'
-      ? event.item.type
-      : null
-  process.stderr.write(
-    `[codex] ${event.type}${itemType ? ` ${itemType}` : ''}\n`,
-  )
-  if (
-    event.type === 'item.completed' &&
-    event.item.type === 'agent_message' &&
-    event.item.text?.trim()
   ) {
-    process.stderr.write(`[codex] message ${event.item.text.trim()}\n`)
+    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 ${event.message}\n`)
+    process.stderr.write(`[codex] error ${formatInline(event.message)}\n`)
+    return
   }
+
   if (event.type === 'turn.failed') {
-    process.stderr.write(`[codex] error ${event.error.message}\n`)
+    process.stderr.write(`[codex] error ${formatInline(event.error.message)}\n`)
   }
 }
 
 function writeClaudeEvent(event: ClaudeAgentEvent) {
-  const detail = event.type === 'text' ? ` ${event.delta}` : ''
-  process.stderr.write(`[claude] ${event.type}${detail}\n`)
+  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(

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/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,76 +60,6 @@ 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,
   verbose: boolean | undefined,
@@ -181,6 +83,17 @@ function createProvider(
   })
 }
 
+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> {
@@ -190,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, input.verbose)
-      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 {}
+}

package/src/commands/run-providers.ts

@@ -0,0 +1,77 @@
+import { createClaudeProvider } from '../agents/claude'
+import { createCodexProvider } from '../agents/codex'
+import {
+  createClaudeEventHandler,
+  createCodexEventHandler,
+} from '../agents/event-log'
+import { createCodexRemoteReviewerProvider } from '../workflow/remote-reviewer'
+
+import type {
+  ImplementerProvider,
+  RemoteReviewerProvider,
+  ReviewerProvider,
+} from '../agents/types'
+import type { WorkspaceContext } from '../types'
+import type { WorkflowProvider, WorkflowRoleConfig } from '../workflow/config'
+
+export type ProviderResolver = (
+  role: WorkflowRoleConfig,
+) => ImplementerProvider & ReviewerProvider
+
+export type RemoteReviewerResolver = (
+  providerName: WorkflowProvider,
+) => RemoteReviewerProvider
+
+export function createProviderResolver(
+  context: WorkspaceContext,
+  verbose: boolean | undefined,
+): ProviderResolver {
+  const cache = new Map<
+    WorkflowProvider,
+    ImplementerProvider & ReviewerProvider
+  >()
+  return (role: WorkflowRoleConfig) => {
+    const cached = cache.get(role.provider)
+    if (cached) {
+      return cached
+    }
+    let provider: ImplementerProvider & ReviewerProvider
+    if (role.provider === 'claude') {
+      const onEvent = createClaudeEventHandler(verbose)
+      provider = createClaudeProvider({
+        ...(role.effort ? { effort: role.effort } : {}),
+        ...(role.model ? { model: role.model } : {}),
+        workspaceRoot: context.workspaceRoot,
+        ...(onEvent ? { onEvent } : {}),
+      })
+    } else {
+      const onEvent = createCodexEventHandler(verbose)
+      provider = createCodexProvider({
+        ...(role.effort ? { effort: role.effort } : {}),
+        ...(role.model ? { model: role.model } : {}),
+        workspaceRoot: context.workspaceRoot,
+        ...(onEvent ? { onEvent } : {}),
+      })
+    }
+    cache.set(role.provider, provider)
+    return provider
+  }
+}
+
+export function createRemoteReviewerResolver(): RemoteReviewerResolver {
+  const cache = new Map<WorkflowProvider, RemoteReviewerProvider>()
+  return (providerName: WorkflowProvider) => {
+    const cached = cache.get(providerName)
+    if (cached) {
+      return cached
+    }
+    if (providerName === 'claude') {
+      throw new Error(
+        'claude remote reviewer is not implemented in pull-request mode',
+      )
+    }
+    const provider = createCodexRemoteReviewerProvider()
+    cache.set(providerName, provider)
+    return provider
+  }
+}