task-while 0.0.1

package/src/core/orchestrator-review-resume.ts

@@ -0,0 +1,228 @@
+import {
+  isPullRequestWorkflowPreset,
+  type WorkflowRuntime,
+} from '../workflow/preset'
+import {
+  recordCommitFailure,
+  recordIntegrateResult,
+  recordReviewApproved,
+  recordReviewFailure,
+  recordReviewResult,
+} from './engine'
+import { shouldPassZeroGate } from './engine-helpers'
+import {
+  appendEvent,
+  now,
+  persistCommittedArtifacts,
+  persistState,
+} from './orchestrator-helpers'
+
+import type {
+  FinalReport,
+  IntegrateArtifact,
+  ReviewArtifact,
+  TaskGraph,
+  WorkflowState,
+} from '../types'
+import type { OrchestratorRuntime } from './runtime'
+
+export interface ResumePullRequestReviewInput {
+  graph: TaskGraph
+  runtime: OrchestratorRuntime
+  state: WorkflowState
+  workflow: WorkflowRuntime
+}
+
+export interface ResumePullRequestReviewResult {
+  report: FinalReport
+  state: WorkflowState
+}
+
+export async function resumePullRequestReview(
+  input: ResumePullRequestReviewInput,
+): Promise<null | ResumePullRequestReviewResult> {
+  const preset = input.workflow.preset
+  if (!isPullRequestWorkflowPreset(preset) || !input.state.currentTaskHandle) {
+    return null
+  }
+
+  const taskHandle = input.state.currentTaskHandle
+  const taskState = input.state.tasks[taskHandle]
+  if (taskState?.status !== 'running' || taskState.stage !== 'review') {
+    return null
+  }
+
+  const artifactKey = {
+    attempt: taskState.attempt,
+    generation: taskState.generation,
+    taskHandle,
+  }
+  const implementArtifact =
+    await input.runtime.store.loadImplementArtifact(artifactKey)
+
+  if (!implementArtifact) {
+    const reason = `Cannot resume review for ${taskHandle} without a persisted implement artifact`
+    const nextState = recordReviewFailure(
+      input.graph,
+      input.state,
+      taskHandle,
+      reason,
+    )
+    await appendEvent(input.runtime, {
+      attempt: taskState.attempt,
+      detail: reason,
+      generation: taskState.generation,
+      taskHandle,
+      timestamp: now(),
+      type: 'review_failed',
+    })
+    const report = await persistState(input.runtime, input.graph, nextState)
+    return {
+      report,
+      state: nextState,
+    }
+  }
+
+  const commitMessage = input.runtime.taskSource.buildCommitSubject(taskHandle)
+  let review
+  let reviewPhaseKind: 'approved' | 'rejected'
+
+  try {
+    const completionCriteria =
+      await input.runtime.taskSource.getCompletionCriteria(taskHandle)
+    const reviewPhase = await preset.review({
+      attempt: taskState.attempt,
+      commitMessage,
+      completionCriteria,
+      runtime: input.runtime,
+      taskHandle,
+    })
+    reviewPhaseKind = reviewPhase.kind
+    review = reviewPhase.review
+    if (review.taskHandle !== taskHandle) {
+      throw new Error(
+        `Review taskHandle mismatch: expected ${taskHandle}, received ${review.taskHandle}`,
+      )
+    }
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error)
+    const nextState = recordReviewFailure(
+      input.graph,
+      input.state,
+      taskHandle,
+      reason,
+    )
+    await appendEvent(input.runtime, {
+      attempt: taskState.attempt,
+      detail: reason,
+      generation: taskState.generation,
+      taskHandle,
+      timestamp: now(),
+      type: 'review_failed',
+    })
+    const report = await persistState(input.runtime, input.graph, nextState)
+    return {
+      report,
+      state: nextState,
+    }
+  }
+
+  const reviewArtifact: ReviewArtifact = {
+    attempt: taskState.attempt,
+    createdAt: now(),
+    generation: taskState.generation,
+    result: review,
+    taskHandle,
+  }
+  await input.runtime.store.saveReviewArtifact(reviewArtifact)
+  await appendEvent(input.runtime, {
+    attempt: taskState.attempt,
+    detail: review.summary,
+    generation: taskState.generation,
+    taskHandle,
+    timestamp: now(),
+    type: 'review_completed',
+  })
+
+  if (reviewPhaseKind === 'approved' && shouldPassZeroGate({ review })) {
+    let nextState = recordReviewApproved(input.state, taskHandle, review)
+    await appendEvent(input.runtime, {
+      attempt: taskState.attempt,
+      generation: taskState.generation,
+      taskHandle,
+      timestamp: now(),
+      type: 'integrate_started',
+    })
+    let report = await persistState(input.runtime, input.graph, nextState)
+
+    let integrateResult
+    try {
+      integrateResult = await input.workflow.preset.integrate({
+        commitMessage,
+        runtime: input.runtime,
+        taskHandle,
+      })
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error)
+      nextState = recordCommitFailure(
+        input.graph,
+        nextState,
+        taskHandle,
+        reason,
+      )
+      await appendEvent(input.runtime, {
+        attempt: taskState.attempt,
+        detail: reason,
+        generation: taskState.generation,
+        taskHandle,
+        timestamp: now(),
+        type: 'integrate_failed',
+      })
+      report = await persistState(input.runtime, input.graph, nextState)
+      return {
+        report,
+        state: nextState,
+      }
+    }
+
+    const integrateArtifact: IntegrateArtifact = {
+      attempt: taskState.attempt,
+      createdAt: now(),
+      generation: taskState.generation,
+      result: integrateResult.result,
+      taskHandle,
+    }
+    nextState = recordIntegrateResult(input.graph, nextState, taskHandle, {
+      commitSha: integrateResult.result.commitSha,
+      review,
+    })
+    report = await persistState(input.runtime, input.graph, nextState)
+    await appendEvent(input.runtime, {
+      attempt: taskState.attempt,
+      detail: integrateResult.result.summary,
+      generation: taskState.generation,
+      taskHandle,
+      timestamp: now(),
+      type: 'integrate_completed',
+    })
+    await input.runtime.store.saveIntegrateArtifact(integrateArtifact)
+    await persistCommittedArtifacts(input.runtime, {
+      commitSha: integrateResult.result.commitSha,
+      implementArtifact,
+      reviewArtifact,
+    })
+    return {
+      report,
+      state: nextState,
+    }
+  }
+
+  const nextState = recordReviewResult(input.graph, input.state, taskHandle, {
+    review,
+  })
+  const report = await persistState(input.runtime, input.graph, nextState)
+  return {
+    report,
+    state: nextState,
+  }
+}

package/src/core/orchestrator-task-attempt.ts

@@ -0,0 +1,257 @@
+import {
+  recordCommitFailure,
+  recordImplementFailure,
+  recordImplementSuccess,
+  recordIntegrateResult,
+  recordReviewApproved,
+  recordReviewFailure,
+  recordReviewResult,
+  startAttempt,
+} from './engine'
+import { shouldPassZeroGate } from './engine-helpers'
+import {
+  appendEvent,
+  now,
+  persistCommittedArtifacts,
+  persistState,
+} from './orchestrator-helpers'
+
+import type {
+  FinalReport,
+  ImplementArtifact,
+  IntegrateArtifact,
+  ReviewArtifact,
+  TaskGraph,
+  WorkflowState,
+} from '../types'
+import type { ReviewPhaseResult, WorkflowRuntime } from '../workflow/preset'
+import type { OrchestratorRuntime } from './runtime'
+
+export interface ExecuteTaskAttemptInput {
+  graph: TaskGraph
+  runtime: OrchestratorRuntime
+  state: WorkflowState
+  taskHandle: string
+  workflow: WorkflowRuntime
+}
+
+export interface ExecuteTaskAttemptResult {
+  report: FinalReport
+  state: WorkflowState
+}
+
+export async function executeTaskAttempt(
+  input: ExecuteTaskAttemptInput,
+): Promise<ExecuteTaskAttemptResult> {
+  let state = startAttempt(input.graph, input.state, input.taskHandle)
+  await appendEvent(input.runtime, {
+    attempt: state.tasks[input.taskHandle]!.attempt,
+    generation: state.tasks[input.taskHandle]!.generation,
+    taskHandle: input.taskHandle,
+    timestamp: now(),
+    type: 'attempt_started',
+  })
+  let report = await persistState(input.runtime, input.graph, state)
+  const taskState = state.tasks[input.taskHandle]!
+  const taskHandle = input.taskHandle
+  const commitMessage = input.runtime.taskSource.buildCommitSubject(taskHandle)
+  let implementArtifact: ImplementArtifact | null = null
+  let reviewArtifact: null | ReviewArtifact = null
+  let implement
+  try {
+    const prompt = await input.runtime.taskSource.buildImplementPrompt({
+      attempt: taskState.attempt,
+      generation: taskState.generation,
+      lastFindings: taskState.lastFindings,
+      taskHandle,
+    })
+    implement = await input.workflow.roles.implementer.implement({
+      attempt: taskState.attempt,
+      generation: taskState.generation,
+      lastFindings: taskState.lastFindings,
+      prompt,
+      taskHandle,
+    })
+    if (implement.taskHandle !== taskHandle) {
+      throw new Error(
+        `Implement taskHandle mismatch: expected ${taskHandle}, received ${implement.taskHandle}`,
+      )
+    }
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error)
+    state = recordImplementFailure(input.graph, state, input.taskHandle, reason)
+    await appendEvent(input.runtime, {
+      attempt: taskState.attempt,
+      detail: reason,
+      generation: taskState.generation,
+      taskHandle: input.taskHandle,
+      timestamp: now(),
+      type: 'implement_failed',
+    })
+    report = await persistState(input.runtime, input.graph, state)
+    return { report, state }
+  }
+  implementArtifact = {
+    attempt: taskState.attempt,
+    createdAt: now(),
+    generation: taskState.generation,
+    result: implement,
+    taskHandle,
+  }
+  await input.runtime.store.saveImplementArtifact(implementArtifact)
+  state = recordImplementSuccess(state, input.taskHandle)
+  await appendEvent(input.runtime, {
+    attempt: taskState.attempt,
+    generation: taskState.generation,
+    taskHandle: input.taskHandle,
+    timestamp: now(),
+    type: 'implement_succeeded',
+  })
+  await appendEvent(input.runtime, {
+    attempt: taskState.attempt,
+    generation: taskState.generation,
+    taskHandle: input.taskHandle,
+    timestamp: now(),
+    type: 'review_started',
+  })
+  report = await persistState(input.runtime, input.graph, state)
+  let review
+  let reviewPhaseKind: 'approved' | 'rejected'
+  try {
+    let reviewPhase: ReviewPhaseResult
+    if (input.workflow.preset.mode === 'direct') {
+      const actualChangedFiles =
+        await input.runtime.git.getChangedFilesSinceHead()
+      const prompt = await input.runtime.taskSource.buildReviewPrompt({
+        actualChangedFiles,
+        attempt: taskState.attempt,
+        generation: taskState.generation,
+        implement,
+        lastFindings: taskState.lastFindings,
+        taskHandle,
+      })
+      reviewPhase = await input.workflow.preset.review({
+        actualChangedFiles,
+        attempt: taskState.attempt,
+        commitMessage,
+        generation: taskState.generation,
+        implement,
+        lastFindings: taskState.lastFindings,
+        prompt,
+        taskHandle,
+      })
+    } else {
+      const completionCriteria =
+        await input.runtime.taskSource.getCompletionCriteria(taskHandle)
+      reviewPhase = await input.workflow.preset.review({
+        attempt: taskState.attempt,
+        commitMessage,
+        completionCriteria,
+        runtime: input.runtime,
+        taskHandle,
+      })
+    }
+    reviewPhaseKind = reviewPhase.kind
+    review = reviewPhase.review
+    if (review.taskHandle !== taskHandle) {
+      throw new Error(
+        `Review taskHandle mismatch: expected ${taskHandle}, received ${review.taskHandle}`,
+      )
+    }
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error)
+    state = recordReviewFailure(input.graph, state, input.taskHandle, reason)
+    await appendEvent(input.runtime, {
+      attempt: taskState.attempt,
+      detail: reason,
+      generation: taskState.generation,
+      taskHandle: input.taskHandle,
+      timestamp: now(),
+      type: 'review_failed',
+    })
+    report = await persistState(input.runtime, input.graph, state)
+    return { report, state }
+  }
+  reviewArtifact = {
+    attempt: taskState.attempt,
+    createdAt: now(),
+    generation: taskState.generation,
+    result: review,
+    taskHandle,
+  }
+  await input.runtime.store.saveReviewArtifact(reviewArtifact)
+  await appendEvent(input.runtime, {
+    attempt: taskState.attempt,
+    detail: review.summary,
+    generation: taskState.generation,
+    taskHandle: input.taskHandle,
+    timestamp: now(),
+    type: 'review_completed',
+  })
+
+  if (reviewPhaseKind === 'approved' && shouldPassZeroGate({ review })) {
+    state = recordReviewApproved(state, input.taskHandle, review)
+    await appendEvent(input.runtime, {
+      attempt: taskState.attempt,
+      generation: taskState.generation,
+      taskHandle: input.taskHandle,
+      timestamp: now(),
+      type: 'integrate_started',
+    })
+    report = await persistState(input.runtime, input.graph, state)
+
+    let integrateResult
+    try {
+      integrateResult = await input.workflow.preset.integrate({
+        commitMessage,
+        runtime: input.runtime,
+        taskHandle,
+      })
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error)
+      state = recordCommitFailure(input.graph, state, input.taskHandle, reason)
+      await appendEvent(input.runtime, {
+        attempt: taskState.attempt,
+        detail: reason,
+        generation: taskState.generation,
+        taskHandle: input.taskHandle,
+        timestamp: now(),
+        type: 'integrate_failed',
+      })
+      report = await persistState(input.runtime, input.graph, state)
+      return { report, state }
+    }
+    const integrateArtifact: IntegrateArtifact = {
+      attempt: taskState.attempt,
+      createdAt: now(),
+      generation: taskState.generation,
+      result: integrateResult.result,
+      taskHandle,
+    }
+    state = recordIntegrateResult(input.graph, state, taskHandle, {
+      commitSha: integrateResult.result.commitSha,
+      review,
+    })
+    report = await persistState(input.runtime, input.graph, state)
+    await appendEvent(input.runtime, {
+      attempt: taskState.attempt,
+      detail: integrateResult.result.summary,
+      generation: taskState.generation,
+      taskHandle: input.taskHandle,
+      timestamp: now(),
+      type: 'integrate_completed',
+    })
+    await input.runtime.store.saveIntegrateArtifact(integrateArtifact)
+    await persistCommittedArtifacts(input.runtime, {
+      commitSha: integrateResult.result.commitSha,
+      implementArtifact,
+      reviewArtifact,
+    })
+    return { report, state }
+  }
+  state = recordReviewResult(input.graph, state, input.taskHandle, {
+    review,
+  })
+  report = await persistState(input.runtime, input.graph, state)
+  return { report, state }
+}

package/src/core/orchestrator.ts

@@ -0,0 +1,99 @@
+import {
+  alignStateWithGraph,
+  createInitialWorkflowState,
+  selectNextRunnableTask,
+} from './engine'
+import { persistState } from './orchestrator-helpers'
+import { resumePullRequestIntegrate } from './orchestrator-integrate-resume'
+import { resumePullRequestReview } from './orchestrator-review-resume'
+import { executeTaskAttempt } from './orchestrator-task-attempt'
+
+import type { FinalReport, TaskGraph, WorkflowState } from '../types'
+import type { WorkflowRuntime } from '../workflow/preset'
+import type { OrchestratorRuntime } from './runtime'
+
+export interface WorkflowRunResult {
+  state: WorkflowState
+  summary: FinalReport['summary']
+}
+
+export interface RunWorkflowInput {
+  graph: TaskGraph
+  runtime: OrchestratorRuntime
+  untilTaskHandle?: string
+  workflow: WorkflowRuntime
+}
+
+export async function runWorkflow(
+  input: RunWorkflowInput,
+): Promise<WorkflowRunResult> {
+  const workflow = input.workflow
+  const isPullRequestMode = workflow.preset.mode === 'pull-request'
+  await input.runtime.store.saveGraph(input.graph)
+  const storedState = await input.runtime.store.loadState()
+  let state = alignStateWithGraph(
+    input.graph,
+    storedState ?? createInitialWorkflowState(input.graph),
+    {
+      preserveRunningIntegrate: isPullRequestMode,
+      preserveRunningReview: isPullRequestMode,
+    },
+  )
+  let report = await persistState(input.runtime, input.graph, state)
+
+  while (
+    report.summary.finalStatus !== 'blocked' &&
+    report.summary.finalStatus !== 'replan_required'
+  ) {
+    if (
+      input.untilTaskHandle &&
+      state.tasks[input.untilTaskHandle]?.status === 'done'
+    ) {
+      break
+    }
+
+    const resumedIntegrate = await resumePullRequestIntegrate({
+      graph: input.graph,
+      runtime: input.runtime,
+      state,
+      workflow,
+    })
+    if (resumedIntegrate) {
+      report = resumedIntegrate.report
+      state = resumedIntegrate.state
+      continue
+    }
+
+    const resumedReview = await resumePullRequestReview({
+      graph: input.graph,
+      runtime: input.runtime,
+      state,
+      workflow,
+    })
+    if (resumedReview) {
+      report = resumedReview.report
+      state = resumedReview.state
+      continue
+    }
+
+    const task = selectNextRunnableTask(input.graph, state)
+    if (!task) {
+      break
+    }
+
+    const next = await executeTaskAttempt({
+      graph: input.graph,
+      runtime: input.runtime,
+      state,
+      taskHandle: task,
+      workflow,
+    })
+    report = next.report
+    state = next.state
+  }
+
+  return {
+    state,
+    summary: report.summary,
+  }
+}