@lota-sdk/core 0.1.30 → 0.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "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.1.30",
+    "@lota-sdk/shared": "0.1.32",
     "@mendable/firecrawl-js": "^4.18.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.141",

package/src/ai/definitions.ts

@@ -81,60 +81,14 @@ export const askingUserQuestionsSkill = defineSkill({
   tools: askingUserQuestionsSkillTools,
   instructions: `# asking-user-questions
 
-## Description
-
-Use this skill when an answer or action requires missing user input that cannot be inferred reliably.
+Use \`userQuestions\` when an answer requires missing user input that cannot be inferred.
 
-## Details
+Types: \`single-select\` (pick one), \`multi-select\` (pick many), \`input\` (free text).
+Pass questions as \`{ questions: [{ question, type, options? }] }\`.
 
-<when-to-use>
-- Requirements are ambiguous and different interpretations would change the outcome.
-- A required identifier is missing (for example project/team/owner/issue reference).
-- The user must choose between materially different options.
-- You need explicit consent before a mutation or irreversible action.
-- You need specific business context only the user can provide.
-- The request is ambiguous and proceeding would produce low-quality output.
-- You need approval or confirmation before taking a significant action.
-</when-to-use>
-
-<how-to-use>
-Use the \`userQuestions\` tool to present structured questions. This renders an interactive form in the chat UI and
-terminates the agent chain until the user responds. The user already sees this form, so do **not** restate the same
-questions in plain text. Do **not** call any additional tools in the same response.
-
-### Question types
-
-- \`single-select\` — user picks one option from a list (with optional custom answer field)
-- \`multi-select\` — user picks multiple options from a list (with optional custom answer field)
-- \`input\` — user types a free-text answer
-
-### Schema
-
-\`\`\`json
-{
-  "questions": [
-    { "question": "What is your target market?", "type": "single-select", "options": ["B2B", "B2C", "Both"] },
-    {
-      "question": "Which features do you need?",
-      "type": "multi-select",
-      "options": ["Authentication", "REST API", "Admin Panel", "Analytics"]
-    },
-    { "question": "What is your budget range?", "type": "input" }
-  ]
-}
-\`\`\`
-
-- \`options\` is a plain string array (no IDs needed).
-- \`allowCustomAnswer\` (optional, defaults to \`true\` for select types) adds a free-text field alongside options.
-- Do **not** generate additional text or tool calls after calling \`userQuestions\` (including repeating the questions as
-  plain text). Your turn is complete.
-</how-to-use>
-
-<do-not-use>
-- Do not ask when reasonable defaults are already explicit in the user request.
-- Do not ask for information that can be retrieved using available read tools.
-- Do not ask broad discovery questions when one targeted question will unblock progress.
-</do-not-use>`,
+Do not restate questions in text after calling the tool — the UI renders them.
+Do not call additional tools in the same response.
+Do not ask when reasonable defaults exist or information is retrievable.`,
 })
 
 const researchSkillTools = ['researchTopic', 'fetchWebpage', 'inspectWebsite'] as const
@@ -146,58 +100,15 @@ export const researchSkill = defineSkill({
   tools: researchSkillTools,
   instructions: `# research
 
-## Description
-
-Use for any task requiring external information gathering: market research, competitive analysis, technical evaluation,
-fact verification, or source-backed answers. Delegates web research to a dedicated research agent.
+Use for external information: market research, competitive analysis, fact verification.
 
-## Details
+## Tools
+- \`researchTopic\` — delegate to research agent. For broad research, call 2-3 in parallel with different focused tasks.
+- \`fetchWebpage\` — only when user shares a specific URL. Do not use for general research.
+- \`inspectWebsite\` — structured analysis of a website. Pass URL in \`url\` field. Use \`forceRefresh: true\` to overwrite.
 
-<when-to-use>
-- The user asks a question that requires current, external information beyond the agent's training data.
-- Market sizing, competitor analysis, or industry trend research.
-- Technical evaluation of tools, frameworks, vendors, or platforms.
-- Fact-checking claims, statistics, or benchmarks before using them in deliverables.
-- Gathering evidence to support or challenge a hypothesis from another skill.
-
-Do NOT use when:
-
-- The question can be answered from conversation context or organizational memory alone.
-- The user is asking for coaching, strategy, or opinion (use a domain skill instead).
-- The task is purely internal (roadmap prioritization, team dynamics, financial modeling from known data).
-</when-to-use>
-
-<how-to-research>
-- Call \`researchTopic\` with a clear, specific research task description.
-- For broad research, call 2-3 \`researchTopic\` instances **in parallel** with different focused tasks (e.g., one for market sizing, one for competitor analysis, one for pricing benchmarks).
-- Each \`researchTopic\` call returns a synthesized markdown report with sources — you do not need to search or fetch pages yourself.
-- Use \`fetchWebpage\` **only** when the user shares a specific URL they want you to read. Do not use it for general research.
-- Use \`inspectWebsite\` when the user wants a structured analysis of a specific website or landing page. Pass the exact URL in the tool's \`url\` field and the learning goal in \`task\`.
-- When the user asks to refresh, re-run, or overwrite existing website extraction, call \`inspectWebsite\` with \`forceRefresh: true\`.
-</how-to-research>
-
-<startup-context>
-- Time is the scarcest resource; research must be fast and decisive, not exhaustive.
-- Early-stage decisions tolerate lower confidence thresholds; a directionally correct answer now beats a perfect answer next week.
-- Prioritize sources that reveal market reality: pricing pages, job postings, SEC filings, G2/Capterra reviews, GitHub activity, and community forums over polished marketing content.
-- Always contextualize findings to the startup's stage, segment, and constraints.
-</startup-context>
-
-<answering-style>
-- Deliver findings directly; do not narrate the research process to the user.
-- Lead with the answer or recommendation, then provide supporting evidence.
-- State confidence level (high / medium / low) for each key claim based on source quality and corroboration.
-- When sources conflict, present both sides and explain the discrepancy.
-- Never mention internal tool names (researchTopic, fetchWebpage, inspectWebsite, skillDetails, memorySearch).
-</answering-style>
-
-<output-structure>
-- Summary: 2-4 sentence bottom-line answer to the research question.
-- Key Findings: Bulleted findings with inline source citations [URL] and confidence tags (high/medium/low).
-- Comparison Table: (when applicable) structured comparison of alternatives, competitors, or options.
-- Confidence Assessment: Overall confidence level with explanation of what drives it up or down.
-- Gaps and Follow-ups: What remains unknown and what specific research would resolve it.
-</output-structure>`,
+## Output
+Lead with the answer. State confidence (high/medium/low). Cite sources inline [URL]. Never mention tool names to the user.`,
 })
 
 const surrealDbSkillTools = [] as const

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

@@ -103,20 +103,9 @@ export function resolveActiveAgentSkills<TAgent extends string, TSkill extends P
   getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
 }): TSkill[] {
   const mode = params.mode ?? toChatMode(params.workstreamMode)
-  const onboardingOwnerAgentId = resolveOnboardingOwnerAgentId(getLeadAgentId()) as TAgent
-  const baseSkills = params
+  return params
     .getAgentSkills(params.agentId, mode)
     .filter((skill) => (params.linearInstalled ? true : skill !== ('linear' as TSkill)))
-
-  if (!params.onboardingActive) {
-    return baseSkills
-  }
-
-  if (params.agentId !== onboardingOwnerAgentId) {
-    return []
-  }
-
-  return baseSkills.filter((skill) => skill === ('asking-user-questions' as TSkill))
 }
 
 export function buildAgentRuntimeConfig<TAgent extends string, TSkill extends PropertyKey>(params: {
@@ -195,10 +184,10 @@ export function buildWorkstreamAgentToolPolicy<TAgent extends string, TSkill ext
   return {
     resolvedMode,
     skills,
-    includeMemorySearch: !params.onboardingActive,
-    includeConversationSearch: !params.onboardingActive,
-    includeMemoryRemember: !params.onboardingActive,
-    includeOrgActionSearch: !params.onboardingActive,
+    includeMemorySearch: true,
+    includeConversationSearch: true,
+    includeMemoryRemember: true,
+    includeOrgActionSearch: true,
     includeMemoryBlockAppend: true,
     includeReadFileParts: true,
     includeInspectWebsite: params.onboardingActive && params.agentId === onboardingOwnerAgentId,

package/src/runtime/context-compaction.ts

@@ -690,6 +690,18 @@ export function createContextCompactionRuntime(
   const formatWorkstreamStateForPrompt = (state: WorkstreamState | null | undefined): string | undefined => {
     if (!state) return undefined
 
+    // Skip serialization when all fields are empty
+    const hasContent =
+      (state.currentPlan !== null && state.currentPlan !== undefined) ||
+      state.activeConstraints.length > 0 ||
+      state.keyDecisions.length > 0 ||
+      state.openQuestions.length > 0 ||
+      state.risks.length > 0 ||
+      state.tasks.length > 0 ||
+      state.artifacts.length > 0 ||
+      state.agentContributions.length > 0
+    if (!hasContent) return undefined
+
     const approvedPlan =
       state.currentPlan && state.currentPlan.approved ? sanitizeStateText(state.currentPlan.text) : null
     const candidatePlan =

package/src/runtime/execution-plan.ts

@@ -1,46 +1,27 @@
-import { PROJECT_PLAN_ROUTING_PROMPT } from '@lota-sdk/shared'
 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, and resume runs.
-- Visible workstream agents do not manually submit node results; dispatched execution nodes are completed by the runtime executor.
-- When the runtime starts a plan-triggered visible execution turn, use the dedicated result-submission tool for that turn and include durable handoffContext for downstream nodes.
+- Create execution plans for multi-step work. Review existing plans before creating new ones.
+- The runtime executor owns lifecycle truth. Do not claim node completion until the executor confirms.
+- Work only on active/ready nodes assigned to you. Stop at human gates.
+- During plan-triggered turns, use the dedicated result-submission tool. Include handoffContext.
 - 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.
+- If contracts or criteria materially change, replace the plan.
 </execution-plan-protocol>`
 
 function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): string | undefined {
   if (plans.length === 0) return undefined
 
-  const payload = {
-    policy: {
-      executorOwnsLifecycleTruth: true,
-      contractDrivenExecution: true,
-      humanGatesAreDurable: true,
-      artifactsAreFirstClassOutputs: true,
-      checkpointRecoveryEnabled: true,
-    },
-    activePlans: plans,
-    planCount: plans.length,
-  }
+  const payload = { activePlans: plans, planCount: plans.length }
 
   return ['<execution-plan-state>', JSON.stringify(payload, null, 2), '</execution-plan-state>'].join('\n')
 }
 
-export function buildExecutionPlanInstructionSections(
-  plans: SerializableExecutionPlan[] | null | undefined,
-): string[] | undefined {
+export function buildExecutionPlanInstructionSections(plans: SerializableExecutionPlan[] | null | undefined): string[] {
   const normalized = plans ?? []
-  const sections = [EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT, PROJECT_PLAN_ROUTING_PROMPT]
+  const sections = [EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT]
   const stateSection = formatExecutionPlansForPrompt(normalized)
-  if (stateSection) {
-    sections.push(stateSection)
-  }
+  if (stateSection) sections.push(stateSection)
   return sections
 }
 

package/src/runtime/workstream-plan-turn.ts

@@ -29,30 +29,9 @@ export interface WorkstreamPlanTurnContext {
   upstreamHandoffs: PlanTurnUpstreamHandoff[]
 }
 
-function describePlanTurnDeliverable(deliverable: PlanNodeSpecRecord['deliverables'][number]): string {
-  return [
-    `- ${deliverable.name}`,
-    `kind=${deliverable.kind}`,
-    deliverable.required ? 'required' : 'optional',
-    deliverable.schemaRef ? `schemaRef=${deliverable.schemaRef}` : undefined,
-    deliverable.description ? `description=${deliverable.description}` : undefined,
-  ]
-    .filter(Boolean)
-    .join(' | ')
-}
-
-function describePlanTurnCompletionCheck(check: PlanNodeSpecRecord['completionChecks'][number]): string {
-  return [
-    `- ${check.description}`,
-    `type=${check.type}`,
-    check.blocking ? 'blocking' : 'warning',
-    Object.keys(check.config).length > 0 ? `config=${JSON.stringify(check.config)}` : undefined,
-  ]
-    .filter(Boolean)
-    .join(' | ')
-}
-
 function buildPlanTurnExecutionSection(planTurn: WorkstreamPlanTurnContext): string {
+  const requiredDeliverables = planTurn.nodeSpec.deliverables.filter((deliverable) => deliverable.required)
+  const completionCheckOutputHints = buildCompletionCheckStructuredOutputHints(planTurn.nodeSpec)
   const payload = {
     runId: planTurn.runId,
     planTitle: planTurn.planTitle,
@@ -75,55 +54,17 @@ function buildPlanTurnExecutionSection(planTurn: WorkstreamPlanTurnContext): str
 
   return [
     '<plan-turn-execution>',
-    'The runtime has activated a visible execution-plan node inside this workstream.',
     `Complete node "${planTurn.nodeSpec.label}" for plan "${planTurn.planTitle}".`,
-    'Use only the node contract, resolved input, input artifacts, and upstream handoff context provided here.',
-    'Do not ask the user for more input and do not rely on unstated external context.',
-    'Do not submit placeholders, partial work, or speculative outputs.',
-    'Before submitting, satisfy every required deliverable, success criterion, and completion check for this node.',
-    'Deliverables must use the exact artifact names and kinds declared in the node contract.',
-    'If a deliverable declares schemaRef, include the same schemaRef and a payload that satisfies that schema.',
-    'If outputSchemaRef is declared, structuredOutput must satisfy that schema before you submit.',
-    `When finished, call ${SUBMIT_PLAN_TURN_RESULT_TOOL_NAME} exactly once.`,
-    'Always include durable handoffContext for downstream nodes when you submit the final result.',
-    'Do not ask the user for confirmation and do not create or replace execution plans in this turn.',
-    JSON.stringify(payload, null, 2),
-    '</plan-turn-execution>',
-  ].join('\n')
-}
-
-function buildPlanTurnResultContractSection(planTurn: WorkstreamPlanTurnContext): string {
-  const requiredDeliverables = planTurn.nodeSpec.deliverables.filter((deliverable) => deliverable.required)
-  const completionCheckOutputHints = buildCompletionCheckStructuredOutputHints(planTurn.nodeSpec)
-  const deliverableLines =
-    planTurn.nodeSpec.deliverables.length > 0
-      ? planTurn.nodeSpec.deliverables.map(describePlanTurnDeliverable)
-      : ['- none']
-  const completionCheckLines =
-    planTurn.nodeSpec.completionChecks.length > 0
-      ? planTurn.nodeSpec.completionChecks.map(describePlanTurnCompletionCheck)
-      : ['- none']
-
-  return [
-    '<plan-turn-result-contract>',
-    `Call ${SUBMIT_PLAN_TURN_RESULT_TOOL_NAME} exactly once with a result object that passes node validation.`,
-    'Validation is strict. Missing required artifacts, schema mismatches, or failed completion checks will fail the node run.',
-    `Required artifacts: ${requiredDeliverables.length > 0 ? requiredDeliverables.map((deliverable) => deliverable.name).join(', ') : 'none'}`,
-    `Structured output: ${
-      planTurn.nodeSpec.outputSchemaRef
-        ? `required and must match schema "${planTurn.nodeSpec.outputSchemaRef}"`
-        : 'optional unless needed by a completion check'
-    }`,
-    'Deliverables:',
-    ...deliverableLines,
-    'Completion checks:',
-    ...completionCheckLines,
+    'Use only the node contract, resolved input, input artifacts, and upstream handoff context.',
+    'Before submitting, satisfy every required deliverable, success criterion, and completion check.',
+    `Call ${SUBMIT_PLAN_TURN_RESULT_TOOL_NAME} exactly once when done.`,
+    `Required artifacts: ${requiredDeliverables.length > 0 ? requiredDeliverables.map((d) => d.name).join(', ') : 'none'}.`,
+    'Include notes with a concise completion summary. Include handoffContext with summary, key decisions, open questions, risks, and recommendations for downstream nodes.',
     ...(completionCheckOutputHints.length > 0
       ? ['Structured output fields required by completion checks:', ...completionCheckOutputHints]
       : []),
-    'Include notes with a concise completion summary grounded in the submitted artifacts and structuredOutput.',
-    'Always include handoffContext for downstream execution with a durable summary, key decisions, open questions, risks, recommendations, and references when relevant.',
-    '</plan-turn-result-contract>',
+    JSON.stringify(payload, null, 2),
+    '</plan-turn-execution>',
   ].join('\n')
 }
 
@@ -153,7 +94,7 @@ export function buildPlanTurnInstructionSections(planTurn: WorkstreamPlanTurnCon
   const upstreamHandoffSection = buildUpstreamHandoffSection(planTurn.upstreamHandoffs)
   return (
     mergeInstructionSections(
-      [buildPlanTurnExecutionSection(planTurn), buildPlanTurnResultContractSection(planTurn)],
+      [buildPlanTurnExecutionSection(planTurn)],
       upstreamHandoffSection ? [upstreamHandoffSection] : undefined,
     ) ?? []
   )

package/src/runtime/workstream-turn-context.ts

@@ -93,14 +93,13 @@ export async function assembleWorkstreamTurnContext(params: {
     userName: params.userName ?? undefined,
     recentDomainEvents,
   })
-  let retrievedKnowledgeSection: string | undefined =
-    onboardingActive || !params.messageText
-      ? undefined
-      : await params.workspaceProvider?.buildRetrievedKnowledgeSection?.({
-          workspaceId: params.orgIdString,
-          userId: params.userIdString,
-          query: params.messageText,
-        })
+  let retrievedKnowledgeSection: string | undefined = !params.messageText
+    ? undefined
+    : await params.workspaceProvider?.buildRetrievedKnowledgeSection?.({
+        workspaceId: params.orgIdString,
+        userId: params.userIdString,
+        query: params.messageText,
+      })
   params.onStep?.('rag-knowledge-retrieval')
 
   const buildContextResult = asRecord(

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

@@ -334,21 +334,27 @@ class PlanRunService {
       includeCheckpoints?: boolean
       includeEvents?: boolean
       includeValidationIssues?: boolean
+      /** When true, non-active/ready nodes are summarized (id, label, status, owner, objective, edges). Reduces prompt tokens. */
+      slim?: boolean
     },
   ): Promise<SerializableExecutionPlan> {
+    const slim = options?.slim === true
     const spec = await this.getPlanSpecById(run.planSpecId)
     const nodeSpecs = await this.listNodeSpecs(spec.id)
     const nodeRuns = await this.listNodeRuns(run.id)
     const artifacts = options?.includeArtifacts === false ? [] : await this.listArtifacts(run.id)
-    const lineageArtifacts = options?.includeArtifacts === false ? [] : await this.collectLineageArtifacts(run)
-    const approvals = options?.includeApprovals === false ? [] : await this.listApprovals(run.id)
+    const lineageArtifacts = options?.includeArtifacts === false || slim ? [] : await this.collectLineageArtifacts(run)
+    const approvals = options?.includeApprovals === false || slim ? [] : await this.listApprovals(run.id)
     const validationIssues =
-      options?.includeValidationIssues === false
+      options?.includeValidationIssues === false || slim
         ? []
         : await this.listValidationIssues({ runId: run.id, planSpecId: spec.id })
     const latestCheckpoint = options?.includeCheckpoints ? await this.getLatestCheckpoint(run.id) : null
-    const recentEvents = options?.includeEvents === false ? [] : await this.listEvents(run.id, 20)
+    const eventLimit = slim ? 5 : 20
+    const recentEvents = options?.includeEvents === false ? [] : await this.listEvents(run.id, eventLimit)
     const nodeRunsById = new Map(nodeRuns.map((nodeRun) => [nodeRun.nodeId, nodeRun]))
+    const activeNodeIds = new Set(run.currentNodeId ? [run.currentNodeId] : [])
+    const readyNodeIds = new Set(run.readyNodeIds)
 
     const nodes: SerializablePlanNode[] = nodeSpecs.map((nodeSpec) => {
       const nodeRun = nodeRunsById.get(nodeSpec.nodeId)
@@ -358,6 +364,26 @@ class PlanRunService {
         )
       }
 
+      const isActiveOrReady = activeNodeIds.has(nodeSpec.nodeId) || readyNodeIds.has(nodeSpec.nodeId)
+
+      // Slim mode: non-active/ready nodes get summary only (used for prompt injection via JSON.stringify).
+      // The cast is safe — this data is only consumed by formatExecutionPlansForPrompt, not by Zod validation.
+      // Plan introspection tools (getExecutionPlanDetails) call toSerializablePlan without slim=true.
+      if (slim && !isActiveOrReady) {
+        return {
+          id: nodeSpec.nodeId,
+          type: nodeSpec.type,
+          label: nodeSpec.label,
+          owner: { executorType: nodeSpec.owner.executorType, ref: nodeSpec.owner.ref },
+          objective: nodeSpec.objective,
+          status: nodeRun.status,
+          upstreamNodeIds: [...nodeSpec.upstreamNodeIds],
+          downstreamNodeIds: [...nodeSpec.downstreamNodeIds],
+          ...(nodeRun.handoffContext ? { handoffContext: nodeRun.handoffContext } : {}),
+          ...(nodeRun.completedAt ? { completedAt: toOptionalIsoDateTimeString(nodeRun.completedAt) } : {}),
+        } as SerializablePlanNode
+      }
+
       return {
         id: nodeSpec.nodeId,
         type: nodeSpec.type,
@@ -415,7 +441,7 @@ class PlanRunService {
       leadAgentId: run.leadAgentId,
       defaultExecutionVisibility: spec.defaultExecutionVisibility,
       executionMode: spec.executionMode,
-      schemaRegistry: structuredClone(spec.schemaRegistry),
+      schemaRegistry: slim ? {} : structuredClone(spec.schemaRegistry),
       entryNodeIds: [...spec.entryNodeIds],
       edges: [...spec.edges],
       schedule: spec.schedule,

package/src/services/workstream-turn-preparation.service.ts

@@ -284,7 +284,9 @@ async function streamAgentResponse(
   streamParams: StreamAgentResponseParams,
 ): Promise<ChatMessage> {
   const agentTimer = lotaDebugLogger.timer(`agent:${streamParams.agentId}`)
-  const executionPlanInstructionSections = await ctx.getExecutionPlanInstructionSections()
+  // Skip full plan state during plan turns — the plan-turn sections already have the active node contract
+  const executionPlanInstructionSections =
+    streamParams.includeExecutionPlanTools === false ? undefined : await ctx.getExecutionPlanInstructionSections()
   agentTimer.step('get-execution-plan')
   const agentResolution = asRecord(
     await ctx.turnHooks.resolveAgent?.({
@@ -361,6 +363,7 @@ async function streamAgentResponse(
     mode: streamParams.mode,
     tools: streamParams.tools,
     extraInstructions: config.extraInstructions,
+    maxRetries: 3,
     stopWhen: (agentResolution?.stopWhen as StopCondition<ToolSet> | Array<StopCondition<ToolSet>> | undefined) ??
       streamParams.stopWhen ?? [stepCountIs(config.maxSteps as number)],
     prepareStep: (agentResolution?.prepareStep as PrepareStepFunction<ToolSet> | undefined) ?? streamParams.prepareStep,
@@ -368,19 +371,32 @@ async function streamAgentResponse(
   const agentAbortSignal = streamParams.abortSignal ?? ctx.runAbortSignal
   agentTimer.step('agent-construction')
 
+  const MAX_STREAM_RETRIES = 3
   let result: unknown
-  try {
-    result = await streamParams.observer.run(() =>
-      agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
-    )
-    agentTimer.step('agent.stream()-resolved')
-  } catch (error) {
-    if (agentAbortSignal.aborted) {
-      streamParams.observer.recordAbort(error)
-    } else {
-      streamParams.observer.recordError(error)
+  for (let attempt = 0; ; attempt++) {
+    try {
+      result = await streamParams.observer.run(() =>
+        agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
+      )
+      agentTimer.step('agent.stream()-resolved')
+      break
+    } catch (error) {
+      if (agentAbortSignal.aborted) {
+        streamParams.observer.recordAbort(error)
+        throw error
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error)
+      const isTransient =
+        errorMessage.includes('client disconnected') ||
+        errorMessage.includes('ECONNRESET') ||
+        errorMessage.includes('socket hang up') ||
+        errorMessage.includes('fetch failed')
+      if (!isTransient || attempt >= MAX_STREAM_RETRIES - 1) {
+        streamParams.observer.recordError(error)
+        throw error
+      }
+      aiLogger.warn`Transient stream error (attempt ${attempt + 1}/${MAX_STREAM_RETRIES}): ${errorMessage} — retrying`
     }
-    throw error
   }
   if (!hasUIMessageStream(result)) {
     throw new Error(`Agent run for ${resolvedAgentId} did not expose a UI message stream.`)
@@ -642,10 +658,10 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
   let memoryBlock = workstreamService.formatMemoryBlockForPrompt(workstreamRecord)
   let workstreamState = initialWorkstreamState
   const executionPlanInstructionSectionCache = createExecutionPlanInstructionSectionCache({
-    disabled: onboardingActive,
+    disabled: false,
     loadPlans: async () => {
       const runs = await planRunService.getActiveRunRecords(workstreamRef)
-      return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run)))
+      return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run, { slim: true })))
     },
   })
   const getExecutionPlans = async () => await executionPlanInstructionSectionCache.getPlans()
@@ -689,7 +705,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
   const learnedSkillsByAgent = new Map<string, string | undefined>()
   const getLearnedSkillsSection = async (agentId: string, queryText = messageText): Promise<string | undefined> => {
-    if (onboardingActive) return undefined
     const cacheKey = `${agentId}::${queryText}`
     if (learnedSkillsByAgent.has(cacheKey)) return learnedSkillsByAgent.get(cacheKey)
 
@@ -843,7 +858,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             const visibleTimer = lotaDebugLogger.timer(`visible:${runParams.agentId}`)
             let runMemoryBlock = memoryBlock
             const includeExecutionPlanTools =
-              runParams.includeExecutionPlanTools ?? (runParams.mode !== 'fixedWorkstreamMode' && !onboardingActive)
+              runParams.includeExecutionPlanTools ?? runParams.mode !== 'fixedWorkstreamMode'
             const rawTools: ToolSet = {
               ...((await buildAgentTools(
                 buildTurnToolParams({
@@ -970,7 +985,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             })
 
             const teamThinkTool =
-              workstream.mode === 'group' && !onboardingActive
+              workstream.mode === 'group'
                 ? createTeamThinkTool({
                     historyMessages: currentMessages,
                     latestUserMessageId: referenceUserMessageId,

package/src/system-agents/delegated-agent-factory.ts

@@ -76,7 +76,6 @@ When your analysis is complete, return your final answer directly as markdown te
 
 const DEFAULT_DELEGATED_AGENT_MAX_OUTPUT_TOKENS = 4096
 const MAX_RETAINED_AGENT_MESSAGES = 10
-const MAX_NON_SUBSTANTIVE_AGENT_RESULT_ATTEMPTS = 2
 const NON_SUBSTANTIVE_AGENT_RESULT_RETRY_PROMPT =
   'Return a complete substantive markdown answer. Do not reply with an empty result, placeholder, or tool-only outcome.'
 
@@ -154,7 +153,7 @@ async function generateSubstantiveDelegatedAgentResult(params: {
     }
 
     // Try a follow-up: feed the agent's tool results back as context and ask for synthesis
-    const toolContext = extractToolResultText(result.messages ?? [])
+    const toolContext = extractToolResultText('messages' in result ? ((result.messages ?? []) as ModelMessage[]) : [])
     if (toolContext.length > 100) {
       const followUpPrompt = [
         params.task,

package/src/system-agents/regular-chat-memory-digest.agent.ts

@@ -12,58 +12,16 @@ import { resolveHelperAgentOptions } from './helper-agent-options'
 const REGULAR_CHAT_MEMORY_DIGEST_MAX_TOKENS = 8_192
 
 const regularChatMemoryDigestPrompt = `<agent-instructions>
-You are the regular-chat memory digest synthesizer.
-
-<goal>
-Given the current workspace profile summary, existing durable memories, and newly added regular-chat transcript lines,
-produce one updated workspace profile summary plus durable memory facts.
-</goal>
-
-<scope>
-- Input transcript contains workstream messages with source prefixes like [workstream:...].
-- Treat source prefixes as thread context only.
-- Use only evidence from provided transcript and existing memory context.
-</scope>
-
-<quality-bar>
-- Stay evidence-grounded. Do not invent details.
-- Keep terminology consistent with existing profile wording unless new evidence contradicts it.
-- Prefer concrete, reusable facts about the workspace, product, users, strategy, decisions, execution, and constraints.
-- Exclude routing chatter, tool chatter, and purely stylistic language.
-- If there are no durable updates, return the current summary block unchanged and an empty facts list.
-</quality-bar>
-
-<profile-format>
-- Return a single summaryBlock string.
-- Preserve the existing labeled-section format when present.
-- Merge corrections from new evidence; remove stale claims only when clearly contradicted.
-</profile-format>
-
-<structured-profile-patch>
-- Also return a structuredProfilePatch object that contains only evidence-grounded host-specific updates.
-- Keep the patch additive when possible.
-- If there are no structured updates, return an empty object.
-</structured-profile-patch>
-
-<facts-format>
-- Return facts as durable, standalone statements.
-- Each fact must be understandable without transcript context.
-- Prefer one concrete claim per fact.
-- Set type to one of: fact, preference, decision.
-- Set confidence between 0 and 1.
-- Set durability to core, standard, or ephemeral based on expected longevity.
-- Set importance between 0 and 1 for long-term usefulness.
-- Set classification to durable, transient, or uncertain.
-- Set rationale to one short evidence-grounded sentence.
-</facts-format>
-
-<output-contract>
-The caller enforces a structured output schema with:
-- summaryBlock: non-empty string
-- structuredProfilePatch: partial structured host-specific updates
-- facts: array of extracted fact objects
-Return only schema fields.
-</output-contract>
+Synthesize an updated workspace profile summary and durable memory facts from conversation transcripts.
+
+<rules>
+- Evidence-grounded only. Do not invent details. Exclude routing/tool chatter.
+- Treat [workstream:...] prefixes as thread context only.
+- Preserve existing profile format. Merge corrections; remove stale claims only when contradicted.
+- Facts must be standalone, one concrete claim each, understandable without transcript context.
+- If no durable updates exist, return current summary unchanged and empty facts.
+- Return structuredProfilePatch with evidence-grounded host-specific updates only; empty object if none.
+</rules>
 </agent-instructions>`
 
 export function createRegularChatMemoryDigestAgent(options: CreateHelperToolLoopAgentOptions) {

package/src/system-agents/skill-extractor.agent.ts

@@ -13,51 +13,17 @@ import { resolveHelperAgentOptions } from './helper-agent-options'
 const SKILL_EXTRACTOR_MAX_TOKENS = 8_192
 
 const skillExtractorPrompt = `<agent-instructions>
-You are the skill extractor.
+Extract reusable procedural patterns from conversation transcripts.
 
-<goal>
-Given recent conversation transcripts, identify reusable procedural patterns that would help agents
-handle similar requests better in the future. Extract only genuine procedures — not facts, preferences,
-or one-off requests.
-</goal>
+<what-to-extract>
+Skills are repeatable workflows, reasoning frameworks, or domain-specific protocols. Each needs a clear trigger and procedural steps.
+Extract from successful agent patterns and user corrections. If no genuine procedures exist, return empty candidates.
+</what-to-extract>
 
-<what-is-a-skill>
-A skill is a reusable procedure: a repeatable workflow, reasoning framework, or domain-specific protocol
-that an agent can follow when encountering similar situations. Examples:
-- "When user asks for competitive analysis, follow this 5-step framework..."
-- "When creating Linear issues for bugs, always include reproduction steps, severity, and affected area..."
-- "When discussing fundraising, use this evaluation checklist..."
-</what-is-a-skill>
-
-<what-is-NOT-a-skill>
-- One-off facts about the company (→ memory fact)
-- User preferences for tone or formatting (→ memory preference)
-- Transient requests with no reusable pattern
-- Highly context-specific decisions that won't recur
-</what-is-NOT-a-skill>
-
-<extraction-rules>
-- Extract from user requests and successful agent execution patterns
-- Learn from user corrections (what the agent did wrong → what it should do instead)
-- Require at least a clear trigger condition and procedural steps
-- Keep instructions concise and actionable
-- Do NOT generate skills from hallucinated or speculative patterns
-- If no genuine procedural patterns exist in the transcript, return empty candidates
-</extraction-rules>
-
-<output-contract>
-Return a JSON object with:
-- candidates: array of skill candidates, each with:
-  - name: kebab-case identifier
-  - description: 1-2 sentence summary for retrieval
-  - instructions: full procedural prompt
-  - triggers: when to use this skill (array of trigger descriptions)
-  - tags: semantic tags
-  - examples: 1-2 example queries that would trigger this
-  - classification: 'skill' | 'fact' | 'preference' | 'discard'
-  - confidence: 0-1
-  - agentId: which agent this is most relevant for (null = all)
-</output-contract>
+<what-to-skip>
+One-off facts (→ memory), tone preferences (→ memory), transient requests, context-specific decisions.
+Do not hallucinate patterns. Keep instructions concise and actionable.
+</what-to-skip>
 </agent-instructions>`
 
 export const SkillCandidateSchema = z.object({