@remnic/core 9.54.5 → 9.54.7

package/src/support-passport/card-service.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { test } from "node:test";
@@ -47,7 +47,7 @@ async function makeSubject() {
   };
 }
 
-async function makeSharedStorageSubject() {
+async function makeSharedStorageSubject(namespaceOverride?: string) {
   StorageManager.clearAllStaticCaches();
   const root = await mkdtemp(path.join(tmpdir(), "remnic-support-passport-shared-"));
   const storage = new StorageManager(path.join(root, "shared"));
@@ -55,8 +55,8 @@ async function makeSharedStorageSubject() {
   const service = new SupportPassportCardService({
     now: () => new Date("2026-08-11T12:00:00.000Z"),
     resolveOwner: async (principal) => {
-      if (principal === "owner:alice") return { principal, namespace: "alice", storage };
-      if (principal === "owner:bob") return { principal, namespace: "bob", storage };
+      if (principal === "owner:alice") return { principal, namespace: namespaceOverride ?? "alice", storage };
+      if (principal === "owner:bob") return { principal, namespace: namespaceOverride ?? "bob", storage };
       throw new Error("unknown test principal");
     },
   });
@@ -344,12 +344,8 @@ test("card operations preserve configured default namespace identities", async (
       reviewBy: OWNER_REVIEW_BY,
     });
     assert.deepEqual(await service.listCards({ principal: "owner:alice" }), [card]);
-    assert.equal(
-      decodeSupportPassportNamespaceAttributes(
-        (await storage.getMemoryById(card.cardId))?.frontmatter.structuredAttributes ?? {},
-      ),
-      namespace
-    );
+    const stored = await storage.getMemoryById(card.cardId);
+    assert.equal(decodeSupportPassportNamespaceAttributes(stored?.frontmatter.structuredAttributes ?? {}), namespace);
   } finally {
     StorageManager.clearAllStaticCaches();
     await rm(root, { recursive: true, force: true });
@@ -382,6 +378,71 @@ test("card operations reject a resolved principal that differs from the authenti
   }
 });
 
+test("generated draft creation rejects a non-canonical resolved namespace before writing", async () => {
+  StorageManager.clearAllStaticCaches();
+  const root = await mkdtemp(path.join(tmpdir(), "remnic-support-passport-generated-namespace-"));
+  const storage = new StorageManager(path.join(root, "shared"));
+  await storage.ensureDirectories();
+  const service = new SupportPassportCardService({
+    resolveOwner: async (principal) => ({ principal, namespace: " alice ", storage }),
+  });
+  try {
+    await assert.rejects(
+      service.createGeneratedDrafts({
+        principal: "owner:alice",
+        cards: [
+          {
+            title: "Quiet place",
+            statement: "Offer me a quiet place.",
+            category: "environment",
+            sourceMemoryIds: ["source-1"],
+          },
+        ],
+      }),
+      (error: unknown) => error instanceof SupportPassportError && error.code === "card_data_invalid"
+    );
+    assert.deepEqual(await storage.readAllMemories(), []);
+  } finally {
+    StorageManager.clearAllStaticCaches();
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("generated draft batches scan the owner corpus once", async () => {
+  const subject = await makeSubject();
+  try {
+    const readAllMemories = subject.aliceStorage.readAllMemories.bind(subject.aliceStorage);
+    let corpusScans = 0;
+    subject.aliceStorage.readAllMemories = async (...args) => {
+      corpusScans += 1;
+      return await readAllMemories(...args);
+    };
+
+    const cards = await subject.service.createGeneratedDrafts({
+      principal: "owner:alice",
+      cards: [
+        {
+          title: "Quiet place",
+          statement: "Offer me a quiet place.",
+          category: "environment",
+          sourceMemoryIds: ["source-1"],
+        },
+        {
+          title: "Plan changes",
+          statement: "Tell me before plans change.",
+          category: "transitions",
+          sourceMemoryIds: ["source-2"],
+        },
+      ],
+    });
+
+    assert.equal(cards.length, 2);
+    assert.equal(corpusScans, 1);
+  } finally {
+    await subject.cleanup();
+  }
+});
+
 test("manual draft creation returns the committed card without a post-write corpus reload", async () => {
   const subject = await makeSubject();
   try {
@@ -409,6 +470,81 @@ test("manual draft creation returns the committed card without a post-write corp
   }
 });
 
+test("manual draft creation rolls back when its request is cancelled after persistence", async () => {
+  const subject = await makeSubject();
+  const controller = new AbortController();
+  const writeSealedMemory = subject.aliceStorage.writeSealedMemory.bind(subject.aliceStorage);
+  subject.aliceStorage.writeSealedMemory = async (...args) => {
+    const written = await writeSealedMemory(...args);
+    controller.abort(new Error("simulated owner request timeout"));
+    return written;
+  };
+  try {
+    await assert.rejects(
+      subject.service.createManualDraft(
+        {
+          principal: "owner:alice",
+          title: "Quiet place",
+          statement: "Offer me a quiet place and time.",
+          category: "environment",
+          reviewBy: OWNER_REVIEW_BY,
+        },
+        { signal: controller.signal }
+      ),
+      /simulated owner request timeout/
+    );
+    assert.deepEqual(await subject.service.listCards({ principal: "owner:alice" }), []);
+    const stored = await subject.aliceStorage.readAllMemories();
+    assert.equal(stored.length, 1);
+    assert.equal(stored[0]?.frontmatter.status, "rejected");
+  } finally {
+    await subject.cleanup();
+  }
+});
+
+test("card replacement rolls back when its request is cancelled after persistence", async () => {
+  const subject = await makeSubject();
+  const controller = new AbortController();
+  try {
+    const draft = await subject.service.createManualDraft({
+      principal: "owner:alice",
+      title: "Quiet place",
+      statement: "Offer me a quiet place.",
+      category: "environment",
+      reviewBy: OWNER_REVIEW_BY,
+    });
+    const writeSealedMemory = subject.aliceStorage.writeSealedMemory.bind(subject.aliceStorage);
+    subject.aliceStorage.writeSealedMemory = async (...args) => {
+      const written = await writeSealedMemory(...args);
+      controller.abort(new Error("simulated owner request timeout"));
+      return written;
+    };
+
+    await assert.rejects(
+      subject.service.replaceCard(
+        {
+          principal: "owner:alice",
+          cardId: draft.cardId,
+          expectedRevision: draft.revision,
+          title: "Quiet place and time",
+          statement: "Offer me a quiet place and time.",
+          category: "environment",
+          reviewBy: OWNER_REVIEW_BY,
+        },
+        { signal: controller.signal }
+      ),
+      /simulated owner request timeout/
+    );
+    assert.deepEqual(await subject.service.listCards({ principal: "owner:alice" }), [draft]);
+    const stored = await subject.aliceStorage.readAllMemories();
+    assert.equal(stored.length, 2);
+    assert.equal(stored.find((memory) => memory.frontmatter.id === draft.cardId)?.frontmatter.status, "pending_review");
+    assert.equal(stored.find((memory) => memory.frontmatter.id !== draft.cardId)?.frontmatter.status, "rejected");
+  } finally {
+    await subject.cleanup();
+  }
+});
+
 test("listing linkless drafts does not rescan the corpus by card ID", async () => {
   const subject = await makeSubject();
   try {
@@ -466,7 +602,7 @@ test("listing a pending replacement does not add a final unchanged-corpus reload
 
     await subject.service.listCards({ principal: "owner:alice" });
 
-    assert.equal(corpusReads, 4);
+    assert.equal(corpusReads, 1);
   } finally {
     await subject.cleanup();
   }
@@ -701,7 +837,8 @@ test("rejecting a source draft rejects its interrupted hidden replacement", asyn
 });
 
 test("replacement audits retain the card owner scope and omit internal attributes", async () => {
-  const subject = await makeSharedStorageSubject();
+  const namespace = "team]primary\ncare";
+  const subject = await makeSharedStorageSubject(namespace);
   try {
     const draft = await subject.service.createManualDraft({
       principal: "owner:alice",
@@ -743,10 +880,10 @@ test("replacement audits retain the card owner scope and omit internal attribute
     );
     assert.equal(stripAttributesSuffix(audit.content).includes("support-passport-title"), false);
     assert.equal(audit.frontmatter.source, "support-passport");
-    assert.equal(
-      decodeSupportPassportNamespaceAttributes(audit.frontmatter.structuredAttributes ?? {}),
-      "alice"
-    );
+    const auditAttributes = audit.frontmatter.structuredAttributes;
+    assert.ok(auditAttributes);
+    assert.equal(decodeSupportPassportNamespaceAttributes(auditAttributes), namespace);
+    assert.notEqual(auditAttributes["support-passport-namespace"], namespace);
     assert.equal(
       audit.frontmatter.structuredAttributes?.["support-passport-owner"],
       (await subject.storage.getMemoryById(active.cardId))?.frontmatter.structuredAttributes?.["support-passport-owner"]
@@ -1394,8 +1531,8 @@ test("retrying an interrupted pending-draft replacement rejects changed content"
     );
     const visible = await subject.service.listCards({ principal: "owner:alice" });
     assert.equal(visible.length, 1);
-    assert.equal(visible[0]?.cardId, replacement.frontmatter.id);
-    assert.equal(visible[0]?.statement, "Offer me a quiet place and time.");
+    assert.equal(visible[0]?.cardId, draft.cardId);
+    assert.equal(visible[0]?.statement, "Offer me a quiet place.");
     assert.equal((await subject.aliceStorage.readAllMemories()).length, 2);
   } finally {
     await subject.cleanup();
@@ -1496,7 +1633,7 @@ test("replacement approval rolls back when predecessor retirement returns false"
   }
 });
 
-test("listing rolls back an incomplete active replacement when retirement returns false", async () => {
+test("listing projects an incomplete active replacement without recovery writes", async () => {
   const subject = await makeSubject();
   try {
     const draft = await subject.service.createManualDraft({
@@ -1534,19 +1671,76 @@ test("listing rolls back an incomplete active replacement when retirement return
       cardId: replacement.cardId,
       expectedRevision: replacement.revision,
     });
-    subject.aliceStorage.supersedeMemory = async () => false;
+    let recoveryWrites = 0;
+    subject.aliceStorage.supersedeMemory = async () => {
+      recoveryWrites += 1;
+      return false;
+    };
+    const writeFrontmatter = subject.aliceStorage.writeMemoryFrontmatterIfUnchanged.bind(subject.aliceStorage);
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = async (...args) => {
+      recoveryWrites += 1;
+      return await writeFrontmatter(...args);
+    };
 
     const visible = await subject.service.listCards({ principal: "owner:alice" });
 
     subject.aliceStorage.supersedeMemory = originalSupersede;
     assert.deepEqual(
       visible.map((card) => [card.cardId, card.status]),
-      [
-        [active.cardId, "active"],
-        [replacement.cardId, "pending_review"],
-      ]
+      [[replacement.cardId, "active"]]
     );
+    assert.equal(recoveryWrites, 0);
+    assert.equal((await subject.aliceStorage.getMemoryById(active.cardId))?.frontmatter.status, "superseded");
+  } finally {
+    await subject.cleanup();
+  }
+});
+
+test("listing projects one card when predecessor retirement has not started", async () => {
+  const subject = await makeSubject();
+  try {
+    const draft = await subject.service.createManualDraft({
+      principal: "owner:alice",
+      title: "Plan changes",
+      statement: "Tell me before plans change.",
+      category: "transitions",
+      reviewBy: OWNER_REVIEW_BY,
+    });
+    const active = await subject.service.approveCard({
+      principal: "owner:alice",
+      cardId: draft.cardId,
+      expectedRevision: draft.revision,
+    });
+    const replacement = await subject.service.replaceCard({
+      principal: "owner:alice",
+      cardId: active.cardId,
+      expectedRevision: active.revision,
+      title: "Plan changes",
+      statement: "Tell me early when plans change.",
+      category: "transitions",
+      reviewBy: OWNER_REVIEW_BY,
+    });
+    const originalWrite = subject.aliceStorage.writeMemoryFrontmatterIfUnchanged.bind(subject.aliceStorage);
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = async (memory, patch, lifecycle) => {
+      if (lifecycle?.reasonCode === "support-passport-replacement-pending") {
+        throw new Error("simulated interruption before predecessor retirement");
+      }
+      return await originalWrite(memory, patch, lifecycle);
+    };
+
+    const approved = await subject.service.approveCard({
+      principal: "owner:alice",
+      cardId: replacement.cardId,
+      expectedRevision: replacement.revision,
+    });
+    const visible = await subject.service.listCards({ principal: "owner:alice" });
+
+    assert.equal(approved.status, "active");
     assert.equal((await subject.aliceStorage.getMemoryById(active.cardId))?.frontmatter.status, "active");
+    assert.deepEqual(
+      visible.map((card) => [card.cardId, card.status]),
+      [[replacement.cardId, "active"]]
+    );
   } finally {
     await subject.cleanup();
   }
@@ -1825,7 +2019,7 @@ test("rejection stops when a retired predecessor cannot be restored", async () =
   }
 });
 
-test("an orphaned replacement is rejected when its replaced draft was approved", async () => {
+test("listing hides an orphaned replacement without recovery writes", async () => {
   const subject = await makeSubject();
   try {
     const { approved, replacement } = await createOrphanedReplacement(subject);
@@ -1926,7 +2120,7 @@ test("failed replacement activation stays pending through recovery", async () =>
   }
 });
 
-test("a draft rollback failure recovers to one visible card", async () => {
+test("a draft rollback failure keeps one visible card", async () => {
   const subject = await makeSubject();
   try {
     const draft = await subject.service.createManualDraft({
@@ -1963,19 +2157,19 @@ test("a draft rollback failure recovers to one visible card", async () => {
     assert.equal(rollbackAttempts, 1);
     const visible = await subject.service.listCards({ principal: "owner:alice" });
     assert.equal(visible.length, 1);
-    assert.notEqual(visible[0]?.cardId, draft.cardId);
+    assert.equal(visible[0]?.cardId, draft.cardId);
     const cards = (await subject.aliceStorage.readAllMemories()).filter((memory) =>
       memory.frontmatter.tags?.includes("support-passport-card")
     );
     assert.equal(cards.length, 2);
-    assert.equal(cards.filter((memory) => memory.frontmatter.status === "pending_review").length, 1);
-    assert.equal(cards.filter((memory) => memory.frontmatter.status === "rejected").length, 1);
+    assert.equal(cards.filter((memory) => memory.frontmatter.status === "pending_review").length, 2);
+    assert.equal(cards.filter((memory) => memory.frontmatter.status === "rejected").length, 0);
   } finally {
     await subject.cleanup();
   }
 });
 
-test("a missing replaced draft rejects its orphaned replacement without blocking the passport", async () => {
+test("a missing replaced draft stays hidden without recovery writes", async () => {
   const subject = await makeSubject();
   try {
     const draft = await subject.service.createManualDraft({
@@ -2015,11 +2209,33 @@ test("a missing replaced draft rejects its orphaned replacement without blocking
     await rm(original.path);
     StorageManager.clearAllStaticCaches();
 
+    let recoveryWrites = 0;
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = async (...args) => {
+      recoveryWrites += 1;
+      return await originalWrite(...args);
+    };
     assert.deepEqual(await subject.service.listCards({ principal: "owner:alice" }), []);
     assert.equal(
       (await subject.aliceStorage.getMemoryById(replacement.frontmatter.id))?.frontmatter.status,
-      "rejected"
+      "pending_review"
     );
+    assert.equal(recoveryWrites, 0);
+    const readStoredMemories = subject.aliceStorage.readAllMemories.bind(subject.aliceStorage);
+    subject.aliceStorage.readAllMemories = async () => [
+      replacement,
+      ...Array.from({ length: 99 }, (_, index) => ({
+        ...original,
+        path: `${original.path}-capacity-${index}`,
+        frontmatter: {
+          ...original.frontmatter,
+          id: `support-card-capacity-${index}`,
+          structuredAttributes: {
+            ...original.frontmatter.structuredAttributes,
+            "support-passport-order": String(index),
+          },
+        },
+      })),
+    ];
     const newDraft = await subject.service.createManualDraft({
       principal: "owner:alice",
       title: "New guide",
@@ -2027,6 +2243,7 @@ test("a missing replaced draft rejects its orphaned replacement without blocking
       category: "other",
       reviewBy: OWNER_REVIEW_BY,
     });
+    subject.aliceStorage.readAllMemories = readStoredMemories;
     assert.equal(newDraft.status, "pending_review");
   } finally {
     await subject.cleanup();
@@ -2460,3 +2677,288 @@ test("draft creation aborts when the owner lock is lost before its write", async
     await subject.cleanup();
   }
 });
+
+test("generated draft rollback retries a compare-and-swap conflict", async () => {
+  const subject = await makeSubject();
+  try {
+    const writeSealedMemory = subject.aliceStorage.writeSealedMemory.bind(subject.aliceStorage);
+    const readAllMemories = subject.aliceStorage.readAllMemories.bind(subject.aliceStorage);
+    let writes = 0;
+    subject.aliceStorage.writeSealedMemory = async (...args) => {
+      writes += 1;
+      if (writes === 2) throw new Error("second draft write failed");
+      return await writeSealedMemory(...args);
+    };
+    const writeFrontmatter = subject.aliceStorage.writeMemoryFrontmatterIfUnchanged.bind(subject.aliceStorage);
+    let rollbackAttempts = 0;
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = async (memory, patch, lifecycle) => {
+      if (lifecycle?.reasonCode === "draft-batch-failed") {
+        rollbackAttempts += 1;
+        if (rollbackAttempts === 1) return false;
+      }
+      return await writeFrontmatter(memory, patch, lifecycle);
+    };
+
+    await assert.rejects(
+      subject.service.createGeneratedDrafts({
+        principal: "owner:alice",
+        cards: [
+          {
+            title: "First draft",
+            statement: "Give me time to answer.",
+            category: "communication",
+            sourceMemoryIds: ["source-1"],
+          },
+          {
+            title: "Second draft",
+            statement: "Tell me before plans change.",
+            category: "transitions",
+            sourceMemoryIds: ["source-2"],
+          },
+        ],
+      }),
+      /second draft write failed/
+    );
+    assert.equal(rollbackAttempts, 2);
+    assert.deepEqual(await subject.service.listCards({ principal: "owner:alice" }), []);
+    const rollbackEvent = (await subject.aliceStorage.readAllMemoryLifecycleEvents()).find(
+      (event) => event.reasonCode === "draft-batch-failed"
+    );
+    assert.equal(rollbackEvent?.actor, "owner:alice");
+  } finally {
+    await subject.cleanup();
+  }
+});
+
+test("generated draft rollback continues after one cleanup throws", async () => {
+  const subject = await makeSubject();
+  try {
+    const writeSealedMemory = subject.aliceStorage.writeSealedMemory.bind(subject.aliceStorage);
+    let writes = 0;
+    subject.aliceStorage.writeSealedMemory = async (...args) => {
+      writes += 1;
+      if (writes === 3) throw new Error("third draft write failed");
+      return await writeSealedMemory(...args);
+    };
+    const writeFrontmatter = subject.aliceStorage.writeMemoryFrontmatterIfUnchanged.bind(subject.aliceStorage);
+    let rollbackAttempts = 0;
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = async (memory, patch, lifecycle) => {
+      if (lifecycle?.reasonCode === "draft-batch-failed") {
+        rollbackAttempts += 1;
+        if (rollbackAttempts === 1) throw new Error("first cleanup failed");
+      }
+      return await writeFrontmatter(memory, patch, lifecycle);
+    };
+
+    await assert.rejects(
+      subject.service.createGeneratedDrafts({
+        principal: "owner:alice",
+        cards: [
+          {
+            title: "First draft",
+            statement: "Give me time to answer.",
+            category: "communication",
+            sourceMemoryIds: ["source-1"],
+          },
+          {
+            title: "Second draft",
+            statement: "Tell me before plans change.",
+            category: "transitions",
+            sourceMemoryIds: ["source-2"],
+          },
+          {
+            title: "Third draft",
+            statement: "Dim bright lights when possible.",
+            category: "sensory",
+            sourceMemoryIds: ["source-3"],
+          },
+        ],
+      }),
+      (error: unknown) => error instanceof SupportPassportError && error.code === "storage_conflict"
+    );
+    assert.equal(rollbackAttempts, 2);
+    const remaining = await subject.service.listCards({ principal: "owner:alice" });
+    assert.deepEqual(remaining, []);
+  } finally {
+    await subject.cleanup();
+  }
+});
+
+test("generated draft rollback rejects known cards when the corpus scan fails", async () => {
+  const subject = await makeSubject();
+  try {
+    const writeSealedMemory = subject.aliceStorage.writeSealedMemory.bind(subject.aliceStorage);
+    const readAllMemories = subject.aliceStorage.readAllMemories.bind(subject.aliceStorage);
+    let writes = 0;
+    subject.aliceStorage.writeSealedMemory = async (...args) => {
+      const written = await writeSealedMemory(...args);
+      writes += 1;
+      if (writes === 1) {
+        let failNextCorpusScan = true;
+        subject.aliceStorage.readAllMemories = async (...readArgs) => {
+          if (!failNextCorpusScan) return await readAllMemories(...readArgs);
+          failNextCorpusScan = false;
+          throw new Error("simulated corpus scan failure");
+        };
+      }
+      if (writes === 2) throw new Error("second draft write failed");
+      return written;
+    };
+
+    await assert.rejects(
+      subject.service.createGeneratedDrafts({
+        principal: "owner:alice",
+        cards: [
+          {
+            title: "First draft",
+            statement: "Give me time to answer.",
+            category: "communication",
+            sourceMemoryIds: ["source-1"],
+          },
+          {
+            title: "Second draft",
+            statement: "Tell me before plans change.",
+            category: "transitions",
+            sourceMemoryIds: ["source-2"],
+          },
+        ],
+      }),
+      (error: unknown) => error instanceof SupportPassportError && error.code === "storage_conflict"
+    );
+    const persisted = (await readAllMemories()).find((memory) =>
+      memory.frontmatter.tags?.includes("support-passport-card")
+    );
+    assert.equal(persisted?.frontmatter.status, "rejected");
+  } finally {
+    await subject.cleanup();
+  }
+});
+
+test("listing stays read-only before a later mutation recovers an incomplete batch", async () => {
+  const subject = await makeSubject();
+  try {
+    const commitWithValidatedSources = async (_commit: () => Promise<void>) => {
+      if ((await subject.aliceStorage.readAllMemories()).length > 0) {
+        throw new Error("simulated process exit after generated card persistence");
+      }
+    };
+    const writeFrontmatter = subject.aliceStorage.writeMemoryFrontmatterIfUnchanged.bind(subject.aliceStorage);
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = async (memory, patch, lifecycle) => {
+      if (lifecycle?.reasonCode === "draft-batch-failed") {
+        throw new Error("simulated process exit before cleanup");
+      }
+      return await writeFrontmatter(memory, patch, lifecycle);
+    };
+
+    await assert.rejects(
+      subject.service.createGeneratedDraftsForOwner({
+        authenticatedPrincipal: "owner:alice",
+        owner: { principal: "owner:alice", namespace: "alice", storage: subject.aliceStorage },
+        cards: [
+          {
+            title: "First draft",
+            statement: "Give me time to answer.",
+            category: "communication",
+            sourceMemoryIds: ["source-1"],
+          },
+        ],
+        commitWithValidatedSources,
+      }),
+      (error: unknown) => error instanceof SupportPassportError && error.code === "storage_conflict"
+    );
+    subject.aliceStorage.writeMemoryFrontmatterIfUnchanged = writeFrontmatter;
+
+    const persisted = await subject.aliceStorage.readAllMemories();
+    const card = persisted.find((memory) => memory.frontmatter.tags?.includes("support-passport-card"));
+    assert.ok(card);
+    assert.equal(card.frontmatter.status, "pending_review");
+    const batchId = card.frontmatter.structuredAttributes?.["support-passport-generated-batch-id"];
+    assert.match(batchId ?? "", /^[0-9a-f-]{36}$/);
+    const markerPath = path.join(
+      subject.aliceStorage.dir,
+      "state",
+      "support-passport",
+      "generated-batches",
+      `${batchId}.json`
+    );
+    const marker = JSON.parse(await readFile(markerPath, "utf8")) as { complete?: unknown; size?: unknown };
+    assert.equal(marker.complete, false);
+    assert.equal(marker.size, 1);
+
+    StorageManager.clearAllStaticCaches();
+    const restartedStorage = new StorageManager(subject.aliceStorage.dir);
+    await restartedStorage.ensureDirectories();
+    const restarted = new SupportPassportCardService({
+      resolveOwner: async (principal) => ({ principal, namespace: "alice", storage: restartedStorage }),
+    });
+    assert.deepEqual(await restarted.listCards({ principal: "owner:alice" }), []);
+    assert.equal(
+      (await restartedStorage.readAllMemories()).find((memory) => memory.frontmatter.id === card.frontmatter.id)
+        ?.frontmatter.status,
+      "pending_review"
+    );
+    await readFile(markerPath, "utf8");
+    await restarted.createManualDraft({
+      principal: "owner:alice",
+      title: "Recovery draft",
+      statement: "This mutation recovers an interrupted generated batch.",
+      category: "other",
+      reviewBy: OWNER_REVIEW_BY,
+    });
+    assert.equal(
+      (await restartedStorage.readAllMemories()).find((memory) => memory.frontmatter.id === card.frontmatter.id)
+        ?.frontmatter.status,
+      "rejected"
+    );
+    await assert.rejects(readFile(markerPath, "utf8"), (error: unknown) => {
+      return (error as NodeJS.ErrnoException).code === "ENOENT";
+    });
+  } finally {
+    await subject.cleanup();
+  }
+});
+
+test("completed generated batches survive individual card withdrawal", async () => {
+  const subject = await makeSubject();
+  try {
+    const drafts = await subject.service.createGeneratedDrafts({
+      principal: "owner:alice",
+      cards: [
+        {
+          title: "Communication",
+          statement: "Give me time to answer.",
+          category: "communication",
+          sourceMemoryIds: ["source-1"],
+        },
+        {
+          title: "Transitions",
+          statement: "Tell me before plans change.",
+          category: "transitions",
+          sourceMemoryIds: ["source-2"],
+        },
+      ],
+    });
+    const active = [];
+    for (const draft of drafts) {
+      active.push(
+        await subject.service.approveCard({
+          principal: "owner:alice",
+          cardId: draft.cardId,
+          expectedRevision: draft.revision,
+        })
+      );
+    }
+    await subject.service.withdrawCard({
+      principal: "owner:alice",
+      cardId: active[0]!.cardId,
+      expectedRevision: active[0]!.revision,
+    });
+
+    assert.deepEqual(
+      (await subject.service.listCards({ principal: "owner:alice" })).map((card) => card.cardId),
+      [active[1]!.cardId]
+    );
+  } finally {
+    await subject.cleanup();
+  }
+});