Memory & context

async function runMemoryConsolidation(
  messages: Array<{ role: string; content: unknown }>,
  model: Model<string>,
  apiKey: string
): Promise<void> {
  try {
    const existing = await getActiveMemories(LOCAL_USER_ID)
    const index =
      existing.length > 0 ? existing.map(memoryIndexLine).join('\n') : '(empty)'

    const responseText = await callLlm(
      model,
      apiKey,
      CONSOLIDATE_SYSTEM,
      `Current memory index:\n${index}\n\nConversation to analyze:\n\n${formatMessages(
        messages
      )}`
    )

    const parsed = ConsolidationSchema.safeParse(
      parseJsonFromResponse(responseText)
    )
    if (!parsed.success) return

    const validIds = new Set(existing.map((m) => m.id))

    for (const op of parsed.data.operations) {
      if (op.op === 'delete') {
        // Nobody watches this job to undo it: the entry is switched off, not
        // removed, and Settings → Memory can restore it.
        if (validIds.has(op.id)) await softDeleteMemory(op.id)
        continue
      }
      const fields = {
        section: op.section as MemorySection,
        key: op.key.trim(),
        summary: op.summary.trim(),
        details: op.details
          .map((d) => d.trim())
          .filter(Boolean)
          .slice(0, 8)
      }
      if (op.op === 'update' && op.id && validIds.has(op.id)) {
        await updateMemory(op.id, {
          ...fields,
          confidence: op.confidence
        })
      } else {
        await createMemory({
          userId: LOCAL_USER_ID,
          source: 'implicit',
          confidence: op.confidence ?? 0.8,
          ...fields
        })
      }
    }
  } catch (err) {
    logger.error('memory', 'Consolidation failed', { error: err })
  }
}

async function runMemoryInstruction(
  instruction: string,
  scopeMemoryId: string | null,
  model: Model<string>,
  apiKey: string
): Promise<MemoryInstructionResult> {
  // Include inactive entries so the user can reference / restore / delete them.
  const all = await getAllMemories(LOCAL_USER_ID)
  const scoped = scopeMemoryId
    ? (all.find((m) => m.id === scopeMemoryId) ?? null)
    : null

  const context = scoped
    ? `The user is editing this entry:\n${memoryEntryBlock(scoped)}\n\n` +
      `Other entries (id + title only):\n${
        all
          .filter((m) => m.id !== scoped.id)
          .map((m) => `- [${m.id}] (${m.section}) ${m.key}`)
          .join('\n') || '(none)'
      }`
    : `Current memory:\n${
        all.length > 0 ? all.map(memoryEntryBlock).join('\n\n') : '(empty)'
      }`

  const responseText = await callLlm(
    model,
    apiKey,
    INSTRUCTION_SYSTEM,
    `${context}\n\nUser instruction:\n${instruction.trim()}`
  )

  const parsed = InstructionSchema.safeParse(
    parseJsonFromResponse(responseText)
  )
  if (!parsed.success) {
    throw new Error("Couldn't interpret that instruction — try rephrasing.")
  }

  const byId = new Map(all.map((m) => [m.id, m]))
  const changes: MemoryChange[] = []

  for (const op of parsed.data.operations) {
    if (op.op === 'delete') {
      const before = op.id ? byId.get(op.id) : undefined
      if (!before) continue // unknown id (or deleted earlier this reply): ignored, not reported
      await hardDeleteMemory(before.id)
      byId.delete(before.id)
      changes.push({
        op: 'delete',
        id: before.id,
        before: snapshotOf(before),
        after: null
      })
      continue
    }

    if (!op.section || !op.key?.trim() || !op.summary?.trim()) continue
    const fields = {
      section: op.section as MemorySection,
      key: op.key.trim(),
      summary: op.summary.trim(),
      details: (op.details ?? [])
        .map((d) => d.trim())
        .filter(Boolean)
        .slice(0, 8)
    }

    if (op.op === 'update') {
      const before = op.id ? byId.get(op.id) : undefined
      // unknown id, or deleted earlier this reply: ignored (never invents a create)
      if (!before) continue
      const updated = await updateMemory(before.id, {
        ...fields,
        confidence: op.confidence
      })
      if (!updated) continue
      byId.set(before.id, updated)
      changes.push({
        op: 'update',
        id: before.id,
        before: snapshotOf(before),
        after: snapshotOf(updated)
      })
    } else {
      const created = await createMemory({
        userId: LOCAL_USER_ID,
        source: 'explicit',
        confidence: op.confidence ?? 0.9,
        ...fields
      })
      changes.push({
        op: 'create',
        id: created.id,
        before: null,
        after: snapshotOf(created)
      })
    }
  }

  return { applied: changes.length, changes }
}

async function loadRelevantMemories(
  question: string,
  model: Model<string>,
  apiKey: string,
  sessionId: string,
  runId: string
): Promise<MemoryRow[]> {
  try {
    const all = await getActiveMemories(LOCAL_USER_ID)
    if (all.length === 0) return []

    const listText = all
      .map(
        (m) =>
          `${m.id}: [${m.section}] ${m.key} — ${m.summary}` +
          (m.details.length ? `\n    ${m.details.join('; ')}` : '')
      )
      .join('\n')

    const responseText = await callLlm(
      model,
      apiKey,
      READ_FILTER_SYSTEM,
      `User message: ${question}\n\nMemory entries:\n${listText}`
    )

    const parsed = MemoryFilterResultSchema.safeParse(
      parseJsonFromResponse(responseText)
    )
    if (!parsed.success) return []

    const selectedIds = new Set(parsed.data.selectedMemoryIds)
    const selected = all.filter((m) => selectedIds.has(m.id))

    if (selected.length > 0) {
      const ids = selected.map((m) => m.id)
      await touchMemories(ids)
      await Promise.all(
        selected.map((m) =>
          logMemoryUsage({
            memoryId: m.id,
            sessionId,
            runId,
            key: m.key,
            section: m.section,
            reason: 'read-filter'
          }).catch(() => {})
        )
      )
    }

    return selected
  } catch (err) {
    logger.error('memory', 'Read filter failed', { error: err })
    return []
  }
}

function formatRunMemory(memories: MemoryRow[]): string {
  if (memories.length === 0) return ''
  const blocks = memories.toSorted(compare).map((m) => {
    const bullets = (m.details ?? []).map((d) => `- ${d}`).join('\n')
    return `## ${m.key} (${m.section})\n${m.summary}${bullets ? `\n${bullets}` : ''}`
  })
  return `<user_memory>\nThe user's saved memory, as chosen for this message:\n\n${blocks.join('\n\n')}\n</user_memory>`
}

function getLeafSummaryPrompt(previousContext: string): string {
  const prevSection = previousContext
    ? `\n\nPrevious context summary for continuity:\n${previousContext}`
    : ''

  return `You are a memory compaction engine. Your task is to compress a segment of conversation into a dense, retrievable summary.

Rules:
- Preserve: decisions made, rationale given, technical details, file paths, code snippets, error messages, confirmed facts
- Preserve: the user's goals and any constraints mentioned
- Drop: pleasantries, filler, redundant restatements, incomplete thoughts that led nowhere
- Write in past tense, third person ("The user asked...", "The assistant suggested...")
- End ALWAYS with a line: "Expand for details about: <comma-separated list of compressed specifics>"
- Target length: 800–1200 tokens${prevSection}`
}