@lota-sdk/core 0.4.3 → 0.4.4

package/infrastructure/schema/02_execution_plan.surql

@@ -86,7 +86,9 @@ DEFINE TABLE IF NOT EXISTS planRun SCHEMAFULL;
 DEFINE FIELD IF NOT EXISTS planSpecId ON TABLE planRun TYPE record<planSpec> REFERENCE ON DELETE CASCADE;
 DEFINE FIELD IF NOT EXISTS organizationId ON TABLE planRun TYPE record<organization>;
 DEFINE FIELD IF NOT EXISTS threadId ON TABLE planRun TYPE record<thread> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS sourceThreadId ON TABLE planRun TYPE option<record<thread>>;
 DEFINE FIELD IF NOT EXISTS leadAgentId ON TABLE planRun TYPE string;
+DEFINE FIELD IF NOT EXISTS createdByAgentId ON TABLE planRun TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS status ON TABLE planRun TYPE string;
 DEFINE FIELD IF NOT EXISTS currentNodeId ON TABLE planRun TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS waitingNodeId ON TABLE planRun TYPE option<string>;
@@ -103,7 +105,9 @@ DEFINE FIELD IF NOT EXISTS completedAt ON TABLE planRun TYPE option<datetime>;
 
 DEFINE INDEX IF NOT EXISTS planRunOrgIdx ON TABLE planRun COLUMNS organizationId;
 DEFINE INDEX IF NOT EXISTS planRunThreadIdx ON TABLE planRun COLUMNS threadId;
+DEFINE INDEX IF NOT EXISTS planRunSourceThreadIdx ON TABLE planRun COLUMNS sourceThreadId;
 DEFINE INDEX IF NOT EXISTS planRunThreadStatusIdx ON TABLE planRun COLUMNS threadId, status;
+DEFINE INDEX IF NOT EXISTS planRunSourceThreadStatusIdx ON TABLE planRun COLUMNS sourceThreadId, status;
 DEFINE INDEX IF NOT EXISTS planRunSpecIdx ON TABLE planRun COLUMNS planSpecId;
 
 DEFINE TABLE IF NOT EXISTS planNodeRun SCHEMAFULL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,7 +32,7 @@
     "@chat-adapter/slack": "^4.23.0",
     "@chat-adapter/state-ioredis": "^4.23.0",
     "@logtape/logtape": "^2.0.5",
-    "@lota-sdk/shared": "0.4.3",
+    "@lota-sdk/shared": "0.4.4",
     "@mendable/firecrawl-js": "^4.18.1",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.145",

package/src/runtime/execution-plan.ts

@@ -16,9 +16,7 @@ function toExecutionPlanPromptSummaries(plans: SerializableExecutionPlan[]): Exe
   return plans.map(({ runId, title }) => ({ runId, title }))
 }
 
-function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): string | undefined {
-  if (plans.length === 0) return undefined
-
+function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): string {
   const payload = { activePlans: toExecutionPlanPromptSummaries(plans), planCount: plans.length }
 
   return ['<execution-plan-state>', JSON.stringify(payload, null, 2), '</execution-plan-state>'].join('\n')
@@ -26,10 +24,7 @@ function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): stri
 
 export function buildExecutionPlanInstructionSections(plans: SerializableExecutionPlan[] | null | undefined): string[] {
   const normalized = plans ?? []
-  const sections = [EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT]
-  const stateSection = formatExecutionPlansForPrompt(normalized)
-  if (stateSection) sections.push(stateSection)
-  return sections
+  return [EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT, formatExecutionPlansForPrompt(normalized)]
 }
 
 export function createExecutionPlanInstructionSectionCache(params: {

package/src/services/agent-activity.service.ts

@@ -41,6 +41,14 @@ type AgentActivityDeps = {
   threadService: Pick<typeof threadService, 'listThreads'>
 }
 
+function isPendingPlanApproval(plan: SerializableExecutionPlan): boolean {
+  return plan.status === 'pending-approval'
+}
+
+function countPendingPlanApprovals(activePlans: ActivePlanEntry[]): number {
+  return activePlans.filter(({ plan }) => isPendingPlanApproval(plan)).length
+}
+
 function normalizeCardStatus(status: string): BoardColumnStatus {
   if (status === 'pending' || status === 'scheduled') return 'ready'
   if (status === 'partial') return 'completed'
@@ -145,9 +153,9 @@ export class AgentActivityService {
 
   async getBoard(userRef: string, orgRef: string): Promise<PlanBoardResponse> {
     const activePlans = await this.getAllActivePlans(userRef, orgRef)
-    const cards = activePlans.flatMap(({ plan, thread }) =>
-      plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)),
-    )
+    const cards = activePlans
+      .filter(({ plan }) => !isPendingPlanApproval(plan))
+      .flatMap(({ plan, thread }) => plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)))
 
     const columns: PlanBoardColumn[] = BOARD_COLUMN_ORDER.map((status) => ({
       status,
@@ -161,7 +169,7 @@ export class AgentActivityService {
         totalNodes: cards.length,
         completedNodes: cards.filter((card) => card.status === 'completed').length,
         activePlanCount: activePlans.length,
-        pendingApprovalCount: cards.filter((card) => card.hasApproval).length,
+        pendingApprovalCount: countPendingPlanApprovals(activePlans) + cards.filter((card) => card.hasApproval).length,
       },
     }
   }
@@ -187,8 +195,13 @@ export class AgentActivityService {
   async getMyTasks(userRef: string, orgRef: string): Promise<MyTasksResponse> {
     const activePlans = await this.getAllActivePlans(userRef, orgRef)
     const tasks: PlanNodeCard[] = []
+    const pendingPlanApprovalCount = countPendingPlanApprovals(activePlans)
 
     for (const { plan, thread } of activePlans) {
+      if (isPendingPlanApproval(plan)) {
+        continue
+      }
+
       for (const node of plan.nodes) {
         const humanOwned = node.owner.executorType === 'user'
         const awaitingHuman = node.status === 'awaiting-human'
@@ -198,7 +211,7 @@ export class AgentActivityService {
       }
     }
 
-    return { tasks, pendingApprovalCount: tasks.filter((task) => task.hasApproval).length }
+    return { tasks, pendingApprovalCount: pendingPlanApprovalCount + tasks.filter((task) => task.hasApproval).length }
   }
 
   async getAgentActivity(userRef: string, orgRef: string): Promise<AgentActivityResponse> {
@@ -210,6 +223,23 @@ export class AgentActivityService {
     }
 
     for (const { plan, thread } of activePlans) {
+      if (isPendingPlanApproval(plan)) {
+        if (plan.leadAgentId.trim()) {
+          const leadEntry = this.ensureEntry(activityByAgent, plan.leadAgentId)
+          leadEntry.isLeadingActivePlan = true
+          this.ensureProjectEntry(leadEntry.projects, {
+            threadId: thread.id,
+            threadTitle: thread.title,
+            planRunId: plan.runId,
+            planTitle: plan.title,
+            status: plan.status,
+          })
+          leadEntry.isRunning = leadEntry.isRunning || thread.isRunning
+          leadEntry.lastActiveAt = maxIsoDate(leadEntry.lastActiveAt, thread.updatedAt)
+        }
+        continue
+      }
+
       const involvedAgents = new Set<string>()
 
       for (const node of plan.nodes) {

package/src/services/artifact.service.ts

@@ -270,25 +270,25 @@ class ArtifactService {
 
     let lastError: unknown = null
     for (let attempt = 1; attempt <= ARTIFACT_PUBLISH_MAX_ATTEMPTS; attempt += 1) {
-      let pendingStorageKey: string | null = null
+      const publishAttemptState: { pendingStorageKey?: string } = {}
       try {
         return await databaseService.withTransaction(
           async (tx) =>
             await this.publishArtifactInTransaction(params, tx, {
               onStorageWrite: (storageKey) => {
-                pendingStorageKey = storageKey
+                publishAttemptState.pendingStorageKey = storageKey
               },
               onStorageCleanup: (storageKey) => {
-                if (pendingStorageKey === storageKey) {
-                  pendingStorageKey = null
+                if (publishAttemptState.pendingStorageKey === storageKey) {
+                  publishAttemptState.pendingStorageKey = undefined
                 }
               },
             }),
         )
       } catch (error) {
-        const storageKeyToCleanup = pendingStorageKey
-        pendingStorageKey = null
-        if (storageKeyToCleanup !== null) {
+        const storageKeyToCleanup = publishAttemptState.pendingStorageKey
+        publishAttemptState.pendingStorageKey = undefined
+        if (typeof storageKeyToCleanup === 'string') {
           await generatedDocumentStorageService.deleteTextArtifact(storageKeyToCleanup).catch(() => undefined)
         }
         lastError = error

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-run-data.ts

@@ -1,4 +1,9 @@
-import type { ExecutionPlanToolResultData, PlanRunRecord, SerializableExecutionPlan } from '@lota-sdk/shared'
+import type {
+  ExecutionPlanToolPlanSummary,
+  ExecutionPlanToolResultData,
+  PlanRunRecord,
+  SerializableExecutionPlan,
+} from '@lota-sdk/shared'
 
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId } from '../db/record-id'
@@ -7,12 +12,25 @@ import { toDatabaseDateTime } from '../utils/date-time'
 
 export type PlanRunUpdate = Omit<
   Partial<PlanRunRecord>,
-  'currentNodeId' | 'waitingNodeId' | 'replacedRunId' | 'lastCheckpointId' | 'startedAt' | 'completedAt'
+  | 'sourceThreadId'
+  | 'createdByAgentId'
+  | 'currentNodeId'
+  | 'waitingNodeId'
+  | 'replacedRunId'
+  | 'lastCheckpointId'
+  | 'scheduledAt'
+  | 'scheduleId'
+  | 'startedAt'
+  | 'completedAt'
 > & {
+  sourceThreadId?: RecordIdInput | null
+  createdByAgentId?: string | null
   currentNodeId?: string | null
   waitingNodeId?: string | null
   replacedRunId?: RecordIdInput | null
   lastCheckpointId?: RecordIdInput | null
+  scheduledAt?: string | Date | null
+  scheduleId?: RecordIdInput | null
   startedAt?: string | Date | null
   completedAt?: string | Date | null
 }
@@ -22,7 +40,21 @@ export function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
     planSpecId: ensureRecordId(run.planSpecId, TABLES.PLAN_SPEC),
     organizationId: ensureRecordId(run.organizationId, TABLES.ORGANIZATION),
     threadId: ensureRecordId(run.threadId, TABLES.THREAD),
+    ...(patch.sourceThreadId === null
+      ? {}
+      : patch.sourceThreadId !== undefined
+        ? { sourceThreadId: ensureRecordId(patch.sourceThreadId, TABLES.THREAD) }
+        : run.sourceThreadId
+          ? { sourceThreadId: ensureRecordId(run.sourceThreadId, TABLES.THREAD) }
+          : {}),
     leadAgentId: patch.leadAgentId ?? run.leadAgentId,
+    ...(patch.createdByAgentId === null
+      ? {}
+      : patch.createdByAgentId !== undefined
+        ? { createdByAgentId: patch.createdByAgentId }
+        : run.createdByAgentId
+          ? { createdByAgentId: run.createdByAgentId }
+          : {}),
     status: patch.status ?? run.status,
     ...(patch.currentNodeId === null
       ? {}
@@ -54,6 +86,20 @@ export function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
         : run.lastCheckpointId
           ? { lastCheckpointId: ensureRecordId(run.lastCheckpointId, TABLES.PLAN_CHECKPOINT) }
           : {}),
+    ...(patch.scheduledAt === null
+      ? {}
+      : patch.scheduledAt !== undefined
+        ? { scheduledAt: toDatabaseDateTime(patch.scheduledAt) }
+        : run.scheduledAt
+          ? { scheduledAt: toDatabaseDateTime(run.scheduledAt) }
+          : {}),
+    ...(patch.scheduleId === null
+      ? {}
+      : patch.scheduleId
+        ? { scheduleId: ensureRecordId(patch.scheduleId, TABLES.PLAN_SCHEDULE) }
+        : run.scheduleId
+          ? { scheduleId: ensureRecordId(run.scheduleId, TABLES.PLAN_SCHEDULE) }
+          : {}),
     ...(patch.startedAt === null
       ? {}
       : patch.startedAt !== undefined
@@ -71,13 +117,17 @@ export function toRunData(run: PlanRunRecord, patch: PlanRunUpdate) {
   }
 }
 
-function toSlimPlanSummary(plan: SerializableExecutionPlan): NonNullable<ExecutionPlanToolResultData['plan']> {
+export function toToolPlanSummary(plan: SerializableExecutionPlan): ExecutionPlanToolPlanSummary {
   const completed = plan.progress.completed + plan.progress.partial
   return {
     runId: plan.runId,
+    threadId: plan.threadId,
     title: plan.title,
     objective: plan.objective,
     status: plan.status,
+    leadAgentId: plan.leadAgentId,
+    ...(plan.sourceThreadId ? { sourceThreadId: plan.sourceThreadId } : {}),
+    ...(plan.createdByAgentId ? { createdByAgentId: plan.createdByAgentId } : {}),
     progress: { completed, total: plan.progress.total },
     nodes: plan.nodes.map((node) => ({
       id: node.id,
@@ -85,7 +135,23 @@ function toSlimPlanSummary(plan: SerializableExecutionPlan): NonNullable<Executi
       type: node.type,
       status: node.status,
       ownerRef: node.owner.ref,
+      objective: node.objective,
+      ownerType: node.owner.executorType,
+      artifactCount: plan.artifacts.filter((artifact) => artifact.nodeId === node.id).length,
+      approvalId:
+        plan.approvals.find((approval) => approval.nodeId === node.id && approval.status === 'pending')?.id ?? null,
+      approvalStatus:
+        plan.approvals.find((approval) => approval.nodeId === node.id && approval.status === 'pending')?.status ?? null,
+      blockedReason: node.blockedReason ?? null,
+      latestNotes: node.latestNotes ?? null,
+      startedAt: node.startedAt ?? null,
+      completedAt: node.completedAt ?? null,
+      readyAt: node.readyAt ?? null,
+      deliverableNames: node.deliverables.map((deliverable) => deliverable.name),
+      upstreamNodeIds: [...node.upstreamNodeIds],
+      downstreamNodeIds: [...node.downstreamNodeIds],
     })),
+    edges: [...plan.edges],
     activeNodeIds: plan.activeNodeIds,
     readyNodeIds: plan.readyNodeIds,
   }
@@ -96,7 +162,7 @@ export function buildExecutionPlanToolResult(params: {
   plan: SerializableExecutionPlan | null
   message: string
 }): ExecutionPlanToolResultData {
-  const slim = params.plan ? toSlimPlanSummary(params.plan) : null
+  const slim = params.plan ? toToolPlanSummary(params.plan) : null
   return {
     action: params.action,
     message: params.message,

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

@@ -37,7 +37,7 @@ import { databaseService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
 
-const ACTIVE_RUN_STATUSES = new Set(['running', 'awaiting-human', 'blocked'])
+const ACTIVE_RUN_STATUSES = new Set(['pending-approval', 'running', 'awaiting-human', 'blocked'])
 
 function buildProgress(nodeRuns: PlanNodeRunRecord[]) {
   const counts = nodeRuns.reduce(
@@ -239,6 +239,31 @@ class PlanRunService {
     return runs.filter((run) => ACTIVE_RUN_STATUSES.has(run.status))
   }
 
+  async getRunsCreatedInContext(params: {
+    organizationId: RecordIdInput
+    sourceThreadId?: RecordIdInput
+    createdByAgentId?: string
+    statuses?: ReadonlyArray<PlanRunRecord['status']>
+  }): Promise<PlanRunRecord[]> {
+    const filter: Record<string, unknown> = {
+      organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+    }
+    if (params.sourceThreadId) {
+      filter.sourceThreadId = ensureRecordId(params.sourceThreadId, TABLES.THREAD)
+    }
+    if (params.createdByAgentId) {
+      filter.createdByAgentId = params.createdByAgentId
+    }
+
+    const runs = await databaseService.findMany(TABLES.PLAN_RUN, filter, PlanRunSchema, {
+      orderBy: 'updatedAt',
+      orderDir: 'DESC',
+    })
+
+    const statuses = params.statuses ? new Set(params.statuses) : ACTIVE_RUN_STATUSES
+    return runs.filter((run) => statuses.has(run.status))
+  }
+
   async listNodeRuns(runId: RecordIdInput): Promise<PlanNodeRunRecord[]> {
     return databaseService.findMany(
       TABLES.PLAN_NODE_RUN,
@@ -435,12 +460,14 @@ class PlanRunService {
       specId: recordIdToString(spec.id, TABLES.PLAN_SPEC),
       runId: recordIdToString(run.id, TABLES.PLAN_RUN),
       threadId: recordIdToString(run.threadId, TABLES.THREAD),
+      sourceThreadId: run.sourceThreadId ? recordIdToString(run.sourceThreadId, TABLES.THREAD) : undefined,
       organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
       title: spec.title,
       objective: spec.objective,
       version: spec.version,
       status: run.status,
       leadAgentId: run.leadAgentId,
+      createdByAgentId: run.createdByAgentId,
       defaultExecutionVisibility: spec.defaultExecutionVisibility,
       executionMode: spec.executionMode,
       schemaRegistry: slim ? {} : structuredClone(spec.schemaRegistry),

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

@@ -143,7 +143,10 @@ class PlanTemplateService {
     templateId: RecordIdInput
     organizationId: RecordIdInput
     threadId: RecordIdInput
+    sourceThreadId?: RecordIdInput
     leadAgentId: string
+    createdByAgentId?: string
+    requireApproval?: boolean
     overrides?: Partial<PlanDraft>
     carryForwardArtifacts?: PlanArtifactRecord[]
   }): Promise<ExecutionPlanToolResultData> {
@@ -162,7 +165,10 @@ class PlanTemplateService {
     return executionPlanService.createPlan({
       organizationId: params.organizationId,
       threadId: params.threadId,
+      sourceThreadId: params.sourceThreadId,
       leadAgentId: params.leadAgentId,
+      createdByAgentId: params.createdByAgentId,
+      requireApproval: params.requireApproval,
       input: draft,
     })
   }

package/src/tools/execution-plan.tool.ts

@@ -56,10 +56,16 @@ export function createExecutionPlanTool(params: {
         case 'create': {
           const draft = extractAgentPlanDraft(parsed)
           params.validateInlinePlan?.(draft)
+          const targetThreadId = parsed.targetThreadId ?? params.threadId
+          const isCrossThreadTarget =
+            recordIdToString(targetThreadId, TABLES.THREAD) !== recordIdToString(params.threadId, TABLES.THREAD)
           result = await resolvedEpService.createPlan({
             organizationId: params.orgId,
-            threadId: parsed.targetThreadId ?? params.threadId,
+            threadId: targetThreadId,
+            ...(isCrossThreadTarget ? { sourceThreadId: params.threadId } : {}),
             leadAgentId: params.agentId,
+            createdByAgentId: params.agentId,
+            requireApproval: parsed.requireApproval ?? isCrossThreadTarget,
             input: draft,
           })
           break
@@ -101,11 +107,15 @@ export function createExecutionPlanTool(params: {
             const created = await resolvedEpService.createPlan({
               organizationId: params.orgId,
               threadId: targetThread.id,
+              sourceThreadId: params.threadId,
               leadAgentId: params.agentId,
+              createdByAgentId: params.agentId,
+              requireApproval: parsed.requireApproval ?? true,
               input: draft,
             })
             result = {
               ...created,
+              runId: created.plan?.runId ?? '',
               threadId: targetThread.id,
               threadTitle: targetThread.title,
               createdThread,
@@ -125,7 +135,8 @@ export function createExecutionPlanTool(params: {
             organizationId: params.orgId,
             threadId: params.threadId,
             leadAgentId: params.agentId,
-            input: { runId: parsed.runId, reason: parsed.reason, ...draft },
+            createdByAgentId: params.agentId,
+            input: { runId: parsed.runId, reason: parsed.reason, requireApproval: parsed.requireApproval, ...draft },
           })
           break
         }

package/src/tools/index.ts

@@ -1,6 +1,7 @@
 export * from './execution-plan.tool'
 export * from './fetch-webpage.tool'
 export * from './memory-block.tool'
+export * from './plan-approval.tool'
 export * from './read-file-parts.tool'
 export * from './remember-memory.tool'
 export * from './research-topic.tool'

package/src/tools/plan-approval.tool.ts

@@ -0,0 +1,66 @@
+import { PlanApprovalArgsSchema, PlanApprovalToolResultDataSchema } from '@lota-sdk/shared'
+import { tool } from 'ai'
+
+import type { RecordIdRef } from '../db/record-id'
+import { executionPlanService } from '../services/execution-plan.service'
+import { toToolPlanSummary } from '../services/plan-run-data'
+
+type PlanApprovalExecutionPlanService = Pick<typeof executionPlanService, 'approvePlan' | 'rejectPlan'>
+
+export function createPlanApprovalTool(params: {
+  orgId: RecordIdRef
+  threadId: RecordIdRef
+  actorId: string
+  executionPlanService?: PlanApprovalExecutionPlanService
+}) {
+  const resolvedExecutionPlanService = params.executionPlanService ?? executionPlanService
+
+  return tool({
+    description:
+      'Approve, reject, or request changes to a plan that is pending approval. Use approve to start execution, reject to abort it, or modify to request a revised plan.',
+    inputSchema: PlanApprovalArgsSchema,
+    outputSchema: PlanApprovalToolResultDataSchema,
+    execute: async (input) => {
+      switch (input.action) {
+        case 'approve': {
+          const plan = await resolvedExecutionPlanService.approvePlan({
+            organizationId: params.orgId,
+            threadId: params.threadId,
+            runId: input.runId,
+            emittedBy: params.actorId,
+          })
+          const toolPlan = toToolPlanSummary(plan)
+          return {
+            action: 'approved',
+            message: `Approved execution plan "${plan.title}" and started it.`,
+            hasPlan: true,
+            status: toolPlan.status,
+            plan: toolPlan,
+          }
+        }
+        case 'reject':
+        case 'modify': {
+          const plan = await resolvedExecutionPlanService.rejectPlan({
+            organizationId: params.orgId,
+            threadId: params.threadId,
+            runId: input.runId,
+            emittedBy: params.actorId,
+            reason: input.reason,
+            resolution: input.action === 'modify' ? 'changes-requested' : 'rejected',
+          })
+          const toolPlan = toToolPlanSummary(plan)
+          return {
+            action: input.action === 'modify' ? 'changes-requested' : 'rejected',
+            message:
+              input.action === 'modify'
+                ? `Requested changes for execution plan "${plan.title}".`
+                : `Rejected execution plan "${plan.title}".`,
+            hasPlan: true,
+            status: toolPlan.status,
+            plan: toolPlan,
+          }
+        }
+      }
+    },
+  })
+}