@llm4ts/flow 2.40.1 → 2.42.0

package/src/CostReport.ts

@@ -3,7 +3,7 @@ import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
 import type { TokenUsage } from "@llm4ts/core/Models"
 import { isEstimatedModel } from "./EstimatedUsage.ts"
-import { TokensUsed } from "./FlowEvents.ts"
+import { TokensUsed, cloneName } from "./FlowEvents.ts"
 import type { TraceLine } from "./FlowRecorder.ts"
 import { estimateCostUsd, PricesAsOf } from "./PriceList.ts"
 
@@ -31,7 +31,10 @@ export class UsageSample extends Schema.Class<UsageSample>("UsageSample")({
   total: Schema.Int,
   cached: Schema.optionalKey(Schema.Int),
   costUsd: Schema.optionalKey(Schema.Number),
-  estimated: Schema.Boolean
+  estimated: Schema.Boolean,
+  /** The lane's executor and clone, when the usage came from a roster lane (ADR 0033). */
+  executor: Schema.optionalKey(Schema.String),
+  clone: Schema.optionalKey(Schema.Int)
 }) {}
 
 export class UsageTotals extends Schema.Class<UsageTotals>("UsageTotals")({
@@ -87,6 +90,13 @@ export class UsageProjection extends Schema.Class<UsageProjection>("UsageProject
   costUsdPerDay: Schema.optionalKey(Schema.Number)
 }) {}
 
+/** One executor clone's usage (`codex#2`): the coder's calls on a lane that holds that clone. */
+export class ExecutorUsage extends Schema.Class<ExecutorUsage>("ExecutorUsage")({
+  executor: Schema.String,
+  totals: UsageTotals,
+  share: Schema.Number
+}) {}
+
 export class CostReport extends Schema.Class<CostReport>("CostReport")({
   schemaVersion: Schema.Int,
   timeZone: Schema.String,
@@ -102,10 +112,12 @@ export class CostReport extends Schema.Class<CostReport>("CostReport")({
   byDay: Schema.Array(UsageBucket),
   byHour: Schema.Array(UsageBucket),
   byModel: Schema.Array(ModelUsage),
-  byAgent: Schema.Array(AgentUsage)
+  byAgent: Schema.Array(AgentUsage),
+  /** Per executor clone, for lanes served by a roster (schema 3, ADR 0033). */
+  byExecutor: Schema.Array(ExecutorUsage)
 }) {}
 
-export const CurrentCostReportSchema = 2
+export const CurrentCostReportSchema = 3
 
 const tokensUsedCodec = Schema.fromJsonString(TokensUsed)
 const decodeTokensUsed = Schema.decodeUnknownOption(tokensUsedCodec)
@@ -145,7 +157,9 @@ export const usageSamplesFromTrace = (
         total: event.usage.total,
         ...(event.usage.cached === undefined ? {} : { cached: event.usage.cached }),
         ...(costUsd === undefined ? {} : { costUsd }),
-        estimated: isEstimatedModel(model)
+        estimated: isEstimatedModel(model),
+        ...(event.executor === undefined ? {} : { executor: event.executor }),
+        ...(event.clone === undefined ? {} : { clone: event.clone })
       })
     ]
   })
@@ -320,6 +334,26 @@ export const buildCostReport = (
         right.totals.total - left.totals.total || left.agent.localeCompare(right.agent)
     )
 
+  // Coder clones only: a sample that names the lane's executor without its
+  // clone is a reviewer's or judge's, which ran elsewhere (ADR 0033).
+  const byExecutorGroups = new Map<string, Array<UsageSample>>()
+  for (const sample of ordered) {
+    if (sample.executor !== undefined && sample.clone !== undefined) {
+      const key = cloneName(sample.executor, sample.clone)
+      byExecutorGroups.set(key, [...(byExecutorGroups.get(key) ?? []), sample])
+    }
+  }
+  const byExecutor = [...byExecutorGroups.entries()]
+    .map(([executor, members]) => {
+      const executorTotals = totalsOf(members)
+      return ExecutorUsage.make({
+        executor,
+        totals: executorTotals,
+        share: tokens === 0 ? 0 : executorTotals.total / tokens
+      })
+    })
+    .sort((left, right) => left.executor.localeCompare(right.executor))
+
   return CostReport.make({
     schemaVersion: CurrentCostReportSchema,
     timeZone: zoneLabel(timeZone),
@@ -349,7 +383,8 @@ export const buildCostReport = (
     byDay,
     byHour,
     byModel,
-    byAgent
+    byAgent,
+    byExecutor
   })
 }
 
@@ -427,6 +462,16 @@ export const renderCostReport = (report: CostReport): string => {
       )
     )
   }
+  if (report.byExecutor.length > 0) {
+    sections.push(
+      "",
+      "by executor clone:",
+      ...report.byExecutor.map(
+        (entry) =>
+          `  ${entry.executor}  ${thousands(entry.totals.total)} tokens (${Math.round(entry.share * 100)}%)${money(entry.totals.costUsd)}`
+      )
+    )
+  }
   const notes = [
     `costs are backend-reported where available, otherwise estimated from the pricing table (rates as of ${report.pricesAsOf} — may be stale)`,
     ...(report.estimated.requests === 0

package/src/Flow.ts

@@ -2,6 +2,7 @@ import { join } from "node:path"
 import * as Clock from "effect/Clock"
 import * as Effect from "effect/Effect"
 import * as Ref from "effect/Ref"
+import * as Semaphore from "effect/Semaphore"
 import type { LlmServiceShape } from "@llm4ts/core/LlmService"
 import { collect } from "@llm4ts/core/Streaming"
 import { withToolActivity } from "./Activity.ts"
@@ -25,10 +26,16 @@ import {
   TokensUsed,
   type FlowEventsShape
 } from "./FlowEvents.ts"
-import type { Plan, Task } from "./Plan.ts"
+import { hasParallelTasks, type Plan, type Task } from "./Plan.ts"
 import type { PlainFileStoreShape, PlanStoreShape } from "./Persistence.ts"
 import { ensureBaseline } from "./GateTriage.ts"
-import { implementTaskLoop, stage } from "./PlanExecution.ts"
+import {
+  implementTaskGraph,
+  implementTaskLoop,
+  stage,
+  type AsideOutcome,
+  type AsideRequest
+} from "./PlanExecution.ts"
 import { truth } from "@llm4ts/core/judgment/Schemas"
 import { certaintyOf, decide, judgmentOf, type JudgmentMode } from "./Judgment.ts"
 import {
@@ -74,6 +81,30 @@ export const completeAndPublish = Effect.fn("@llm4ts/flow/Flow.completeAndPublis
   return response.content
 })
 
+/** What a task run aside replaces in the plan's options (ADR 0034). */
+export interface TaskOverrides {
+  /** The gates in the aside worktree; `undefined` runs none. */
+  readonly lint?: Effect.Effect<ReviewResult, FlowError> | undefined
+  readonly triage?: GateTriageOptions
+  /** Present to replace the evidence check: the aside coder's tool calls are elsewhere. */
+  readonly onTaskReply?: ImplementPlanOptions["onTaskReply"] | undefined
+  /** The coder's system prompt there: its own working directory, its own paths. */
+  readonly system?: string
+}
+
+/** Tasks beside the held coder (ADR 0034): how many at once, and who runs one. */
+export interface ParallelPlanTasks {
+  readonly concurrency: number
+  /**
+   * Runs one ready task on another coder: `run` is the task's whole body
+   * (coder, review, gates, commit) in the context it is given.
+   */
+  readonly aside: (
+    request: AsideRequest,
+    run: (context: FlowContextShape, overrides: TaskOverrides) => Effect.Effect<void, FlowError>
+  ) => Effect.Effect<AsideOutcome, FlowError>
+}
+
 export interface ImplementPlanOptions {
   readonly store: PlanStoreShape
   readonly planPath: string
@@ -86,6 +117,11 @@ export interface ImplementPlanOptions {
    * one Chat is shared across every task in the plan.
    */
   readonly chatPerTask?: boolean
+  /**
+   * Ready tasks run beside the held coder (ADR 0034), with `chatPerTask`
+   * only, and only in a plan whose tasks declare that they may.
+   */
+  readonly parallel?: ParallelPlanTasks
   readonly reviewers?: ReadonlyArray<Reviewer>
   readonly commitMessage?: (plan: Plan, task: Task) => string
   readonly checkoutBranch?: boolean
@@ -288,24 +324,26 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
     })
   }
 
-  return yield* implementTaskLoop(
-    options.store,
-    context.events,
-    options.planPath,
-    plan,
-    (task, planSoFar) =>
-      Effect.gen(function* () {
+  const carryLock = yield* Semaphore.make(1)
+  /** The task's body in `ctx`: the plan's own context at home, another one aside (ADR 0034). */
+  const taskBody =
+    (ctx: FlowContextShape, over: TaskOverrides) =>
+    (task: Task, planSoFar: Plan): Effect.Effect<void, FlowError> => {
+      const lint = "lint" in over ? over.lint : options.lint
+      const onTaskReply = "onTaskReply" in over ? over.onTaskReply : options.onTaskReply
+      const system = over.system ?? options.system
+      return Effect.gen(function* () {
         // `sharedCoder`'s definedness mirrors `options.chatPerTask !== true`
         // above: when it's set, every task reuses it; when it's undefined,
         // chatPerTask is active and each task builds its own fresh Chat.
         let coder: Chat
-        if (sharedCoder !== undefined) {
+        if (sharedCoder !== undefined && ctx === context) {
           coder = sharedCoder
         } else {
-          coder = yield* makeChat(context.coder, {
-            events: context.events,
+          coder = yield* makeChat(ctx.coder, {
+            events: ctx.events,
             agent: "coder",
-            system: composeSystem(options.system, planSoFar.render),
+            system: composeSystem(system, planSoFar.render),
             ...(options.stall === undefined ? {} : { stall: options.stall })
           })
         }
@@ -319,11 +357,17 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
         const keepFindings = (reply: string): Effect.Effect<void, FlowError> =>
           Effect.gen(function* () {
             const found = findingsIn(reply)
-            if (options.carry !== undefined && found !== undefined) {
-              yield* options.carry.write(appendNote(notes, task.title, found))
+            const carry = options.carry
+            if (carry !== undefined && found !== undefined) {
+              // Tasks may run at once (ADR 0034): append to the notes as they are now.
+              yield* carryLock.withPermit(
+                Effect.flatMap(carry.read, (latest) =>
+                  carry.write(appendNote(latest, task.title, found))
+                )
+              )
             }
-            if (options.onTaskReply !== undefined) {
-              yield* options.onTaskReply(task, reply, trailerIn(found), taskStartedAt)
+            if (onTaskReply !== undefined) {
+              yield* onTaskReply(task, reply, trailerIn(found), taskStartedAt)
             }
           })
         yield* keepFindings(
@@ -333,7 +377,7 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
               : `${withNotes(plan.taskPrompt(task), notes)}\n${findingsRequest}`
           )
         )
-        const produced = yield* context.git.diffAll
+        const produced = yield* ctx.git.diffAll
         if (produced.trim().length === 0) {
           // An empty diff is ambiguous: the task may be genuinely satisfied
           // already, or the coder may simply have produced nothing. Ask
@@ -348,19 +392,19 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
             ].join("\n")
           )
           yield* keepFindings(confirmation)
-          const afterConfirmation = yield* context.git.diffAll
+          const afterConfirmation = yield* ctx.git.diffAll
           if (afterConfirmation.trim().length === 0) {
             const judged =
               options.satisfiedProbe !== undefined && options.satisfiedProbe !== "literal"
                 ? yield* satisfiedByJudgment(
-                    context,
+                    ctx,
                     task.title,
                     confirmation,
                     options.satisfiedProbe === "judgment" ? "act" : options.satisfiedProbe.mode
                   )
                 : undefined
             if (judged ?? confirmation.includes("TASK_ALREADY_SATISFIED")) {
-              yield* context.events.publish(
+              yield* ctx.events.publish(
                 Info.make({
                   message: `task "${task.title}" confirmed already satisfied; skipping review and commit`
                 })
@@ -368,7 +412,7 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
               return
             }
             if (options.noopTaskPolicy === "complete") {
-              yield* context.events.publish(
+              yield* ctx.events.publish(
                 Info.make({
                   message: `task "${task.title}" produced no changes without confirming TASK_ALREADY_SATISFIED; marking complete per noopTaskPolicy`
                 })
@@ -380,7 +424,7 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
             })
           }
         }
-        const triage = yield* triageFor(context, options)
+        const triage = over.triage ?? (yield* triageFor(ctx, options))
         const repoRules = options.repoRules === undefined ? undefined : yield* options.repoRules
         const reviewers = [
           ...(options.reviewers ?? minimalReviewers),
@@ -390,8 +434,8 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
           options.fixer === "separate"
             ? (prompt: string): Effect.Effect<string, FlowError> =>
                 Effect.flatMap(
-                  makeChat(context.coder, {
-                    events: context.events,
+                  makeChat(ctx.coder, {
+                    events: ctx.events,
                     agent: "coder",
                     system: withContract(fixerBrief),
                     ...(options.stall === undefined ? {} : { stall: options.stall })
@@ -403,7 +447,7 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
           options.oracle === undefined
             ? undefined
             : {
-                diff: context.git.diffAll,
+                diff: ctx.git.diffAll,
                 ...(options.oracle.rules === undefined ? {} : { rules: options.oracle.rules }),
                 ...(options.oracle.testsChange === undefined
                   ? {}
@@ -414,14 +458,14 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
               }
         yield* reviewAndFixLoop({
           reviewers,
-          reviewerService: flowReviewer(context),
+          reviewerService: flowReviewer(ctx),
           coder,
           taskTitle: task.title,
-          currentDiff: context.git.diffAll,
-          events: context.events,
+          currentDiff: ctx.git.diffAll,
+          events: ctx.events,
           ...(options.maxRounds === undefined ? {} : { maxRounds: options.maxRounds }),
           ...(options.settle === undefined ? {} : { settle: options.settle }),
-          ...(options.lint === undefined ? {} : { lint: options.lint }),
+          ...(lint === undefined ? {} : { lint }),
           ...(options.format === undefined ? {} : { format: options.format }),
           ...(triage === undefined ? {} : { triage }),
           ...(oracle === undefined ? {} : { oracle }),
@@ -439,12 +483,12 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
                     : options.onReview(task, round, result, settled)
               })
         })
-        if (options.lint !== undefined) {
+        if (lint !== undefined) {
           const reported = yield* Ref.make<ReadonlySet<string>>(new Set())
           const gate = yield* withOracle(
-            yield* applyTriage(yield* options.lint, triage, context.events, reported),
+            yield* applyTriage(yield* lint, triage, ctx.events, reported),
             oracle,
-            context.events,
+            ctx.events,
             yield* Ref.make(true)
           )
           if (!gate.isClean) {
@@ -460,7 +504,37 @@ export const implementPlanFlow = Effect.fn("@llm4ts/flow/Flow.implementPlan")(fu
             })
           }
         }
-        yield* context.git.commitAll((options.commitMessage ?? defaultCommitMessage)(plan, task))
+        yield* ctx.git.commitAll((options.commitMessage ?? defaultCommitMessage)(plan, task))
       })
+    }
+
+  const parallel = options.parallel
+  if (
+    parallel !== undefined &&
+    parallel.concurrency > 1 &&
+    options.chatPerTask === true &&
+    hasParallelTasks(plan)
+  ) {
+    return yield* implementTaskGraph(
+      options.store,
+      context.events,
+      options.planPath,
+      plan,
+      taskBody(context, {}),
+      {
+        concurrency: parallel.concurrency,
+        aside: (request) =>
+          parallel.aside(request, (ctx, over) =>
+            taskBody(ctx, over)(request.node.task, request.planSoFar)
+          )
+      }
+    )
+  }
+  return yield* implementTaskLoop(
+    options.store,
+    context.events,
+    options.planPath,
+    plan,
+    taskBody(context, {})
   )
 })

package/src/FlowContext.ts

@@ -16,6 +16,11 @@ export interface ContextOptions {
   readonly prefer?: string
   /** Who the context is for, in the roster's events ("story conto-overview"). */
   readonly label?: string
+  /**
+   * Take a coder only if one is free now, else fail `RosterExhausted` at
+   * once: a task offered aside never waits for a slot (ADR 0034).
+   */
+  readonly ifFree?: boolean
 }
 
 export interface FlowContextShape {

package/src/FlowEvents.ts

@@ -88,6 +88,8 @@ export class Info extends Schema.TaggedClass<Info>()("Info", {
 export class ToolUse extends Schema.TaggedClass<ToolUse>()("ToolUse", {
   tool: Schema.String,
   args: Schema.String,
+  /** The tool call this one runs inside, when a harness delegated it to a sub-agent (ADR 0033). */
+  parent: Schema.optionalKey(Schema.String),
   /** The concurrent unit (a story) this event belongs to; absent for run-wide events. */
   lane: Schema.optionalKey(Schema.String),
   /** The roster executor working that lane, when there is one (ADR 0019). */
@@ -109,7 +111,9 @@ export class TokensUsed extends Schema.TaggedClass<TokensUsed>()("TokensUsed", {
   /** The concurrent unit (a story) this event belongs to; absent for run-wide events. */
   lane: Schema.optionalKey(Schema.String),
   /** The roster executor working that lane, when there is one (ADR 0019). */
-  executor: Schema.optionalKey(Schema.String)
+  executor: Schema.optionalKey(Schema.String),
+  /** The executor's clone that made the call, when the lane's coder holds a slot (ADR 0033). */
+  clone: Schema.optionalKey(Schema.Int)
 }) {}
 
 /** One issue a review round found, as the operator sees it. */
@@ -270,9 +274,58 @@ export class StoryJudged extends Schema.TaggedClass<StoryJudged>()("StoryJudged"
  * The executor roster's events (ADR 0019, 0022). `label` names who holds the
  * lease — a story's id, or "the run" — so a view can put an executor on its lane.
  */
+/** One task of a story's plan as the task loop announces it (ADR 0033). */
+export const PlannedTask = Schema.Struct({
+  title: Schema.String,
+  completed: Schema.Boolean,
+  /** The acceptance criteria the task's description names (`Satisfies: 1, 3`). */
+  satisfies: Schema.optionalKey(Schema.Array(Schema.Int))
+})
+
+/** The task loop's plan, before its first task: every task in order (ADR 0033). */
+export class TasksPlanned extends Schema.TaggedClass<TasksPlanned>()("TasksPlanned", {
+  tasks: Schema.Array(PlannedTask),
+  lane: Schema.optionalKey(Schema.String),
+  executor: Schema.optionalKey(Schema.String)
+}) {}
+
+/** A task begins: its position in the plan, from 1, and the plan's size (ADR 0033). */
+export class TaskStarted extends Schema.TaggedClass<TaskStarted>()("TaskStarted", {
+  index: Schema.Int,
+  count: Schema.Int,
+  title: Schema.String,
+  satisfies: Schema.optionalKey(Schema.Array(Schema.Int)),
+  /** The task runs beside the story's held coder, in its own worktree (ADR 0034). */
+  parallel: Schema.optionalKey(Schema.Boolean),
+  /** The clone of the extra coder a parallel task holds (ADR 0034). */
+  clone: Schema.optionalKey(Schema.Int),
+  lane: Schema.optionalKey(Schema.String),
+  executor: Schema.optionalKey(Schema.String)
+}) {}
+
+/** A task is ticked in the plan (ADR 0033). */
+export class TaskCompleted extends Schema.TaggedClass<TaskCompleted>()("TaskCompleted", {
+  index: Schema.Int,
+  count: Schema.Int,
+  title: Schema.String,
+  lane: Schema.optionalKey(Schema.String),
+  executor: Schema.optionalKey(Schema.String)
+}) {}
+
+/** A story moved on the epic's board (ADR 0033); the statuses are `BoardSync`'s. */
+export class StoryStatusChanged extends Schema.TaggedClass<StoryStatusChanged>()(
+  "StoryStatusChanged",
+  {
+    id: Schema.String,
+    status: Schema.Literals(["planned", "active", "waiting", "done", "failed", "skipped"])
+  }
+) {}
+
 export class ExecutorLeased extends Schema.TaggedClass<ExecutorLeased>()("ExecutorLeased", {
   executor: Schema.String,
   role: Schema.String,
+  /** Which of the executor's clones took the slot, from 1 (ADR 0033); absent when borrowed or before 2.41. */
+  clone: Schema.optionalKey(Schema.Int),
   label: Schema.optionalKey(Schema.String),
   /** What the call is for beyond its role: a review lens, a vote. */
   purpose: Schema.optionalKey(Schema.String),
@@ -290,6 +343,8 @@ export class ExecutorLeased extends Schema.TaggedClass<ExecutorLeased>()("Execut
 export class ExecutorReleased extends Schema.TaggedClass<ExecutorReleased>()("ExecutorReleased", {
   executor: Schema.String,
   role: Schema.String,
+  /** Which of the executor's clones freed the slot (ADR 0033); absent when borrowed or before 2.41. */
+  clone: Schema.optionalKey(Schema.Int),
   label: Schema.optionalKey(Schema.String)
 }) {}
 
@@ -335,12 +390,16 @@ const resumedWords: Readonly<Record<ExecutorResumed["why"], string>> = {
  * the roster used to publish as `Info` — or `undefined` for one it does not
  * show (a release) and for any other event.
  */
+/** `codex#2` for a numbered clone, the bare executor otherwise (ADR 0033). */
+export const cloneName = (executor: string, clone: number | undefined): string =>
+  clone === undefined ? executor : `${executor}#${clone}`
+
 export const rosterEventMessage = (event: FlowEvent): string | undefined => {
   const forLabel = (label: string | undefined): string =>
     label === undefined ? "" : ` for ${label}`
   switch (event._tag) {
     case "ExecutorLeased": {
-      const taken = `roster: ${event.executor} takes ${event.role}${forLabel(event.label)}${
+      const taken = `roster: ${cloneName(event.executor, event.clone)} takes ${event.role}${forLabel(event.label)}${
         event.purpose === undefined ? "" : ` · ${event.purpose}`
       }`
       if (event.because === undefined && event.borrowed !== true) {
@@ -395,7 +454,11 @@ export const FlowEvent = Schema.Union([
   ExecutorHandedOver,
   StoryJudged,
   Timed,
-  Began
+  Began,
+  TasksPlanned,
+  TaskStarted,
+  TaskCompleted,
+  StoryStatusChanged
 ])
 export type FlowEvent = typeof FlowEvent.Type
 
@@ -419,6 +482,8 @@ export interface Lane {
   readonly lane: string
   /** The executor working it now; read at every publish, so a handover shows. */
   readonly executor?: Effect.Effect<string | undefined>
+  /** The coder's clone number, read at every publish as `executor` is (ADR 0033). */
+  readonly clone?: Effect.Effect<number | undefined>
   /** The lane's working directory, dropped from tool arguments (the lane already names it). */
   readonly workDir?: string
 }
@@ -436,10 +501,37 @@ const stamped = (
   event: FlowEvent,
   lane: string,
   executor: string | undefined,
-  workDir: string | undefined
+  workDir: string | undefined,
+  clone: number | undefined
 ): FlowEvent => {
   const tags = { lane, ...(executor === undefined ? {} : { executor }) }
+  const usageTags = { ...tags, ...(clone === undefined ? {} : { clone }) }
   switch (event._tag) {
+    case "TasksPlanned":
+      return event.lane !== undefined ? event : TasksPlanned.make({ tasks: event.tasks, ...tags })
+    case "TaskStarted":
+      return event.lane !== undefined
+        ? event
+        : TaskStarted.make({
+            index: event.index,
+            count: event.count,
+            title: event.title,
+            ...(event.satisfies === undefined ? {} : { satisfies: event.satisfies }),
+            ...tags,
+            // A parallel task names its own coder, not the lane's (ADR 0034).
+            ...(event.parallel === undefined ? {} : { parallel: event.parallel }),
+            ...(event.executor === undefined ? {} : { executor: event.executor }),
+            ...(event.clone === undefined ? {} : { clone: event.clone })
+          })
+    case "TaskCompleted":
+      return event.lane !== undefined
+        ? event
+        : TaskCompleted.make({
+            index: event.index,
+            count: event.count,
+            title: event.title,
+            ...tags
+          })
     case "StageStarted":
       return event.lane !== undefined ? event : StageStarted.make({ stage: event.stage, ...tags })
     case "StageCompleted":
@@ -456,6 +548,7 @@ const stamped = (
         : ToolUse.make({
             tool: event.tool,
             args: shortenLaneArgs(event.args, workDir),
+            ...(event.parent === undefined ? {} : { parent: event.parent }),
             ...tags
           })
     case "AssistantMessage":
@@ -485,7 +578,9 @@ const stamped = (
             agent: event.agent,
             usage: event.usage,
             ...(event.model === undefined ? {} : { model: event.model }),
-            ...tags
+            // The lane's clone is its coder's: a reviewer or judge on the
+            // lane's events ran on another executor (ADR 0033).
+            ...(event.agent === "coder" ? usageTags : tags)
           })
     // The lane's executor is its coder's: it names a coder call or tool, not
     // a reviewer's or judge's call made on another executor.
@@ -523,7 +618,9 @@ const stamped = (
 export const withLane = (events: FlowEventsShape, lane: Lane): FlowEventsShape => ({
   publish: (event) =>
     Effect.flatMap(lane.executor ?? Effect.succeed(undefined), (executor) =>
-      events.publish(stamped(event, lane.lane, executor, lane.workDir))
+      Effect.flatMap(lane.clone ?? Effect.succeed(undefined), (clone) =>
+        events.publish(stamped(event, lane.lane, executor, lane.workDir, clone))
+      )
     )
 })
 

package/src/Perimeter.ts

@@ -131,3 +131,39 @@ export const strayTasks = (
     })
     return [{ task, paths, foreign }]
   })
+
+/** A task's `Owns:` entry as a path prefix: `src/session/*` and `src/routes/**` own their directory. */
+const ownedPrefix = (entry: string): string => entry.replace(/\/?\*+$/u, "")
+
+/**
+ * A task run aside (ADR 0034) as a gate over what it changed: every path
+ * outside its `Owns:` entries is one Critical issue handed back to its
+ * coder, so two tasks running at once keep to their own files. A task that
+ * names no paths is not checked; the story's perimeter still is.
+ */
+export const taskOwnsGate = (
+  changedPaths: ReadonlyArray<string>,
+  owns: ReadonlyArray<string>
+): ReviewResult => {
+  if (owns.length === 0) {
+    return ReviewResult.make({ issues: [], summary: "" })
+  }
+  const prefixes = owns.map(ownedPrefix)
+  const stray = changedPaths.filter((path) => !prefixes.some((prefix) => pathWithin(path, prefix)))
+  return stray.length === 0
+    ? ReviewResult.make({ issues: [], summary: "task owns: clean" })
+    : ReviewResult.make({
+        issues: [
+          ReviewIssue.make({
+            severity: "Critical",
+            title: "task owns",
+            description: [
+              `This task owns ${owns.join(", ")} and changed paths outside them: ${stray.join(", ")}.`,
+              "Another task may be changing those right now. Revert them and keep this task's",
+              "work inside the paths it owns."
+            ].join("\n")
+          })
+        ],
+        summary: "task owns: violated"
+      })
+}