tulingcode 0.1.0

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

@@ -0,0 +1,259 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,219 @@
+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.tulingcode_HOME
+  process.env.tulingcode_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.tulingcode_HOME
+    else process.env.tulingcode_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")
+  })
+})