@stigmer/runner 3.1.3 → 3.1.5

package/src/activities/execute-deep-agent/index.ts

@@ -26,6 +26,10 @@ import {
   WorkspaceLockTimeoutError,
   type ReleaseWorkspaceLock,
 } from "../../shared/workspace/workspace-lock.js";
+import {
+  ensureStigmerSymlink,
+  removeStigmerSymlink,
+} from "../../shared/workspace/stigmer-link.js";
 import type { ToolOutputOffloadContext } from "../../shared/status-offload.js";
 import { publishPlanArtifact } from "../../shared/plan-artifact.js";
 import { classifyTool } from "../../shared/tool-kind.js";
@@ -52,14 +56,26 @@ import {
 } from "../../shared/filereview/capture.js";
 import {
   captureFileChangeProgress,
+  createGitProgressSubstrate,
+  createHybridProgressSubstrate,
   newProgressCaptureState,
+  type ProgressSubstrate,
 } from "../../shared/filereview/progress.js";
+import {
+  createCasProgressSubstrate,
+  type CasTouchedSnapshot,
+} from "../../shared/filereview/cas-progress.js";
 import { hasCandidateCaptured } from "../../shared/filereview/events.js";
 import { casBlobReader, type CasPathCapture } from "../../shared/filereview/cas-substrate.js";
 import { partitionIgnoredPathsBySecret } from "../../shared/filereview/secret-paths.js";
 import type { CasCaptureObserver } from "./cas-capture-observer.js";
-import { collectSubAgentToolCallIds, withholdSecretContentFromMessages } from "../../shared/tool-row.js";
+import {
+  collectSettledToolCallIds,
+  collectSubAgentToolCallIds,
+  withholdSecretContentFromMessages,
+} from "../../shared/tool-row.js";
 import { stampFlowedFileEditRows, stampFlowedSubAgentFileEditRows } from "./stamp-flowed-rows.js";
+import { deriveTurnCommandProvenance } from "./command-provenance.js";
 
 /** The harness id stamped on the deep-agent's file-review ledger events. */
 const DEEP_AGENT_HARNESS_ID = "deep-agent";
@@ -217,6 +233,22 @@ export function createDeepAgentActivities(config: Config) {
           throw lockErr;
         }
 
+        // Bridge the workspace to the session's platform dir so the agent's
+        // file tools can read platform-mounted content (`.stigmer/inputs/…`
+        // attachments incl. the approved plan, `.stigmer/skills/…`) — the
+        // deepagents FilesystemBackend resolves paths against the workspace
+        // root and knows nothing of the LocalWorkspaceBackend's `.stigmer`
+        // routing. Two ordering invariants (see shared/workspace/stigmer-link.ts):
+        //  - AFTER the lock: the link is a tree mutation; sessions sharing one
+        //    attached directory must not re-point it under a running turn.
+        //  - BEFORE the baseline capture below: present in both the baseline
+        //    and candidate trees, the link cancels out of the file-review diff
+        //    even when the workspace's git excludes do not list `.stigmer`.
+        // Removed in cleanup() (the finally below), before the lock releases.
+        if (setup.workspaceBackend.platformDir) {
+          await ensureStigmerSymlink(gitRoot, setup.workspaceBackend.platformDir);
+        }
+
         // (1) Capture-mode resume — reconcile any DECIDED change set FIRST (this
         // drops the per-execution refs), before the next baseline re-pins them
         // (refs are executionId-keyed). Then (2) short-circuit a pure file-review
@@ -303,8 +335,10 @@ export function createDeepAgentActivities(config: Config) {
         }
 
         // Turn start (capture mode): pin the pre-turn tree + author BASELINE. Taken
-        // AFTER any reconcile above and AFTER performSetup's workspace writes, so
-        // the baseline absorbs the reconciled state and the runner-owned files.
+        // AFTER any reconcile above and AFTER performSetup's workspace writes and
+        // the `.stigmer` symlink above, so the baseline absorbs the reconciled
+        // state and the runner-owned files (the symlink then cancels out of the
+        // baseline→candidate diff).
         let captureBaselineTree = "";
         // Snapshot the sub-agent tool-call ids that exist BEFORE this turn's
         // stream, so the turn-boundary stamp scopes itself to sub-agent rows
@@ -312,6 +346,12 @@ export function createDeepAgentActivities(config: Config) {
         // seeds prior sub-agents — but computed, not assumed, so it stays correct
         // if that ever changes; see collectSubAgentToolCallIds).
         const priorSubAgentToolCallIds = collectSubAgentToolCallIds(initialStatus.subAgentExecutions);
+        // Snapshot the top-level tool-call ids already SETTLED before this turn's
+        // stream, so the approved-command provenance (DD-28) scopes itself to THIS
+        // turn's executed commands by identity. The deep-agent's approved shell
+        // executes in place at its seeded position, so the Cursor positional scope
+        // would miss it — see execute-deep-agent/command-provenance.ts.
+        const priorSettledToolCallIds = collectSettledToolCallIds(initialStatus.messages);
         if (setup.captureMode) {
           captureBaselineTree = await captureBaselineToLedger({
             status: initialStatus,
@@ -323,14 +363,34 @@ export function createDeepAgentActivities(config: Config) {
           });
         }
 
-        // Per-turn state for mid-run live capture (DD-32): the last progress tree
-        // sha (short-circuit) + last capture time (floor), threaded across the
-        // streaming loop's persists via the beforePersist hook below. The capture
-        // flags are hoisted so the deferred hook does not depend on `setup`
-        // (non-null here, but not narrowable inside a later-invoked closure).
+        // Per-turn state + substrate for mid-run live capture (DD-32 / DD-33). The
+        // floor lives in progressState; the substrate is chosen for this turn's
+        // workspace shape and owns its own short-circuit cache. An atomic snapshot
+        // of the shared observer feeds the CAS/HYBRID substrates — copied
+        // synchronously so a concurrent sub-agent write cannot mutate it mid-read.
         const progressState = newProgressCaptureState();
-        const progressCaptureMode = setup.captureMode;
-        const progressGitWorkspace = setup.gitWorkspace;
+        const casObserver = setup.casObserver;
+        const readObserverTouched = (): CasTouchedSnapshot => ({
+          before: new Map(casObserver.before),
+          blockedSecretPaths: new Set(casObserver.blockedSecretPaths),
+        });
+        // Git tree -> hybrid (numstat for tracked + observer for gitignored);
+        // non-git -> cas over the observer (no baseline tree needed). Undefined
+        // outside capture mode (writes are deny-gated, nothing is captured).
+        const progressSubstrate: ProgressSubstrate | undefined = !setup.captureMode
+          ? undefined
+          : setup.gitWorkspace
+            ? captureBaselineTree
+              ? createHybridProgressSubstrate(
+                  createGitProgressSubstrate({
+                    workspaceRoot: gitRoot,
+                    executionId,
+                    baselineTree: captureBaselineTree,
+                  }),
+                  createCasProgressSubstrate({ workspaceRoot: gitRoot, read: readObserverTouched }),
+                )
+              : undefined
+            : createCasProgressSubstrate({ workspaceRoot: gitRoot, read: readObserverTouched });
 
         const cancellationSignal = Context.current().cancellationSignal;
 
@@ -357,20 +417,20 @@ export function createDeepAgentActivities(config: Config) {
             globalBypass: setup.globalBypass,
           },
           streamVersion: setup.streamVersion,
-          // Mid-run live capture (DD-32): attach file_change_progress before each
-          // scheduled persist. Git capture mode only (a pinned baseline exists);
-          // deep-agent writes no runner-owned gate files into the tree, so no
-          // excludePaths — matching its turn-boundary candidate capture.
+          // Mid-run live capture (DD-32 / DD-33): attach file_change_progress
+          // before each scheduled persist, throttled by the floor inside
+          // captureFileChangeProgress. The substrate (git / non-git CAS / hybrid)
+          // was chosen for this turn above; the deep-agent's only runner-owned
+          // tree entry is the `.stigmer` symlink, created before the baseline
+          // so it appears identically in every capture and cancels out of the
+          // diff — the git slice therefore needs no excludePaths, matching its
+          // turn-boundary candidate capture.
           beforePersist: async (status) => {
-            if (!progressCaptureMode || !progressGitWorkspace || !captureBaselineTree) {
-              return;
-            }
+            if (!progressSubstrate) return;
             await captureFileChangeProgress({
               status,
-              gitRoot,
-              executionId,
               changeSetId,
-              baselineTree: captureBaselineTree,
+              substrate: progressSubstrate,
               state: progressState,
             });
           },
@@ -429,6 +489,25 @@ export function createDeepAgentActivities(config: Config) {
             gitRoot,
             casCaptureClass,
           );
+          // Approved-command turn facts (DD-28): when every mutation-capable call
+          // this turn was a consented shell command, attach the provenance so the
+          // backend can verify the cited consent rows and auto-keep the set
+          // instead of arming a second review gate. Fail-closed: any non-qualifying
+          // turn attaches nothing and reviews manually exactly as before. Attached
+          // only when captureCandidateToLedger actually authors a CANDIDATE.
+          const commandProvenance = deriveTurnCommandProvenance({
+            status: initialStatus,
+            priorSettledToolCallIds,
+            priorSubAgentToolCallIds,
+            globalBypass: setup.globalBypass,
+          });
+          if (commandProvenance) {
+            console.log(
+              `[ExecuteDeepAgent] capture: turn qualifies for approved-command auto-keep ` +
+              `(consent rows: ${commandProvenance.consentToolCallIds.join(",") || "(auto_approve_all)"}); ` +
+              `attaching provenance to candidate (execution=${executionId})`,
+            );
+          }
           await captureCandidateToLedger({
             status: initialStatus,
             gitRoot,
@@ -441,6 +520,7 @@ export function createDeepAgentActivities(config: Config) {
             unreviewablePaths,
             unreviewableCaptureClass: casCaptureClass,
             gitWorkspace: setup.gitWorkspace,
+            commandProvenance,
           });
           // Review is pending iff a CANDIDATE was actually authored (the seam
           // drops no-op captures), so a turn that only touched-then-unchanged an
@@ -872,5 +952,12 @@ async function cleanup(setup: SetupResult | null): Promise<void> {
       console.warn("[ExecuteDeepAgent] MCP connection cleanup failed:", err);
     }
   }
+
+  // Drop the workspace→platform `.stigmer` symlink so an attached repo is
+  // left untouched between turns (issue #173 semantics; a multi-turn session
+  // recreates it next turn). Runs in the activity finally, BEFORE the
+  // workspace lock releases, so the next queued turn baselines a clean tree.
+  // Best-effort and symlink-only: a real `.stigmer` directory is never removed.
+  await removeStigmerSymlink(setup.workspaceBackend.rootDir);
 }
 

package/src/activities/execute-deep-agent/status-builder.ts

@@ -24,9 +24,11 @@ import {
   ExecutionPhase,
   MessageType,
   ToolCallStatus,
+  ToolKind,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { resolveApprovalMessage as resolveApprovalMsg } from "../../shared/approval-policy.js";
 import { classifyTool } from "../../shared/tool-kind.js";
+import { applyTodoUpdate } from "../../shared/todos.js";
 import { ExecutionState } from "./execution-state.js";
 import { utcTimestamp } from "../../shared/status.js";
 import type { ExecutionStatusWriter } from "./execution-status-writer.js";
@@ -348,6 +350,13 @@ export class StatusBuilder {
       // (see v3 builder note). Truncating here would corrupt image base64.
       tc.status = ToolCallStatus.TOOL_CALL_COMPLETED;
       tc.result = extractToolResult(event.data);
+
+      // Project a completed to-do write into status.todos — success branch only,
+      // since a failed write_todos never ran its state-mutating Command. Shares
+      // the mapper and rationale documented in V3StatusBuilder.handleToolFinished.
+      if (tc.toolKind === ToolKind.TODO) {
+        applyTodoUpdate(this.state.proto.todos, tc.args?.todos, { merge: false });
+      }
     }
 
     tc.completedAt = utcTimestamp();

package/src/activities/execute-deep-agent/v3-status-builder.ts

@@ -23,9 +23,11 @@ import {
   ExecutionPhase,
   MessageType,
   ToolCallStatus,
+  ToolKind,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { resolveApprovalMessage as resolveApprovalMsg } from "../../shared/approval-policy.js";
 import { classifyTool } from "../../shared/tool-kind.js";
+import { applyTodoUpdate } from "../../shared/todos.js";
 import { ExecutionState } from "./execution-state.js";
 import { utcTimestamp } from "../../shared/status.js";
 import type { ExecutionStatusWriter } from "./execution-status-writer.js";
@@ -340,6 +342,17 @@ export class V3StatusBuilder implements ExecutionStatusWriter {
     this.state.toolStartTimes.delete(callId);
     this.toolArgBuffers.delete(callId);
 
+    // Project a completed to-do write into status.todos. deepagents' write_todos
+    // runs its state-mutating Command when the tool node COMPLETES, so we mirror
+    // it here (not at tool-start) — a call cancelled before finishing correctly
+    // projects nothing. Keyed on the harness-agnostic ToolKind.TODO (stamped at
+    // tool-start) and fed by the same shared mapper the Cursor tracker uses;
+    // deepagents always full-replaces (no merge field). The tool call itself
+    // stays in messages (the client filters ToolKind.TODO from the thread).
+    if (tc.toolKind === ToolKind.TODO) {
+      applyTodoUpdate(this.state.proto.todos, tc.args?.todos, { merge: false });
+    }
+
     this._forceNextUpdate = true;
   }
 

package/src/activities/execute-deep-agent/writeback-coordinator.ts

@@ -27,6 +27,7 @@ import { GitWriteBackMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import type { WorkspaceBackend, ProvisionResult } from "../../shared/workspace/types.js";
 import { SourceType } from "../../shared/workspace/types.js";
+import { gitCommitAsAgent } from "../../shared/workspace/git-identity.js";
 import type { ExecutionStatusWriter } from "./execution-status-writer.js";
 
 const WRITE_BACK_ENABLED_MODES = new Set([
@@ -273,7 +274,10 @@ export class WriteBackCoordinator {
     commitMsg: string,
   ): Promise<void> {
     await exec("git add -A");
-    await exec(`git commit -m "${commitMsg}"`);
+    // Committed as the agent identity: the cloud sandbox has no git identity
+    // configured (a bare commit fails with "Author identity unknown"), and in
+    // local mode the agent's work should not be attributed to the host user.
+    await exec(gitCommitAsAgent(commitMsg));
 
     entryState.commitCount++;
     const shaOutput = await exec("git rev-parse HEAD");

package/src/otel.ts

@@ -125,12 +125,20 @@ export async function startCursorTurnSpan(attrs: {
         [ATTR_SESSION_ID]: attrs.sessionId,
       },
     });
+    // Guard against a double end / a late setTokens: the turn span is ended from
+    // the activity's finally (finishTurnTelemetry), and OTel warns when a span is
+    // ended twice or mutated after end. Making this a no-op keeps the caller free
+    // to end idempotently on every exit path.
+    let ended = false;
     return {
       setTokens(input: number, output: number) {
+        if (ended) return;
         if (input) span.setAttribute(ATTR_LLM_INPUT_TOKENS, input);
         if (output) span.setAttribute(ATTR_LLM_OUTPUT_TOKENS, output);
       },
       end() {
+        if (ended) return;
+        ended = true;
         span.end();
       },
     };

package/src/shared/__tests__/todos.test.ts

@@ -0,0 +1,216 @@
+/**
+ * Unit tests for applyTodoUpdate — the harness-agnostic to-do map projection
+ * shared by the Cursor TodoTracker and the native v2/v3 status builders.
+ *
+ * These pin the exact mapping contract (status coercion, id synthesis,
+ * created_at preservation, merge vs. full-replace, clear-on-empty, defensive
+ * input handling, dirty return) so no two writers of status.todos can drift.
+ */
+
+import { describe, it, expect } from "vitest";
+import { TodoStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { TodoItem } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/todo_pb";
+import { applyTodoUpdate } from "../todos.js";
+
+function emptyMap(): { [key: string]: TodoItem } {
+  return {};
+}
+
+describe("applyTodoUpdate", () => {
+  describe("status mapping", () => {
+    it("maps pending", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A", status: "pending" }], { merge: false });
+      expect(m["todo-0"].status).toBe(TodoStatus.TODO_PENDING);
+    });
+
+    it("maps in_progress (snake_case)", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A", status: "in_progress" }], { merge: false });
+      expect(m["todo-0"].status).toBe(TodoStatus.TODO_IN_PROGRESS);
+    });
+
+    it("maps inProgress (camelCase, via toLowerCase)", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A", status: "inProgress" }], { merge: false });
+      expect(m["todo-0"].status).toBe(TodoStatus.TODO_IN_PROGRESS);
+    });
+
+    it("maps completed", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A", status: "completed" }], { merge: false });
+      expect(m["todo-0"].status).toBe(TodoStatus.TODO_COMPLETED);
+    });
+
+    it("maps cancelled (Cursor superset)", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A", status: "cancelled" }], { merge: false });
+      expect(m["todo-0"].status).toBe(TodoStatus.TODO_CANCELLED);
+    });
+
+    it("defaults unknown status to pending", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A", status: "bogus" }], { merge: false });
+      expect(m["todo-0"].status).toBe(TodoStatus.TODO_PENDING);
+    });
+
+    it("defaults missing status to pending", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A" }], { merge: false });
+      expect(m["todo-0"].status).toBe(TodoStatus.TODO_PENDING);
+    });
+  });
+
+  describe("id synthesis", () => {
+    it("uses a provided id", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "t1", content: "A", status: "pending" }], { merge: false });
+      expect(Object.keys(m)).toEqual(["t1"]);
+      expect(m["t1"].id).toBe("t1");
+    });
+
+    it("falls back to todo-<index> when id is absent", () => {
+      const m = emptyMap();
+      applyTodoUpdate(
+        m,
+        [
+          { content: "A", status: "pending" },
+          { content: "B", status: "completed" },
+        ],
+        { merge: false },
+      );
+      expect(Object.keys(m)).toEqual(["todo-0", "todo-1"]);
+    });
+
+    it("falls back to todo-<index> when id is an empty string", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "", content: "A", status: "pending" }], { merge: false });
+      expect(Object.keys(m)).toEqual(["todo-0"]);
+    });
+  });
+
+  describe("timestamps", () => {
+    it("sets created_at from raw.created_at on full-replace", () => {
+      const m = emptyMap();
+      applyTodoUpdate(
+        m,
+        [{ id: "t1", content: "A", status: "pending", created_at: "2026-01-01T00:00:00Z" }],
+        { merge: false, now: "2026-06-06T06:06:06Z" },
+      );
+      expect(m["t1"].createdAt).toBe("2026-01-01T00:00:00Z");
+    });
+
+    it("uses now for created_at when raw.created_at is absent (full-replace)", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A", status: "pending" }], {
+        merge: false,
+        now: "2026-06-06T06:06:06Z",
+      });
+      expect(m["todo-0"].createdAt).toBe("2026-06-06T06:06:06Z");
+    });
+
+    it("always bumps updated_at to now", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ content: "A", status: "pending" }], {
+        merge: false,
+        now: "2026-06-06T06:06:06Z",
+      });
+      expect(m["todo-0"].updatedAt).toBe("2026-06-06T06:06:06Z");
+    });
+
+    it("preserves created_at from the prior entry ONLY on merge", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "t1", content: "A", status: "pending" }], {
+        merge: false,
+        now: "2026-01-01T00:00:00Z",
+      });
+      applyTodoUpdate(m, [{ id: "t1", content: "A", status: "completed" }], {
+        merge: true,
+        now: "2026-02-02T00:00:00Z",
+      });
+      expect(m["t1"].createdAt).toBe("2026-01-01T00:00:00Z");
+      expect(m["t1"].updatedAt).toBe("2026-02-02T00:00:00Z");
+      expect(m["t1"].status).toBe(TodoStatus.TODO_COMPLETED);
+    });
+
+    it("does NOT preserve created_at on full-replace of the same id", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "t1", content: "A", status: "pending" }], {
+        merge: false,
+        now: "2026-01-01T00:00:00Z",
+      });
+      applyTodoUpdate(m, [{ id: "t1", content: "A", status: "pending" }], {
+        merge: false,
+        now: "2026-02-02T00:00:00Z",
+      });
+      expect(m["t1"].createdAt).toBe("2026-02-02T00:00:00Z");
+    });
+  });
+
+  describe("merge vs. full-replace", () => {
+    it("full-replace clears prior entries", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "a", content: "A", status: "pending" }], { merge: false });
+      applyTodoUpdate(m, [{ id: "b", content: "B", status: "pending" }], { merge: false });
+      expect(Object.keys(m)).toEqual(["b"]);
+    });
+
+    it("merge preserves other existing entries", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "a", content: "A", status: "pending" }], { merge: false });
+      applyTodoUpdate(m, [{ id: "b", content: "B", status: "pending" }], { merge: true });
+      expect(Object.keys(m).sort()).toEqual(["a", "b"]);
+    });
+
+    it("merge updates an existing entry by id", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "a", content: "A", status: "pending" }], { merge: false });
+      applyTodoUpdate(m, [{ id: "a", content: "A2", status: "completed" }], { merge: true });
+      expect(m["a"].content).toBe("A2");
+      expect(m["a"].status).toBe(TodoStatus.TODO_COMPLETED);
+    });
+  });
+
+  describe("clear-on-empty", () => {
+    it("clears the map on empty array + full-replace and reports a change", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "a", content: "A", status: "pending" }], { merge: false });
+      const changed = applyTodoUpdate(m, [], { merge: false });
+      expect(changed).toBe(true);
+      expect(Object.keys(m)).toHaveLength(0);
+    });
+
+    it("does NOT clear and reports no change on empty array + merge", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "a", content: "A", status: "pending" }], { merge: false });
+      const changed = applyTodoUpdate(m, [], { merge: true });
+      expect(changed).toBe(false);
+      expect(Object.keys(m)).toEqual(["a"]);
+    });
+
+    it("treats a non-array payload like empty (clears on full-replace)", () => {
+      const m = emptyMap();
+      applyTodoUpdate(m, [{ id: "a", content: "A", status: "pending" }], { merge: false });
+      const changed = applyTodoUpdate(m, undefined, { merge: false });
+      expect(changed).toBe(true);
+      expect(Object.keys(m)).toHaveLength(0);
+    });
+  });
+
+  describe("defensive input handling", () => {
+    it("coerces non-object array entries to empty todos", () => {
+      const m = emptyMap();
+      const changed = applyTodoUpdate(m, ["oops", null, 42], { merge: false });
+      expect(changed).toBe(true);
+      expect(Object.keys(m)).toEqual(["todo-0", "todo-1", "todo-2"]);
+      expect(m["todo-0"].content).toBe("");
+      expect(m["todo-0"].status).toBe(TodoStatus.TODO_PENDING);
+    });
+  });
+
+  describe("dirty return value", () => {
+    it("returns true when items are written", () => {
+      expect(applyTodoUpdate(emptyMap(), [{ content: "A" }], { merge: false })).toBe(true);
+    });
+  });
+});