@lota-sdk/core 0.1.14 → 0.1.16

package/src/runtime/agent-runtime-policy.ts

@@ -1,3 +1,5 @@
+import type { ExecutionMode, PlanArtifactSubmission, PlanNodeSpec } from '@lota-sdk/shared'
+
 import { getLeadAgentId } from '../config/agent-defaults'
 import { resolveOnboardingOwnerAgentId } from '../config/workstream-defaults'
 import type { ChatMode } from './agent-types'
@@ -31,6 +33,30 @@ export interface AgentToolPolicy<TSkill extends PropertyKey> {
   includeIndexedRepository: boolean
 }
 
+export const OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES = Object.freeze([
+  'conversationSearch',
+  'createExecutionPlan',
+  'replaceExecutionPlan',
+  'submitExecutionNodeResult',
+  'listExecutionPlans',
+  'getExecutionPlanDetails',
+  'resumeExecutionPlanRun',
+  'consultSpecialist',
+  'consultTeam',
+  'teamThink',
+])
+
+function buildOwnershipDispatchArtifactPayload(artifacts: PlanArtifactSubmission[]) {
+  return artifacts.map((artifact) => ({
+    name: artifact.name,
+    kind: artifact.kind,
+    pointer: artifact.pointer,
+    ...(artifact.schemaRef ? { schemaRef: artifact.schemaRef } : {}),
+    ...(artifact.description ? { description: artifact.description } : {}),
+    ...(artifact.payload !== undefined ? { payload: artifact.payload } : {}),
+  }))
+}
+
 export function toChatMode(workstreamMode: 'direct' | 'group'): ChatMode {
   return workstreamMode === 'direct' ? 'fixedWorkstreamMode' : 'workstreamMode'
 }
@@ -160,37 +186,96 @@ export function buildWorkstreamAgentToolPolicy<TAgent extends string, TSkill ext
   }
 }
 
-export function buildTeamConsultationAgentToolPolicy<TAgent extends string, TSkill extends PropertyKey>(params: {
-  agentId: TAgent
-  blockedSkills: readonly TSkill[]
+export function buildTeamConsultationAgentToolPolicy({
+  githubInstalled,
+  provideRepoTool,
+  blockedToolNames,
+}: {
   blockedToolNames: readonly string[]
   githubInstalled: boolean
   provideRepoTool: boolean
-  getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
-}): AgentToolPolicy<TSkill> & { blockedToolNames: Set<string> } {
-  const skills = resolveActiveAgentSkills({
-    agentId: params.agentId,
-    workstreamMode: 'group',
-    mode: 'fixedWorkstreamMode',
-    onboardingActive: false,
-    linearInstalled: false,
-    getAgentSkills: params.getAgentSkills,
-  }).filter((skill) => !params.blockedSkills.includes(skill))
-
+}): AgentToolPolicy<string> & { blockedToolNames: Set<string> } {
   return {
     resolvedMode: 'fixedWorkstreamMode',
-    skills,
-    includeMemorySearch: true,
-    includeConversationSearch: true,
+    skills: [],
+    includeMemorySearch: false,
+    includeConversationSearch: false,
     includeMemoryRemember: false,
-    includeOrgActionSearch: true,
+    includeOrgActionSearch: false,
     includeMemoryBlockAppend: false,
-    includeReadFileParts: true,
+    includeReadFileParts: false,
     includeInspectWebsite: false,
     includeProceedInOnboarding: false,
     includeGithubIntegration: false,
     includeIndexRepositoryByURL: false,
-    includeIndexedRepository: params.githubInstalled && params.provideRepoTool,
-    blockedToolNames: new Set(params.blockedToolNames),
+    includeIndexedRepository: githubInstalled && provideRepoTool,
+    blockedToolNames: new Set(blockedToolNames),
+  }
+}
+
+export function buildOwnershipDispatchContextSection(params: {
+  node: PlanNodeSpec
+  resolvedInput: Record<string, unknown>
+  inputArtifacts: PlanArtifactSubmission[]
+}): string {
+  const payload = {
+    node: {
+      id: params.node.id,
+      label: params.node.label,
+      owner: params.node.owner,
+      objective: params.node.objective,
+      instructions: params.node.instructions,
+      outputSchemaRef: params.node.outputSchemaRef ?? null,
+      deliverables: params.node.deliverables,
+      successCriteria: params.node.successCriteria,
+      completionChecks: params.node.completionChecks,
+      toolPolicy: params.node.toolPolicy,
+      contextPolicy: params.node.contextPolicy,
+    },
+    resolvedInput: params.resolvedInput,
+    inputArtifacts: buildOwnershipDispatchArtifactPayload(params.inputArtifacts),
   }
+
+  return [
+    '<ownership-dispatch-execution>',
+    'You are executing a single isolated execution-plan node.',
+    'Do not ask the user questions. Do not reference any hidden or prior workstream chat history.',
+    'Use only the provided node context, resolved input, and input artifacts.',
+    'Return only the final structured node result that satisfies the required output contract.',
+    JSON.stringify(payload, null, 2),
+    '</ownership-dispatch-execution>',
+  ].join('\n')
+}
+
+export function buildOwnershipDispatchResponseGuard(params: {
+  node: PlanNodeSpec
+  executionMode?: ExecutionMode
+}): string {
+  const mode = params.executionMode ?? 'linear'
+
+  if (mode === 'linear') {
+    return [
+      '<ownership-dispatch-result-contract>',
+      'Return a single JSON object with this exact shape:',
+      '{"structuredOutput"?: object, "artifacts": Array<{ "name": string, "kind": "json"|"markdown"|"file"|"external-ref"|"record", "pointer": string, "schemaRef"?: string, "description"?: string, "payload"?: object|array }>, "notes"?: string}',
+      'Do not wrap the JSON in markdown or code fences.',
+      `Node label: ${params.node.label}`,
+      `Required deliverables: ${params.node.deliverables.length > 0 ? params.node.deliverables.map((item) => item.name).join(', ') : 'none'}`,
+      '</ownership-dispatch-result-contract>',
+    ].join('\n')
+  }
+
+  return [
+    '<ownership-dispatch-result-contract>',
+    'Produce outputs by calling the writeIntent tool for each deliverable.',
+    `Required deliverables: ${
+      params.node.deliverables
+        .filter((d) => d.required)
+        .map((d) => d.name)
+        .join(', ') || 'none'
+    }`,
+    'If writeIntent returns validation_failed, correct and re-call.',
+    'After all writes, return a brief summary.',
+    '</ownership-dispatch-result-contract>',
+  ].join('\n')
 }

package/src/runtime/agent-stream-helpers.ts

@@ -2,13 +2,14 @@ import type { ChatMessage } from '@lota-sdk/shared'
 import type { LanguageModelUsage, UIMessageStreamOptions } from 'ai'
 
 import { agentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defaults'
+import { readRecord as _readRecord } from '../utils/string'
 
 export function readFiniteNumber(value: unknown): number | undefined {
   return typeof value === 'number' && Number.isFinite(value) ? value : undefined
 }
 
 export function readRecord(value: unknown): Record<string, unknown> | undefined {
-  return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined
+  return _readRecord(value) ?? undefined
 }
 
 export function readOpenRouterUsageCost(usage: LanguageModelUsage): { cost?: number; upstreamInferenceCost?: number } {

package/src/runtime/approval-continuation.ts

@@ -45,21 +45,27 @@ export function readApprovalContinuationResponse(message: ChatMessage): Approval
 }
 
 export function isApprovalContinuationRequest(messages: ChatMessage[]): boolean {
-  const lastAssistant = [...messages].reverse().find((message) => message.role === 'assistant')
-  if (!lastAssistant) return false
+  let lastAssistantIndex = -1
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'assistant') {
+      lastAssistantIndex = i
+      break
+    }
+  }
+  if (lastAssistantIndex < 0) return false
 
-  const lastMessageIndex = messages.lastIndexOf(lastAssistant)
-  const hasUserAfter = messages.slice(lastMessageIndex + 1).some((message) => message.role === 'user')
+  const hasUserAfter = messages.slice(lastAssistantIndex + 1).some((message) => message.role === 'user')
   if (hasUserAfter) return false
 
-  return hasApprovalRespondedParts(lastAssistant)
+  return hasApprovalRespondedParts(messages[lastAssistantIndex])
 }
 
 const PLAN_TOOL_NAMES = new Set([
   'createExecutionPlan',
   'replaceExecutionPlan',
   'submitExecutionNodeResult',
-  'getActiveExecutionPlan',
+  'listExecutionPlans',
+  'getExecutionPlanDetails',
   'resumeExecutionPlanRun',
 ])
 

package/src/runtime/context-compaction-constants.ts

@@ -7,5 +7,5 @@ export const CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES = ['userQuestions', 'proceed
 export const CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES = ['linear'] as const
 export const MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES = 15
 export const MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES = 10
-export const CONTEXT_SIZE = 200_000
+export const CONTEXT_WINDOW_TOKENS = 200_000
 export const WORKSTREAM_RAW_TAIL_MESSAGES = 6

package/src/runtime/context-compaction-runtime.ts

@@ -1,4 +1,4 @@
-import { createContextCompacterAgent } from '../system-agents/context-compacter.agent'
+import { createContextCompactionAgent } from '../system-agents/context-compaction.agent'
 import {
   buildContextCompactionPrompt,
   buildMemoryBlockCompactionPrompt,
@@ -18,6 +18,8 @@ import {
 import type { GenerateHelperStructuredParams, GenerateHelperTextParams } from './helper-model'
 import { StructuredCompactionOutputSchema } from './workstream-state'
 
+const CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS = 512
+
 interface HelperModelRuntime {
   generateHelperStructured<T>(params: GenerateHelperStructuredParams<T>): Promise<T>
   generateHelperText(params: GenerateHelperTextParams): Promise<string>
@@ -32,7 +34,7 @@ interface CreateContextCompactionRuntimeDeps {
 async function runContextCompacter(helperModelRuntime: HelperModelRuntime, params: ContextCompactionRunnerParams) {
   const output = await helperModelRuntime.generateHelperStructured({
     tag: 'context-compaction',
-    createAgent: createContextCompacterAgent,
+    createAgent: createContextCompactionAgent,
     messages: [
       {
         role: 'user',
@@ -74,11 +76,11 @@ export function createWiredContextCompactionRuntime(deps: CreateContextCompactio
     const newEntriesText = params.newEntriesText.trim()
     if (!previousSummary && !newEntriesText) return ''
 
-    return await helperModelRuntime.generateHelperText({
+    return helperModelRuntime.generateHelperText({
       tag: 'memory-block-compaction',
-      createAgent: createContextCompacterAgent,
+      createAgent: createContextCompactionAgent,
       messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
-      maxOutputTokens: 512,
+      maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
     })
   }
 

package/src/runtime/context-compaction.ts

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from 'node:crypto'
 
 import type { ChatMessage } from '@lota-sdk/shared'
 
-import { readString } from '../utils/string'
+import { CHARS_PER_TOKEN_ESTIMATE, compactWhitespace, readRecord, readString, stringifyUnknown } from '../utils/string'
 import {
   COMPACTION_CHUNK_MAX_CHARS,
   CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES,
@@ -15,14 +15,8 @@ import {
 import {
   StructuredCompactionOutputSchema,
   WorkstreamStateDeltaSchema,
-  WORKSTREAM_STATE_MAX_ACTIVE_CONSTRAINTS,
-  WORKSTREAM_STATE_MAX_AGENT_CONTRIBUTIONS,
-  WORKSTREAM_STATE_MAX_ARTIFACTS,
-  WORKSTREAM_STATE_MAX_KEY_DECISIONS,
-  WORKSTREAM_STATE_MAX_OPEN_QUESTIONS,
-  WORKSTREAM_STATE_MAX_RISKS,
-  WORKSTREAM_STATE_MAX_TASKS,
   WorkstreamStateSchema,
+  applyWorkstreamStateCaps,
   createEmptyWorkstreamState,
   parseStructuredWorkstreamStateDelta,
 } from './workstream-state'
@@ -99,15 +93,11 @@ const PROMPT_INJECTION_PATTERN =
   /\b(ignore (all )?(previous|prior|system|developer)? instructions?|system prompt|developer prompt|tool override|jailbreak|role ?override|do not follow|bypass)\b/i
 
 function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 3)
-}
-
-function normalizeWhitespace(value: string): string {
-  return value.replace(/\s+/g, ' ').trim()
+  return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE)
 }
 
 function sanitizeStateText(value: string): string | null {
-  const normalized = normalizeWhitespace(value)
+  const normalized = compactWhitespace(value)
   if (!normalized) return null
   if (PROMPT_INJECTION_PATTERN.test(normalized)) return null
   return normalized
@@ -116,36 +106,18 @@ function sanitizeStateText(value: string): string | null {
 function createStableId(prefix: string, ...parts: Array<string | number | undefined>): string {
   const payload = parts
     .map((part) => (part === undefined ? '' : String(part)))
-    .map((part) => normalizeWhitespace(part))
+    .map((part) => compactWhitespace(part))
     .join('|')
   const hash = createHash('sha1').update(`${prefix}|${payload}`).digest('hex').slice(0, 20)
   return `${prefix}_${hash}`
 }
 
-function readRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : null
-}
-
-function stringifyUnknown(value: unknown): string | null {
-  if (value === undefined) return null
-  if (typeof value === 'string') {
-    const normalized = value.trim()
-    return normalized.length > 0 ? normalized : null
-  }
-
-  try {
-    return JSON.stringify(value)
-  } catch {
-    return null
-  }
-}
-
 function appendUnique(values: string[], nextValues: string[]): string[] {
-  const seen = new Set(values.map((value) => normalizeWhitespace(value).toLowerCase()))
+  const seen = new Set(values.map((value) => compactWhitespace(value).toLowerCase()))
   const merged = [...values]
 
   for (const value of nextValues) {
-    const normalized = normalizeWhitespace(value)
+    const normalized = compactWhitespace(value)
     if (!normalized) continue
     const key = normalized.toLowerCase()
     if (seen.has(key)) continue
@@ -395,7 +367,7 @@ export function mergeStateDelta(
       const normalizedRationale = sanitizeStateText(decision.rationale)
       if (!normalizedDecision || !normalizedRationale) continue
 
-      const sourceIds = [...new Set(decision.sourceMessageIds.map((id) => normalizeWhitespace(id)).filter(Boolean))]
+      const sourceIds = [...new Set(decision.sourceMessageIds.map((id) => compactWhitespace(id)).filter(Boolean))]
       const decisionId = createStableId('decision', normalizedDecision, normalizedRationale, sourceIds.sort().join('|'))
       const alreadyExists = state.keyDecisions.some((item) => item.id === decisionId)
       if (alreadyExists) continue
@@ -403,7 +375,7 @@ export function mergeStateDelta(
         id: decisionId,
         decision: normalizedDecision,
         rationale: normalizedRationale,
-        agent: normalizeWhitespace(decision.agent),
+        agent: compactWhitespace(decision.agent),
         sourceMessageIds: sourceIds,
         confidence: decision.confidence,
         timestamp,
@@ -417,11 +389,9 @@ export function mergeStateDelta(
       if (!title) continue
 
       const externalId = sanitizeStateText(update.externalId ?? '')
-      const owner = normalizeWhitespace(update.owner)
+      const owner = compactWhitespace(update.owner)
       const taskId = externalId ? createStableId('task-external', externalId) : createStableId('task', title, owner)
-      const sourceMessageIds = [
-        ...new Set(update.sourceMessageIds.map((id) => normalizeWhitespace(id)).filter(Boolean)),
-      ]
+      const sourceMessageIds = [...new Set(update.sourceMessageIds.map((id) => compactWhitespace(id)).filter(Boolean))]
       const existingIndex = state.tasks.findIndex((task) => task.id === taskId)
       const nextTask = {
         id: taskId,
@@ -455,7 +425,7 @@ export function mergeStateDelta(
       const artifactId = createStableId('artifact', name, pointer)
       const exists = state.artifacts.some((item) => item.id === artifactId)
       if (exists) continue
-      state.artifacts.push({ id: artifactId, name, type: normalizeWhitespace(artifact.type), pointer, timestamp })
+      state.artifacts.push({ id: artifactId, name, type: compactWhitespace(artifact.type), pointer, timestamp })
     }
   }
 
@@ -495,13 +465,7 @@ export function mergeStateDelta(
     state.approvalNote = sanitizeStateText(delta.approvalNote) ?? undefined
   }
 
-  state.keyDecisions = state.keyDecisions.slice(-WORKSTREAM_STATE_MAX_KEY_DECISIONS)
-  state.activeConstraints = state.activeConstraints.slice(-WORKSTREAM_STATE_MAX_ACTIVE_CONSTRAINTS)
-  state.tasks = state.tasks.slice(-WORKSTREAM_STATE_MAX_TASKS)
-  state.openQuestions = state.openQuestions.slice(-WORKSTREAM_STATE_MAX_OPEN_QUESTIONS)
-  state.risks = state.risks.slice(-WORKSTREAM_STATE_MAX_RISKS)
-  state.artifacts = state.artifacts.slice(-WORKSTREAM_STATE_MAX_ARTIFACTS)
-  state.agentContributions = state.agentContributions.slice(-WORKSTREAM_STATE_MAX_AGENT_CONTRIBUTIONS)
+  applyWorkstreamStateCaps(state)
 
   return WorkstreamStateSchema.parse(state)
 }
@@ -727,9 +691,12 @@ export function createContextCompactionRuntime(
     return summaryMessage ? [summaryMessage, ...liveMessages] : [...liveMessages]
   }
 
+  const CONTEXT_OUTPUT_RESERVE_MAX_RATIO = 0.35
+  const CONTEXT_SAFETY_MARGIN_MAX_RATIO = 0.1
+
   const estimateThreshold = (contextSize = 256_000): number => {
-    const reservedOutput = Math.min(outputReserveTokens, Math.floor(contextSize * 0.35))
-    const safetyMargin = Math.min(safetyMarginTokens, Math.floor(contextSize * 0.1))
+    const reservedOutput = Math.min(outputReserveTokens, Math.floor(contextSize * CONTEXT_OUTPUT_RESERVE_MAX_RATIO))
+    const safetyMargin = Math.min(safetyMarginTokens, Math.floor(contextSize * CONTEXT_SAFETY_MARGIN_MAX_RATIO))
     const reservedThreshold = contextSize - (reservedOutput + safetyMargin)
     const ratioThreshold = Math.floor(contextSize * thresholdRatio)
     return Math.max(1_000, Math.min(contextSize - 1, Math.min(reservedThreshold, ratioThreshold)))
@@ -785,6 +752,24 @@ export function createContextCompactionRuntime(
     const initialPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
     const inputChars = initialPayload.length
 
+    const buildEarlyExitResult = (estimatedTokens: number): CompactHistoryResult => {
+      const exitSummaryPayload = buildSyntheticSummaryPayload(summaryText)
+      const outputPayload = JSON.stringify([...(exitSummaryPayload ? [exitSummaryPayload] : []), ...remainingMessages])
+      return {
+        compacted: compactedMessages.length > 0,
+        summaryText,
+        ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
+        compactedMessages,
+        compactedMessageCount: compactedMessages.length,
+        remainingMessageCount: remainingMessages.length,
+        estimatedTokens,
+        inputChars,
+        outputChars: outputPayload.length,
+        state,
+        stateDelta: mergedDelta,
+      }
+    }
+
     for (;;) {
       const assessment = shouldCompactHistory({
         summaryText,
@@ -793,40 +778,12 @@ export function createContextCompactionRuntime(
       })
 
       if (!assessment.shouldCompact) {
-        const summaryPayload = buildSyntheticSummaryPayload(summaryText)
-        const outputPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
-        return {
-          compacted: compactedMessages.length > 0,
-          summaryText,
-          ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
-          compactedMessages,
-          compactedMessageCount: compactedMessages.length,
-          remainingMessageCount: remainingMessages.length,
-          estimatedTokens: assessment.estimatedTokens,
-          inputChars,
-          outputChars: outputPayload.length,
-          state,
-          stateDelta: mergedDelta,
-        }
+        return buildEarlyExitResult(assessment.estimatedTokens)
       }
 
       const boundary = Math.max(0, remainingMessages.length - params.tailMessageCount)
       if (boundary <= 0) {
-        const summaryPayload = buildSyntheticSummaryPayload(summaryText)
-        const outputPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
-        return {
-          compacted: compactedMessages.length > 0,
-          summaryText,
-          ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
-          compactedMessages,
-          compactedMessageCount: compactedMessages.length,
-          remainingMessageCount: remainingMessages.length,
-          estimatedTokens: assessment.estimatedTokens,
-          inputChars,
-          outputChars: outputPayload.length,
-          state,
-          stateDelta: mergedDelta,
-        }
+        return buildEarlyExitResult(assessment.estimatedTokens)
       }
 
       const candidatePrefix = remainingMessages.slice(0, boundary)
@@ -834,22 +791,8 @@ export function createContextCompactionRuntime(
       const contextMessages = messagesToCompact.map(toContextMessageFromChatMessage)
       const sourceText = toCompactionTranscript(contextMessages)
 
-      if (!normalizeWhitespace(sourceText)) {
-        const summaryPayload = buildSyntheticSummaryPayload(summaryText)
-        const outputPayload = JSON.stringify([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages])
-        return {
-          compacted: compactedMessages.length > 0,
-          summaryText,
-          ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
-          compactedMessages,
-          compactedMessageCount: compactedMessages.length,
-          remainingMessageCount: remainingMessages.length,
-          estimatedTokens: assessment.estimatedTokens,
-          inputChars,
-          outputChars: outputPayload.length,
-          state,
-          stateDelta: mergedDelta,
-        }
+      if (!compactWhitespace(sourceText)) {
+        return buildEarlyExitResult(assessment.estimatedTokens)
       }
 
       let compactionOutput = await compactContextMessages({

package/src/runtime/execution-plan.ts

@@ -1,17 +1,19 @@
 import type { SerializableExecutionPlan } from '@lota-sdk/shared'
 
-export const EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT = `<execution-plan-protocol>
+const EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT = `<execution-plan-protocol>
 - Before doing multi-step work, create a contract-driven execution plan instead of tracking steps only in prose.
+- A workstream may have multiple active execution plans. Review all plans before creating new ones.
 - Plans are graph-capable workflow contracts. Every execution node must define objective, instructions, deliverables, success criteria, completion checks, retry policy, failure policy, and tool/context policy.
 - The runtime executor owns lifecycle truth. Do not claim that a node is complete until submitExecutionNodeResult succeeds.
-- Use execution-plan tools to create, replace, inspect, submit node results, and resume runs.
-- Treat the active execution run in <execution-plan-state> as authoritative. Do not mutate run or node status in prose.
+- Use execution-plan tools to create, replace, inspect, and resume runs.
+- Visible workstream agents do not manually submit node results; dispatched execution nodes are completed by the runtime executor.
+- Treat the active execution runs in <execution-plan-state> as authoritative. Do not mutate run or node status in prose.
 - Work only on nodes that are active or explicitly ready for your executor. If a node is awaiting human input or approval, stop and let the runtime resume it.
 - If the graph, contracts, or success criteria materially change, replace the plan instead of silently drifting.
 </execution-plan-protocol>`
 
-export function formatExecutionPlanForPrompt(plan: SerializableExecutionPlan | null | undefined): string | undefined {
-  if (!plan) return undefined
+function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): string | undefined {
+  if (plans.length === 0) return undefined
 
   const payload = {
     policy: {
@@ -21,46 +23,48 @@ export function formatExecutionPlanForPrompt(plan: SerializableExecutionPlan | n
       artifactsAreFirstClassOutputs: true,
       checkpointRecoveryEnabled: true,
     },
-    plan,
+    activePlans: plans,
+    planCount: plans.length,
   }
 
   return ['<execution-plan-state>', JSON.stringify(payload, null, 2), '</execution-plan-state>'].join('\n')
 }
 
 export function buildExecutionPlanInstructionSections(
-  plan: SerializableExecutionPlan | null | undefined,
+  plans: SerializableExecutionPlan[] | null | undefined,
 ): string[] | undefined {
+  const normalized = plans ?? []
   const sections = [EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT]
-  const executionPlanStateSection = formatExecutionPlanForPrompt(plan)
-  if (executionPlanStateSection) {
-    sections.push(executionPlanStateSection)
+  const stateSection = formatExecutionPlansForPrompt(normalized)
+  if (stateSection) {
+    sections.push(stateSection)
   }
   return sections
 }
 
 export function createExecutionPlanInstructionSectionCache(params: {
   disabled?: boolean
-  loadPlan: () => Promise<SerializableExecutionPlan | null | undefined>
+  loadPlans: () => Promise<SerializableExecutionPlan[]>
 }) {
-  let planPromise: Promise<SerializableExecutionPlan | null | undefined> | null = null
+  let plansPromise: Promise<SerializableExecutionPlan[]> | null = null
   let sectionsPromise: Promise<string[] | undefined> | null = null
 
   return {
     invalidate() {
-      planPromise = null
+      plansPromise = null
       sectionsPromise = null
     },
-    async getPlan(): Promise<SerializableExecutionPlan | null | undefined> {
-      if (params.disabled) return undefined
+    async getPlans(): Promise<SerializableExecutionPlan[]> {
+      if (params.disabled) return []
 
-      planPromise ??= params.loadPlan()
-      return await planPromise
+      plansPromise ??= params.loadPlans()
+      return plansPromise
     },
     async getSections(): Promise<string[] | undefined> {
       if (params.disabled) return undefined
 
-      sectionsPromise ??= this.getPlan().then((plan) => buildExecutionPlanInstructionSections(plan))
-      return await sectionsPromise
+      sectionsPromise ??= this.getPlans().then((plans) => buildExecutionPlanInstructionSections(plans))
+      return sectionsPromise
     },
   }
 }

package/src/runtime/graph-designer.ts

@@ -0,0 +1,15 @@
+import type { GraphDesignRequest, GraphDesignResponse } from '@lota-sdk/shared'
+
+export interface GraphDesigner {
+  designGraph(request: GraphDesignRequest): Promise<GraphDesignResponse>
+}
+
+let _graphDesigner: GraphDesigner | null = null
+
+export function configureGraphDesigner(designer: GraphDesigner): void {
+  _graphDesigner = designer
+}
+
+export function getGraphDesigner(): GraphDesigner | null {
+  return _graphDesigner
+}