fix(core): drill-down lists descendants under untracked intermediates

listEntries({ parentId: X }) now applies the top-level rule relative to X: this user's
live entries on descendants of X (up to three levels) with no live-entry work strictly
between them and X, so it agrees with childSummary. Restoring an engagement's re-parenting
onto a soft-deleted entry throws ValidationError("entryId", "target entry is deleted").

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

packages/core/test/engagements.test.ts

@@ -7,7 +7,7 @@ import {
   softDeleteEngagement,
   updateEngagement,
 } from "../src/engagements.ts";
-import { softDeleteEntry, upsertEntry } from "../src/entries.ts";
+import { moveEntryToWork, softDeleteEntry, upsertEntry } from "../src/entries.ts";
 import { NotFoundError, ValidationError } from "../src/errors.ts";
 import { getHistory, restoreVersion } from "../src/history.ts";
 import { makeUser, makeWork } from "./user-layer-fixtures.ts";
@@ -122,6 +122,19 @@ forEachDialect("engagements", (getDb) => {
     await expect(softDeleteEngagement(db, userId, eg.id, "user")).rejects.toThrow(NotFoundError);
   });
 
+  test("restoring a re-parenting onto a soft-deleted entry is rejected", async () => {
+    const { db, userId, entry } = await setup();
+    const other = await upsertEntry(db, userId, await makeWork(db, { title: "Other" }), {}, "user");
+    const eg = await addEngagement(db, userId, entry.id, {}, "user");
+    await moveEntryToWork(db, userId, entry.id, other.workId, "user");
+    const [h] = await getHistory(db, userId, "engagement", eg.id);
+    expect(h!.before).toEqual({ entryId: entry.id });
+    // the merged-away entry is soft-deleted, so the engagement cannot go back to it
+    const err = await restoreVersion(db, userId, h!.id).catch((e: unknown) => e);
+    expect(err).toBeInstanceOf(ValidationError);
+    expect(err).toMatchObject({ field: "entryId", reason: "target entry is deleted" });
+  });
+
   test("another user's engagements are not found", async () => {
     const { db, userId, entry } = await setup();
     const bob = await makeUser(db, "bob");

packages/core/test/entries.test.ts

@@ -140,6 +140,18 @@ forEachDialect("entries", (getDb) => {
     const top2 = await listEntries(db, userId, {});
     expect(top2.items.map((i) => i.id).sort()).toEqual([showEntry.id, lone.id, show2Entry.id].sort());
     expect(top2.items.find((i) => i.id === show2Entry.id)!.childSummary).toEqual({ total: 2, completed: 1 });
+
+    // drilling into the show lists the episodes, since the season between them has no entry
+    const drill = await listEntries(db, userId, { parentId: show2 });
+    expect(drill.items.map((i) => i.work.mediaType)).toEqual(["episode", "episode"]);
+    expect(await listEntries(db, userId, { parentId: show2, q: "nothing matches" })).toEqual({ items: [], nextCursor: null });
+
+    // once the season has an entry, the show lists the season and the season lists the episodes
+    const seasonEntry = await upsertEntry(db, userId, season, { status: "in_progress" }, "user");
+    expect((await listEntries(db, userId, { parentId: show2 })).items.map((i) => i.id)).toEqual([seasonEntry.id]);
+    const seasonDrill = await listEntries(db, userId, { parentId: season });
+    expect(seasonDrill.items.map((i) => i.work.mediaType)).toEqual(["episode", "episode"]);
+    expect(seasonDrill.items.find((i) => i.id === seasonEntry.id)).toBeUndefined();
   });
 
   test("orphaned child entries are top level until an ancestor has an entry", async () => {