task-while 0.0.2 → 0.0.3

package/src/programs/shared-steps.ts

@@ -0,0 +1,252 @@
+import { execa } from 'execa'
+
+import { buildImplementerPrompt } from '../prompts/implementer'
+import { buildReviewerPrompt } from '../prompts/reviewer'
+import {
+  implementOutputSchema,
+  reviewOutputSchema,
+  validateImplementOutput,
+  validateReviewOutput,
+} from '../schema'
+
+import type { GitPort } from '../core/runtime'
+import type { Artifact } from '../harness/state'
+import type { AgentPort } from '../ports/agent'
+import type { TaskSourceSession } from '../task-sources/types'
+import type { ImplementOutput, ReviewFinding } from '../types'
+
+export interface TaskPrompt {
+  instructions: string[]
+  sections: { content: string; title: string }[]
+}
+
+export interface ContractPayload {
+  completionCriteria: string[]
+  prompt: TaskPrompt
+}
+
+export type ImplementPayload = ImplementOutput
+
+export interface IntegratePayload {
+  commitSha: string
+}
+
+export interface ReviewPayload {
+  findings: ReviewFinding[]
+  summary: string
+  verdict: string
+}
+
+export interface VerifyPayload {
+  checks: {
+    command: string
+    durationMs: number
+    exitCode: number
+    signal: null | string
+  }[]
+}
+
+export interface RuntimePorts {
+  git: GitPort
+  taskSource: TaskSourceSession
+}
+
+export interface SharedSteps {
+  contract: (
+    subjectId: string,
+    input: { attempt: number; lastFindings: ReviewFinding[] },
+  ) => Promise<Artifact<ContractPayload>>
+  implement: (
+    subjectId: string,
+    input: {
+      attempt: number
+      lastFindings: ReviewFinding[]
+      prompt: TaskPrompt
+    },
+  ) => Promise<Artifact<ImplementPayload>>
+  integrate: (subjectId: string) => Promise<Artifact<IntegratePayload>>
+  review: (
+    subjectId: string,
+    input: {
+      attempt: number
+      implement: ImplementPayload
+      lastFindings: ReviewFinding[]
+    },
+  ) => Promise<Artifact<ReviewPayload>>
+  verify: (subjectId: string) => Promise<Artifact<VerifyPayload>>
+}
+
+function makeArtifact<T>(
+  kind: string,
+  subjectId: string,
+  payload: T,
+): Artifact<T> {
+  return {
+    id: `${kind}-${subjectId}-${Date.now()}`,
+    kind,
+    payload,
+    subjectId,
+    timestamp: new Date().toISOString(),
+  }
+}
+
+export function createSharedSteps(deps: {
+  artifactKinds: {
+    contract: string
+    implementation: string
+    integrateResult: string
+    reviewResult: string
+    verifyResult: string
+  }
+  implementer: AgentPort
+  ports: RuntimePorts
+  reviewer: AgentPort
+  verifyCommands: string[]
+  workspaceRoot: string
+}): SharedSteps {
+  const {
+    artifactKinds,
+    implementer,
+    ports,
+    reviewer,
+    verifyCommands,
+    workspaceRoot,
+  } = deps
+
+  return {
+    async contract(subjectId, input) {
+      const prompt = await ports.taskSource.buildImplementPrompt({
+        attempt: input.attempt,
+        generation: 1,
+        lastFindings: input.lastFindings,
+        taskHandle: subjectId,
+      })
+      const completionCriteria =
+        await ports.taskSource.getCompletionCriteria(subjectId)
+      const payload: ContractPayload = {
+        completionCriteria,
+        prompt: {
+          instructions: prompt.instructions,
+          sections: prompt.sections,
+        },
+      }
+      return makeArtifact(artifactKinds.contract, subjectId, payload)
+    },
+
+    async implement(subjectId, input) {
+      const promptText = await buildImplementerPrompt({
+        attempt: input.attempt,
+        generation: 1,
+        lastFindings: input.lastFindings,
+        prompt: input.prompt,
+        taskHandle: subjectId,
+      })
+      const raw = await implementer.execute({
+        outputSchema: implementOutputSchema,
+        prompt: promptText,
+        role: 'implementer',
+      })
+      const validated = validateImplementOutput(raw)
+      return makeArtifact(artifactKinds.implementation, subjectId, validated)
+    },
+
+    async integrate(subjectId) {
+      const message = ports.taskSource.buildCommitSubject(subjectId)
+      const alreadyDone = await ports.taskSource.isTaskCompleted(subjectId)
+      if (!alreadyDone) {
+        await ports.taskSource.applyTaskCompletion(subjectId)
+      }
+      try {
+        const result = await ports.git.commitTask({ message })
+        return makeArtifact(artifactKinds.integrateResult, subjectId, {
+          commitSha: result.commitSha,
+        })
+      } catch (error) {
+        if (!alreadyDone) {
+          try {
+            await ports.taskSource.revertTaskCompletion(subjectId)
+          } catch {
+            // revert best-effort
+          }
+        }
+        throw error
+      }
+    },
+
+    async review(subjectId, input) {
+      const changedFiles = await ports.git.getChangedFilesSinceHead()
+      const implementOutput: ImplementOutput = {
+        assumptions: input.implement.assumptions,
+        needsHumanAttention: input.implement.needsHumanAttention,
+        notes: input.implement.notes,
+        status: input.implement.status,
+        summary: input.implement.summary,
+        taskHandle: subjectId,
+        unresolvedItems: input.implement.unresolvedItems,
+      }
+      const prompt = await ports.taskSource.buildReviewPrompt({
+        actualChangedFiles: changedFiles,
+        attempt: input.attempt,
+        generation: 1,
+        implement: implementOutput,
+        lastFindings: input.lastFindings,
+        taskHandle: subjectId,
+      })
+      const promptText = await buildReviewerPrompt({
+        actualChangedFiles: changedFiles,
+        attempt: input.attempt,
+        generation: 1,
+        implement: implementOutput,
+        lastFindings: input.lastFindings,
+        prompt,
+        taskHandle: subjectId,
+      })
+      const raw = await reviewer.execute({
+        outputSchema: reviewOutputSchema,
+        prompt: promptText,
+        role: 'reviewer',
+      })
+      const validated = validateReviewOutput(raw)
+      const verdict =
+        validated.verdict === 'pass'
+          ? 'approved'
+          : validated.verdict === 'blocked'
+            ? 'replan_required'
+            : 'rejected'
+      const payload: ReviewPayload = {
+        findings: validated.findings,
+        summary: validated.summary,
+        verdict,
+      }
+      return makeArtifact(artifactKinds.reviewResult, subjectId, payload)
+    },
+
+    async verify(subjectId) {
+      const checks: VerifyPayload['checks'] = []
+      for (const command of verifyCommands) {
+        const start = Date.now()
+        try {
+          const result = await execa(command, {
+            cwd: workspaceRoot,
+            reject: false,
+            shell: true,
+          })
+          checks.push({
+            command,
+            durationMs: Date.now() - start,
+            exitCode: result.exitCode,
+            signal: result.signal ?? null,
+          })
+        } catch {
+          checks.push({
+            command,
+            durationMs: Date.now() - start,
+            exitCode: 1,
+            signal: null,
+          })
+        }
+      }
+      return makeArtifact(artifactKinds.verifyResult, subjectId, { checks })
+    },
+  }
+}

package/src/schedulers/scheduler.ts

@@ -0,0 +1,208 @@
+import { TaskStatus } from '../harness/state'
+
+import type { HarnessStore } from '../harness/store'
+
+export interface ScheduledSubject {
+  resumeFromSuspended?: boolean
+  subjectId: string
+}
+
+export interface Scheduler {
+  markBlocked: (subjectId: string) => Promise<void>
+  markDone: (subjectId: string) => Promise<void>
+  markSuspended: (subjectId: string) => Promise<void>
+  next: () => Promise<null | ScheduledSubject>
+  rebuild: () => Promise<{
+    blocked: Set<string>
+    done: Set<string>
+    replan: Set<string>
+    suspended: Set<string>
+  }>
+}
+
+export function createRunGraphScheduler(input: {
+  graph: { dependsOn: string[]; subjectId: string }[]
+  protocol: string
+  store: HarnessStore
+  untilTaskHandle?: string
+}): Scheduler {
+  const done = new Set<string>()
+  const blocked = new Set<string>()
+  const replan = new Set<string>()
+  const suspended = new Set<string>()
+  const deferred = new Set<string>()
+
+  return {
+    async markBlocked(subjectId: string) {
+      deferred.delete(subjectId)
+      blocked.add(subjectId)
+    },
+
+    async markDone(subjectId: string) {
+      deferred.delete(subjectId)
+      done.add(subjectId)
+    },
+
+    async markSuspended(subjectId: string) {
+      suspended.add(subjectId)
+    },
+
+    async next() {
+      if (input.untilTaskHandle && done.has(input.untilTaskHandle)) {
+        return null
+      }
+
+      for (const node of input.graph) {
+        if (done.has(node.subjectId)) {
+          continue
+        }
+        if (blocked.has(node.subjectId)) {
+          continue
+        }
+        if (suspended.has(node.subjectId)) {
+          continue
+        }
+        if (deferred.has(node.subjectId)) {
+          continue
+        }
+        if (node.dependsOn.every((dep) => done.has(dep))) {
+          return { subjectId: node.subjectId }
+        }
+      }
+
+      const deferredSubject = deferred.values().next()
+      if (!deferredSubject.done) {
+        deferred.delete(deferredSubject.value)
+        return {
+          resumeFromSuspended: true,
+          subjectId: deferredSubject.value,
+        }
+      }
+
+      return null
+    },
+
+    async rebuild() {
+      done.clear()
+      blocked.clear()
+      suspended.clear()
+      deferred.clear()
+      replan.clear()
+
+      for (const node of input.graph) {
+        const state = await input.store.loadState(
+          input.protocol,
+          node.subjectId,
+        )
+        if (!state) {
+          continue
+        }
+        if (state.status === TaskStatus.Done) {
+          done.add(node.subjectId)
+        } else if (state.status === TaskStatus.Blocked) {
+          blocked.add(node.subjectId)
+        } else if (state.status === TaskStatus.Replan) {
+          replan.add(node.subjectId)
+        } else if (state.status === TaskStatus.Suspended) {
+          suspended.add(node.subjectId)
+          deferred.add(node.subjectId)
+        }
+      }
+
+      return {
+        blocked: new Set(blocked),
+        done: new Set(done),
+        replan: new Set(replan),
+        suspended: new Set(suspended),
+      }
+    },
+  }
+}
+
+export function createBatchRetryScheduler(input: {
+  files: string[]
+  protocol: string
+  results: Record<string, unknown>
+  store: HarnessStore
+}): Scheduler {
+  const queue: { resumeFromSuspended: boolean; subjectId: string }[] = []
+  const done = new Set<string>()
+  const blocked = new Set<string>()
+  const replan = new Set<string>()
+  const suspended = new Set<string>()
+
+  return {
+    async markBlocked(subjectId: string) {
+      const idx = queue.findIndex((item) => item.subjectId === subjectId)
+      if (idx !== -1) {
+        queue.splice(idx, 1)
+      }
+      blocked.add(subjectId)
+    },
+
+    async markDone(subjectId: string) {
+      const idx = queue.findIndex((item) => item.subjectId === subjectId)
+      if (idx !== -1) {
+        queue.splice(idx, 1)
+      }
+      done.add(subjectId)
+    },
+
+    async markSuspended(subjectId: string) {
+      const idx = queue.findIndex((item) => item.subjectId === subjectId)
+      if (idx !== -1) {
+        queue.splice(idx, 1)
+      }
+      suspended.add(subjectId)
+      queue.push({ resumeFromSuspended: true, subjectId })
+    },
+
+    async next() {
+      if (queue.length === 0) {
+        return null
+      }
+      return queue[0]!
+    },
+
+    async rebuild() {
+      queue.length = 0
+      done.clear()
+      blocked.clear()
+      replan.clear()
+      suspended.clear()
+
+      for (const file of input.files) {
+        if (file in input.results) {
+          done.add(file)
+          continue
+        }
+
+        const state = await input.store.loadState(input.protocol, file)
+        if (!state) {
+          queue.push({ resumeFromSuspended: false, subjectId: file })
+          continue
+        }
+
+        if (state.status === TaskStatus.Done) {
+          done.add(file)
+        } else if (state.status === TaskStatus.Blocked) {
+          blocked.add(file)
+        } else if (state.status === TaskStatus.Replan) {
+          replan.add(file)
+        } else if (state.status === TaskStatus.Suspended) {
+          suspended.add(file)
+          queue.push({ resumeFromSuspended: true, subjectId: file })
+        } else {
+          queue.push({ resumeFromSuspended: false, subjectId: file })
+        }
+      }
+
+      return {
+        blocked: new Set(blocked),
+        done: new Set(done),
+        replan: new Set(replan),
+        suspended: new Set(suspended),
+      }
+    },
+  }
+}

package/src/session/session.ts

@@ -0,0 +1,127 @@
+import { TaskStatus } from '../harness/state'
+
+import type { KernelResult } from '../harness/kernel'
+import type { Scheduler } from '../schedulers/scheduler'
+
+export enum SessionEventType {
+  SessionDone = 'session.done',
+  SessionFailed = 'session.failed',
+  SessionStarted = 'session.started',
+  SubjectBlocked = 'subject.blocked',
+  SubjectDone = 'subject.done',
+  SubjectResumed = 'subject.resumed',
+  SubjectStarted = 'subject.started',
+  SubjectSuspended = 'subject.suspended',
+}
+
+export interface SessionEvent {
+  detail: unknown
+  subjectId: string
+  timestamp: string
+  type: SessionEventType
+}
+
+export interface SessionProgress {
+  blocked: number
+  completed: number
+  suspended: number
+  total: number
+}
+
+export async function* runSession(input: {
+  concurrency?: number
+  config: Record<string, unknown>
+  kernel: { run: (subjectId: string) => Promise<KernelResult> }
+  scheduler: Scheduler
+}): AsyncGenerator<SessionEvent> {
+  const { kernel, scheduler } = input
+
+  const sets = await scheduler.rebuild()
+
+  const progress: SessionProgress = {
+    blocked: sets.blocked.size,
+    completed: sets.done.size,
+    suspended: sets.suspended.size,
+    total: 0,
+  }
+
+  yield {
+    detail: { progress },
+    subjectId: '',
+    timestamp: new Date().toISOString(),
+    type: SessionEventType.SessionStarted,
+  }
+
+  try {
+    for (;;) {
+      const scheduled = await scheduler.next()
+      if (!scheduled) {
+        break
+      }
+
+      const { subjectId } = scheduled
+
+      if (scheduled.resumeFromSuspended) {
+        yield {
+          detail: null,
+          subjectId,
+          timestamp: new Date().toISOString(),
+          type: SessionEventType.SubjectResumed,
+        }
+      } else {
+        yield {
+          detail: null,
+          subjectId,
+          timestamp: new Date().toISOString(),
+          type: SessionEventType.SubjectStarted,
+        }
+      }
+
+      const result: KernelResult = await kernel.run(subjectId)
+
+      if (result.status === TaskStatus.Done) {
+        await scheduler.markDone(subjectId)
+        yield {
+          detail: null,
+          subjectId,
+          timestamp: new Date().toISOString(),
+          type: SessionEventType.SubjectDone,
+        }
+      } else if (result.status === TaskStatus.Suspended) {
+        await scheduler.markSuspended(subjectId)
+        yield {
+          detail: null,
+          subjectId,
+          timestamp: new Date().toISOString(),
+          type: SessionEventType.SubjectSuspended,
+        }
+      } else if (
+        result.status === TaskStatus.Blocked ||
+        result.status === TaskStatus.Replan
+      ) {
+        await scheduler.markBlocked(subjectId)
+        yield {
+          detail: null,
+          subjectId,
+          timestamp: new Date().toISOString(),
+          type: SessionEventType.SubjectBlocked,
+        }
+      }
+    }
+
+    yield {
+      detail: null,
+      subjectId: '',
+      timestamp: new Date().toISOString(),
+      type: SessionEventType.SessionDone,
+    }
+  } catch (error) {
+    yield {
+      detail: { error },
+      subjectId: '',
+      timestamp: new Date().toISOString(),
+      type: SessionEventType.SessionFailed,
+    }
+    throw error
+  }
+}

package/src/workflow/config.ts

@@ -58,9 +58,16 @@ const taskConfigSchema = z
   })
   .strict()
 
+const verifyConfigSchema = z
+  .object({
+    commands: z.array(z.string().trim().min(1)).default([]),
+  })
+  .strict()
+
 const workflowConfigSchema = z
   .object({
     task: taskConfigSchema.default({}),
+    verify: verifyConfigSchema.default({}),
     workflow: z
       .object({
         mode: workflowModeSchema.default('direct'),
@@ -92,8 +99,13 @@ export interface TaskSettingsConfig {
   source: string
 }
 
+export interface VerifyConfig {
+  commands: string[]
+}
+
 export interface WorkflowConfig {
   task: TaskSettingsConfig
+  verify: VerifyConfig
   workflow: WorkflowSettingsConfig
 }
 
@@ -119,6 +131,9 @@ export async function loadWorkflowConfig(
       maxIterations: parsedConfig.task.maxIterations,
       source: parsedConfig.task.source,
     },
+    verify: {
+      commands: parsedConfig.verify.commands,
+    },
     workflow: {
       mode: parsedConfig.workflow.mode,
       roles: parsedConfig.workflow.roles,