woozlit 2.3.0 → 2.3.2

package/test/session/checkpoint-main-slice.test.ts

@@ -1,259 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Deferred, Effect, Layer } from "effect"
-import { Bus } from "../../src/bus"
-import { Config } from "../../src/config"
-import { Agent } from "../../src/agent/agent"
-import { Memory } from "../../src/memory"
-import { ActorRegistry } from "../../src/actor/registry"
-import { Actor, type AgentOutcome, type SpawnInput } from "../../src/actor/spawn"
-import { spawnRef } from "../../src/actor/spawn-ref"
-import { prefixCaptureRef } from "../../src/session/prefix-capture-ref"
-import { TaskRegistry } from "../../src/task/registry"
-import { SessionCheckpoint } from "../../src/session/checkpoint"
-import { Log } from "../../src/util"
-import { Plugin } from "../../src/plugin"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { Session as SessionNs } from "../../src/session"
-import { MessageID, PartID } from "../../src/session/schema"
-import { ModelID, ProviderID } from "../../src/provider/schema"
-import { ProviderTest } from "../fake/provider"
-import { testEffect } from "../lib/effect"
-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"),
-}
-
-// Capture the SpawnInput passed to actor.spawn so the test can inspect the
-// ForkContext (specifically watermarkMsgID) that tryStartCheckpointWriter
-// computed. The outcome never resolves — we only care about what was passed
-// in, not what the writer produces.
-interface PrefixRecord {
-  id: string
-  agentID?: string
-}
-interface Captures {
-  input: SpawnInput | undefined
-  prefixMsgs: ReadonlyArray<PrefixRecord> | undefined
-}
-const captures: Captures = { input: undefined, prefixMsgs: undefined }
-
-const recordingActor = Layer.effect(
-  Actor.Service,
-  Effect.gen(function* () {
-    const impl = Actor.Service.of({
-      spawn: (input) =>
-        Effect.gen(function* () {
-          captures.input = input
-          const outcome = yield* Deferred.make<AgentOutcome>()
-          return {
-            actorID: `${input.agentType}-1`,
-            sessionID: input.sessionID,
-            outcome,
-          }
-        }),
-      cancel: () => Effect.void,
-      getForkContext: () => Effect.succeed(undefined),
-    })
-    spawnRef.current = impl
-
-    // Stand-in prefix capture: records what msgs[] was passed in (which is
-    // the slice tryStartCheckpointWriter sliced from `msgs` at the watermark)
-    // and returns an empty prefix so the fork capture path completes.
-    const capture: typeof prefixCaptureRef.current = (input) =>
-      Effect.sync(() => {
-        captures.prefixMsgs = (input.msgs as Array<{ info: { id: string; agentID?: string } }>).map((m) => ({
-          id: m.info.id,
-          agentID: m.info.agentID,
-        }))
-        return {
-          system: [] as string[],
-          tools: {},
-          inheritedMessages: [],
-          parentPermission: [],
-        }
-      })
-    prefixCaptureRef.current = capture
-
-    yield* Effect.addFinalizer(() =>
-      Effect.sync(() => {
-        if (spawnRef.current === impl) spawnRef.current = undefined
-        if (prefixCaptureRef.current === capture) prefixCaptureRef.current = undefined
-      }),
-    )
-    return impl
-  }),
-)
-
-const deps = Layer.mergeAll(
-  ProviderTest.fake().layer,
-  Agent.defaultLayer,
-  Plugin.defaultLayer,
-  Bus.layer,
-  Config.defaultLayer,
-  Memory.defaultLayer,
-  TaskRegistry.defaultLayer,
-  ActorRegistry.defaultLayer,
-  recordingActor,
-)
-
-const env = Layer.mergeAll(
-  SessionNs.defaultLayer,
-  CrossSpawnSpawner.defaultLayer,
-  SessionCheckpoint.layer.pipe(Layer.provide(SessionNs.defaultLayer), Layer.provideMerge(deps)),
-)
-
-const it = testEffect(env)
-
-// Regression for fork-prefix parity: tryStartCheckpointWriter must consume the
-// main-only slice (matching parent's runLoop view at prompt.ts:2036-2040). If
-// it ever pulls the unfiltered session stream again, computeBoundary lands on
-// a subagent's finished assistant turn and the prefix-cache invariant from
-// docs/superpowers/specs/2026-05-26-fork-agent-prefix-cache-design.md breaks.
-describe("SessionCheckpoint.tryStartCheckpointWriter main-slice", () => {
-  it.live(
-    "watermark + prefix msgs ignore non-main agentID rows",
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        captures.input = undefined
-        captures.prefixMsgs = undefined
-
-        const ssn = yield* SessionNs.Service
-        const info = yield* ssn.create({})
-
-        // Helper: seed a (user, finished assistant) main pair with body text
-        // sized to clear computeBoundary's TAIL_MIN_TOKENS floor.
-        const big = "lorem ipsum ".repeat(800) // ≈ 9.6KB → ~2.4k tokens, 5 pairs > TAIL_MIN_TOKENS
-        const mainIDs: string[] = []
-        let t = Date.now()
-        for (let i = 0; i < 5; i++) {
-          const u = yield* ssn.updateMessage({
-            id: MessageID.ascending(),
-            role: "user",
-            sessionID: info.id,
-            agent: "build",
-            model: ref,
-            time: { created: t++ },
-          })
-          yield* ssn.updatePart({
-            id: PartID.ascending(),
-            messageID: u.id,
-            sessionID: info.id,
-            type: "text",
-            text: big,
-          })
-          mainIDs.push(u.id)
-          const aID = MessageID.ascending()
-          yield* ssn.updateMessage({
-            id: aID,
-            role: "assistant" as const,
-            sessionID: info.id,
-            agentID: "main",
-            agent: "build",
-            mode: "primary",
-            modelID: ref.modelID,
-            providerID: ref.providerID,
-            parentID: u.id,
-            time: { created: t++, completed: t++ },
-            finish: "end_turn",
-            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-            path: { cwd: "/", root: "/" },
-            cost: 0,
-          })
-          const a = { id: aID }
-          yield* ssn.updatePart({
-            id: PartID.ascending(),
-            messageID: a.id,
-            sessionID: info.id,
-            type: "text",
-            text: big,
-          })
-          mainIDs.push(a.id)
-        }
-
-        // Subagent slice on the SAME sessionID. Without main-slice filtering,
-        // computeBoundary's `findLastIndex(finish !== undefined)` lands on
-        // this subagent assistant. We size the subagent payload above
-        // TAIL_MAX_TOKENS so the natural tail clears the algorithm's
-        // walk-back gates: under the buggy unfiltered path this freezes the
-        // watermark inside the subagent slice and the captured prefix carries
-        // subagent rows.
-        const huge = "explore body ".repeat(40_000) // ~480KB / 4 ≈ 120k token est.
-        const subUser = yield* ssn.updateMessage({
-          id: MessageID.ascending(),
-          role: "user",
-          sessionID: info.id,
-          agentID: "explore-1",
-          agent: "explore",
-          model: ref,
-          time: { created: t++ },
-        })
-        yield* ssn.updatePart({
-          id: PartID.ascending(),
-          messageID: subUser.id,
-          sessionID: info.id,
-          type: "text",
-          text: huge,
-        })
-        const subAsstID = MessageID.ascending()
-        yield* ssn.updateMessage({
-          id: subAsstID,
-          role: "assistant" as const,
-          sessionID: info.id,
-          agentID: "explore-1",
-          agent: "explore",
-          mode: "default",
-          modelID: ref.modelID,
-          providerID: ref.providerID,
-          parentID: subUser.id,
-          time: { created: t++, completed: t++ },
-          finish: "end_turn",
-          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-          path: { cwd: "/", root: "/" },
-          cost: 0,
-        })
-        const subAsst = { id: subAsstID }
-        yield* ssn.updatePart({
-          id: PartID.ascending(),
-          messageID: subAsst.id,
-          sessionID: info.id,
-          type: "text",
-          text: huge,
-        })
-
-        const svc = yield* SessionCheckpoint.Service
-        const status = yield* svc.tryStartCheckpointWriter({
-          sessionID: info.id,
-          model: { providerID: "test", modelID: "test-model" },
-          promptOps: {} as never,
-        })
-        expect(status).toBe("started")
-
-        // ForkContext.watermarkMsgID must point at a MAIN message — not a
-        // subagent turn that an unfiltered stream would have pulled in.
-        const capturedInput: SpawnInput | undefined = yield* Effect.sync(() => captures.input)
-        const capturedPrefixMsgs: ReadonlyArray<PrefixRecord> | undefined = yield* Effect.sync(
-          () => captures.prefixMsgs,
-        )
-        const fork = capturedInput?.forkContext
-        expect(fork).toBeDefined()
-        const mainSet = new Set(mainIDs)
-        expect(mainSet.has(fork!.watermarkMsgID as string)).toBe(true)
-
-        // Slice fed to buildPrefix must be main-only. If a future regression
-        // pulls in subagent rows, this assertion fails — the prefix-cache
-        // parity invariant from the spec relies on parent's runLoop and
-        // tryStartCheckpointWriter consuming the same main slice.
-        const seenIDs = capturedPrefixMsgs?.map((m) => m.id) ?? []
-        for (const id of seenIDs) expect(mainSet.has(id)).toBe(true)
-        expect(seenIDs).not.toContain(subUser.id)
-        expect(seenIDs).not.toContain(subAsst.id)
-        const seenAgents = new Set(capturedPrefixMsgs?.map((m) => m.agentID ?? "main"))
-        expect(seenAgents).toEqual(new Set(["main"]))
-      }),
-    ),
-  )
-})

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

@@ -1,78 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import fs from "fs/promises"
-import { Global } from "../../src/global"
-import { SessionID } from "../../src/session/schema"
-import { ProjectID } from "../../src/project/schema"
-import { notesPath, globalMemoryPath, memoryPath, migrateProjectMemory } from "../../src/session/checkpoint-paths"
-
-describe("notesPath (F14)", () => {
-  test("resolves to <data>/memory/sessions/<sid>/notes.md", () => {
-    const sid = SessionID.make("ses_test_xyz")
-    expect(notesPath(sid)).toBe(path.join(Global.Path.data, "memory", "sessions", sid, "notes.md"))
-  })
-})
-
-describe("globalMemoryPath", () => {
-  test("returns <data>/memory/global/MEMORY.md", () => {
-    expect(globalMemoryPath()).toBe(
-      path.join(Global.Path.data, "memory", "global", "MEMORY.md"),
-    )
-  })
-})
-
-describe("migrateProjectMemory", () => {
-  test("renames legacy memory.md to MEMORY.md when only legacy exists", async () => {
-    const pid = ProjectID.make(`p_test_${Date.now()}_${Math.random().toString(36).slice(2)}`)
-    const upper = memoryPath(pid)
-    const dir = path.dirname(upper)
-    const lower = path.join(dir, "memory.md")
-    await fs.mkdir(dir, { recursive: true })
-    await fs.writeFile(lower, "legacy content")
-
-    await migrateProjectMemory(pid)
-
-    expect(await Bun.file(upper).text()).toBe("legacy content")
-    expect(await Bun.file(lower).exists()).toBe(false)
-    await fs.rm(dir, { recursive: true, force: true })
-  })
-
-  test("no-op when MEMORY.md already exists", async () => {
-    const pid = ProjectID.make(`p_test_${Date.now()}_${Math.random().toString(36).slice(2)}`)
-    const upper = memoryPath(pid)
-    const dir = path.dirname(upper)
-    const lower = path.join(dir, "memory.md")
-    await fs.mkdir(dir, { recursive: true })
-    await fs.writeFile(upper, "new content")
-    await fs.writeFile(lower, "stale legacy")
-
-    await migrateProjectMemory(pid)
-
-    // Existing MEMORY.md is authoritative; legacy left untouched (not clobbered).
-    expect(await Bun.file(upper).text()).toBe("new content")
-    await fs.rm(dir, { recursive: true, force: true })
-  })
-
-  test("no-op when neither file exists", async () => {
-    const pid = ProjectID.make(`p_test_${Date.now()}_${Math.random().toString(36).slice(2)}`)
-    await migrateProjectMemory(pid) // must not throw
-    expect(await Bun.file(memoryPath(pid)).exists()).toBe(false)
-  })
-
-  test("concurrent migrators on same project: loser's ENOENT is tolerated, content preserved", async () => {
-    const pid = ProjectID.make(`p_test_${Date.now()}_${Math.random().toString(36).slice(2)}`)
-    const upper = memoryPath(pid)
-    const dir = path.dirname(upper)
-    const lower = path.join(dir, "memory.md")
-    await fs.mkdir(dir, { recursive: true })
-    await fs.writeFile(lower, "legacy content")
-
-    // Both pass the exists() checks before either rename runs; the loser's
-    // rename hits ENOENT and must be swallowed, not thrown.
-    const results = await Promise.allSettled([migrateProjectMemory(pid), migrateProjectMemory(pid)])
-    expect(results.every((r) => r.status === "fulfilled")).toBe(true)
-    expect(await Bun.file(upper).text()).toBe("legacy content")
-    expect(await Bun.file(lower).exists()).toBe(false)
-    await fs.rm(dir, { recursive: true, force: true })
-  })
-})

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

@@ -1,136 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import path from "path"
-import { Bus } from "../../src/bus"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Permission } from "../../src/permission"
-import { Global } from "../../src/global"
-import { Instance } from "../../src/project/instance"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { askEditUnlessMemory } from "../../src/tool/external-directory"
-import type * as Tool from "../../src/tool/tool"
-import { SYSTEM_SPAWNED_AGENT_TYPES } from "../../src/agent/config"
-import { Log } from "../../src/util"
-
-void Log.init({ print: false })
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-const bus = Bus.layer
-const env = Layer.mergeAll(Permission.layer.pipe(Layer.provide(bus)), bus, CrossSpawnSpawner.defaultLayer)
-const it = testEffect(env)
-
-// Recording Tool.Context whose ask() pushes the permission name onto a log so
-// tests can assert "ask was / was not invoked".
-function makeRecordingCtx(calls: string[]): Tool.Context {
-  return {
-    sessionID: "ses_test" as never,
-    abort: new AbortController().signal,
-    messageID: "msg_test" as never,
-    callID: "call_test",
-    agent: "checkpoint-writer",
-    messages: [],
-    metadata: () => Effect.void,
-    ask: (req: { permission: string }) =>
-      Effect.sync(() => {
-        calls.push(req.permission)
-      }),
-  } as unknown as Tool.Context
-}
-
-describe("checkpoint writer permission invariants", () => {
-  // T13: pure static guard — detects accidental removal during refactors.
-  // checkpoint-writer is the writer agent that prompt.ts/processor.ts inject
-  // `interactive: false` for; dropping it from the set silently re-enables a
-  // hangable ask path.
-  it.live("T13: SYSTEM_SPAWNED_AGENT_TYPES includes 'checkpoint-writer'", () =>
-    Effect.sync(() => {
-      expect(SYSTEM_SPAWNED_AGENT_TYPES.has("checkpoint-writer")).toBe(true)
-    }),
-  )
-
-  // T11: pin Permission.ask's interactive=false fail-clean branch
-  // (permission/index.ts:206-210). With an `ask`-rule on a non-memory path,
-  // the request would normally enter the pending map and block on a Deferred;
-  // interactive=false MUST short-circuit to DeniedError instead. This is the
-  // protection that lets a non-interactive writer never hang.
-  it.live(
-    "T11: writer's permission ask never blocks (returns DeniedError)",
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const perm = yield* Permission.Service
-        let asked = 0
-        const unsub = Bus.subscribe(Permission.Event.Asked, () => {
-          asked += 1
-        })
-        const result = yield* perm
-          .ask({
-            permission: "edit" as never,
-            patterns: ["/some/non-memory/path"],
-            always: ["*"],
-            metadata: {},
-            sessionID: "ses_test" as never,
-            // ruleset with `edit: ask` on the path — would otherwise pend.
-            ruleset: [{ permission: "edit", pattern: "*", action: "ask" }],
-            tool: { messageID: "msg_test" as never, callID: "call_test" },
-            interactive: false,
-          })
-          .pipe(Effect.exit)
-        unsub()
-        expect(result._tag).toBe("Failure")
-        expect(asked).toBe(0)
-        // pending must be empty — fail-clean branch never inserts an entry.
-        const pending = yield* perm.list()
-        expect(pending.length).toBe(0)
-      }),
-    ),
-  )
-
-  // T12: pin askEditUnlessMemory's path-based bypass (external-directory.ts:119)
-  // for paths under <data>/memory/, regardless of the parent's `edit` rule.
-  // Even with `edit: ask` configured, the gate must NOT call ctx.ask for memory
-  // paths — otherwise a parent's `edit:ask` would deadlock the writer (no human
-  // to reply) even with the T11 fail-clean (the writer's ctx.ask is the parent
-  // tool's permission ask, not the spawn-level interactive=false ask).
-  it.live(
-    "T12: askEditUnlessMemory does not call ctx.ask for memory paths under `edit: ask`",
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const calls: string[] = []
-        const target = path.join(Global.Path.data, "memory", "sessions", "ses_x", "checkpoint.md")
-        // The askEditUnlessMemory contract is path-based: it short-circuits
-        // BEFORE reading any ruleset. We don't need to thread an `edit: ask`
-        // ruleset into the call — the function never consults rules for
-        // memory paths. The bypass is what protects the writer regardless of
-        // parent permission config.
-        yield* askEditUnlessMemory(makeRecordingCtx(calls), target, {
-          patterns: ["checkpoint.md"],
-          diff: "",
-        })
-        expect(calls).toEqual([])
-      }),
-    ),
-  )
-
-  // T8: same path-based bypass as T12, but documents the `edit: deny` case
-  // explicitly. The bypass short-circuits before any ruleset evaluation, so
-  // the parent's deny rule never has a chance to block memory writes. This
-  // is what guarantees the writer can ALWAYS write memory.md.
-  it.live(
-    "T8: askEditUnlessMemory bypasses ctx.ask even when parent edit:deny",
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const calls: string[] = []
-        const target = path.join(Global.Path.data, "memory", "sessions", "ses_x", "checkpoint.md")
-        yield* askEditUnlessMemory(makeRecordingCtx(calls), target, {
-          patterns: ["checkpoint.md"],
-          diff: "",
-        })
-        expect(calls).toEqual([])
-      }),
-    ),
-  )
-})

package/test/session/checkpoint-progress-reconcile.test.ts

@@ -1,219 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import os from "os"
-import path from "path"
-import {
-  parseWrittenAt,
-  parseReconciledMap,
-  buildProgressDiffItems,
-  renderProgressDiffBlock,
-  buildProgressDiff,
-} from "../../src/session/checkpoint-progress-reconcile"
-import { checkpointPath, tasksDir, progressPath } from "../../src/session/checkpoint-paths"
-import { SessionID } from "../../src/session/schema"
-
-async function withTmpHome<T>(fn: (sid: SessionID) => Promise<T>): Promise<T> {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "progress-reconcile-test-"))
-  const prevHome = process.env.WOOZLIT_CODE_HOME
-  process.env.WOOZLIT_CODE_HOME = dir
-  try {
-    const sid = SessionID.make("ses_test_" + Date.now())
-    await fs.mkdir(tasksDir(sid), { recursive: true })
-    return await fn(sid)
-  } finally {
-    if (prevHome === undefined) delete process.env.WOOZLIT_CODE_HOME
-    else process.env.WOOZLIT_CODE_HOME = prevHome
-    await fs.rm(dir, { recursive: true, force: true })
-  }
-}
-
-async function writeProgress(sid: SessionID, tid: string, body: string): Promise<void> {
-  const fp = progressPath(sid, tid)
-  await fs.mkdir(path.dirname(fp), { recursive: true })
-  await Bun.write(fp, body)
-}
-
-async function writeMain(sid: SessionID, body: string): Promise<void> {
-  const fp = checkpointPath(sid)
-  await fs.mkdir(path.dirname(fp), { recursive: true })
-  await Bun.write(fp, body)
-}
-
-describe("parseWrittenAt", () => {
-  test("returns null when no frontmatter", () => {
-    expect(parseWrittenAt("## §1 Task identity\n...\n")).toBeNull()
-  })
-  test("returns null when frontmatter lacks written-at", () => {
-    expect(parseWrittenAt("---\nfoo: bar\n---\n## §1\n")).toBeNull()
-  })
-  test("returns number when present", () => {
-    expect(parseWrittenAt("---\nwritten-at: 1717000050\n---\nbody")).toBe(1717000050)
-  })
-  test("returns null when value non-numeric", () => {
-    expect(parseWrittenAt("---\nwritten-at: oops\n---\nbody")).toBeNull()
-  })
-})
-
-describe("parseReconciledMap", () => {
-  test("empty main returns empty map", () => {
-    expect(parseReconciledMap("").size).toBe(0)
-  })
-  test("parses single §4 marker", () => {
-    const main =
-      "## §4 Task tree\n" +
-      "🔵 T4 type checker (progress: tasks/T4/progress.md, last-reconciled-written-at: 1717000050)\n"
-    const m = parseReconciledMap(main)
-    expect(m.get("T4")).toBe(1717000050)
-  })
-  test("parses multiple markers", () => {
-    const main =
-      "🔵 T1 a (progress: tasks/T1/progress.md, last-reconciled-written-at: 100)\n" +
-      "✅ T2 b (progress: tasks/T2/progress.md, last-reconciled-written-at: 200)\n"
-    const m = parseReconciledMap(main)
-    expect(m.get("T1")).toBe(100)
-    expect(m.get("T2")).toBe(200)
-  })
-  test("ignores lines without full marker", () => {
-    const main =
-      "🔵 T1 a (progress: tasks/T1/progress.md)\n" +
-      "✅ T2 b (progress: tasks/T2/progress.md, last-reconciled-written-at: 200)\n"
-    const m = parseReconciledMap(main)
-    expect(m.size).toBe(1)
-    expect(m.get("T2")).toBe(200)
-  })
-})
-
-describe("renderProgressDiffBlock", () => {
-  test("empty items → empty string", () => {
-    expect(renderProgressDiffBlock([])).toBe("")
-  })
-  test("single NEW item", () => {
-    const out = renderProgressDiffBlock([{ taskId: "T4", writtenAt: 100, status: "NEW" }])
-    expect(out).toContain("SUBAGENT PROGRESS to integrate")
-    expect(out).toContain("T4 (NEW, written-at=100)")
-  })
-  test("CHANGED item shows prior", () => {
-    const out = renderProgressDiffBlock([
-      { taskId: "T4", writtenAt: 200, status: "CHANGED", prior: 100 },
-    ])
-    expect(out).toContain("T4 (CHANGED, written-at=200, prior=100)")
-  })
-})
-
-describe("buildProgressDiffItems", () => {
-  test("empty tasks dir → no items", async () => {
-    await withTmpHome(async (sid) => {
-      const items = await buildProgressDiffItems(sid)
-      expect(items).toEqual([])
-    })
-  })
-
-  test("single NEW (no §4 marker in main)", async () => {
-    await withTmpHome(async (sid) => {
-      await writeMain(sid, "## §4 Task tree\n(none)\n")
-      await writeProgress(sid, "T4", "---\nwritten-at: 100\n---\n## §1\n")
-      const items = await buildProgressDiffItems(sid)
-      expect(items).toEqual([{ taskId: "T4", writtenAt: 100, status: "NEW" }])
-    })
-  })
-
-  test("CHANGED when written-at > prior", async () => {
-    await withTmpHome(async (sid) => {
-      await writeMain(
-        sid,
-        "🔵 T4 a (progress: tasks/T4/progress.md, last-reconciled-written-at: 100)\n",
-      )
-      await writeProgress(sid, "T4", "---\nwritten-at: 200\n---\nbody")
-      const items = await buildProgressDiffItems(sid)
-      expect(items).toEqual([{ taskId: "T4", writtenAt: 200, status: "CHANGED", prior: 100 }])
-    })
-  })
-
-  test("UNCHANGED when written-at <= prior", async () => {
-    await withTmpHome(async (sid) => {
-      await writeMain(
-        sid,
-        "🔵 T4 a (progress: tasks/T4/progress.md, last-reconciled-written-at: 100)\n",
-      )
-      await writeProgress(sid, "T4", "---\nwritten-at: 100\n---\nbody")
-      const items = await buildProgressDiffItems(sid)
-      expect(items).toEqual([])
-    })
-  })
-
-  test("missing frontmatter (splitover-authored) is skipped", async () => {
-    await withTmpHome(async (sid) => {
-      await writeMain(sid, "## §4 Task tree\n(none)\n")
-      await writeProgress(sid, "T4", "## §1 Task identity\nno frontmatter\n")
-      const items = await buildProgressDiffItems(sid)
-      expect(items).toEqual([])
-    })
-  })
-
-  test("mixed NEW + CHANGED + UNCHANGED + skip", async () => {
-    await withTmpHome(async (sid) => {
-      await writeMain(
-        sid,
-        "🔵 T2 (progress: tasks/T2/progress.md, last-reconciled-written-at: 50)\n" +
-          "🔵 T3 (progress: tasks/T3/progress.md, last-reconciled-written-at: 200)\n",
-      )
-      await writeProgress(sid, "T1", "---\nwritten-at: 10\n---\nNEW")
-      await writeProgress(sid, "T2", "---\nwritten-at: 100\n---\nCHANGED 50→100")
-      await writeProgress(sid, "T3", "---\nwritten-at: 200\n---\nUNCHANGED")
-      await writeProgress(sid, "T4", "## §1 no frontmatter\n")
-      const items = await buildProgressDiffItems(sid)
-      const sorted = [...items].sort((a, b) => a.taskId.localeCompare(b.taskId))
-      expect(sorted).toEqual([
-        { taskId: "T1", writtenAt: 10, status: "NEW" },
-        { taskId: "T2", writtenAt: 100, status: "CHANGED", prior: 50 },
-      ])
-    })
-  })
-})
-
-describe("buildProgressDiff (integration)", () => {
-  test("empty when nothing to reconcile", async () => {
-    await withTmpHome(async (sid) => {
-      expect(await buildProgressDiff(sid)).toBe("")
-    })
-  })
-
-  test("renders block when items exist", async () => {
-    await withTmpHome(async (sid) => {
-      await writeMain(sid, "## §4 Task tree\n(none)\n")
-      await writeProgress(sid, "T4", "---\nwritten-at: 100\n---\nbody")
-      const out = await buildProgressDiff(sid)
-      expect(out).toContain("SUBAGENT PROGRESS to integrate")
-      expect(out).toContain("T4 (NEW, written-at=100)")
-    })
-  })
-})
-
-describe("composeWriterPrompt progressDiff injection", () => {
-  test("includes progress diff block in prompt when non-empty", async () => {
-    const { composeWriterPromptForTest } = await import("../../src/session/checkpoint")
-    const prompt = composeWriterPromptForTest({
-      checkpointFile: "/x/checkpoint.md",
-      memoryFile: "/x/memory.md",
-      taskMemDir: "/x/tasks",
-      notesFile: "/x/notes.md",
-      rangeDesc: "test range",
-      progressDiff: "SUBAGENT PROGRESS to integrate:\n  - T4 (NEW, written-at=100)",
-    })
-    expect(prompt).toContain("SUBAGENT PROGRESS to integrate")
-    expect(prompt).toContain("T4 (NEW, written-at=100)")
-  })
-
-  test("no-op when progressDiff is empty", async () => {
-    const { composeWriterPromptForTest } = await import("../../src/session/checkpoint")
-    const prompt = composeWriterPromptForTest({
-      checkpointFile: "/x/checkpoint.md",
-      memoryFile: "/x/memory.md",
-      taskMemDir: "/x/tasks",
-      notesFile: "/x/notes.md",
-      rangeDesc: "test range",
-      progressDiff: "",
-    })
-    expect(prompt).not.toContain("SUBAGENT PROGRESS to integrate")
-  })
-})