tulingcode 0.1.0

package/test/session/bootstrap-skip-system.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, test } from "bun:test"
+import { Effect, Layer } from "effect"
+import * as fs from "fs/promises"
+import { Bus } from "../../src/bus"
+import { Config } from "../../src/config"
+import { Memory } from "../../src/memory"
+import { ActorRegistry } from "../../src/actor/registry"
+import { Actor } from "../../src/actor/spawn"
+import { TaskRegistry } from "../../src/task/registry"
+import { SessionCheckpoint } from "../../src/session/checkpoint"
+import { Log } from "../../src/util"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { Session as SessionNs } from "../../src/session"
+import { MessageID, PartID } from "../../src/session/schema"
+import { ProviderID, ModelID } from "../../src/provider/schema"
+import { checkpointPath } from "../../src/session/checkpoint-paths"
+import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
+
+void Log.init({ print: false })
+
+const ref = {
+  providerID: ProviderID.make("test"),
+  modelID: ModelID.make("test-model"),
+}
+
+const stubActorRegistry = Layer.succeed(
+  ActorRegistry.Service,
+  ActorRegistry.Service.of({
+    register: () => Effect.die("not used"),
+    updateStatus: () => Effect.void,
+    updateTurn: () => Effect.void,
+    get: () => Effect.succeed(undefined),
+    listBySession: () => Effect.succeed([]),
+    listActive: () => Effect.succeed([]),
+    listByParent: () => Effect.succeed([]),
+    renderForAgent: () => Effect.succeed(""),
+    agentTypeFor: () => Effect.succeed("main"),
+    // Force the guard inside tryStartCheckpointWriter to fire by always reporting true.
+    isSystemSpawned: () => Effect.succeed(true),
+    allocateActorID: () => Effect.die("not used"),
+  }),
+)
+
+// The system-spawn guard short-circuits before Actor.spawn is reached, so this
+// stub never gets called — but we still need to satisfy the SessionCheckpoint
+// layer's Actor.Service requirement at construction time.
+const stubActor = Layer.succeed(
+  Actor.Service,
+  Actor.Service.of({
+    spawn: () => Effect.die("Actor.spawn unexpectedly called in system-spawn skip path"),
+    cancel: () => Effect.die("Actor.cancel unexpectedly called in system-spawn skip path"),
+    getForkContext: () => Effect.succeed(undefined),
+  }),
+)
+
+const deps = Layer.mergeAll(
+  Bus.layer,
+  Config.defaultLayer,
+  Memory.defaultLayer,
+  TaskRegistry.defaultLayer,
+  stubActorRegistry,
+  stubActor,
+)
+
+const env = Layer.mergeAll(
+  SessionNs.defaultLayer,
+  CrossSpawnSpawner.defaultLayer,
+  SessionCheckpoint.layer.pipe(Layer.provide(SessionNs.defaultLayer), Layer.provideMerge(deps)),
+)
+
+describe("SessionCheckpoint.tryStartCheckpointWriter — system-spawn skip", () => {
+  test("returns 'skipped' and does NOT bootstrap checkpoint.md when isSystemSpawned=true", async () => {
+    await Effect.runPromise(
+      provideTmpdirInstance(() =>
+        Effect.gen(function* () {
+          const svc = yield* SessionCheckpoint.Service
+          const ssn = yield* SessionNs.Service
+          const info = yield* ssn.create({})
+
+          // Seed enough state that the empty-message guard would not fire — so
+          // we know it's the system-spawn guard short-circuiting the bootstrap.
+          const user = yield* ssn.updateMessage({
+            id: MessageID.ascending(),
+            role: "user",
+            sessionID: info.id,
+            agent: "build",
+            model: ref,
+            time: { created: Date.now() },
+          })
+          yield* ssn.updatePart({
+            id: PartID.ascending(),
+            messageID: user.id,
+            sessionID: info.id,
+            type: "text",
+            text: "seed",
+          })
+
+          const outcome = yield* svc.tryStartCheckpointWriter({
+            sessionID: info.id,
+            model: { providerID: "test", modelID: "test-model" },
+            promptOps: {} as any,
+          })
+          expect(outcome).toBe("skipped")
+
+          // Bootstrap helpers (ensureCheckpointTemplate / ensureMemoryTemplate)
+          // run AFTER the system-spawn guard. With the guard active, no
+          // checkpoint.md should appear on disk.
+          const cpPath = checkpointPath(info.id)
+          const exists = yield* Effect.promise(() =>
+            fs.stat(cpPath).then(() => true).catch(() => false),
+          )
+          expect(exists).toBe(false)
+
+          // Sanity: the writer table should not have been updated either.
+          const running = yield* svc.isWriterRunning(info.id)
+          expect(running).toBe(false)
+        }),
+      ).pipe(Effect.scoped, Effect.provide(env)),
+    )
+  })
+})

package/test/session/boundary.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test"
+import { adjustBoundaryForApiInvariants } from "../../src/session/boundary"
+
+type Msg = { role: "user" | "assistant" | "tool"; content: any[]; id?: string }
+
+describe("adjustBoundaryForApiInvariants", () => {
+  test("walks back to include tool_use when tool_result is in tail", () => {
+    const msgs: Msg[] = [
+      { role: "user", content: [{ type: "text", text: "hello" }] },
+      { role: "assistant", content: [{ type: "tool_use", id: "X", name: "read" }] },
+      { role: "tool", content: [{ type: "tool_result", tool_use_id: "X", text: "result" }] },
+      { role: "assistant", content: [{ type: "text", text: "done" }] },
+    ]
+    // Candidate boundary at idx=2 (tail starts with tool_result)
+    // Should walk back to idx=1 (include the tool_use)
+    expect(adjustBoundaryForApiInvariants(msgs, 2)).toBe(1)
+  })
+
+  test("returns boundary unchanged when no orphans", () => {
+    const msgs: Msg[] = [
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+      { role: "assistant", content: [{ type: "text", text: "hi back" }] },
+      { role: "user", content: [{ type: "text", text: "more" }] },
+    ]
+    expect(adjustBoundaryForApiInvariants(msgs, 2)).toBe(2)
+  })
+
+  test("returns boundary unchanged when 0 or full length", () => {
+    const msgs: Msg[] = [{ role: "user", content: [] }]
+    expect(adjustBoundaryForApiInvariants(msgs, 0)).toBe(0)
+    expect(adjustBoundaryForApiInvariants(msgs, 1)).toBe(1)
+  })
+})

package/test/session/budgeted-read.test.ts

@@ -0,0 +1,74 @@
+import { describe, test, expect } from "bun:test"
+import { readBudgeted, readBudgetedSectionAware } from "../../src/session/budgeted-read"
+import * as fs from "fs/promises"
+import * as path from "path"
+import * as os from "os"
+
+describe("readBudgeted", () => {
+  const tmpDir = os.tmpdir()
+
+  test("returns full content when under budget", async () => {
+    const file = path.join(tmpDir, "budgeted-test-small.md")
+    await fs.writeFile(file, "short content")
+    const result = await readBudgeted(file, 1000)
+    expect(result?.truncated).toBe(false)
+    expect(result?.text).toBe("short content")
+  })
+
+  test("truncates with Read hint when over budget", async () => {
+    const file = path.join(tmpDir, "budgeted-test-large.md")
+    await fs.writeFile(file, "word ".repeat(5000)) // ~5000 tokens
+    const result = await readBudgeted(file, 100)
+    expect(result?.truncated).toBe(true)
+    expect(result?.text).toContain("Truncated at ~100 tokens")
+    expect(result?.text).toContain("Read(")
+    expect(result?.text).toContain("offset=")
+  })
+
+  test("returns undefined for missing file", async () => {
+    const result = await readBudgeted("/tmp/nonexistent-xyz.md", 1000)
+    expect(result).toBeUndefined()
+  })
+})
+
+describe("readBudgetedSectionAware", () => {
+  const tmpDir = os.tmpdir()
+
+  test("preserves all section headers when content truncated", async () => {
+    const file = path.join(tmpDir, "section-aware.md")
+    const content = `# Title
+## §1 Active intent
+_instruction_
+
+${"x ".repeat(2000)}
+
+## §2 Next action
+_instruction_
+
+short
+`
+    await fs.writeFile(file, content)
+    const result = await readBudgetedSectionAware(file, 100)
+    expect(result?.text).toContain("## §1 Active intent")
+    expect(result?.text).toContain("## §2 Next action")
+    expect(result?.text).toContain("_instruction_")
+  })
+
+  test("preserves spillover index lines (- See ...md) even when truncated", async () => {
+    const file = path.join(tmpDir, "spill-aware.md")
+    const content = `# Title
+## §7 Discovered knowledge
+_instruction_
+
+${"y ".repeat(3000)}
+- See checkpoint-lexer.md (15 items) — Position type, Token shape
+
+## §9 Live resources
+_instruction_
+short
+`
+    await fs.writeFile(file, content)
+    const result = await readBudgetedSectionAware(file, 100)
+    expect(result?.text).toContain("- See checkpoint-lexer.md")
+  })
+})

package/test/session/checkpoint-align.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test"
+import { alignToNonToolResultUser } from "../../src/session/checkpoint-align"
+
+// Minimal shape: alignToNonToolResultUser only needs `info.role` and
+// `parts[].type`. Use literal objects rather than full MessageV2.WithParts
+// — the helper should be schema-light.
+type Msg = {
+  info: { role: "user" | "assistant"; id: string }
+  parts: Array<{ type: string }>
+}
+
+const u = (id: string, partTypes: string[] = ["text"]): Msg => ({
+  info: { role: "user", id },
+  parts: partTypes.map((t) => ({ type: t })),
+})
+const a = (id: string, partTypes: string[] = ["text"]): Msg => ({
+  info: { role: "assistant", id },
+  parts: partTypes.map((t) => ({ type: t })),
+})
+
+describe("alignToNonToolResultUser", () => {
+  test("returns the input idx when it already points at a non-tool-result-only user", () => {
+    const msgs = [u("u1", ["text"]), a("a1"), u("u2", ["text"])]
+    expect(alignToNonToolResultUser(msgs, 2)).toBe(2)
+  })
+
+  test("walks back past assistant tool_use to the previous user", () => {
+    const msgs = [u("u1"), a("a1", ["tool_use"]), u("u2", ["tool_result"]), a("a2", ["text"])]
+    // idx=2 (u2 with tool_result-only parts) must back up to idx=0 (u1 plain text)
+    expect(alignToNonToolResultUser(msgs, 2)).toBe(0)
+  })
+
+  test("treats user message with mixed parts (tool_result + text) as valid", () => {
+    const msgs = [u("u1"), a("a1", ["tool_use"]), u("u2", ["tool_result", "text"])]
+    expect(alignToNonToolResultUser(msgs, 2)).toBe(2)
+  })
+
+  test("returns 0 when no qualifying message exists in [0, idx]", () => {
+    // Degenerate: only tool-result-only users + assistants
+    const msgs = [u("u1", ["tool_result"]), a("a1", ["tool_use"]), u("u2", ["tool_result"])]
+    expect(alignToNonToolResultUser(msgs, 2)).toBe(0)
+  })
+
+  test("returns idx itself when idx is past the end (empty delta intent)", () => {
+    const msgs = [u("u1"), a("a1")]
+    expect(alignToNonToolResultUser(msgs, 2)).toBe(2)
+  })
+
+  test("idx 0 with valid first message returns 0", () => {
+    const msgs = [u("u1")]
+    expect(alignToNonToolResultUser(msgs, 0)).toBe(0)
+  })
+
+  test("treats user with empty parts as valid (cannot be orphan tool_result)", () => {
+    const msgs: Msg[] = [u("u1", ["tool_result"]), a("a1", ["tool_use"]), { info: { role: "user", id: "u2" }, parts: [] }]
+    expect(alignToNonToolResultUser(msgs, 2)).toBe(2)
+  })
+})

package/test/session/checkpoint-boundary.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, test } from "bun:test"
+import type { MessageV2 } from "../../src/session/message-v2"
+import type { MessageID, SessionID } from "../../src/session/schema"
+import { computeBoundary } from "../../src/session/checkpoint"
+
+const SID = "s_test" as SessionID
+
+function userMsg(id: string, time: number, parts?: Array<{ type: string; text?: string; [k: string]: unknown }>): MessageV2.WithParts {
+  return {
+    info: {
+      id: id as MessageID,
+      sessionID: SID,
+      role: "user",
+      time: { created: time },
+      agent: "build",
+      model: { providerID: "anthropic" as never, modelID: "claude" as never },
+    } as MessageV2.User,
+    parts: parts ?? [],
+  } as unknown as MessageV2.WithParts
+}
+
+function asstMsg(id: string, time: number, finish?: string, parts?: Array<{ type: string; text?: string; [k: string]: unknown }>): MessageV2.WithParts {
+  return {
+    info: {
+      id: id as MessageID,
+      sessionID: SID,
+      role: "assistant",
+      time: { created: time },
+      agent: "build",
+      providerID: "anthropic" as never,
+      modelID: "claude" as never,
+      mode: "build",
+      variant: "default" as never,
+      path: { cwd: "/", root: "/" },
+      cost: 0,
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+      ...(finish ? { finish } : {}),
+    } as unknown as MessageV2.Assistant,
+    parts: parts ?? [],
+  } as unknown as MessageV2.WithParts
+}
+
+// Helper: build a chunk of text parts whose stringified size sums to ~target tokens.
+// Token.estimate is roughly chars/4. Multiply by 4 to size the text payload.
+function textParts(targetTokens: number): Array<{ type: string; text: string }> {
+  const charCount = Math.max(100, targetTokens * 4)
+  return [{ type: "text", text: "x".repeat(charCount) }]
+}
+
+// Helper: build a chunk of "tool" parts whose stringified size sums to ~target tokens.
+function toolParts(targetTokens: number): Array<{ type: string; tool: string; payload: string }> {
+  const charCount = Math.max(100, targetTokens * 4)
+  return [{ type: "tool", tool: "read", payload: "x".repeat(charCount) }]
+}
+
+describe("computeBoundary", () => {
+  test("normal user → asst: small tail expands backward to meet floors", () => {
+    // u0 + a1, both empty parts = ~0 tokens, 1 text block (a1 has no text parts so 0).
+    // Should expand backward but stops at u0 (no earlier messages).
+    const msgs = [userMsg("u0", 0), asstMsg("a1", 10, "stop")]
+    const result = computeBoundary(msgs)
+    // With empty parts, tail is tiny and will try to expand. Result depends on token estimation.
+    expect(["u0"]).toContain(result)
+  })
+
+  test("tool-call loop with sufficient tokens stays in reasonable range", () => {
+    // All empty parts, so total tokens ~0. Should expand backward to meet floors.
+    const msgs = [
+      userMsg("u0", 0),
+      asstMsg("a1", 10, "stop"),
+      asstMsg("a2", 20, "stop"),
+      asstMsg("a3", 30, "stop"),
+    ]
+    const result = computeBoundary(msgs)
+    // Without tokens, expands backward; result is in early range.
+    expect(["u0", "a1"]).toContain(result)
+  })
+
+  test("only one finished asst at the start: returns that asst (degenerate but doesn't crash)", () => {
+    const msgs = [asstMsg("a1", 10, "stop")]
+    expect(computeBoundary(msgs)).toBe("a1")
+  })
+
+  test("trailing asst without finish is skipped — boundary set by prior finished turn", () => {
+    const msgs = [
+      userMsg("u0", 0),
+      asstMsg("a1", 10, "stop"),
+      asstMsg("a2_pending", 20, undefined),
+    ]
+    const result = computeBoundary(msgs)
+    // lastAsstIdx = 1 (a1), startIdx = 0 (u0). Tail = u0 + a1, empty parts.
+    // Expands backward but stops at u0.
+    expect(["u0"]).toContain(result)
+  })
+
+  test("no finished asst (degenerate): falls back to msgs[0]", () => {
+    const msgs = [userMsg("u0", 0)]
+    expect(computeBoundary(msgs)).toBe("u0")
+  })
+
+  test("0 messages returns empty", () => {
+    expect(computeBoundary([])).toBe("")
+  })
+
+  test("small tail expands backward to hit minTokens floor", () => {
+    // Build: u1(~2K), a1(~2K), u2(~2K), a2(~2K), u3(~100), a3(~100, finished)
+    // lastAsstIdx = 5, startIdx = 4 (u3). Tail = u3 + a3 = ~200 tokens.
+    // Below minTokens(10K), so walk backward to include a2, u2, a1, u1.
+    // Expected: walk back until >= 10K tokens AND >= 5 text blocks.
+    const msgs = [
+      userMsg("u1", 0, textParts(2000)),
+      asstMsg("a1", 10, "stop", textParts(2000)),
+      userMsg("u2", 20, textParts(2000)),
+      asstMsg("a2", 30, "stop", textParts(2000)),
+      userMsg("u3", 40, textParts(100)),
+      asstMsg("a3", 50, "stop", textParts(100)),
+    ]
+    const result = computeBoundary(msgs)
+    // Should expand back to include earlier messages (a1 or u1 or both).
+    expect(["u1", "a1"]).toContain(result)
+  })
+
+  test("huge natural tail stays put (soft ceiling — no forward contraction)", () => {
+    // Build: u1(~1K), a1(~1K), u2(~1K), a2(~55K, finished)
+    // lastAsstIdx = 3, startIdx = 2 (u2). Tail = u2 + a2 = ~56K.
+    // >= maxTokens(20K), so leave boundary as-is and return.
+    // Forward contraction would split tool_use/tool_result pairs and
+    // adjustBoundaryForApiInvariants would just walk back — net no-op.
+    // Expected: boundary stays at u2.
+    const msgs = [
+      userMsg("u1", 0, textParts(1000)),
+      asstMsg("a1", 10, "stop", textParts(1000)),
+      userMsg("u2", 20, textParts(1000)),
+      asstMsg("a2", 30, "stop", toolParts(55000)),
+    ]
+    const result = computeBoundary(msgs)
+    expect(result).toBe("u2")
+  })
+
+  test("goldilocks range (10K–40K with 5+ text blocks): boundary stays in reasonable range", () => {
+    // Build: u1, a1, u2, a2, u3, a3(finished)
+    // Each message ~3K tokens, textPart.
+    // lastAsstIdx = 5, startIdx = 4 (u3). Tail = u3(~3K) + a3(~3K) = ~6K.
+    // Below minTokens but has 2 text blocks. Walk back: add a2(~3K), u2(~3K), a1(~3K), u1(~3K).
+    // Cumulative: ~6K + 12K = ~18K, 6 text blocks. Both conditions met; stop.
+    // Expected: boundary should be at or before u1 (but expansion is predictable).
+    const msgs = [
+      userMsg("u1", 0, textParts(3000)),
+      asstMsg("a1", 10, "stop", textParts(3000)),
+      userMsg("u2", 20, textParts(3000)),
+      asstMsg("a2", 30, "stop", textParts(3000)),
+      userMsg("u3", 40, textParts(3000)),
+      asstMsg("a3", 50, "stop", textParts(3000)),
+    ]
+    const result = computeBoundary(msgs)
+    // Should expand to include enough history to hit 10K floor and 5 text blocks.
+    expect(["u1", "a1", "u2", "a2"]).toContain(result)
+  })
+
+  test("tail with no text blocks expands backward even at high tokens", () => {
+    // Build: u1(~10K tool), a1(~10K tool), u2(~10K tool), a2(~10K tool),
+    //        u3(no text), a3(no text, finished)
+    // Tool parts don't count as text blocks. Tail u3+a3 has ~0 tokens but 0 text blocks.
+    // Below minTextBlockMessages(5), so walk backward to include a2, u2, a1, u1.
+    // Loop stops when textBlockCount >= 5 OR startIdx reaches 0 OR tailSum >= maxTokens.
+    // Expected: walk back through tool-only messages until finding text-block messages or hitting limit.
+    const msgs = [
+      userMsg("u1", 0, toolParts(10000)),
+      asstMsg("a1", 10, "stop", toolParts(10000)),
+      userMsg("u2", 20, toolParts(10000)),
+      asstMsg("a2", 30, "stop", toolParts(10000)),
+      userMsg("u3", 40, []),
+      asstMsg("a3", 50, "stop", []),
+    ]
+    const result = computeBoundary(msgs)
+    // Should walk back to look for text blocks or hit max tokens.
+    // Since tail has no text blocks, walks back to earlier messages.
+    expect(["u1", "a1", "u2", "a2"]).toContain(result)
+  })
+
+  test("lastAsstIdx === 0 returns that msg", () => {
+    // assistant is the very first message, no preceding user.
+    const msgs = [asstMsg("a1", 10, "stop")]
+    expect(computeBoundary(msgs)).toBe("a1")
+  })
+})