@lota-sdk/core 0.1.14 → 0.1.16

package/src/runtime/runtime-extensions.ts

@@ -1,7 +1,7 @@
 import type { ToolSet } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
-import type { ReadableUploadMetadata } from '../services/attachment.service'
+import type { ReadableUploadMetadata } from '../storage/attachment-types'
 import type { LotaRuntimeWorkerExtensions } from './runtime-worker-registry'
 
 export interface LotaRuntimeBackgroundCursor {
@@ -34,7 +34,7 @@ export interface LotaRuntimeWorkspaceProvider {
   ): Promise<LotaRuntimeWorkspaceLifecycleState> | LotaRuntimeWorkspaceLifecycleState
   readProfileProjectionState?(
     workspace: Record<string, unknown>,
-  ): Promise<LotaRuntimeWorkspaceProjectionState | void> | LotaRuntimeWorkspaceProjectionState | void
+  ): Promise<LotaRuntimeWorkspaceProjectionState | undefined> | LotaRuntimeWorkspaceProjectionState | undefined
   buildPromptSummary?(workspaceId: RecordIdRef): Promise<string | undefined>
   listRecentDomainEvents?(workspaceId: RecordIdRef, limit?: number): Promise<Array<Record<string, unknown>>>
   hasActiveKnowledgeSources?(workspaceId: string): Promise<boolean>
@@ -76,11 +76,87 @@ export interface LotaRuntimeTeamThinkToolsParams {
   toolProviders?: ToolSet
 }
 
+export interface BuildContextParams {
+  workstream: unknown
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  workspace: Record<string, unknown>
+  onboardingActive: boolean
+  messageText: string
+  linearInstalled: boolean
+  githubInstalled: boolean
+  indexedRepoContext: unknown
+  promptContext: unknown
+  workspaceLifecycleState: unknown
+  workspaceProfileState: unknown
+  promptSummary: string | undefined
+  recentDomainEvents: Array<Record<string, unknown>>
+  retrievedKnowledgeSection: string | undefined
+  [key: string]: unknown
+}
+
+export interface AfterTurnParams {
+  workstream: unknown
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  onboardingActive: boolean
+  referenceUserMessage: unknown
+  assistantMessages: unknown[]
+  latestWorkstreamRecord: unknown
+  latestPersistedState: unknown
+  context: Record<string, unknown> | null
+  [key: string]: unknown
+}
+
+export interface ResolveAgentParams {
+  agentId: string
+  mode: string
+  workstream: unknown
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  onboardingActive: boolean
+  linearInstalled: boolean
+  githubInstalled: boolean
+  reasoningProfile: string
+  skills?: string[]
+  additionalInstructionSections?: string[]
+  context: Record<string, unknown> | null
+  [key: string]: unknown
+}
+
+export interface BuildExtraInstructionSectionsParams {
+  workstream: unknown
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  workspace: Record<string, unknown>
+  onboardingActive: boolean
+  messageText: string
+  linearInstalled: boolean
+  githubInstalled: boolean
+  indexedRepoContext: unknown
+  promptContext: unknown
+  workspaceLifecycleState: unknown
+  workspaceProfileState: unknown
+  promptSummary: string | undefined
+  recentDomainEvents: Array<Record<string, unknown>>
+  retrievedKnowledgeSection: string | undefined
+  context: Record<string, unknown> | null
+  [key: string]: unknown
+}
+
 export interface LotaRuntimeTurnHooks {
-  buildContext?: (params: Record<string, unknown>) => Promise<Record<string, unknown> | void>
-  afterTurn?: (params: Record<string, unknown>) => Promise<void>
-  resolveAgent?: (params: Record<string, unknown>) => Promise<Record<string, unknown> | void>
-  buildExtraInstructionSections?: (params: Record<string, unknown>) => Promise<string[] | void>
+  buildContext?: (params: BuildContextParams) => Promise<Record<string, unknown> | void>
+  afterTurn?: (params: AfterTurnParams) => Promise<void>
+  resolveAgent?: (params: ResolveAgentParams) => Promise<Record<string, unknown> | void>
+  buildExtraInstructionSections?: (params: BuildExtraInstructionSectionsParams) => Promise<string[] | void>
 }
 
 export interface LotaRuntimeAdapters {
@@ -90,8 +166,8 @@ export interface LotaRuntimeAdapters {
     buildTeamThinkAgentTools?: (params: LotaRuntimeTeamThinkToolsParams) => Promise<{ tools: ToolSet }>
   }
   queues?: {
-    enqueuePostChatOrgAction?: (job: Record<string, unknown>) => Promise<void> | void
-    enqueueOnboardingRepoIndexFollowUp?: (job: Record<string, unknown>) => Promise<void> | void
+    enqueuePostChatOrgAction?: (job: Record<string, unknown>) => Promise<void>
+    enqueueOnboardingRepoIndexFollowUp?: (job: Record<string, unknown>) => Promise<void>
   }
   workers?: {
     connectPluginDatabases?: () => Promise<void>
@@ -115,17 +191,17 @@ let runtimeExtensionsState: RuntimeExtensionsState = {
   extraWorkers: {},
 }
 
-export function configureRuntimeExtensions(params?: {
+export function configureRuntimeExtensions(params: {
   adapters?: LotaRuntimeAdapters
   turnHooks?: LotaRuntimeTurnHooks
   toolProviders?: ToolSet
   extraWorkers?: LotaRuntimeWorkerExtensions
 }): void {
   runtimeExtensionsState = {
-    adapters: params?.adapters ?? {},
-    turnHooks: params?.turnHooks ?? {},
-    toolProviders: params?.toolProviders ?? EMPTY_TOOLS,
-    extraWorkers: params?.extraWorkers ?? {},
+    adapters: params.adapters ?? {},
+    turnHooks: params.turnHooks ?? {},
+    toolProviders: params.toolProviders ?? EMPTY_TOOLS,
+    extraWorkers: params.extraWorkers ?? {},
   }
 }
 
@@ -148,8 +224,8 @@ export function getConfiguredPluginDatabaseConnector(): (() => Promise<void>) |
 export async function withConfiguredWorkspaceMemoryLock<T>(workspaceId: string, fn: () => Promise<T>): Promise<T> {
   const adapter = runtimeExtensionsState.adapters.workers?.withWorkspaceMemoryLock
   if (!adapter) {
-    return await fn()
+    return fn()
   }
 
-  return await adapter(workspaceId, fn)
+  return adapter(workspaceId, fn)
 }

package/src/runtime/runtime-worker-registry.ts

@@ -1,5 +1,7 @@
 import { startContextCompactionWorker } from '../queues/context-compaction.queue'
+import { startDelayedNodePromotionWorker } from '../queues/delayed-node-promotion.queue'
 import { scheduleRecurringConsolidation, startMemoryConsolidationWorker } from '../queues/memory-consolidation.queue'
+import { startPlanSchedulerWorker } from '../queues/plan-scheduler.queue'
 import { startPostChatMemoryWorker } from '../queues/post-chat-memory.queue'
 import { startRecentActivityTitleRefinementWorker } from '../queues/recent-activity-title-refinement.queue'
 import { startRegularChatMemoryDigestWorker } from '../queues/regular-chat-memory-digest.queue'
@@ -8,7 +10,9 @@ import { startWorkstreamTitleGenerationWorker } from '../queues/workstream-title
 
 export interface LotaRuntimeWorkerStartRegistry {
   contextCompaction: typeof startContextCompactionWorker
+  delayedNodePromotion: typeof startDelayedNodePromotionWorker
   memoryConsolidation: typeof startMemoryConsolidationWorker
+  planScheduler: typeof startPlanSchedulerWorker
   postChatMemory: typeof startPostChatMemoryWorker
   regularChatMemoryDigest: typeof startRegularChatMemoryDigestWorker
   skillExtraction: typeof startSkillExtractionWorker
@@ -34,7 +38,9 @@ export function buildRuntimeWorkerRegistry(extraWorkers?: LotaRuntimeWorkerExten
   return {
     start: {
       contextCompaction: startContextCompactionWorker,
+      delayedNodePromotion: startDelayedNodePromotionWorker,
       memoryConsolidation: startMemoryConsolidationWorker,
+      planScheduler: startPlanSchedulerWorker,
       postChatMemory: startPostChatMemoryWorker,
       regularChatMemoryDigest: startRegularChatMemoryDigestWorker,
       skillExtraction: startSkillExtractionWorker,

package/src/runtime/team-consultation-orchestrator.ts

@@ -1,6 +1,6 @@
 import { ConsultTeamArgsSchema, withMessageCreatedAt } from '@lota-sdk/shared'
 import type { ChatMessage, ConsultTeamResultData } from '@lota-sdk/shared'
-import { convertToModelMessages, readUIMessageStream, tool as createTool } from 'ai'
+import { convertToModelMessages, tool as createTool } from 'ai'
 
 import { agentDisplayNames, teamConsultParticipants } from '../config/agent-defaults'
 import { createTimedAbortSignal } from './agent-stream-helpers'
@@ -33,6 +33,28 @@ function getConsultTeamOutput(output: unknown): ConsultTeamResultData | undefine
   return undefined
 }
 
+function findLastUserMessage(
+  messages: ChatMessage[],
+  predicate: (message: ChatMessage) => boolean,
+): ChatMessage | null {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (predicate(message)) {
+      return message
+    }
+  }
+
+  return null
+}
+
+function selectTeamConsultationContextMessages(messages: ChatMessage[], latestUserMessageId: string): ChatMessage[] {
+  const latestUserMessage =
+    findLastUserMessage(messages, (message) => message.id === latestUserMessageId && message.role === 'user') ??
+    findLastUserMessage(messages, (message) => message.role === 'user')
+
+  return latestUserMessage ? [latestUserMessage] : []
+}
+
 interface ParticipantObserver {
   run<T>(fn: () => T | Promise<T>): Promise<T>
   recordError?: (error: unknown) => void
@@ -51,6 +73,7 @@ export interface TeamConsultationParticipantRunner {
     },
   ): Promise<{
     agent: {
+      generate(params: Record<string, unknown>): Promise<{ text: string }>
       stream(
         params: Record<string, unknown>,
       ): Promise<{
@@ -119,16 +142,22 @@ export function createConsultTeamTool(params: CreateConsultTeamToolParams) {
           })
           const modelMessages = await convertToModelMessages(
             buildModelInputMessagesWithUploadMetadata({
-              messages: params.historyMessages,
+              messages: selectTeamConsultationContextMessages(params.historyMessages, params.latestUserMessageId),
               latestUserMessageId: params.latestUserMessageId,
               uploadMetadataText,
             }),
             { ignoreIncompleteToolCalls: true },
           )
 
-          let result: Awaited<ReturnType<typeof agent.stream>>
+          let result: Awaited<ReturnType<typeof agent.generate>>
           try {
-            result = await observer.run(() => agent.stream({ messages: modelMessages, abortSignal: timedAbort.signal }))
+            result = await observer.run(() =>
+              agent.generate({
+                messages: modelMessages,
+                abortSignal: timedAbort.signal,
+                timeout: TEAM_CONSULTATION_TIMEOUT_MS,
+              }),
+            )
           } catch (error) {
             if (params.abortSignal.aborted || timedAbort.signal.aborted) {
               observer.recordAbort?.(error)
@@ -138,33 +167,21 @@ export function createConsultTeamTool(params: CreateConsultTeamToolParams) {
             throw error
           }
 
-          for await (const message of readUIMessageStream<ChatMessage>({
-            stream: result.toUIMessageStream({
-              generateMessageId: () => Bun.randomUUIDv7(),
-              sendReasoning: true,
-              sendSources: true,
-              sendStart: false,
-              sendFinish: false,
-            }) as ReadableStream<never>,
-            onError: (error) => {
-              params.onReadError?.(agentId, error)
-            },
-          })) {
-            latestMessage = withMessageCreatedAt(message)
-            responses[index] = {
-              agentId,
-              agentName,
-              status: 'running',
-              summary: extractMessageText(latestMessage).trim() || undefined,
-              message: latestMessage,
-            }
-            pushSnapshot()
-          }
-
-          if (!latestMessage) {
+          const responseText = result.text.trim()
+          if (!responseText) {
             throw new Error(`Team participant ${agentId} did not produce a response.`)
           }
 
+          latestMessage = withMessageCreatedAt(
+            {
+              id: Bun.randomUUIDv7(),
+              role: 'assistant',
+              parts: [{ type: 'text', text: responseText }],
+              metadata: { agentId, agentName },
+            } satisfies ChatMessage,
+            Date.now(),
+          )
+
           responses[index] = {
             agentId,
             agentName,

package/src/runtime/team-consultation-prompts.ts

@@ -3,12 +3,21 @@ import { agentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defa
 export function buildTeamConsultationResponseGuard(params: { agentId: string; task: string }) {
   const agentName = agentDisplayNames[params.agentId] ?? params.agentId
   const leadAgentDisplayName = getLeadAgentDisplayName()
+  const mentorConstraint =
+    params.agentId === 'mentor'
+      ? ['- As Mentor, answer as an experienced operator reviewing launch discipline, not as a coach or therapist.']
+      : []
   return [
     '<team-consultation-agent-protocol>',
     `- You are participating in a structured internal team consultation led by ${leadAgentDisplayName}.`,
     `- Your role for this response is ${agentName}.`,
-    '- Use markdown when it helps clarity.',
-    '- Make the recommendation, explain key tradeoffs, and note the next decision.',
+    '- Chief is already coordinating this panel. Do not refer the task back to Chief or tell the user to consult another agent.',
+    '- Answer only from your role-specific perspective for the task below.',
+    '- Do not coach the user, ask follow-up questions, or challenge assumptions in this panel response. Give the recommendation directly.',
+    ...mentorConstraint,
+    '- Return exactly 3 short markdown bullets in this order: recommendation, key risk/tradeoff, next decision.',
+    '- Keep the whole response under 120 words.',
+    '- Do not use headings, code fences, XML, evidence blocks, gap lists, or preamble text.',
     '',
     '<team-consultation-task>',
     params.task.trim(),

package/src/runtime/title-helpers.ts

@@ -1,12 +1,19 @@
+import { compactWhitespace, truncateText } from '../utils/string'
+
 const TITLE_WORD_LIMIT = 5
 
 export function limitTitleWords(text: string): string {
-  const words = text.replace(/\s+/g, ' ').trim().split(' ').filter(Boolean)
+  const words = compactWhitespace(text).split(' ').filter(Boolean)
   return words.slice(0, TITLE_WORD_LIMIT).join(' ')
 }
 
 export function deriveTitle(text: string): string {
-  const trimmed = text.replace(/\s+/g, ' ').trim()
-  if (trimmed.length <= 60) return trimmed
-  return `${trimmed.slice(0, 57)}...`
+  return truncateText(compactWhitespace(text), 60)
+}
+
+export function normalizeTitle(value: string): string {
+  const normalized = compactWhitespace(value)
+    .replace(/^["'`]+|["'`]+$/g, '')
+    .replace(/[.!?,;:]+$/g, '')
+  return normalized.length <= 80 ? normalized : normalized.slice(0, 80).trim()
 }

package/src/runtime/workstream-chat-helpers.ts

@@ -77,7 +77,7 @@ export function appendPersistedWorkstreamContextToHistoryMessages(
     nextHistoryMessages.push({ role: 'agent', content: `Compacted chat summary:\n${compactionSummary}` })
   }
 
-  if (params.persistedState !== undefined && params.persistedState !== null) {
+  if (params.persistedState !== null && params.persistedState !== undefined) {
     nextHistoryMessages.push({
       role: 'agent',
       content: `Structured workstream state:\n${JSON.stringify(params.persistedState)}`,
@@ -114,14 +114,13 @@ export function collectToolOutputErrors(params: {
     if (typeof part !== 'object') continue
     if (part.type !== undefined && typeof part.type !== 'string') continue
     if (!part.type?.startsWith('tool-')) continue
-    if ((part as Record<string, unknown>).state !== 'output-error') continue
+
+    const p = part as Record<string, unknown>
+    if (p.state !== 'output-error') continue
 
     const toolName = part.type.slice('tool-'.length) || 'unknown'
-    const toolCallId =
-      typeof (part as Record<string, unknown>).toolCallId === 'string' && (part as Record<string, unknown>).toolCallId
-        ? ((part as Record<string, unknown>).toolCallId as string)
-        : 'unknown'
-    const errorTextRaw = (part as Record<string, unknown>).errorText
+    const toolCallId = typeof p.toolCallId === 'string' && p.toolCallId ? p.toolCallId : 'unknown'
+    const errorTextRaw = p.errorText
     const errorText =
       typeof errorTextRaw === 'string' && errorTextRaw.trim()
         ? errorTextRaw.trim()

package/src/runtime/workstream-routing-policy.ts

@@ -36,36 +36,6 @@ export function uniqueMentionOrder(message: string): string[] {
   return ordered
 }
 
-const GTM_STRONG_INTENT_PATTERNS: RegExp[] = [
-  /\bgo[-\s]?to[-\s]?market\b/i,
-  /\bgtm\b/i,
-  /\bcontent\s+marketing\b/i,
-  /\bcontent\s+strategy\b/i,
-  /\bdemand\s+generation\b/i,
-  /\bdistribution\s+strategy\b/i,
-  /\bpositioning\s+strategy\b/i,
-  /\blaunch\s+strategy\b/i,
-  /\blaunch\s+plan\b/i,
-]
-
-const GTM_WEAK_INTENT_PATTERNS: RegExp[] = [/\blaunch\b/i, /\bcommunity\b/i, /\bdistribution\b/i, /\bpositioning\b/i]
-
-export function isGtmIntentMessage(message: string): boolean {
-  const text = message.trim()
-  if (!text) return false
-
-  if (GTM_STRONG_INTENT_PATTERNS.some((pattern) => pattern.test(text))) {
-    return true
-  }
-
-  let weakMatches = 0
-  for (const pattern of GTM_WEAK_INTENT_PATTERNS) {
-    if (pattern.test(text)) weakMatches += 1
-    if (weakMatches >= 2) return true
-  }
-  return false
-}
-
 const HIGH_IMPACT_CLASS_PATTERNS: Array<{ className: HighImpactResponseClass; patterns: RegExp[] }> = [
   {
     className: 'architecture-recommendation',

package/src/runtime/workstream-state.ts

@@ -238,13 +238,23 @@ export interface CompactionOutput {
   stateDelta: WorkstreamStateDelta
 }
 
-export const WORKSTREAM_STATE_MAX_KEY_DECISIONS = 8
-export const WORKSTREAM_STATE_MAX_ACTIVE_CONSTRAINTS = 6
-export const WORKSTREAM_STATE_MAX_TASKS = 10
-export const WORKSTREAM_STATE_MAX_OPEN_QUESTIONS = 5
-export const WORKSTREAM_STATE_MAX_RISKS = 5
-export const WORKSTREAM_STATE_MAX_ARTIFACTS = 10
-export const WORKSTREAM_STATE_MAX_AGENT_CONTRIBUTIONS = 6
+const WORKSTREAM_STATE_MAX_KEY_DECISIONS = 8
+const WORKSTREAM_STATE_MAX_ACTIVE_CONSTRAINTS = 6
+const WORKSTREAM_STATE_MAX_TASKS = 10
+const WORKSTREAM_STATE_MAX_OPEN_QUESTIONS = 5
+const WORKSTREAM_STATE_MAX_RISKS = 5
+const WORKSTREAM_STATE_MAX_ARTIFACTS = 10
+const WORKSTREAM_STATE_MAX_AGENT_CONTRIBUTIONS = 6
+
+export function applyWorkstreamStateCaps(state: WorkstreamState): void {
+  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)
+}
 
 export function createEmptyWorkstreamState(now = Date.now()): WorkstreamState {
   return {

package/src/services/adaptive-playbook.service.ts

@@ -0,0 +1,152 @@
+import type { PlaybookVersion, Recommendation } from '@lota-sdk/shared'
+import { PlaybookSchema, PlaybookVersionSchema } from '@lota-sdk/shared'
+
+import { ensureRecordId, recordIdToString } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { TABLES } from '../db/tables'
+
+class AdaptivePlaybookService {
+  async refineFromCycle(params: {
+    playbookId: string
+    runId: string
+    recommendations: Recommendation[]
+    organizationId: string
+  }): Promise<PlaybookVersion> {
+    const playbook = await databaseService.findOne(
+      TABLES.PLAYBOOK,
+      { id: ensureRecordId(params.playbookId, TABLES.PLAYBOOK) },
+      PlaybookSchema,
+    )
+    if (!playbook) {
+      throw new Error(`Playbook not found: ${params.playbookId}`)
+    }
+
+    const currentVersion = await databaseService.findOne(
+      TABLES.PLAYBOOK_VERSION,
+      {
+        id: ensureRecordId(
+          recordIdToString(playbook.currentVersionId, TABLES.PLAYBOOK_VERSION),
+          TABLES.PLAYBOOK_VERSION,
+        ),
+      },
+      PlaybookVersionSchema,
+    )
+
+    const nextVersionNumber = currentVersion ? currentVersion.version + 1 : 1
+    const now = new Date()
+
+    const newVersion = await databaseService.create(
+      TABLES.PLAYBOOK_VERSION,
+      {
+        playbookId: ensureRecordId(params.playbookId, TABLES.PLAYBOOK),
+        version: nextVersionNumber,
+        parentVersionId: playbook.currentVersionId,
+        appliedRecommendations: params.recommendations.map((r) => r.description),
+        status: 'testing',
+        createdAt: now,
+      },
+      PlaybookVersionSchema,
+    )
+
+    await databaseService.update(
+      TABLES.PLAYBOOK,
+      ensureRecordId(params.playbookId, TABLES.PLAYBOOK),
+      {
+        currentVersionId: newVersion.id,
+        previousVersionId: playbook.currentVersionId,
+        cycleCount: playbook.cycleCount + 1,
+      },
+      PlaybookSchema,
+    )
+
+    return newVersion
+  }
+
+  evaluateRegression(params: { currentScore: number; previousScore: number; threshold?: number }): {
+    shouldRollback: boolean
+  } {
+    const threshold = params.threshold ?? 0.9
+    if (params.previousScore === 0) return { shouldRollback: false }
+    return { shouldRollback: params.currentScore < params.previousScore * threshold }
+  }
+
+  async rollback(params: {
+    playbookId: string
+    organizationId: string
+    maxLevels?: number
+  }): Promise<PlaybookVersion | null> {
+    const maxLevels = params.maxLevels ?? 3
+    return this.rollbackRecursive(params.playbookId, params.organizationId, maxLevels)
+  }
+
+  private async rollbackRecursive(
+    playbookId: string,
+    organizationId: string,
+    remainingLevels: number,
+  ): Promise<PlaybookVersion | null> {
+    if (remainingLevels <= 0) return null
+
+    const playbook = await databaseService.findOne(
+      TABLES.PLAYBOOK,
+      { id: ensureRecordId(playbookId, TABLES.PLAYBOOK) },
+      PlaybookSchema,
+    )
+    if (!playbook) return null
+
+    const currentVersion = await databaseService.findOne(
+      TABLES.PLAYBOOK_VERSION,
+      {
+        id: ensureRecordId(
+          recordIdToString(playbook.currentVersionId, TABLES.PLAYBOOK_VERSION),
+          TABLES.PLAYBOOK_VERSION,
+        ),
+      },
+      PlaybookVersionSchema,
+    )
+    if (!currentVersion?.parentVersionId) return null
+
+    // Mark current version as rolled-back
+    await databaseService.update(
+      TABLES.PLAYBOOK_VERSION,
+      ensureRecordId(recordIdToString(currentVersion.id, TABLES.PLAYBOOK_VERSION), TABLES.PLAYBOOK_VERSION),
+      { status: 'rolled-back' },
+      PlaybookVersionSchema,
+    )
+
+    // Restore parent version as active
+    const parentVersion = await databaseService.findOne(
+      TABLES.PLAYBOOK_VERSION,
+      {
+        id: ensureRecordId(
+          recordIdToString(currentVersion.parentVersionId, TABLES.PLAYBOOK_VERSION),
+          TABLES.PLAYBOOK_VERSION,
+        ),
+      },
+      PlaybookVersionSchema,
+    )
+    if (!parentVersion) return null
+
+    await databaseService.update(
+      TABLES.PLAYBOOK_VERSION,
+      ensureRecordId(recordIdToString(parentVersion.id, TABLES.PLAYBOOK_VERSION), TABLES.PLAYBOOK_VERSION),
+      { status: 'active' },
+      PlaybookVersionSchema,
+    )
+
+    await databaseService.update(
+      TABLES.PLAYBOOK,
+      ensureRecordId(playbookId, TABLES.PLAYBOOK),
+      { currentVersionId: parentVersion.id, previousVersionId: parentVersion.parentVersionId },
+      PlaybookSchema,
+    )
+
+    // Check if parent version is also regressed (caller can evaluate and re-invoke)
+    if (parentVersion.qualityScore !== undefined && parentVersion.qualityScore < 0.5) {
+      return this.rollbackRecursive(playbookId, organizationId, remainingLevels - 1)
+    }
+
+    return parentVersion
+  }
+}
+
+export const adaptivePlaybookService = new AdaptivePlaybookService()