task-while 0.0.1 → 0.0.2

package/README.md

@@ -163,7 +163,7 @@ Batch behavior:
 - execution state is written beside the YAML file in `state.json`
 - structured results are written beside the YAML file in `results.json`
 - result keys are relative to the directory that contains `batch.yaml`
-- `--verbose` prints per-file failure reasons to `stderr`
+- `--verbose` streams provider agent events to `stderr` during batch execution
 - rerunning the command resumes unfinished work and skips files that already have accepted results
 - when the current `pending` queue is exhausted and `failed` is non-empty, the command persists a recycle transition that moves `failed` back into `pending` for the next round
 - the command exits only when both `pending` and `failed` are empty

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-while",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "packageManager": "pnpm@10.32.1",
   "description": "Git-first task orchestrator for task-source workspaces",
   "author": "Zhang Yu",

package/src/agents/event-log.ts

@@ -0,0 +1,50 @@
+import type { ClaudeAgentEvent, ClaudeAgentEventHandler } from './claude'
+import type { CodexThreadEvent, CodexThreadEventHandler } from './codex'
+
+function writeCodexEvent(event: CodexThreadEvent) {
+  const itemType =
+    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`)
+  }
+  if (event.type === 'error') {
+    process.stderr.write(`[codex] error ${event.message}\n`)
+  }
+  if (event.type === 'turn.failed') {
+    process.stderr.write(`[codex] error ${event.error.message}\n`)
+  }
+}
+
+function writeClaudeEvent(event: ClaudeAgentEvent) {
+  const detail = event.type === 'text' ? ` ${event.delta}` : ''
+  process.stderr.write(`[claude] ${event.type}${detail}\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/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

@@ -158,12 +158,16 @@ async function recycleFailedFiles(
   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,6 +176,7 @@ function createProvider(config: BatchConfig): BatchStructuredOutputProvider {
     provider: 'claude',
     ...(config.effort ? { effort: config.effort } : {}),
     ...(config.model ? { model: config.model } : {}),
+    ...(verbose === undefined ? {} : { verbose }),
     workspaceRoot: config.configDir,
   })
 }
@@ -223,7 +228,7 @@ export async function runBatchCommand(
     await writeJsonAtomic(statePath, state)
 
     try {
-      provider ??= createProvider(config)
+      provider ??= createProvider(config, input.verbose)
       const absoluteFilePath = path.join(config.configDir, filePath)
       const content = await readFile(absoluteFilePath, 'utf8')
       const output = await provider.runFile({

package/src/commands/run.ts

@@ -1,13 +1,9 @@
+import { createClaudeProvider } from '../agents/claude'
+import { createCodexProvider } from '../agents/codex'
 import {
-  createClaudeProvider,
-  type ClaudeAgentEvent,
-  type ClaudeAgentEventHandler,
-} from '../agents/claude'
-import {
-  createCodexProvider,
-  type CodexThreadEvent,
-  type CodexThreadEventHandler,
-} from '../agents/codex'
+  createClaudeEventHandler,
+  createCodexEventHandler,
+} from '../agents/event-log'
 import { providerOptionsEqual } from '../agents/provider-options'
 import { runWorkflow, type WorkflowRunResult } from '../core/orchestrator'
 import { buildTaskTopology } from '../core/task-topology'
@@ -62,54 +58,6 @@ export type RemoteReviewerResolver = (
   providerName: WorkflowProvider,
 ) => RemoteReviewerProvider
 
-function writeCodexEvent(event: CodexThreadEvent) {
-  const itemType =
-    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`)
-  }
-  if (event.type === 'error') {
-    process.stderr.write(`[codex] error ${event.message}\n`)
-  }
-  if (event.type === 'turn.failed') {
-    process.stderr.write(`[codex] error ${event.error.message}\n`)
-  }
-}
-
-function createCodexEventHandler(
-  verbose: boolean | undefined,
-): CodexThreadEventHandler | undefined {
-  if (!verbose) {
-    return undefined
-  }
-  return writeCodexEvent
-}
-
-function writeClaudeEvent(event: ClaudeAgentEvent) {
-  const detail = event.type === 'text' ? ` ${event.delta}` : ''
-  process.stderr.write(`[claude] ${event.type}${detail}\n`)
-}
-
-function createClaudeEventHandler(
-  verbose: boolean | undefined,
-): ClaudeAgentEventHandler | undefined {
-  if (!verbose) {
-    return undefined
-  }
-  return writeClaudeEvent
-}
-
 function createProviderResolver(
   context: WorkspaceContext,
   verbose: boolean | undefined,