task-while 0.0.2 → 0.0.3

package/src/commands/run.ts

@@ -1,33 +1,16 @@
-import { createClaudeProvider } from '../agents/claude'
-import { createCodexProvider } from '../agents/codex'
-import {
-  createClaudeEventHandler,
-  createCodexEventHandler,
-} from '../agents/event-log'
+import { createFsHarnessStore } from '../adapters/fs/harness-store'
 import { providerOptionsEqual } from '../agents/provider-options'
-import { runWorkflow, type WorkflowRunResult } from '../core/orchestrator'
+import { createRuntimePorts } from '../core/create-runtime-ports'
 import { buildTaskTopology } from '../core/task-topology'
-import { createOrchestratorRuntime } from '../runtime/fs-runtime'
+import { runKernel } from '../harness/kernel'
+import { createRunDirectProgram } from '../programs/run-direct'
+import { createRunPrProgram } from '../programs/run-pr'
+import { createRuntimePaths } from '../runtime/path-layout'
+import { createRunGraphScheduler } from '../schedulers/scheduler'
+import { runSession } from '../session/session'
 import { openTaskSource } from '../task-sources/registry'
-import {
-  loadWorkflowConfig,
-  type WorkflowConfig,
-  type WorkflowProvider,
-  type WorkflowRoleConfig,
-} from '../workflow/config'
-import {
-  createDirectWorkflowPreset,
-  createPullRequestWorkflowPreset,
-  type WorkflowRuntime,
-} from '../workflow/preset'
-import { createCodexRemoteReviewerProvider } from '../workflow/remote-reviewer'
-
-import type {
-  ImplementerProvider,
-  RemoteReviewerProvider,
-  ReviewerProvider,
-  WorkflowRoleProviders,
-} from '../agents/types'
+import { loadWorkflowConfig, type WorkflowConfig } from '../workflow/config'
+
 import type { WorkspaceContext } from '../types'
 
 export interface RunCommandOptions {
@@ -36,110 +19,56 @@ export interface RunCommandOptions {
   verbose?: boolean
 }
 
-export type WorkflowExecutionRunner = () => Promise<WorkflowRunResult>
-
-export interface WorkflowExecution {
-  config: WorkflowConfig
-  execute: WorkflowExecutionRunner
-  workflow: WorkflowRuntime
-}
-
-export interface ResolveWorkflowRuntimeInput {
-  config: WorkflowConfig
-  context: WorkspaceContext
-  options: RunCommandOptions
+export interface RunCommandResult {
+  summary: {
+    blockedTasks: number
+    completedTasks: number
+    finalStatus: 'blocked' | 'completed' | 'in_progress' | 'replan_required'
+    replanTasks: number
+    totalTasks: number
+  }
 }
 
-export type ProviderResolver = (
-  role: WorkflowRoleConfig,
-) => ImplementerProvider & ReviewerProvider
+export async function runCommand(
+  context: WorkspaceContext,
+  options: RunCommandOptions = {},
+): Promise<RunCommandResult> {
+  const config =
+    options.config ?? (await loadWorkflowConfig(context.workspaceRoot))
 
-export type RemoteReviewerResolver = (
-  providerName: WorkflowProvider,
-) => RemoteReviewerProvider
+  const taskSource = await openTaskSource(config.task.source, {
+    featureDir: context.featureDir,
+    featureId: context.featureId,
+    workspaceRoot: context.workspaceRoot,
+  })
 
-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
-  }
-}
+  const ports = createRuntimePorts({
+    config,
+    context,
+    taskSource,
+    verbose: options.verbose,
+  })
 
-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
-  }
-}
+  await ports.git.requireCleanWorktree()
 
-function resolveWorkflowRuntime(
-  input: ResolveWorkflowRuntimeInput,
-): WorkflowRuntime {
-  const resolveProvider = createProviderResolver(
-    input.context,
-    input.options.verbose,
+  const topology = buildTaskTopology(
+    taskSource,
+    context.featureId,
+    config.task.maxIterations,
   )
-  const implementerRole = input.config.workflow.roles.implementer
-  const reviewerRole = input.config.workflow.roles.reviewer
-
-  if (input.config.workflow.mode === 'pull-request') {
-    const resolveRemoteReviewer = createRemoteReviewerResolver()
-    const reviewer = resolveRemoteReviewer(reviewerRole.provider)
-    const implementer = resolveProvider(implementerRole)
-    const roles: WorkflowRoleProviders = {
-      implementer,
-      reviewer,
-    }
-
-    return {
-      roles,
-      preset: createPullRequestWorkflowPreset({
-        reviewer,
-      }),
-    }
+
+  const isPullRequest = config.workflow.mode === 'pull-request'
+  const implementerRole = config.workflow.roles.implementer
+  const reviewerRole = config.workflow.roles.reviewer
+
+  if (isPullRequest && reviewerRole.provider === 'claude') {
+    throw new Error(
+      'claude remote reviewer is not implemented in pull-request mode',
+    )
   }
 
   if (
+    !isPullRequest &&
     implementerRole.provider === reviewerRole.provider &&
     !providerOptionsEqual(implementerRole, reviewerRole)
   ) {
@@ -148,71 +77,86 @@ function resolveWorkflowRuntime(
     )
   }
 
-  const implementer = resolveProvider(implementerRole)
-  const reviewer = resolveProvider(reviewerRole)
-  const roles: WorkflowRoleProviders = {
-    implementer,
-    reviewer,
-  }
+  const protocol = isPullRequest ? 'run-pr' : 'run-direct'
+  const store = createFsHarnessStore(
+    createRuntimePaths(context.featureDir).runtimeDir,
+  )
 
-  return {
-    roles,
-    preset: createDirectWorkflowPreset({
-      reviewer,
-    }),
-  }
-}
+  const implementer = ports.resolveAgent(implementerRole)
+  const reviewer = ports.resolveAgent(reviewerRole)
+
+  const program =
+    protocol === 'run-pr'
+      ? createRunPrProgram({
+          implementer,
+          maxIterations: config.task.maxIterations,
+          ports,
+          reviewer,
+          verifyCommands: config.verify.commands,
+          workspaceRoot: context.workspaceRoot,
+        })
+      : createRunDirectProgram({
+          implementer,
+          maxIterations: config.task.maxIterations,
+          ports,
+          reviewer,
+          verifyCommands: config.verify.commands,
+          workspaceRoot: context.workspaceRoot,
+        })
 
-export async function loadWorkflowExecution(
-  context: WorkspaceContext,
-  options: RunCommandOptions = {},
-): Promise<WorkflowExecution> {
-  const config =
-    options.config ?? (await loadWorkflowConfig(context.workspaceRoot))
-  const workflow = resolveWorkflowRuntime({
-    config,
-    context,
-    options,
-  })
-  const taskSource = await openTaskSource(config.task.source, {
-    featureDir: context.featureDir,
-    featureId: context.featureId,
-    workspaceRoot: context.workspaceRoot,
-  })
-  const runtime = createOrchestratorRuntime({
-    featureDir: context.featureDir,
-    taskSource,
-    workspaceRoot: context.workspaceRoot,
-  })
-  await runtime.git.requireCleanWorktree()
-  const graph = buildTaskTopology(
-    taskSource,
-    context.featureId,
-    config.task.maxIterations,
-  )
   const untilTaskHandle = options.untilTaskId
     ? taskSource.resolveTaskSelector(options.untilTaskId)
     : undefined
-  const workflowInput = {
-    graph,
-    runtime,
-    workflow,
+
+  const scheduler = createRunGraphScheduler({
+    protocol,
+    store,
+    graph: topology.tasks.map((t) => ({
+      dependsOn: t.dependsOn,
+      subjectId: t.handle,
+    })),
     ...(untilTaskHandle ? { untilTaskHandle } : {}),
+  })
+
+  for await (const event of runSession({
+    config: {},
+    scheduler,
+    kernel: {
+      run: (subjectId) =>
+        runKernel({
+          config: { verify: config.verify, workflow: config.workflow },
+          program,
+          protocol,
+          store,
+          subjectId,
+        }),
+    },
+  })) {
+    void event
   }
 
+  const sets = await scheduler.rebuild()
+  const totalTasks = topology.tasks.length
+  const completedTasks = sets.done.size
+  const blockedTasks = sets.blocked.size
+  const replanTasks = sets.replan.size
+
+  const finalStatus =
+    replanTasks > 0
+      ? ('replan_required' as const)
+      : blockedTasks > 0
+        ? ('blocked' as const)
+        : completedTasks === totalTasks
+          ? ('completed' as const)
+          : ('in_progress' as const)
+
   return {
-    config,
-    workflow,
-    async execute() {
-      return runWorkflow(workflowInput)
+    summary: {
+      blockedTasks,
+      completedTasks,
+      finalStatus,
+      replanTasks,
+      totalTasks,
     },
   }
 }
-
-export async function runCommand(
-  context: WorkspaceContext,
-  options: RunCommandOptions = {},
-) {
-  const execution = await loadWorkflowExecution(context, options)
-  return execution.execute()
-}

package/src/core/create-runtime-ports.ts

@@ -0,0 +1,118 @@
+import {
+  createClaudeProvider,
+  type ClaudeAgentClientOptions,
+} from '../agents/claude'
+import {
+  createCodexProvider,
+  type CodexAgentClientOptions,
+} from '../agents/codex'
+import {
+  createClaudeEventHandler,
+  createCodexEventHandler,
+} from '../agents/event-log'
+import { GitRuntime } from '../runtime/git'
+import { GitHubRuntime } from '../runtime/github'
+import { createRuntimePaths } from '../runtime/path-layout'
+
+import type { ImplementerProvider } from '../agents/types'
+import type { AgentPort } from '../ports/agent'
+import type { TaskSourceSession } from '../task-sources/types'
+import type { WorkspaceContext } from '../types'
+import type { WorkflowConfig } from '../workflow/config'
+import type { AgentRoleConfig, RuntimePorts } from './runtime'
+
+interface InvokeCapable {
+  invokeStructured: <T>(input: {
+    outputSchema: Record<string, unknown>
+    prompt: string
+  }) => Promise<T>
+}
+
+function hasInvokeStructured(
+  provider: ImplementerProvider,
+): provider is ImplementerProvider & InvokeCapable {
+  return (
+    'invokeStructured' in provider &&
+    typeof provider.invokeStructured === 'function'
+  )
+}
+
+export interface CreateRuntimePortsInput {
+  config: WorkflowConfig
+  context: WorkspaceContext
+  taskSource: TaskSourceSession
+  verbose?: boolean | undefined
+}
+
+export function createRuntimePorts(
+  input: CreateRuntimePortsInput,
+): RuntimePorts {
+  const { context, taskSource, verbose } = input
+  const runtimePaths = createRuntimePaths(context.featureDir)
+  const git = new GitRuntime(context.workspaceRoot, runtimePaths.runtimeDir)
+  const codeHost = new GitHubRuntime(context.workspaceRoot)
+  const agentCache = new Map<string, AgentPort>()
+
+  function resolveAgent(role: AgentRoleConfig): AgentPort {
+    const key = `${role.provider}:${role.model ?? ''}:${role.effort ?? ''}`
+    const cached = agentCache.get(key)
+    if (cached) {
+      return cached
+    }
+
+    let provider: ImplementerProvider
+    if (role.provider === 'claude') {
+      const onEvent = createClaudeEventHandler(verbose)
+      provider = createClaudeProvider({
+        ...(role.effort
+          ? {
+              effort: role.effort as NonNullable<
+                ClaudeAgentClientOptions['effort']
+              >,
+            }
+          : {}),
+        ...(role.model ? { model: role.model } : {}),
+        workspaceRoot: context.workspaceRoot,
+        ...(onEvent ? { onEvent } : {}),
+      })
+    } else {
+      const onEvent = createCodexEventHandler(verbose)
+      provider = createCodexProvider({
+        ...(role.effort
+          ? {
+              effort: role.effort as NonNullable<
+                CodexAgentClientOptions['effort']
+              >,
+            }
+          : {}),
+        ...(role.model ? { model: role.model } : {}),
+        workspaceRoot: context.workspaceRoot,
+        ...(onEvent ? { onEvent } : {}),
+      })
+    }
+
+    if (!hasInvokeStructured(provider)) {
+      throw new Error(
+        `Provider ${role.provider} does not support invokeStructured`,
+      )
+    }
+
+    const invoke = provider.invokeStructured.bind(provider)
+    const agent: AgentPort = {
+      name: provider.name,
+      async execute(invocation) {
+        return invoke(invocation)
+      },
+    }
+
+    agentCache.set(key, agent)
+    return agent
+  }
+
+  return {
+    codeHost,
+    git,
+    resolveAgent,
+    taskSource,
+  }
+}

package/src/core/runtime.ts

@@ -1,39 +1,6 @@
+import type { AgentPort } from '../ports/agent'
+import type { CodeHostPort } from '../ports/code-host'
 import type { TaskSourceSession } from '../task-sources/types'
-import type {
-  FinalReport,
-  ImplementArtifact,
-  IntegrateArtifact,
-  ReviewArtifact,
-  TaskGraph,
-  WorkflowEvent,
-  WorkflowState,
-} from '../types'
-
-export interface AttemptArtifactKey {
-  attempt: number
-  generation: number
-  taskHandle: string
-}
-
-export interface WorkflowStore {
-  appendEvent: (event: WorkflowEvent) => Promise<void>
-  loadGraph: () => Promise<null | TaskGraph>
-  loadImplementArtifact: (
-    key: AttemptArtifactKey,
-  ) => Promise<ImplementArtifact | null>
-  loadReviewArtifact: (
-    key: AttemptArtifactKey,
-  ) => Promise<null | ReviewArtifact>
-  loadState: () => Promise<null | WorkflowState>
-  readReport: () => Promise<FinalReport | null>
-  reset: () => Promise<void>
-  saveGraph: (graph: TaskGraph) => Promise<void>
-  saveImplementArtifact: (artifact: ImplementArtifact) => Promise<void>
-  saveIntegrateArtifact: (artifact: IntegrateArtifact) => Promise<void>
-  saveReport: (report: FinalReport) => Promise<void>
-  saveReviewArtifact: (artifact: ReviewArtifact) => Promise<void>
-  saveState: (state: WorkflowState) => Promise<void>
-}
 
 export interface GitCheckoutBranchOptions {
   create?: boolean
@@ -167,9 +134,21 @@ export interface SquashMergePullRequestInput {
   subject: string
 }
 
+export interface AgentRoleConfig {
+  effort?: string | undefined
+  model?: string | undefined
+  provider: 'claude' | 'codex'
+}
+
 export interface OrchestratorRuntime {
   git: GitPort
   github: GitHubPort
-  store: WorkflowStore
+  taskSource: TaskSourceSession
+}
+
+export interface RuntimePorts {
+  codeHost: CodeHostPort
+  git: GitPort
+  resolveAgent: (role: AgentRoleConfig) => AgentPort
   taskSource: TaskSourceSession
 }

package/src/harness/in-memory-store.ts

@@ -0,0 +1,45 @@
+import type { Artifact, TaskState, TransitionRecord } from './state'
+import type { HarnessStore } from './store'
+
+const storeKey = (protocol: string, subjectId: string) =>
+  `${protocol}:${subjectId}`
+
+export function createInMemoryHarnessStore(): HarnessStore {
+  const states = new Map<string, TaskState>()
+  const artifacts = new Map<string, Artifact>()
+  const transitions = new Map<string, TransitionRecord[]>()
+
+  return {
+    async appendTransition(protocol, subjectId, record) {
+      const k = storeKey(protocol, subjectId)
+      const list = transitions.get(k) ?? []
+      list.push(structuredClone(record))
+      transitions.set(k, list)
+    },
+    async listArtifacts(protocol, subjectId) {
+      const prefix = `${storeKey(protocol, subjectId)}:`
+      return [...artifacts.entries()]
+        .filter(([k]) => k.startsWith(prefix))
+        .map(([, v]) => structuredClone(v))
+    },
+    async loadArtifact(protocol, subjectId, artifactId) {
+      const artifact = artifacts.get(
+        `${storeKey(protocol, subjectId)}:${artifactId}`,
+      )
+      return artifact ? structuredClone(artifact) : null
+    },
+    async loadState(protocol, subjectId) {
+      const state = states.get(storeKey(protocol, subjectId))
+      return state ? structuredClone(state) : null
+    },
+    async saveArtifact(protocol, subjectId, artifact) {
+      artifacts.set(
+        `${storeKey(protocol, subjectId)}:${artifact.id}`,
+        structuredClone(artifact),
+      )
+    },
+    async saveState(protocol, subjectId, state) {
+      states.set(storeKey(protocol, subjectId), structuredClone(state))
+    },
+  }
+}