saeeol 1.4.1 → 1.4.3

package/src/overlay/session/compaction-chunks.ts

@@ -1,125 +0,0 @@
-import { Effect } from "effect"
-import { MessageV2 } from "@/session/message-v2"
-import { PartID } from "@/session/schema"
-import * as Log from "@saeeol/core/util/log"
-import {
-  type Input,
-  type Batch,
-  CONCURRENCY,
-  DEFAULT_AUTO_BATCHES,
-  TOOL_OUTPUT_MAX_CHARS,
-  batchSplit,
-  budget,
-  eligible as eligibleImpl,
-  large,
-  needed as neededImpl,
-  transcript,
-} from "./compaction-chunks-utils"
-import { processBatch, replay as replayImpl, run } from "./compaction-chunks-core"
-
-const log = Log.create({ service: "saeeol.compaction.chunks" })
-
-const autoPrompt = [
-  "Summarize the oldest conversation history below.",
-  "This summary will replace those messages in context, so preserve all important facts.",
-  "Keep concrete file paths, commands, errors, decisions, and unresolved tasks.",
-  "Use terse Markdown bullets. Do not mention compaction or summarization.",
-].join("\n")
-
-function manualProcess(input: Input, batches: Batch[]) {
-  return Effect.gen(function* () {
-    log.info("manual batch compaction", { batches: batches.length })
-    const results = yield* Effect.forEach(
-      batches,
-      (b) => processBatch({ ...input, b, total: batches.length }),
-      { concurrency: Math.min(CONCURRENCY, batches.length) },
-    )
-    if (results.some((r) => r.result !== "continue" || !r.output)) return "compact" as const
-    const final = results.map((r) => r.output!).join("\n\n")
-    yield* input.updatePart({
-      id: PartID.ascending(),
-      messageID: input.target.id,
-      sessionID: input.sessionID,
-      type: "text",
-      text: final,
-    })
-    input.target.finish = "stop"
-    input.target.error = undefined
-    input.target.time.completed = Date.now()
-    yield* input.updateMessage(input.target)
-    return "continue" as const
-  })
-}
-
-function autoProcess(input: Input, batches: Batch[]) {
-  return Effect.gen(function* () {
-    const autoLimit = input.cfg.compaction?.auto_batches ?? DEFAULT_AUTO_BATCHES
-    const limit = Math.min(autoLimit, batches.length)
-    const oldest = batches.slice(0, limit)
-    const rest = batches.slice(limit)
-
-    if (input.out && rest.length) {
-      const first = rest[0]?.first[0]
-      if (first) input.out.tail_start_id = first.info.id
-    }
-
-    const autoMessages = oldest.flatMap((b) => [...b.first, ...b.middle, ...b.last])
-    log.info("auto batch compaction", { total: batches.length, oldest: limit, messages: autoMessages.length })
-
-    const size = budget({ cfg: input.cfg, model: input.model })
-    const tooLarge = yield* large({ messages: autoMessages, model: input.model, size })
-    const data = tooLarge
-      ? [
-          {
-            role: "user" as const,
-            content: [
-              {
-                type: "text" as const,
-                text: [
-                  "The following compacted transcript represents an oversized conversation section.",
-                  "Summarize all facts present in the transcript.",
-                  "<conversation>",
-                  transcript({ messages: autoMessages }),
-                  "</conversation>",
-                ].join("\n"),
-              },
-            ],
-          },
-        ]
-      : yield* MessageV2.toModelMessagesEffect(autoMessages, input.model, {
-          stripMedia: true,
-          toolOutputMaxChars: TOOL_OUTPUT_MAX_CHARS,
-        })
-
-    const result = yield* run({ ...input, data, text: autoPrompt })
-    if (result.result !== "continue" || !result.output) return "compact" as const
-
-    yield* input.updatePart({
-      id: PartID.ascending(),
-      messageID: input.target.id,
-      sessionID: input.sessionID,
-      type: "text",
-      text: result.output,
-    })
-    input.target.finish = "stop"
-    input.target.error = undefined
-    input.target.time.completed = Date.now()
-    yield* input.updateMessage(input.target)
-    return "continue" as const
-  })
-}
-
-export namespace SaeeolCompactionChunks {
-  export const eligible = eligibleImpl
-  export const needed = neededImpl
-  export const replay = replayImpl
-
-  export function process(input: Input) {
-    return Effect.gen(function* () {
-      const batches = batchSplit(input.messages, input.cfg)
-      if (!batches.length) return "compact" as const
-      if (input.auto) return yield* autoProcess(input, batches)
-      return yield* manualProcess(input, batches)
-    })
-  }
-}

package/src/overlay/session/compaction-payload-recovery.ts

@@ -1,108 +0,0 @@
-import { Effect } from "effect"
-import type { Agent } from "@/agent/agent"
-import type { Provider } from "@/provider/provider"
-import type { LLM } from "@/session/llm"
-import { MessageV2 } from "@/session/message-v2"
-import type { SessionProcessor } from "@/session/processor"
-import type { MessageID, SessionID } from "@/session/schema"
-
-type Update = <T extends MessageV2.Part>(part: T) => Effect.Effect<T>
-type UpdateMessage = <T extends MessageV2.Info>(msg: T) => Effect.Effect<T>
-
-const pattern = /request entity too large|function_payload_too_large/i
-
-export namespace SaeeolCompactionPayloadRecovery {
-  export function matches(error: MessageV2.Assistant["error"]) {
-    if (!error) return false
-    if (error.name !== "ContextOverflowError" && error.name !== "APIError") return false
-    return pattern.test([error.data.message, error.data.responseBody].filter(Boolean).join("\n"))
-  }
-
-  export function prompt(text: string) {
-    return [
-      "The previous compaction request exceeded the provider's 4MB payload limit.",
-      "Older tool outputs and media attachments were removed from this compaction request.",
-      text,
-    ].join("\n\n")
-  }
-
-  export function strip(input: { messages: MessageV2.WithParts[]; update: Update }) {
-    return Effect.forEach(
-      input.messages,
-      (msg) =>
-        Effect.forEach(msg.parts, (part) => {
-          if (part.type === "tool" && part.state.status === "completed" && !part.state.time.compacted) {
-            part.state.time.compacted = Date.now()
-            return input.update(part)
-          }
-          if (part.type === "file" && MessageV2.isMedia(part.mime)) {
-            return input.update({
-              id: part.id,
-              messageID: part.messageID,
-              sessionID: part.sessionID,
-              type: "text",
-              text: `[Attached ${part.mime}: ${part.filename ?? "file"}]`,
-            })
-          }
-          return Effect.void
-        }),
-      { concurrency: 1 },
-    )
-  }
-
-  export function process(input: {
-    processor: SessionProcessor.Handle
-    user: MessageV2.User
-    agent: Agent.Info
-    sessionID: SessionID
-    model: Provider.Model
-    messages: LLM.StreamInput["messages"]
-    prompt: string
-    recovery: MessageV2.WithParts[]
-    updateMessage: UpdateMessage
-    updatePart: Update
-  }) {
-    const run = Effect.fn("SaeeolCompactionPayloadRecovery.process")(function* (
-      messages: LLM.StreamInput["messages"],
-      text: string,
-    ) {
-      return yield* input.processor.process({
-        user: input.user,
-        agent: input.agent,
-        sessionID: input.sessionID,
-        tools: {},
-        system: [],
-        messages: [
-          ...messages,
-          {
-            role: "user",
-            content: [{ type: "text", text }],
-          },
-        ],
-        model: input.model,
-      })
-    })
-
-    return run(input.messages, input.prompt).pipe(
-      Effect.flatMap((result) => {
-        if (result !== "compact" && (result !== "stop" || !matches(input.processor.message.error))) {
-          return Effect.succeed(result)
-        }
-        if (result === "compact" && !matches(input.processor.compactError?.())) {
-          return Effect.succeed(result)
-        }
-        return Effect.gen(function* () {
-          input.processor.message.error = undefined
-          input.processor.message.finish = undefined
-          yield* input.updateMessage(input.processor.message)
-          yield* strip({ messages: input.recovery, update: input.updatePart })
-          const stripped = yield* MessageV2.toModelMessagesEffect(input.recovery, input.model, {
-            stripMedia: true,
-            toolOutputMaxChars: 0,
-          })
-          return yield* run(stripped, prompt(input.prompt))
-        })
-      }),
-    )
-  }
-}

package/src/overlay/session/cost-propagation.ts

@@ -1,68 +0,0 @@
-import { Effect } from "effect"
-import { Session } from "@/session/session"
-import { MessageV2 } from "@/session/message-v2"
-import { SessionID, MessageID } from "@/session/schema"
-
-export namespace SaeeolCostPropagation {
-  /**
-   * Per-key promise chain that serializes concurrent `propagate` calls against
-   * the same parent message. Prevents lost updates when the LLM launches
-   * several `task` tool calls in parallel (each release stage races to
-   * read-modify-write the same parent cost field).
-   */
-  const locks = new Map<string, Promise<void>>()
-
-  function acquire(key: string): Promise<() => void> {
-    const prev = locks.get(key) ?? Promise.resolve()
-    let release!: () => void
-    const current = new Promise<void>((r) => (release = r))
-    const chain = prev.catch(() => {}).then(() => current)
-    locks.set(key, chain)
-    return prev
-      .catch(() => {})
-      .then(() => () => {
-        release()
-        if (locks.get(key) === chain) locks.delete(key)
-      })
-  }
-
-  /**
-   * Total assistant-message cost in a session. Because each subagent propagates
-   * its own total into the parent assistant message when it finishes, this sum
-   * already reflects descendant sessions recursively — no tree walk needed.
-   */
-  export const childCost = Effect.fn("SaeeolCostPropagation.childCost")(function* (
-    sessions: Session.Interface,
-    id: SessionID,
-  ) {
-    const msgs = yield* sessions.messages({ sessionID: id })
-    return msgs.reduce((sum, m) => sum + (m.info.role === "assistant" ? m.info.cost : 0), 0)
-  })
-
-  /**
-   * Add `amount` to the given parent assistant message's cost. No-op when
-   * `amount` is non-positive or the target is not an assistant message.
-   *
-   * Concurrent calls against the same parent are serialized internally so the
-   * read-modify-write cannot lose updates when subagents complete in parallel.
-   */
-  export const propagate = Effect.fn("SaeeolCostPropagation.propagate")(function* (
-    sessions: Session.Interface,
-    sid: SessionID,
-    mid: MessageID,
-    amount: number,
-  ) {
-    if (!(amount > 0)) return
-    yield* Effect.acquireUseRelease(
-      Effect.promise(() => acquire(`${sid}:${mid}`)),
-      () =>
-        Effect.gen(function* () {
-          const parent = yield* Effect.sync(() => MessageV2.get({ sessionID: sid, messageID: mid }))
-          if (parent.info.role !== "assistant") return
-          parent.info.cost += amount
-          yield* sessions.updateMessage(parent.info)
-        }),
-      (release) => Effect.sync(() => release()),
-    )
-  })
-}

package/src/overlay/session/digest-storage.ts

@@ -1,57 +0,0 @@
-import * as Log from "@saeeol/core/util/log"
-import path from "path"
-import { Global } from "@saeeol/core/global"
-import z from "zod"
-import fs from "fs"
-
-const log = Log.create({ service: "saeeol.digest-storage" })
-
-export const DigestSchema = z.object({
-  project: z.string(),
-  updated: z.number(),
-  entities: z.array(z.object({
-    name: z.string(),
-    type: z.string(),
-    observations: z.array(z.string()),
-  })),
-  relations: z.array(z.object({
-    from: z.string(),
-    to: z.string(),
-    type: z.string(),
-  })).optional(),
-  summary: z.string().optional(),
-})
-
-export type Digest = z.infer<typeof DigestSchema>
-
-function digestPath(): string {
-  return path.join(Global.Path.data, "saeeol", "digests", "current.json")
-}
-
-export function readDigest(): Digest | null {
-  try {
-    const p = digestPath()
-    if (!fs.existsSync(p)) return null
-    const raw = fs.readFileSync(p, "utf-8")
-    const parsed = DigestSchema.safeParse(JSON.parse(raw))
-    if (!parsed.success) {
-      log.info("digest parse error", { error: parsed.error.message })
-      return null
-    }
-    return parsed.data
-  } catch (e) {
-    log.info("digest read error", { error: String(e) })
-    return null
-  }
-}
-
-export function writeDigest(digest: Digest): void {
-  try {
-    const p = digestPath()
-    fs.mkdirSync(path.dirname(p), { recursive: true })
-    fs.writeFileSync(p, JSON.stringify(digest, null, 2))
-    log.info("digest saved", { entities: digest.entities.length })
-  } catch (e) {
-    log.info("digest write error", { error: String(e) })
-  }
-}

package/src/overlay/session/fork.ts

@@ -1,66 +0,0 @@
-import { Session } from "@/session/session"
-import { MessageV2 } from "@/session/message-v2"
-import { SessionID, PartID } from "@/session/schema"
-import * as Log from "@saeeol/core/util/log"
-
-const log = Log.create({ service: "session.fork" })
-
-/**
- * Extracts the child session ID from a task tool part.
- */
-function childID(part: MessageV2.Part): string | undefined {
-  if (part.type !== "tool" || part.tool !== "task") return undefined
-  return (part.state as { metadata?: { sessionId?: string } }).metadata?.sessionId
-}
-
-/**
- * Recursively fork all child (subagent) sessions referenced by task tool parts
- * in the given session, then update the parts to point at the forked copies.
- *
- * This prevents subagent state from leaking between forked sessions in the
- * same worktree: without remapping, two forked sessions would share the same
- * child session references, causing SSE events and permission prompts to bleed
- * across sessions.
- */
-export async function remapChildren(sid: SessionID): Promise<void> {
-  const msgs = await Session.messages({ sessionID: sid })
-  const refs: { part: MessageV2.ToolPart; child: string }[] = []
-  for (const msg of msgs) {
-    for (const part of msg.parts) {
-      const child = childID(part)
-      if (child) refs.push({ part: part as MessageV2.ToolPart, child })
-    }
-  }
-  if (refs.length === 0) return
-
-  const remapped = new Map<string, SessionID>()
-  for (const ref of refs) {
-    if (remapped.has(ref.child)) continue
-    const exists = await Session.get(SessionID.make(ref.child)).catch(() => undefined)
-    if (!exists) continue
-    // Session.fork() already calls remapChildren on the forked child,
-    // so nested subagents are handled recursively without an explicit call here.
-    const forked = await Session.fork({ sessionID: SessionID.make(ref.child) })
-    remapped.set(ref.child, forked.id)
-  }
-
-  if (remapped.size === 0) return
-
-  for (const ref of refs) {
-    const replacement = remapped.get(ref.child)
-    if (!replacement) continue
-    const meta = (ref.part.state as { metadata?: Record<string, unknown> }).metadata
-    if (!meta) continue
-    await Session.updatePart({
-      ...ref.part,
-      id: PartID.make(ref.part.id),
-      sessionID: SessionID.make(ref.part.sessionID),
-      state: {
-        ...ref.part.state,
-        metadata: { ...meta, sessionId: replacement },
-      },
-    } as MessageV2.ToolPart)
-  }
-
-  log.info("remapped child sessions", { session: sid, count: remapped.size })
-}

package/src/overlay/session/index.ts

@@ -1,70 +0,0 @@
-import z from "zod"
-import { remapChildren as _remapChildren } from "./fork"
-import { Schema } from "effect"
-import { Session } from "@/session/session"
-import { SessionID, MessageID } from "@/session/schema"
-import { makeRuntime } from "@/effect/run-service"
-import { fn } from "@/util/fn"
-import * as Platform from "./platform"
-import * as Queries from "./queries"
-import type { ProjectInfo as ProjectInfoType } from "./queries"
-
-export namespace SaeeolSession {
-  export type CloseReason = Schema.Schema.Type<typeof Platform.CloseReasonSchema>
-
-  export const Event = Platform.Event
-
-  export const register = Platform.register
-  export const setPlatformOverride = Platform.setPlatformOverride
-  export const getPlatformOverride = Platform.getPlatformOverride
-  export const resolvePlatform = Platform.resolvePlatform
-  export const resolveRoot = Platform.resolveRoot
-  export const featureForPlatform = Platform.featureForPlatform
-  export const clearPlatformOverride = Platform.clearPlatformOverride
-  export const attribution = Platform.attribution
-
-  export const family = Queries.family
-  export const filters = Queries.filters
-  export const providerCost = Queries.providerCost
-  export const runSyncSafe = Queries.runSyncSafe
-
-  export const ProjectInfo = Queries.ProjectInfo
-  export type ProjectInfo = ProjectInfoType
-
-  export const listGlobal = Queries.listGlobal
-
-  export async function shareSession(id: string): Promise<{ url: string }> {
-    const { SaeeolSessions } = await import("@/sessions/sessions")
-    return SaeeolSessions.share(id)
-  }
-
-  export async function unshareSession(id: string): Promise<void> {
-    const { SaeeolSessions } = await import("@/sessions/sessions")
-    await SaeeolSessions.unshare(id)
-  }
-
-  export async function removeSession(id: string): Promise<void> {
-    const { SaeeolSessions } = await import("@/sessions/sessions")
-    await SaeeolSessions.remove(id).catch(() => {})
-  }
-
-  export async function cleanup(id: string): Promise<void> {
-    await removeSession(id)
-    Platform.clearPlatformOverride(id)
-    const [app, state] = await Promise.all([import("@/effect/app-runtime"), import("@/session/run-state")])
-    const { SessionID: SID } = await import("@/session/schema")
-    await app.AppRuntime.runPromise(state.SessionRunState.Service.use((svc) => svc.cancel(SID.make(id))))
-  }
-
-  export const remapChildren = _remapChildren
-}
-
-export const saeeolSessionFork = fn(
-  z.object({ sessionID: SessionID.zod, messageID: MessageID.zod.optional() }),
-  async (input) => {
-    const { runPromise } = makeRuntime(Session.Service, Session.defaultLayer)
-    const session = await runPromise((svc) => svc.fork(input))
-    await SaeeolSession.remapChildren(session.id)
-    return session
-  },
-)

package/src/overlay/session/instruction.ts

@@ -1,7 +0,0 @@
-import { SaeeolMarkdown } from "../config/markdown"
-
-export namespace SaeeolInstruction {
-  export function content(text: string, item: string) {
-    return SaeeolMarkdown.substitute(text, item)
-  }
-}

package/src/overlay/session/kg-compaction.ts

@@ -1,138 +0,0 @@
-import { Effect } from "effect"
-import * as Log from "@saeeol/core/util/log"
-import { MessageV2 } from "@/session/message-v2"
-import { MessageID, PartID, type SessionID } from "@/session/schema"
-import type { Session } from "@/session/session"
-import { InstanceState } from "@/effect/instance-state"
-import { readDigest, type Digest } from "./digest-storage"
-
-const log = Log.create({ service: "saeeol.kg-compaction" })
-
-type Input = {
-  session: Pick<Session.Interface, "updateMessage" | "updatePart">
-  sessionID: SessionID
-  parentID: string
-  variant: string
-  agent: string
-  model: { providerID: string; modelID: string }
-}
-
-function formatDigest(digest: Digest): string {
-  const lines: string[] = []
-  lines.push("# Session Memory (Knowledge Graph Digest)")
-  lines.push("")
-  lines.push(`Last updated: ${new Date(digest.updated).toISOString()}`)
-  lines.push("")
-
-  if (digest.summary) {
-    lines.push("## Summary")
-    lines.push(digest.summary)
-    lines.push("")
-  }
-
-  for (const entity of digest.entities) {
-    lines.push(`## ${entity.name} [${entity.type}]`)
-    for (const obs of entity.observations) {
-      lines.push(`- ${obs}`)
-    }
-    lines.push("")
-  }
-
-  if (digest.relations?.length) {
-    lines.push("## Relations")
-    for (const rel of digest.relations) {
-      lines.push(`- ${rel.from} —${rel.type}→ ${rel.to}`)
-    }
-  }
-
-  return lines.join("\n")
-}
-
-export namespace KgCompaction {
-  export function tryKgCompaction(input: Input) {
-    return Effect.gen(function* () {
-      const digest = readDigest()
-
-      if (!digest) {
-        log.info("no digest found, falling back to LLM compaction")
-        return null
-      }
-
-      if (!digest.entities.length) {
-        log.info("empty digest, falling back to LLM compaction")
-        return null
-      }
-
-      const age = Date.now() - digest.updated
-      const maxAge = 30 * 60 * 1000
-      if (age > maxAge) {
-        log.info("digest too old, falling back", { ageMin: Math.round(age / 60_000) })
-        return null
-      }
-
-      const ctx = yield* InstanceState.context
-      const summaryText = formatDigest(digest)
-      const content = [
-        "This session is being continued. The Knowledge Graph digest below covers accumulated project memory.",
-        "",
-        summaryText,
-        "",
-        "Continue the conversation from where it left off.",
-      ].join("\n")
-
-      const userMsg: MessageV2.User = {
-        id: MessageID.ascending(),
-        role: "user",
-        sessionID: input.sessionID,
-        time: { created: Date.now() },
-        agent: input.agent,
-        model: input.model as any,
-      }
-      yield* input.session.updateMessage(userMsg)
-
-      yield* input.session.updatePart({
-        id: PartID.ascending(),
-        messageID: userMsg.id,
-        sessionID: input.sessionID,
-        type: "text",
-        synthetic: true,
-        text: content,
-        time: { start: Date.now(), end: Date.now() },
-      } satisfies MessageV2.TextPart)
-
-      const assistantMsg: MessageV2.Assistant = {
-        id: MessageID.ascending(),
-        role: "assistant",
-        parentID: userMsg.id,
-        sessionID: input.sessionID,
-        mode: "compaction",
-        agent: "compaction",
-        variant: input.variant as any,
-        summary: true,
-        path: { cwd: ctx.directory, root: ctx.worktree },
-        cost: 0,
-        tokens: { output: 0, input: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-        time: { created: Date.now(), completed: Date.now() },
-        finish: "stop",
-        modelID: "" as any,
-        providerID: "" as any,
-      }
-      yield* input.session.updateMessage(assistantMsg)
-
-      yield* input.session.updatePart({
-        id: PartID.ascending(),
-        messageID: assistantMsg.id,
-        sessionID: input.sessionID,
-        type: "text",
-        text: "⊟ Compacted via Knowledge Graph (no LLM call)",
-      } satisfies MessageV2.TextPart)
-
-      log.info("KG compaction complete", {
-        entities: digest.entities.length,
-        ageSec: Math.round(age / 1000),
-      })
-
-      return "continue" as const
-    })
-  }
-}