@lota-sdk/core 0.1.15 → 0.1.17

package/src/tools/team-think.tool.ts

@@ -27,7 +27,8 @@ async function buildTeamThinkAgentTools(
   return { tools: result.tools as Record<string, unknown> }
 }
 
-const TEAM_THINK_AGENT_MAX_RETRIES = 4
+const TEAM_THINK_AGENT_MAX_RETRIES = 1
+const TEAM_THINK_AGENT_MAX_STEPS = 3
 
 export function createTeamThinkTool(params: {
   historyMessages: ChatMessage[]
@@ -39,7 +40,6 @@ export function createTeamThinkTool(params: {
   availableUploads: ReadableUploadMetadata[]
   provideRepoTool: boolean
   defaultRepoSectionsByAgent: Record<string, DefaultRepoSections | undefined>
-  reasoningProfile: 'fast' | 'standard' | 'deep'
   systemWorkspaceDetails?: string
   getPreSeededMemoriesSection: (agentId: string) => Promise<string | undefined>
   retrievedKnowledgeSection?: string
@@ -58,7 +58,6 @@ export function createTeamThinkTool(params: {
         mode: 'fixedWorkstreamMode',
         onboardingActive: false,
         linearInstalled: false,
-        reasoningProfile: runParams.reasoningProfile,
         systemWorkspaceDetails: runParams.systemWorkspaceDetails,
         preSeededMemoriesSection: runParams.preSeededMemoriesSection,
         retrievedKnowledgeSection: runParams.retrievedKnowledgeSection,
@@ -75,7 +74,7 @@ export function createTeamThinkTool(params: {
         workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
         workstreamId: params.workstreamId,
         githubInstalled: params.githubInstalled,
-        provideRepoTool: params.provideRepoTool,
+        provideRepoTool: agentId !== 'mentor' && params.provideRepoTool,
         availableUploads: params.availableUploads,
         defaultRepoSections: params.defaultRepoSectionsByAgent[agentId],
         context: params.context,
@@ -83,7 +82,8 @@ export function createTeamThinkTool(params: {
       })
       const agentConfig = config as Record<string, unknown>
       const agentId_ = typeof agentConfig.id === 'string' ? agentConfig.id : agentId
-      const maxSteps = typeof agentConfig.maxSteps === 'number' ? agentConfig.maxSteps : 10
+      const configuredMaxSteps = typeof agentConfig.maxSteps === 'number' ? agentConfig.maxSteps : 10
+      const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
       const agent = createAgent[agentId_]({
         mode: 'fixedWorkstreamMode',
         tools,
@@ -114,7 +114,6 @@ export function createTeamThinkTool(params: {
     latestUserMessageId: params.latestUserMessageId,
     availableUploads: params.availableUploads,
     defaultRepoSectionsByAgent: params.defaultRepoSectionsByAgent,
-    reasoningProfile: params.reasoningProfile,
     systemWorkspaceDetails: params.systemWorkspaceDetails,
     getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
     retrievedKnowledgeSection: params.retrievedKnowledgeSection,

package/src/utils/async.ts

@@ -1,3 +1,4 @@
+import { serverLogger } from '../config/logger'
 import { getErrorMessage } from './errors'
 
 class TimeoutError extends Error {
@@ -41,7 +42,7 @@ export function createSafeEnqueue(logger: { warn: (message: string) => void }) {
   }
 }
 
-const _defaultSafeEnqueue = createSafeEnqueue({ warn: console.warn })
+const _defaultSafeEnqueue = createSafeEnqueue({ warn: (message: string) => serverLogger.warn`${message}` })
 export function safeEnqueue<T>(
   operation: () => T | Promise<T>,
   options: { operationName: string; onError?: (error: unknown) => void; logPrefix?: string },

package/src/utils/date-time.ts

@@ -1,34 +1,6 @@
-export function toIsoDateTimeString(value: unknown): string {
-  if (value instanceof Date) {
-    return value.toISOString()
-  }
+export { toIsoDateTimeString, toOptionalIsoDateTimeString } from '@lota-sdk/shared'
 
-  // Assume API boundaries already use ISO strings.
-  if (typeof value === 'string') {
-    return value
-  }
-
-  // Support unix timestamps (seconds or milliseconds).
-  if (typeof value === 'number') {
-    const millis = value < 1_000_000_000_000 ? value * 1000 : value
-    return new Date(millis).toISOString()
-  }
-
-  // Support objects that expose toISOString (e.g., SurrealDB temporal types).
-  if (value && typeof value === 'object') {
-    const maybeToIso = (value as { toISOString?: unknown }).toISOString
-    if (typeof maybeToIso === 'function') {
-      return (value as { toISOString: () => string }).toISOString()
-    }
-  }
-
-  return String(value)
-}
-
-export function toOptionalIsoDateTimeString(value: unknown): string | undefined {
-  if (value === null || value === undefined || value === '') {
-    return undefined
-  }
-
-  return toIsoDateTimeString(value)
+export function toDatabaseDateTime(value: string | Date | null | undefined): Date | undefined {
+  if (value === null || value === undefined) return undefined
+  return value instanceof Date ? value : new Date(value)
 }

package/src/utils/env.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads a required environment variable. Throws if the variable is missing or empty.
+ */
+export function getRequiredEnv(key: string): string {
+  const value = process.env[key]
+  if (!value) throw new Error(`Missing required env var: ${key}`)
+  return value
+}

package/src/utils/errors.ts

@@ -1,13 +1,4 @@
-export function getErrorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message
-  if (typeof error === 'string') return error
-
-  try {
-    return JSON.stringify(error)
-  } catch {
-    return String(error)
-  }
-}
+export { getErrorMessage } from '@lota-sdk/shared'
 
 export function toError(value: unknown): Error {
   return value instanceof Error ? value : new Error(String(value))
@@ -41,3 +32,44 @@ export class BadRequestError extends AppError {
     super(message, 'BAD_REQUEST', 400)
   }
 }
+
+type ErrorCode =
+  | 'UNAUTHORIZED'
+  | 'FORBIDDEN'
+  | 'NOT_FOUND'
+  | 'CONFLICT'
+  | 'BAD_REQUEST'
+  | 'VALIDATION_ERROR'
+  | 'INTERNAL_SERVER_ERROR'
+  | 'HTTP_ERROR'
+  | 'TOO_MANY_REQUESTS'
+
+interface ValidationIssue {
+  path: string
+  message: string
+}
+
+export interface ErrorBody {
+  error: { code: ErrorCode; message: string; issues?: ValidationIssue[] }
+}
+
+function createErrorResponse(code: ErrorCode, message: string): ErrorBody {
+  return { error: { code, message } }
+}
+
+function createValidationErrorResponse(message: string, issues: ValidationIssue[]): ErrorBody {
+  return { error: { code: 'VALIDATION_ERROR', message, issues } }
+}
+
+export const errorResponses = {
+  unauthorized: (message = 'Invalid credentials') => createErrorResponse('UNAUTHORIZED', message),
+  forbidden: (message = 'Access denied') => createErrorResponse('FORBIDDEN', message),
+  notFound: (message: string) => createErrorResponse('NOT_FOUND', message),
+  conflict: (message: string) => createErrorResponse('CONFLICT', message),
+  badRequest: (message: string) => createErrorResponse('BAD_REQUEST', message),
+  tooManyRequests: (message = 'Too many requests') => createErrorResponse('TOO_MANY_REQUESTS', message),
+  serverError: (message = 'Internal server error') => createErrorResponse('INTERNAL_SERVER_ERROR', message),
+  validationError: (issues: ValidationIssue[], message = 'Validation failed') =>
+    createValidationErrorResponse(message, issues),
+  httpError: (message: string) => createErrorResponse('HTTP_ERROR', message),
+} as const

package/src/utils/index.ts

@@ -1,14 +1,23 @@
 export * from './async'
 export * from './date-time'
+export * from './env'
 export * from './errors'
 export * from './hono-error-handler'
 export * from './sse-keepalive'
 export {
   CHARS_PER_TOKEN_ESTIMATE,
+  clampImportance,
+  compactRecord,
   compactWhitespace,
   isRecord,
+  parseLineList,
+  readRecordArray,
   readString,
+  readStringArray,
   readStringField,
+  slugify,
+  stringifyLineList,
+  stringifyUnknown,
   truncateOptionalText,
   truncateText,
 } from './string'

package/src/utils/string.ts

@@ -29,7 +29,7 @@ export function readStringField(record: Record<string, unknown>, key: string): s
  * Returns the original string when it fits within maxChars.
  */
 export function truncateText(value: string, maxChars: number): string {
-  return value.length <= maxChars ? value : `${value.slice(0, maxChars).trimEnd()}...`
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars - 3).trimEnd()}...`
 }
 
 /**
@@ -59,7 +59,120 @@ export function readRecord(value: unknown): Record<string, unknown> | null {
   return value as Record<string, unknown>
 }
 
+/**
+ * Strips null and undefined values from a record, returning a new object with only defined entries.
+ */
+export function compactRecord(value: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== null && entry !== undefined))
+}
+
+/**
+ * Converts a string into a URL-safe slug: lowercase, non-alphanumeric runs
+ * replaced with hyphens, leading/trailing hyphens stripped, capped at 80 chars.
+ */
+export function slugify(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '')
+    .slice(0, 80)
+}
+
 /**
  * Rough character-to-token estimate used for context budget calculations.
  */
 export const CHARS_PER_TOKEN_ESTIMATE = 3
+
+/**
+ * Converts an unknown value to a trimmed, non-empty string representation.
+ * Returns null for null, undefined, empty, or whitespace-only results.
+ *
+ * When maxChars is provided, the result is compacted and truncated.
+ * Without maxChars, strings are trimmed and objects are JSON-serialized.
+ */
+export function stringifyUnknown(value: unknown, maxChars?: number): string | null {
+  if (value === null || value === undefined) return null
+
+  const raw = (() => {
+    if (typeof value === 'string') return value
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+      return String(value)
+    }
+    if (typeof value === 'symbol') return value.description ? `Symbol(${value.description})` : 'Symbol()'
+    if (typeof value === 'function') return value.name ? `[function ${value.name}]` : '[function anonymous]'
+    if (Array.isArray(value)) {
+      try {
+        return JSON.stringify(value)
+      } catch {
+        return `[array(${value.length})]`
+      }
+    }
+
+    try {
+      return JSON.stringify(value)
+    } catch {
+      const maybeName =
+        isRecord(value) && typeof (value as { constructor?: { name?: unknown } }).constructor?.name === 'string'
+          ? (value as { constructor?: { name?: string } }).constructor?.name
+          : 'Object'
+      return `[object ${maybeName}]`
+    }
+  })()
+
+  if (maxChars !== undefined) {
+    const normalized = compactWhitespace(raw)
+    if (!normalized) return null
+    return truncateText(normalized, maxChars)
+  }
+
+  const trimmed = raw.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+
+/**
+ * Clamps a numeric importance/confidence value to [0, 1].
+ * Returns 0 for non-finite values.
+ */
+export function clampImportance(value: number): number {
+  if (!Number.isFinite(value)) return 0
+  return Math.max(0, Math.min(1, value))
+}
+
+/**
+ * Splits a string on newlines, trims each line, and filters empties.
+ */
+export function parseLineList(value: string): string[] {
+  return value
+    .split('\n')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0)
+}
+
+/**
+ * Joins an array of values into a newline-separated string.
+ * Returns an empty string for non-array inputs.
+ */
+export function stringifyLineList(value: unknown): string {
+  return Array.isArray(value) ? value.map(String).join('\n') : ''
+}
+
+/**
+ * Reads an array of strings from an unknown value.
+ * Returns an empty array when the input is not an array.
+ */
+export function readStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value.filter((entry): entry is string => typeof entry === 'string')
+}
+
+/**
+ * Reads an array of plain records from an unknown value.
+ * Returns an empty array when the input is not an array.
+ */
+export function readRecordArray(value: unknown): Array<Record<string, unknown>> {
+  if (!Array.isArray(value)) return []
+  return value.filter(
+    (entry): entry is Record<string, unknown> => typeof entry === 'object' && entry !== null && !Array.isArray(entry),
+  )
+}

package/src/workers/index.ts

@@ -5,3 +5,4 @@ export * from './utils/file-section-chunker'
 export * from './utils/repomix-file-sections'
 export * from './utils/repo-structure-extractor'
 export * from './utils/repomix-process-concurrency'
+export * from './utils/sandbox-error'

package/src/workers/regular-chat-memory-digest.helpers.ts

@@ -2,7 +2,7 @@ import { isAgentName } from '../config/agent-defaults'
 import { compactWhitespace } from '../utils/string'
 
 interface DigestMessageForTranscript {
-  source: 'workstream'
+  source: 'workstream' | 'social'
   sourceId: string
   role: 'system' | 'user' | 'assistant'
   parts: Array<Record<string, unknown>>

package/src/workers/regular-chat-memory-digest.runner.ts

@@ -14,6 +14,7 @@ import type { RegularChatMemoryDigestJob } from '../queues/regular-chat-memory-d
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import { getRuntimeAdapters, withConfiguredWorkspaceMemoryLock } from '../runtime/runtime-extensions'
 import { memoryService } from '../services/memory.service'
+import { socialChatHistoryService } from '../services/social-chat-history.service'
 import { createRegularChatMemoryDigestAgent } from '../system-agents/regular-chat-memory-digest.agent'
 import { compactWhitespace } from '../utils/string'
 import { buildDigestTranscript, resolveWorkspaceBootstrapCutoff } from './regular-chat-memory-digest.helpers'
@@ -48,6 +49,7 @@ const helperModelRuntime = createHelperModelRuntime()
 interface RegularChatDigestRunResult {
   skipped: boolean
   processedWorkstreamMessages: number
+  processedSocialMessages: number
   followUpScheduled: boolean
 }
 
@@ -130,7 +132,7 @@ async function hasNewEligibleWorkstreamMessages(params: {
 }
 
 async function loadExistingOrganizationMemories(orgId: string): Promise<Array<{ content: string }>> {
-  return await databaseService.queryMany(
+  return databaseService.queryMany(
     new BoundQuery(
       `SELECT content, createdAt, id FROM ${TABLES.MEMORY}
        WHERE metadata.orgId = $orgId
@@ -152,24 +154,24 @@ export async function runRegularChatMemoryDigest(
   const workspaceProvider = getRuntimeAdapters().services?.workspaceProvider
   if (!workspaceProvider) {
     serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider is not configured`
-    return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
+    return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
   }
 
-  return await withConfiguredWorkspaceMemoryLock(orgId, async () => {
+  return withConfiguredWorkspaceMemoryLock(orgId, async () => {
     if (
       !workspaceProvider.getBackgroundCursor ||
       !workspaceProvider.setBackgroundCursor ||
       !workspaceProvider.applyProfileProjection
     ) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider background/profile methods are incomplete`
-      return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
     const workspace = await workspaceProvider.getWorkspace(orgRef)
     const lifecycleState = await workspaceProvider.getLifecycleState?.(workspace)
     if (lifecycleState?.bootstrapActive ?? false) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: onboarding is not completed`
-      return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
     const projectionState = await workspaceProvider.readProfileProjectionState?.(workspace)
 
@@ -185,13 +187,23 @@ export async function runRegularChatMemoryDigest(
       cursor: existingWorkstreamCursor,
       onboardingCutoff: workstreamOnboardingCutoff,
     })
+    const existingSocialCursor = await socialChatHistoryService.getBackgroundCursor('regular-chat-digest', orgId)
+    const socialOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
+      hasExistingCursor: existingSocialCursor !== null,
+      bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
+    })
+    const socialMessages = await socialChatHistoryService.listWorkspaceMessages({
+      workspaceId: orgId,
+      cursor: existingSocialCursor,
+      onboardingCutoff: socialOnboardingCutoff,
+    })
 
-    if (workstreamMessages.length === 0) {
+    if (workstreamMessages.length === 0 && socialMessages.length === 0) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: no eligible messages`
-      return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
+      return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
-    const combinedMessages = [...workstreamMessages].sort(compareDigestMessageOrder)
+    const combinedMessages = [...workstreamMessages, ...socialMessages].sort(compareDigestMessageOrder)
     const { transcript, involvedAgentNames } = buildDigestTranscript({ messages: combinedMessages })
     const existingMemories = await loadExistingOrganizationMemories(orgId)
 
@@ -219,7 +231,8 @@ export async function runRegularChatMemoryDigest(
       throw new Error('Regular chat memory digest returned an empty summaryBlock')
     }
 
-    const processedWorkstreamCursor = getLastCursor(combinedMessages)
+    const processedWorkstreamCursor = getLastCursor(workstreamMessages)
+    const processedSocialCursor = getLastCursor(socialMessages)
     const digestRunAt = new Date().toISOString()
 
     if (synthesis.facts.length > 0) {
@@ -235,6 +248,12 @@ export async function runRegularChatMemoryDigest(
                 digestWorkstreamCursorId: processedWorkstreamCursor.id,
               }
             : {}),
+          ...(processedSocialCursor
+            ? {
+                digestSocialCursorCreatedAt: processedSocialCursor.createdAt.toISOString(),
+                digestSocialCursorId: processedSocialCursor.id,
+              }
+            : {}),
         },
         agentNames: involvedAgentNames,
         acquireLock: false,
@@ -248,6 +267,9 @@ export async function runRegularChatMemoryDigest(
     if (processedWorkstreamCursor) {
       await workspaceProvider.setBackgroundCursor('regular-chat-digest', orgRef, processedWorkstreamCursor)
     }
+    if (processedSocialCursor) {
+      await socialChatHistoryService.setBackgroundCursor('regular-chat-digest', orgId, processedSocialCursor)
+    }
 
     const workstreamBoundaryCursor = processedWorkstreamCursor ?? existingWorkstreamCursor
     const hasMoreWorkstreamMessages = await hasNewEligibleWorkstreamMessages({
@@ -255,15 +277,26 @@ export async function runRegularChatMemoryDigest(
       cursor: workstreamBoundaryCursor,
       onboardingCutoff: workstreamBoundaryCursor ? null : workstreamOnboardingCutoff,
     })
+    const socialBoundaryCursor = processedSocialCursor ?? existingSocialCursor
+    const hasMoreSocialMessages = await socialChatHistoryService.hasWorkspaceMessages({
+      workspaceId: orgId,
+      cursor: socialBoundaryCursor,
+      onboardingCutoff: socialBoundaryCursor ? null : socialOnboardingCutoff,
+    })
 
-    const followUpScheduled = hasMoreWorkstreamMessages
+    const followUpScheduled = hasMoreWorkstreamMessages || hasMoreSocialMessages
     if (followUpScheduled) {
       await clearRegularChatMemoryDigestDeduplicationKey(orgId)
       await enqueueRegularChatMemoryDigest({ orgId })
     }
 
-    serverLogger.info`Regular chat memory digest completed for ${orgId}: workstreamMessages=${workstreamMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
+    serverLogger.info`Regular chat memory digest completed for ${orgId}: workstreamMessages=${workstreamMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`
 
-    return { skipped: false, processedWorkstreamMessages: workstreamMessages.length, followUpScheduled }
+    return {
+      skipped: false,
+      processedWorkstreamMessages: workstreamMessages.length,
+      processedSocialMessages: socialMessages.length,
+      followUpScheduled,
+    }
   })
 }

package/src/workers/skill-extraction.runner.ts

@@ -6,6 +6,7 @@ import type { SkillExtractionJob } from '../queues/skill-extraction.queue'
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import { getRuntimeAdapters, withConfiguredWorkspaceMemoryLock } from '../runtime/runtime-extensions'
 import { learnedSkillService } from '../services/learned-skill.service'
+import { socialChatHistoryService } from '../services/social-chat-history.service'
 import { createSkillExtractorAgent, SkillExtractionOutputSchema } from '../system-agents/skill-extractor.agent'
 import type { SkillCandidate } from '../system-agents/skill-extractor.agent'
 import { createSkillManagerAgent, SkillManagerOutputSchema } from '../system-agents/skill-manager.agent'
@@ -86,7 +87,7 @@ export async function runSkillExtraction(data: SkillExtractionJob): Promise<Skil
     return { skipped: true, processedMessages: 0, extractedSkills: 0 }
   }
 
-  return await withConfiguredWorkspaceMemoryLock(orgId, async () => {
+  return withConfiguredWorkspaceMemoryLock(orgId, async () => {
     const workspace = await cursorAwareWorkspaceProvider.getWorkspace(orgRef)
     const lifecycleState = await cursorAwareWorkspaceProvider.getLifecycleState?.(workspace)
     if (lifecycleState?.bootstrapActive ?? false) {
@@ -100,9 +101,24 @@ export async function runSkillExtraction(data: SkillExtractionJob): Promise<Skil
       hasExistingCursor: existingCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
+    const existingSocialCursor = await socialChatHistoryService.getBackgroundCursor('skill-extraction', orgId)
+    const socialOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
+      hasExistingCursor: existingSocialCursor !== null,
+      bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
+    })
 
     const workstreamIds = await listWorkstreamIdsForOrg(orgRef)
-    const messages = await listEligibleWorkstreamMessages({ workstreamIds, cursor: existingCursor, onboardingCutoff })
+    const workstreamMessages = await listEligibleWorkstreamMessages({
+      workstreamIds,
+      cursor: existingCursor,
+      onboardingCutoff,
+    })
+    const socialMessages = await socialChatHistoryService.listWorkspaceMessages({
+      workspaceId: orgId,
+      cursor: existingSocialCursor,
+      onboardingCutoff: socialOnboardingCutoff,
+    })
+    const messages = [...workstreamMessages, ...socialMessages]
 
     if (messages.length < MIN_MESSAGE_THRESHOLD) {
       serverLogger.info`Skipping skill extraction for ${orgId}: only ${messages.length} messages (threshold: ${MIN_MESSAGE_THRESHOLD})`
@@ -225,12 +241,16 @@ export async function runSkillExtraction(data: SkillExtractionJob): Promise<Skil
       }
     }
 
-    const lastMessage = sortedMessages.at(-1)
-    if (lastMessage) {
-      await cursorAwareWorkspaceProvider.setBackgroundCursor('skill-extraction', orgRef, lastMessage.cursor)
+    const lastWorkstreamMessage = workstreamMessages.at(-1)
+    const lastSocialMessage = socialMessages.at(-1)
+    if (lastWorkstreamMessage) {
+      await cursorAwareWorkspaceProvider.setBackgroundCursor('skill-extraction', orgRef, lastWorkstreamMessage.cursor)
+    }
+    if (lastSocialMessage) {
+      await socialChatHistoryService.setBackgroundCursor('skill-extraction', orgId, lastSocialMessage.cursor)
     }
 
-    serverLogger.info`Skill extraction completed for ${orgId}: messages=${messages.length}, extracted=${extractedSkills}`
+    serverLogger.info`Skill extraction completed for ${orgId}: messages=${messages.length}, socialMessages=${socialMessages.length}, extracted=${extractedSkills}`
 
     return { skipped: false, processedMessages: messages.length, extractedSkills }
   })

package/src/workers/utils/file-section-chunker.ts

@@ -1,8 +1,9 @@
+import { CHARS_PER_TOKEN_ESTIMATE } from '../../utils/string'
+
 export const DEFAULT_FILE_SECTION_CHUNK_MAX_CHARS = 250_000
 export const MIN_FILE_SECTION_CHUNK_MAX_CHARS = 4_000
 export const DEFAULT_FILE_SECTION_CHUNK_MIN_CHARS = 10_000
 const SECTION_SEPARATOR_LENGTH = 2
-const CHARS_PER_TOKEN_ESTIMATE = 3
 const MIN_CHUNK_CHARS_FLOOR = 512
 
 export interface FileSection {

package/src/workers/utils/repo-structure-extractor.ts

@@ -1,4 +1,4 @@
-import { readdir, readFile } from 'node:fs/promises'
+import { readdir } from 'node:fs/promises'
 import path from 'node:path'
 
 import { RepositoryStructureArtifactSchema, RepositoryStructureSummarySchema } from '@lota-sdk/shared'
@@ -119,7 +119,7 @@ async function collectRelativeFilePaths(rootDir: string, currentDir = ''): Promi
 
 async function readPackageJson(rootDir: string, relativePath: string): Promise<PackageJson | null> {
   try {
-    const raw = await readFile(path.join(rootDir, relativePath), 'utf8')
+    const raw = await Bun.file(path.join(rootDir, relativePath)).text()
     return JSON.parse(raw) as PackageJson
   } catch {
     return null

package/src/workers/utils/repomix-file-sections.ts

@@ -27,7 +27,7 @@ export function parseRepomixFileSections(repomixOutput: string): FileSection[] {
     const nextStart = matches[index + 1]?.index ?? source.length
     const content = source.slice(start, nextStart).trim()
     if (!content) continue
-    const filePath = (match[1] ?? '').trim()
+    const filePath = match[1].trim()
     sections.push({ kind: 'file', content, filePath: filePath || undefined })
   }
 
@@ -38,5 +38,5 @@ export async function chunkRepomixFileSections(
   repomixOutput: string,
   options: FileSectionChunkOptions = {},
 ): Promise<FileSectionChunk[]> {
-  return await chunkFileSections(parseRepomixFileSections(repomixOutput), options)
+  return chunkFileSections(parseRepomixFileSections(repomixOutput), options)
 }

package/src/workers/utils/sandbox-error.ts

@@ -1,5 +1,14 @@
-export function toSandboxedWorkerError(error: unknown, context?: string): Error {
-  const base = error instanceof Error ? error : new Error(String(error))
+export interface SandboxedWorkerError {
+  name: string
+  message: string
+  stack?: string
+}
+
+export function toSandboxedWorkerError(error: unknown, context?: string): SandboxedWorkerError {
+  const base =
+    error instanceof Error
+      ? { name: error.name || 'Error', message: error.message, stack: error.stack }
+      : { name: 'Error', message: String(error) }
   if (context) base.message = `${context}: ${base.message}`
   return base
 }