@lota-sdk/core 0.4.3 → 0.4.5

package/src/services/execution-plan.service.ts

@@ -8,6 +8,7 @@ import type {
   PlanDraft,
   PlanNodeRunRecord,
   PlanNodeSpecRecord,
+  PlanRunRecord,
   PlanSpecRecord,
   SerializableExecutionPlan,
   SubmitPlanTurnResultArgs,
@@ -47,6 +48,25 @@ function aggregateBlockingIssues(issues: Array<{ code: string; message: string }
   return issues.map((issue) => `${issue.code}: ${issue.message}`).join(' | ')
 }
 
+function hasCrossThreadSourceContext(sourceThreadId: RecordIdInput | undefined, threadId: RecordIdInput): boolean {
+  if (!sourceThreadId) {
+    return false
+  }
+
+  return recordIdToString(sourceThreadId, TABLES.THREAD) !== recordIdToString(threadId, TABLES.THREAD)
+}
+
+function isPlanVisibleInThreadContext(
+  threadId: RecordIdInput,
+  params: { threadId: RecordIdInput; sourceThreadId?: RecordIdInput },
+): boolean {
+  const currentThreadId = recordIdToString(threadId, TABLES.THREAD)
+  return (
+    currentThreadId === recordIdToString(params.threadId, TABLES.THREAD) ||
+    (params.sourceThreadId !== undefined && currentThreadId === recordIdToString(params.sourceThreadId, TABLES.THREAD))
+  )
+}
+
 function toSpecData(spec: PlanSpecRecord, patch: Partial<PlanSpecRecord> & { replacedSpecId?: RecordIdInput | null }) {
   return {
     organizationId: ensureRecordId(spec.organizationId, TABLES.ORGANIZATION),
@@ -168,17 +188,29 @@ class ExecutionPlanService {
     const runs = await planRunService.getActiveRunRecords(threadId)
     if (runs.length === 0) return []
 
-    return await Promise.all(
-      runs.map((run) =>
-        planRunService.toSerializablePlan(run, {
-          includeEvents: options?.includeEvents,
-          includeArtifacts: options?.includeArtifacts,
-          includeApprovals: options?.includeApprovals,
-          includeCheckpoints: options?.includeCheckpoints,
-          includeValidationIssues: options?.includeValidationIssues,
-        }),
-      ),
-    )
+    return await this.serializeRuns(runs, options)
+  }
+
+  async getPlansCreatedInContext(params: {
+    organizationId: RecordIdInput
+    sourceThreadId?: RecordIdInput
+    createdByAgentId?: string
+    statuses?: ReadonlyArray<PlanRunRecord['status']>
+    includeEvents?: boolean
+    includeArtifacts?: boolean
+    includeApprovals?: boolean
+    includeCheckpoints?: boolean
+    includeValidationIssues?: boolean
+  }): Promise<SerializableExecutionPlan[]> {
+    const runs = await planRunService.getRunsCreatedInContext({
+      organizationId: params.organizationId,
+      sourceThreadId: params.sourceThreadId,
+      createdByAgentId: params.createdByAgentId,
+      statuses: params.statuses,
+    })
+    if (runs.length === 0) return []
+
+    return await this.serializeRuns(runs, params)
   }
 
   async listActivePlanSummaries(threadId: RecordIdInput): Promise<ListExecutionPlansToolResultData> {
@@ -245,9 +277,14 @@ class ExecutionPlanService {
   async createPlan(params: {
     organizationId: RecordIdInput
     threadId: RecordIdInput
+    sourceThreadId?: RecordIdInput
     leadAgentId: string
+    createdByAgentId?: string
+    requireApproval?: boolean
     input: PlanDraft
   }): Promise<ExecutionPlanToolResultData> {
+    const requireApproval =
+      params.requireApproval ?? hasCrossThreadSourceContext(params.sourceThreadId, params.threadId)
     const preparedDraft = planBuilderService.prepareDraft(PlanDraftSchema.parse(params.input))
     const validation = planValidatorService.validateDraft(preparedDraft)
     if (validation.blocking.length > 0) {
@@ -281,7 +318,10 @@ class ExecutionPlanService {
         spec,
         organizationId: params.organizationId,
         threadId: params.threadId,
+        sourceThreadId: params.sourceThreadId,
         leadAgentId: params.leadAgentId,
+        createdByAgentId: params.createdByAgentId,
+        requireApproval,
         nodes: compiled.nodes,
         emittedEvents,
         createdEventType: 'plan-created',
@@ -293,25 +333,13 @@ class ExecutionPlanService {
 
     await planEventDeliveryService.dispatchEvents(emittedEvents)
 
-    // Create a plan-level schedule record if the draft specifies a schedule
-    if (compiled.draft.schedule) {
-      const schedule = await planSchedulerService.createSchedule({
+    if (!requireApproval) {
+      await this.attachPlanScheduleIfNeeded({
         organizationId: params.organizationId,
         threadId: params.threadId,
-        planSpecId: specId,
         runId,
-        scheduleSpec: compiled.draft.schedule,
+        planSpecId: specId,
       })
-
-      await databaseService.update(
-        TABLES.PLAN_RUN,
-        ensureRecordId(runId, TABLES.PLAN_RUN),
-        {
-          scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE),
-          scheduledAt: schedule.nextFireAt ? toDatabaseDateTime(schedule.nextFireAt) : undefined,
-        },
-        PlanRunSchema,
-      )
     }
 
     const plan = await this.finalizePlanSnapshot({ runId, emittedBy: params.leadAgentId })
@@ -323,7 +351,8 @@ class ExecutionPlanService {
     threadId: RecordIdInput
     organizationId: RecordIdInput
     leadAgentId: string
-    input: PlanDraft & { runId: string; reason: string }
+    createdByAgentId?: string
+    input: PlanDraft & { runId: string; reason: string; requireApproval?: boolean }
   }): Promise<ExecutionPlanToolResultData> {
     const activeRun = await planRunService.getRunById(params.input.runId)
     const resolvedThreadId = activeRun.threadId
@@ -337,7 +366,7 @@ class ExecutionPlanService {
     }
 
     const activeSpec = await planRunService.getPlanSpecById(activeRun.planSpecId)
-    const { runId: _runId, reason: _reason, ...draftInput } = params.input
+    const { runId: _runId, reason: _reason, requireApproval: requestedRequireApproval, ...draftInput } = params.input
     const preparedDraft = planBuilderService.prepareDraft(PlanDraftSchema.parse(draftInput))
     const validation = planValidatorService.validateDraft(preparedDraft)
     if (validation.blocking.length > 0) {
@@ -394,7 +423,11 @@ class ExecutionPlanService {
         spec,
         organizationId: params.organizationId,
         threadId: resolvedThreadId,
+        sourceThreadId: activeRun.sourceThreadId,
         leadAgentId: params.leadAgentId,
+        createdByAgentId: params.createdByAgentId ?? params.leadAgentId,
+        requireApproval:
+          requestedRequireApproval ?? hasCrossThreadSourceContext(activeRun.sourceThreadId, resolvedThreadId),
         nodes: compiled.nodes,
         emittedEvents,
         runPatch: { replacedRunId: abortedRun.id },
@@ -410,6 +443,15 @@ class ExecutionPlanService {
 
     await planEventDeliveryService.dispatchEvents(emittedEvents)
 
+    if (!(requestedRequireApproval ?? hasCrossThreadSourceContext(activeRun.sourceThreadId, resolvedThreadId))) {
+      await this.attachPlanScheduleIfNeeded({
+        organizationId: params.organizationId,
+        threadId: resolvedThreadId,
+        runId,
+        planSpecId: specId,
+      })
+    }
+
     const plan = await this.finalizePlanSnapshot({ runId, emittedBy: params.leadAgentId })
 
     return buildExecutionPlanToolResult({
@@ -482,6 +524,243 @@ class ExecutionPlanService {
     })
   }
 
+  async approvePlan(params: {
+    organizationId: RecordIdInput
+    threadId: RecordIdInput
+    runId: RecordIdInput
+    emittedBy: string
+  }): Promise<SerializableExecutionPlan> {
+    const run = await planRunService.getRunById(params.runId)
+    if (
+      recordIdToString(run.organizationId, TABLES.ORGANIZATION) !==
+      recordIdToString(params.organizationId, TABLES.ORGANIZATION)
+    ) {
+      throw new Error('Plan run belongs to a different organization.')
+    }
+    if (!isPlanVisibleInThreadContext(params.threadId, run)) {
+      throw new Error('Plan run is not available in this thread context.')
+    }
+    if (run.status !== 'pending-approval') {
+      throw new Error('Only pending-approval plans can be approved.')
+    }
+
+    const [spec, nodeSpecs, nodeRuns, latestCheckpoint] = await Promise.all([
+      planRunService.getPlanSpecById(run.planSpecId),
+      planRunService.listNodeSpecs(run.planSpecId),
+      planRunService.listNodeRuns(run.id),
+      planRunService.getLatestCheckpoint(run.id),
+    ])
+    const emittedEvents: PlanEventRecord[] = []
+
+    await databaseService.withTransaction(async (tx) => {
+      const activatedRun = PlanRunSchema.parse(
+        await tx
+          .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
+          .content(toRunData(run, { status: 'running', startedAt: run.startedAt ?? new Date() }))
+          .output('after'),
+      )
+
+      const synced = await planExecutorService.syncRunGraph({
+        tx,
+        run: activatedRun,
+        spec,
+        nodeSpecs,
+        nodeRuns,
+        artifacts: [],
+        emittedBy: params.emittedBy,
+        capturedEvents: emittedEvents,
+      })
+
+      const checkpoint = PlanCheckpointSchema.parse(
+        await tx
+          .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
+          .content({
+            runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
+            sequence: (latestCheckpoint?.sequence ?? 0) + 1,
+            runStatus: synced.run.status,
+            readyNodeIds: [...synced.run.readyNodeIds],
+            activeNodeIds: synced.run.currentNodeId ? [synced.run.currentNodeId] : [],
+            artifactIds: [],
+            lastCompletedNodeIds: synced.nodeRuns
+              .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
+              .map((nodeRun) => nodeRun.nodeId),
+            snapshot: {
+              reason: 'plan-approved',
+              currentNodeId: synced.run.currentNodeId,
+              waitingNodeId: synced.run.waitingNodeId,
+              readyNodeIds: synced.run.readyNodeIds,
+            },
+          })
+          .output('after'),
+      )
+
+      const updatedRun = PlanRunSchema.parse(
+        await tx
+          .update(ensureRecordId(synced.run.id, TABLES.PLAN_RUN))
+          .content(toRunData(synced.run, { lastCheckpointId: checkpoint.id }))
+          .output('after'),
+      )
+
+      const approvedEvent = await tx
+        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+        .content({
+          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
+          runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
+          eventType: 'plan-approved',
+          fromStatus: run.status,
+          toStatus: updatedRun.status,
+          message: `Approved execution plan "${spec.title}".`,
+          emittedBy: params.emittedBy,
+          detail: { title: spec.title, objective: spec.objective },
+        })
+        .output('after')
+      emittedEvents.push(PlanEventSchema.parse(approvedEvent))
+
+      const checkpointEvent = await tx
+        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+        .content({
+          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
+          runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
+          eventType: 'checkpoint-saved',
+          message: `Saved checkpoint ${(latestCheckpoint?.sequence ?? 0) + 1}.`,
+          emittedBy: 'system',
+          detail: { checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT), reason: 'plan-approved' },
+        })
+        .output('after')
+      emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
+    })
+
+    await planEventDeliveryService.dispatchEvents(emittedEvents)
+    await this.attachPlanScheduleIfNeeded({
+      organizationId: run.organizationId,
+      threadId: run.threadId,
+      runId: run.id,
+      planSpecId: run.planSpecId,
+    })
+
+    return await this.finalizePlanSnapshot({ runId: run.id, emittedBy: params.emittedBy })
+  }
+
+  async rejectPlan(params: {
+    organizationId: RecordIdInput
+    threadId: RecordIdInput
+    runId: RecordIdInput
+    emittedBy: string
+    reason?: string
+    resolution?: 'rejected' | 'changes-requested'
+  }): Promise<SerializableExecutionPlan> {
+    const resolution = params.resolution ?? 'rejected'
+    const eventType = resolution === 'changes-requested' ? 'plan-changes-requested' : 'plan-rejected'
+    const run = await planRunService.getRunById(params.runId)
+    if (
+      recordIdToString(run.organizationId, TABLES.ORGANIZATION) !==
+      recordIdToString(params.organizationId, TABLES.ORGANIZATION)
+    ) {
+      throw new Error('Plan run belongs to a different organization.')
+    }
+    if (!isPlanVisibleInThreadContext(params.threadId, run)) {
+      throw new Error('Plan run is not available in this thread context.')
+    }
+    if (run.status !== 'pending-approval') {
+      throw new Error('Only pending-approval plans can be rejected.')
+    }
+
+    const [spec, nodeRuns, latestCheckpoint] = await Promise.all([
+      planRunService.getPlanSpecById(run.planSpecId),
+      planRunService.listNodeRuns(run.id),
+      planRunService.getLatestCheckpoint(run.id),
+    ])
+    const emittedEvents: PlanEventRecord[] = []
+    const checkpointReason = resolution === 'changes-requested' ? 'plan-changes-requested' : 'plan-rejected'
+
+    await databaseService.withTransaction(async (tx) => {
+      const rejectedRun = PlanRunSchema.parse(
+        await tx
+          .update(ensureRecordId(run.id, TABLES.PLAN_RUN))
+          .content(
+            toRunData(run, {
+              status: 'aborted',
+              currentNodeId: null,
+              waitingNodeId: null,
+              readyNodeIds: [],
+              completedAt: new Date(),
+            }),
+          )
+          .output('after'),
+      )
+
+      const event = await tx
+        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+        .content({
+          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
+          runId: ensureRecordId(rejectedRun.id, TABLES.PLAN_RUN),
+          eventType,
+          fromStatus: run.status,
+          toStatus: rejectedRun.status,
+          message:
+            resolution === 'changes-requested'
+              ? `Requested changes for execution plan "${spec.title}".`
+              : `Rejected execution plan "${spec.title}".`,
+          emittedBy: params.emittedBy,
+          detail: { resolution, ...(params.reason ? { reason: params.reason } : {}) },
+        })
+        .output('after')
+      emittedEvents.push(PlanEventSchema.parse(event))
+
+      const checkpoint = PlanCheckpointSchema.parse(
+        await tx
+          .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
+          .content({
+            runId: ensureRecordId(rejectedRun.id, TABLES.PLAN_RUN),
+            sequence: (latestCheckpoint?.sequence ?? 0) + 1,
+            runStatus: rejectedRun.status,
+            readyNodeIds: [],
+            activeNodeIds: [],
+            artifactIds: [],
+            lastCompletedNodeIds: nodeRuns
+              .filter((nodeRun) => nodeRun.status === 'completed' || nodeRun.status === 'partial')
+              .map((nodeRun) => nodeRun.nodeId),
+            snapshot: {
+              reason: checkpointReason,
+              resolution,
+              currentNodeId: null,
+              waitingNodeId: null,
+              readyNodeIds: [],
+            },
+          })
+          .output('after'),
+      )
+
+      const updatedRun = PlanRunSchema.parse(
+        await tx
+          .update(ensureRecordId(rejectedRun.id, TABLES.PLAN_RUN))
+          .content(toRunData(rejectedRun, { lastCheckpointId: checkpoint.id }))
+          .output('after'),
+      )
+
+      const checkpointEvent = await tx
+        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+        .content({
+          planSpecId: ensureRecordId(spec.id, TABLES.PLAN_SPEC),
+          runId: ensureRecordId(updatedRun.id, TABLES.PLAN_RUN),
+          eventType: 'checkpoint-saved',
+          message: `Saved checkpoint ${(latestCheckpoint?.sequence ?? 0) + 1}.`,
+          emittedBy: 'system',
+          detail: {
+            checkpointId: recordIdToString(checkpoint.id, TABLES.PLAN_CHECKPOINT),
+            reason: checkpointReason,
+            resolution,
+          },
+        })
+        .output('after')
+      emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
+    })
+
+    await planEventDeliveryService.dispatchEvents(emittedEvents)
+
+    return await planRunService.toSerializablePlan(await planRunService.getRunById(run.id))
+  }
+
   async applyApprovalResponseFromMessages(params: {
     threadId: RecordIdInput
     approvalMessages: ChatMessage[]
@@ -554,6 +833,23 @@ class ExecutionPlanService {
     return ownershipDispatcherService.dispatchRunToStableBoundary({ runId: run.id, emittedBy: params.respondedBy })
   }
 
+  private async serializeRuns(
+    runs: PlanRunRecord[],
+    options?: Partial<ExecutionPlanQueryArgs>,
+  ): Promise<SerializableExecutionPlan[]> {
+    return await Promise.all(
+      runs.map((run) =>
+        planRunService.toSerializablePlan(run, {
+          includeEvents: options?.includeEvents,
+          includeArtifacts: options?.includeArtifacts,
+          includeApprovals: options?.includeApprovals,
+          includeCheckpoints: options?.includeCheckpoints,
+          includeValidationIssues: options?.includeValidationIssues,
+        }),
+      ),
+    )
+  }
+
   private async assertDispatchExecutors(preparedDraft: Parameters<typeof planValidatorService.validateDraft>[0]) {
     const issues = ownershipDispatcherService.validateDraftExecutors(preparedDraft)
     if (issues.length > 0) {
@@ -568,6 +864,41 @@ class ExecutionPlanService {
     return ownershipDispatcherService.dispatchRunToStableBoundary({ runId: params.runId, emittedBy: params.emittedBy })
   }
 
+  private async attachPlanScheduleIfNeeded(params: {
+    organizationId: RecordIdInput
+    threadId: RecordIdInput
+    runId: RecordIdInput
+    planSpecId: RecordIdInput
+  }): Promise<PlanRunRecord> {
+    const [run, spec] = await Promise.all([
+      planRunService.getRunById(params.runId),
+      planRunService.getPlanSpecById(params.planSpecId),
+    ])
+    if (!spec.schedule || run.scheduleId) {
+      return run
+    }
+
+    const schedule = await planSchedulerService.createSchedule({
+      organizationId: params.organizationId,
+      threadId: params.threadId,
+      planSpecId: params.planSpecId,
+      runId: params.runId,
+      scheduleSpec: spec.schedule,
+    })
+
+    const updatedRun = await databaseService.update(
+      TABLES.PLAN_RUN,
+      ensureRecordId(params.runId, TABLES.PLAN_RUN),
+      toRunData(run, {
+        scheduleId: schedule.id,
+        scheduledAt: schedule.nextFireAt ? toDatabaseDateTime(schedule.nextFireAt) : undefined,
+      }),
+      PlanRunSchema,
+    )
+
+    return updatedRun ?? run
+  }
+
   private async createNodeSpecs(
     tx: DatabaseTransaction,
     planSpecId: RecordIdInput,
@@ -657,7 +988,10 @@ class ExecutionPlanService {
     spec: PlanSpecRecord
     organizationId: RecordIdInput
     threadId: RecordIdInput
+    sourceThreadId?: RecordIdInput
     leadAgentId: string
+    createdByAgentId?: string
+    requireApproval: boolean
     nodes: CompiledPlanNode[]
     emittedEvents: PlanEventRecord[]
     createdEventType: 'plan-created' | 'plan-replaced'
@@ -665,7 +999,7 @@ class ExecutionPlanService {
     createdEventDetail: Record<string, unknown>
     checkpointReason: 'plan-created' | 'plan-replaced'
     runPatch?: { replacedRunId?: RecordIdInput }
-  }): Promise<void> {
+  }): Promise<PlanRunRecord> {
     const nodeSpecs = await this.createNodeSpecs(params.tx, params.spec.id, params.nodes)
     const run = PlanRunSchema.parse(
       await params.tx
@@ -674,29 +1008,33 @@ class ExecutionPlanService {
           planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
           organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
           threadId: ensureRecordId(params.threadId, TABLES.THREAD),
+          ...(params.sourceThreadId ? { sourceThreadId: ensureRecordId(params.sourceThreadId, TABLES.THREAD) } : {}),
           leadAgentId: params.leadAgentId,
-          status: 'running',
+          ...(params.createdByAgentId ? { createdByAgentId: params.createdByAgentId } : {}),
+          status: params.requireApproval ? 'pending-approval' : 'running',
           readyNodeIds: [],
           failureCount: 0,
           ...(params.runPatch?.replacedRunId
             ? { replacedRunId: ensureRecordId(params.runPatch.replacedRunId, TABLES.PLAN_RUN) }
             : {}),
-          startedAt: new Date(),
+          ...(params.requireApproval ? {} : { startedAt: new Date() }),
         })
         .output('after'),
     )
 
     const nodeRuns = await this.createNodeRuns(params.tx, run.id, params.spec.id, nodeSpecs)
-    const synced = await planExecutorService.syncRunGraph({
-      tx: params.tx,
-      run,
-      spec: params.spec,
-      nodeSpecs,
-      nodeRuns,
-      artifacts: [],
-      emittedBy: params.leadAgentId,
-      capturedEvents: params.emittedEvents,
-    })
+    const synced = params.requireApproval
+      ? { run, nodeRuns }
+      : await planExecutorService.syncRunGraph({
+          tx: params.tx,
+          run,
+          spec: params.spec,
+          nodeSpecs,
+          nodeRuns,
+          artifacts: [],
+          emittedBy: params.leadAgentId,
+          capturedEvents: params.emittedEvents,
+        })
 
     const event = await params.tx
       .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
@@ -711,6 +1049,22 @@ class ExecutionPlanService {
       .output('after')
     params.emittedEvents.push(PlanEventSchema.parse(event))
 
+    if (params.requireApproval) {
+      const pendingApprovalEvent = await params.tx
+        .create(new RecordId(TABLES.PLAN_EVENT, Bun.randomUUIDv7()))
+        .content({
+          planSpecId: ensureRecordId(params.spec.id, TABLES.PLAN_SPEC),
+          runId: ensureRecordId(synced.run.id, TABLES.PLAN_RUN),
+          eventType: 'plan-pending-approval',
+          toStatus: synced.run.status,
+          message: `Execution plan "${params.spec.title}" is pending approval.`,
+          emittedBy: params.leadAgentId,
+          detail: { ...params.createdEventDetail, nodeCount: nodeSpecs.length },
+        })
+        .output('after')
+      params.emittedEvents.push(PlanEventSchema.parse(pendingApprovalEvent))
+    }
+
     const checkpoint = PlanCheckpointSchema.parse(
       await params.tx
         .create(new RecordId(TABLES.PLAN_CHECKPOINT, Bun.randomUUIDv7()))
@@ -756,6 +1110,8 @@ class ExecutionPlanService {
       })
       .output('after')
     params.emittedEvents.push(PlanEventSchema.parse(checkpointEvent))
+
+    return updatedRun
   }
 }
 

package/src/services/global-orchestrator.service.ts

@@ -16,7 +16,7 @@ function formatDispatchError(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
 }
 
-const STABLE_RUN_STATUSES = new Set(['awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
+const STABLE_RUN_STATUSES = new Set(['pending-approval', 'awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
 
 class GlobalOrchestratorService {
   detectConvergence(params: {

package/src/services/ownership-dispatcher.service.ts

@@ -34,7 +34,7 @@ import { systemExecutorService } from './system-executor.service'
 import { ThreadSchema } from './thread.types'
 import { userService } from './user.service'
 
-const STABLE_RUN_STATUSES = new Set(['awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
+const STABLE_RUN_STATUSES = new Set(['pending-approval', 'awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
 const MAX_DISPATCH_ITERATIONS = 64
 
 function toPlanNodeSpec(nodeSpec: PlanNodeSpecRecord): PlanNodeSpec {

package/src/services/plan-agent-query.service.ts

@@ -1,5 +1,6 @@
 import type { PlanExecutionVisibility, PlanNodeSpecRecord, PlanRunRecord, PlanSpecRecord } from '@lota-sdk/shared'
 import { PlanRunSchema } from '@lota-sdk/shared'
+import { BoundQuery } from 'surrealdb'
 
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
@@ -254,10 +255,10 @@ class PlanAgentQueryService {
 
     const whereOrganization = organizationId ? ' AND organizationId = $organizationId' : ''
     return databaseService.queryMany(
-      {
-        query: `SELECT * FROM ${TABLES.PLAN_RUN} WHERE status INSIDE $statuses${whereOrganization} ORDER BY updatedAt DESC`,
+      new BoundQuery(
+        `SELECT * FROM ${TABLES.PLAN_RUN} WHERE status INSIDE $statuses${whereOrganization} ORDER BY updatedAt DESC`,
         bindings,
-      },
+      ),
       PlanRunSchema,
     )
   }

package/src/services/plan-builder.service.ts

@@ -18,10 +18,6 @@ function buildImplicitLinearEdges(draft: PlanDraft) {
 }
 
 class PlanBuilderService {
-  roleAssignment(draft: PlanDraft): PlanDraft {
-    return draft
-  }
-
   structureDesign(draft: PlanDraft): PlanDraft {
     return {
       ...draft,
@@ -63,8 +59,7 @@ class PlanBuilderService {
   }
 
   prepareDraft(draft: PlanDraft): PlanDraft {
-    const withRoles = this.roleAssignment(draft)
-    const withStructure = this.structureDesign(withRoles)
+    const withStructure = this.structureDesign(draft)
     return this.semanticCompletion(withStructure)
   }
 }

package/src/services/plan-deadline.service.ts

@@ -8,7 +8,7 @@ import type {
   PlanRunRecord,
 } from '@lota-sdk/shared'
 import { PlanEventSchema, PlanNodeRunSchema, PlanNodeSpecRecordSchema, PlanRunSchema } from '@lota-sdk/shared'
-import { RecordId } from 'surrealdb'
+import { BoundQuery, RecordId } from 'surrealdb'
 
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
@@ -185,10 +185,9 @@ class PlanDeadlineService {
     entries: Array<{ nodeRun: PlanNodeRunRecord; nodeSpec: PlanNodeSpecRecord; evaluation: DeadlineEvaluationResult }>
   }> {
     const activeNodeRuns = await databaseService.queryMany(
-      {
-        query: `SELECT * FROM ${TABLES.PLAN_NODE_RUN} WHERE status IN $statuses`,
-        bindings: { statuses: ['running', 'awaiting-human'] },
-      },
+      new BoundQuery(`SELECT * FROM ${TABLES.PLAN_NODE_RUN} WHERE status IN $statuses`, {
+        statuses: ['running', 'awaiting-human'],
+      }),
       PlanNodeRunSchema,
     )
 
@@ -380,20 +379,20 @@ class PlanDeadlineService {
 
     if (dedupeKey) {
       const existing = await databaseService.queryMany(
-        {
-          query: `SELECT * FROM ${TABLES.PLAN_EVENT}
+        new BoundQuery(
+          `SELECT * FROM ${TABLES.PLAN_EVENT}
             WHERE runId = $runId
               AND nodeId = $nodeId
               AND eventType = $eventType
               AND detail.dedupeKey = $dedupeKey
             LIMIT 1`,
-          bindings: {
+          {
             runId: ensureRecordId(params.run.id, TABLES.PLAN_RUN),
             nodeId: params.nodeRun.nodeId,
             eventType: params.eventType,
             dedupeKey,
           },
-        },
+        ),
         PlanEventSchema,
       )
       if (existing.length > 0) {