@lota-sdk/core 0.1.15 → 0.1.17

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

@@ -1,18 +1,14 @@
+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'
-import { resolveReasoningProfile } from './workstream-routing-policy'
-import type { ReasoningProfileName } from './workstream-routing-policy'
-
 export interface AgentRuntimeConfig<TAgent extends string> {
   id: TAgent
   displayName: string
   mode: ChatMode
   extraInstructions?: string
   maxSteps: number
-  reasoningProfile: ReasoningProfileName
-  toolCallBudget: number
-  maxInputTokensHint: number
 }
 
 export interface AgentToolPolicy<TSkill extends PropertyKey> {
@@ -31,6 +27,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'
 }
@@ -74,7 +94,6 @@ export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends Pr
   skills?: TSkill[]
   onboardingActive: boolean
   linearInstalled: boolean
-  reasoningProfile?: ReasoningProfileName
   systemWorkspaceDetails?: string
   preSeededMemoriesSection?: string
   retrievedKnowledgeSection?: string
@@ -89,7 +108,6 @@ export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends Pr
   buildOnboardingPromptSection: () => string
 }): AgentRuntimeConfig<TAgent> {
   const mode = params.mode ?? toChatMode(params.workstreamMode)
-  const profile = resolveReasoningProfile({ message: '', explicitProfile: params.reasoningProfile ?? 'standard' })
   const rulesSection = params.buildGlobalRuleInstructionSection()
   const skillsSection =
     params.skills && params.skills.length > 0 ? params.buildSkillInstructionSection(params.skills) : ''
@@ -115,10 +133,7 @@ export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends Pr
     displayName: params.displayNameByAgent[params.agentId] ?? params.agentId,
     mode,
     extraInstructions,
-    maxSteps: profile.maxSteps,
-    reasoningProfile: profile.name,
-    toolCallBudget: profile.toolCallBudget,
-    maxInputTokensHint: profile.maxInputTokensHint,
+    maxSteps: 15,
   }
 }
 
@@ -154,43 +169,102 @@ export function buildWorkstreamAgentToolPolicy<TAgent extends string, TSkill ext
     includeReadFileParts: true,
     includeInspectWebsite: params.onboardingActive && params.agentId === onboardingOwnerAgentId,
     includeProceedInOnboarding: params.onboardingActive && params.agentId === onboardingOwnerAgentId,
-    includeGithubIntegration: params.onboardingActive && params.agentId === onboardingOwnerAgentId,
-    includeIndexRepositoryByURL: params.onboardingActive && params.agentId === onboardingOwnerAgentId,
+    includeGithubIntegration: params.agentId === onboardingOwnerAgentId,
+    includeIndexRepositoryByURL: params.agentId === onboardingOwnerAgentId,
     includeIndexedRepository: params.githubInstalled && params.provideRepoTool,
   }
 }
 
-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/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-runtime.ts

@@ -76,7 +76,7 @@ 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: createContextCompactionAgent,
       messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],

package/src/runtime/context-compaction.ts

@@ -1,8 +1,6 @@
-import { createHash, randomUUID } from 'node:crypto'
-
 import type { ChatMessage } from '@lota-sdk/shared'
 
-import { CHARS_PER_TOKEN_ESTIMATE, compactWhitespace, readRecord, 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,
@@ -108,24 +106,10 @@ function createStableId(prefix: string, ...parts: Array<string | number | undefi
     .map((part) => (part === undefined ? '' : String(part)))
     .map((part) => compactWhitespace(part))
     .join('|')
-  const hash = createHash('sha1').update(`${prefix}|${payload}`).digest('hex').slice(0, 20)
+  const hash = new Bun.CryptoHasher('sha1').update(`${prefix}|${payload}`).digest('hex').slice(0, 20)
   return `${prefix}_${hash}`
 }
 
-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) => compactWhitespace(value).toLowerCase()))
   const merged = [...values]
@@ -546,7 +530,7 @@ export function createContextCompactionRuntime(
   options: CreateContextCompactionRuntimeOptions,
 ): ContextCompactionRuntime {
   const now = options.now ?? (() => Date.now())
-  const randomId = options.randomId ?? (() => randomUUID())
+  const randomId = options.randomId ?? (() => crypto.randomUUID())
   const thresholdRatio = options.thresholdRatio ?? CONTEXT_COMPACTION_THRESHOLD_RATIO
   const outputReserveTokens = options.outputReserveTokens ?? CONTEXT_OUTPUT_RESERVE_TOKENS
   const safetyMarginTokens = options.safetyMarginTokens ?? CONTEXT_SAFETY_MARGIN_TOKENS
@@ -766,6 +750,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,
@@ -774,40 +776,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)
@@ -816,21 +790,7 @@ export function createContextCompactionRuntime(
       const sourceText = toCompactionTranscript(contextMessages)
 
       if (!compactWhitespace(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,
-        }
+        return buildEarlyExitResult(assessment.estimatedTokens)
       }
 
       let compactionOutput = await compactContextMessages({

package/src/runtime/execution-plan.ts

@@ -2,16 +2,18 @@ import type { SerializableExecutionPlan } from '@lota-sdk/shared'
 
 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>`
 
-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 @@ function formatExecutionPlanForPrompt(plan: SerializableExecutionPlan | null | u
       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
+}