@fungi.computer/shiitake 0.5.0 → 0.7.0

package/dist/internal/woodstock/session-store.js

@@ -7,6 +7,8 @@ import { compactionSummaryMessage } from "../compaction/utils.js";
 import { SessionTitleSchema, sessionTitleLimit } from "../client-boundary.js";
 import { commandTimestamp, decodeStoredSessionEntry, encodeStoredSessionEntry, isCompactCommand, commandContextMessage, operatorContextMessage, promptCommand, } from "./session-entry.js";
 import { prepareSessionAttention } from "./session-attention.js";
+import { prepareWorkSenders } from "./work-senders.js";
+import { prepareSessionDelegators } from "./session-delegator.js";
 import { copySessionGrants, prepareSessionGrants } from "./session-grants.js";
 import { prepareSessionInbox, touchSessionInbox } from "./session-inbox.js";
 import { sessionIds } from "./identities.js";
@@ -268,9 +270,9 @@ function selectedLineageFirstPromptId(owner, sessionId, leafId) {
          UNION
          SELECT parent.id, parent.parent_id, parent.sequence,
                 parent.type, parent.role, parent.state, parent.work_id
-           FROM session_entries AS parent
-           JOIN branch AS child ON parent.id = child.parent_id
-          WHERE parent.session_id = ?
+           FROM branch AS child
+           CROSS JOIN session_entries AS parent
+          WHERE parent.id = child.parent_id AND parent.session_id = ?
        )
        SELECT
          (SELECT command.id FROM branch AS command
@@ -534,6 +536,12 @@ const pendingAdmissions = `FROM session_command_admissions AS a
        WHERE e.session_id = a.session_id AND e.work_id = a.work_id
          AND e.type IN ('command', 'cancellation', 'run_terminal', 'work_terminal')
     )`;
+/** A written run terminal closes the window for attaching another steer. */
+export function hasRecordedRunTerminal(owner, sessionId, workId) {
+    return (owner.sql
+        .exec("SELECT 1 FROM session_entries WHERE session_id = ? AND work_id = ? AND type = 'run_terminal' LIMIT 1", sessionId, workId)
+        .toArray().length > 0);
+}
 const decodeIdentity = Schema.decodeUnknownSync(Schema.Struct({ identity: Schema.NullOr(Schema.String) }));
 /** Extract the host-selected principal without giving the engine domain grammar. */
 export function readAdmissionIdentity(owner, path, meta) {
@@ -576,7 +584,8 @@ export function readPendingSessionCommands(owner, sessionId, limit, only = "all"
         .one()).total;
     const commands = owner.sql
         .exec(`SELECT ${admissionColumns("a.")} ${pendingAdmissions} ${filter}
-     ORDER BY a.sequence ASC LIMIT ?`, sessionId, limit)
+     ORDER BY (json_extract(a.data_json, '$.delivery') = 'steer') DESC,
+              a.sequence ASC LIMIT ?`, sessionId, limit)
         .toArray()
         .map(parseCommandAdmissionRow);
     return { commands, total };
@@ -645,6 +654,7 @@ export function settleSessionControls(owner, input) {
                     jobId: row.entry.workId,
                     sessionId: input.sessionId,
                     commandFactId: row.id,
+                    delivery: "steer",
                 });
                 continue;
             }
@@ -680,6 +690,18 @@ function readSessionCommandAdmissionByWorkId(owner, sessionId, workId) {
 export function readSessionCommandAdmissionByRequest(owner, sessionId, requestId) {
     return readCommandAdmission(owner, sessionId, { requestId });
 }
+/** Probe the indexed terminal facts without materializing a live work's body. */
+export function hasSessionWorkTerminal(owner, sessionId, workId) {
+    // Keep the readability check even when the work has no terminal rows.
+    readSessionRow(owner, sessionId);
+    return (owner.sql
+        .exec(`SELECT 1 AS present FROM session_entries
+         INDEXED BY idx_session_entries_work_terminal
+         WHERE session_id = ? AND work_id = ?
+           AND type IN ('run_terminal', 'work_terminal')
+         LIMIT 1`, sessionId, workId)
+        .toArray().length > 0);
+}
 /** Read entries correlated to one accepted work identity in Session order. */
 export function readSessionEntriesForWork(owner, sessionId, workId) {
     // Refuse the Session before selecting entries: a damaged work may have no
@@ -832,6 +854,7 @@ export function deleteStoredSession(owner, input) {
             "DELETE FROM session_command_admissions WHERE session_id = ?",
             // The inbox row references the Session; it goes in the same transaction.
             "DELETE FROM session_attention WHERE session_id = ?",
+            "DELETE FROM session_work_senders WHERE session_id = ?",
             "DELETE FROM session_tool_grants WHERE session_id = ?",
             "DELETE FROM session_inbox WHERE session_id = ?",
             "DELETE FROM session_creation_receipts WHERE session_id = ?",
@@ -1128,6 +1151,8 @@ export function prepareSessionStore(owner) {
         createSessionEntryTable(owner);
         prepareSessionDocuments(owner);
         prepareSessionAttention(owner);
+        prepareWorkSenders(owner);
+        prepareSessionDelegators(owner);
         prepareSessionGrants(owner);
         prepareSessionInbox(owner);
         owner.sql.exec(`
@@ -1136,13 +1161,28 @@ export function prepareSessionStore(owner) {
       session_id TEXT NOT NULL UNIQUE REFERENCES sessions(id)
     )
   `);
+        // Preview admissions could have mistaken a later worker for the creator.
+        owner.sql.exec(`DELETE FROM session_delegators
+      WHERE NOT EXISTS (
+        SELECT 1 FROM session_creation_receipts AS creation
+        WHERE creation.session_id = session_delegators.session_id
+          AND creation.request_id = session_delegators.mail_key
+      )`);
         owner.sql.exec("CREATE INDEX IF NOT EXISTS idx_session_entries_parent ON session_entries(parent_id)");
+        // Replace the preview index, not its payload-length expression: preparing
+        // identity lookup must never read every stored message's payload.
+        owner.sql.exec("DROP INDEX IF EXISTS idx_session_entries_lineage");
+        owner.sql.exec(`CREATE INDEX IF NOT EXISTS idx_session_entries_ancestry
+       ON session_entries(id, session_id, parent_id, sequence, state, type)`);
         owner.sql.exec("CREATE INDEX IF NOT EXISTS idx_session_entries_session ON session_entries(session_id, sequence)");
         owner.sql.exec("CREATE INDEX IF NOT EXISTS idx_session_entries_streaming ON session_entries(session_id, state)");
         owner.sql.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_session_entries_request
        ON session_entries(session_id, request_id)
        WHERE request_id IS NOT NULL`);
         owner.sql.exec("CREATE INDEX IF NOT EXISTS idx_session_entries_work ON session_entries(work_id, sequence)");
+        owner.sql.exec(`CREATE INDEX IF NOT EXISTS idx_session_entries_work_terminal
+       ON session_entries(session_id, work_id)
+       WHERE type IN ('run_terminal', 'work_terminal')`);
         // Context and preference reads look up these rare older facts directly
         // rather than walking the history behind them.
         owner.sql.exec(`CREATE INDEX IF NOT EXISTS idx_session_entries_model_preference
@@ -1339,6 +1379,8 @@ const lineageByteLimit = 4 * 1_048_576;
  * selected walk steps only to an older parent, so it ends without
  * deduplicating; the fork walk keeps every link for its whole-lineage check.
  */
+// Keep each recursive step child-first: SQLite must look up that child's
+// parent, not scan every entry of the Session before joining the walk.
 const lineageWalks = {
     selected: `WITH RECURSIVE branch (id, parent_id, sequence, state) AS (
        SELECT id, parent_id, sequence, state
@@ -1346,9 +1388,10 @@ const lineageWalks = {
         WHERE session_id = ? AND id = ?
        UNION ALL
        SELECT parent.id, parent.parent_id, parent.sequence, parent.state
-         FROM session_entries AS parent
-         JOIN branch AS child ON parent.id = child.parent_id
-        WHERE parent.session_id = ? AND child.sequence > ?
+         FROM branch AS child
+         CROSS JOIN session_entries AS parent
+        WHERE parent.id = child.parent_id AND parent.session_id = ?
+          AND child.sequence > ?
           AND +parent.sequence < child.sequence
      )`,
     fork: `WITH RECURSIVE branch (id, parent_id, sequence, state) AS (
@@ -1357,9 +1400,10 @@ const lineageWalks = {
         WHERE session_id = ? AND id = ? AND state != 'streaming'
        UNION
        SELECT parent.id, parent.parent_id, parent.sequence, parent.state
-         FROM session_entries AS parent
-         JOIN branch AS child ON parent.id = child.parent_id
-        WHERE parent.session_id = ? AND child.sequence > ?
+         FROM branch AS child
+         CROSS JOIN session_entries AS parent
+        WHERE parent.id = child.parent_id AND parent.session_id = ?
+          AND child.sequence > ?
           AND parent.state != 'streaming'
      )`,
 };
@@ -1375,6 +1419,130 @@ const lineageFailures = {
         invalid: "Fork path is invalid",
     },
 };
+const decodeAncestryRow = Schema.decodeUnknownResult(Schema.Struct({
+    id: boundedId,
+    parent_id: Schema.NullOr(Schema.String),
+    sequence,
+    state: Schema.Literals(["complete", "streaming"]),
+}), closed);
+const sessionReads = new WeakMap();
+/**
+ * One synchronous, transaction-consistent Session baseline. Activity, timeline,
+ * extension projections and context figures share its identity-only ancestry;
+ * asynchronous model description runs after this scope has ended. Nothing is
+ * retained between reads, and payload windows keep their row and byte bounds.
+ */
+export function withSessionRead(owner, sessionId, read, before = Number.MAX_SAFE_INTEGER) {
+    const previous = sessionReads.get(owner);
+    sessionReads.set(owner, { sessionId, before, encoded: new Map() });
+    try {
+        return owner.transactionSync(read);
+    }
+    finally {
+        if (previous === undefined)
+            sessionReads.delete(owner);
+        else
+            sessionReads.set(owner, previous);
+    }
+}
+/** Join the shared Session baseline, or keep a direct projection atomic. */
+export function withSessionReadTransaction(owner, sessionId, read) {
+    return sessionReads.get(owner)?.sessionId === sessionId
+        ? read()
+        : owner.transactionSync(read);
+}
+/**
+ * Walk identities once to the kept context boundary and the requested page's
+ * row lookahead, whichever needs the older floor. Only compactions need their
+ * payload to identify that boundary. A historical page's intervening gap is
+ * traversed in SQL, not materialized into this request's identity cache.
+ *
+ * A context's kept entry can reuse the suffix starting at that ancestor. A later
+ * tip may share only if it is the seed or an ancestor retained in that suffix;
+ * another valid leaf uses its own walk instead of becoming an unavailable read.
+ * A query crossing an omitted gap or asking below the cached floor also uses
+ * its existing bounded walk. Nothing is retained between requests.
+ */
+function readAncestry(owner, sessionId, tipId, range) {
+    const read = sessionReads.get(owner);
+    if (read?.sessionId !== sessionId)
+        return undefined;
+    read.ancestry ??= owner.sql
+        .exec(`WITH RECURSIVE read_window (before_sequence, rows) AS (VALUES (?, ?)),
+       ancestry (id, parent_id, sequence, state, head, context_closed, taken) AS (
+         SELECT id, parent_id, sequence, state,
+                ${compactionHead("session_entries")}, 0,
+                CASE WHEN state != 'streaming'
+                           AND sequence < (SELECT before_sequence FROM read_window)
+                     THEN 1 ELSE 0 END
+           FROM session_entries INDEXED BY idx_session_entries_ancestry
+          WHERE session_id = ? AND id = ?
+         UNION ALL
+         SELECT parent.id, parent.parent_id, parent.sequence, parent.state,
+                COALESCE(child.head, ${compactionHead("parent")}),
+                child.context_closed OR
+                  (child.head IS child.id AND child.state != 'streaming'),
+                child.taken + CASE WHEN parent.state != 'streaming'
+                         AND parent.sequence < (SELECT before_sequence FROM read_window)
+                     THEN 1 ELSE 0 END
+           FROM ancestry AS child
+           CROSS JOIN session_entries AS parent INDEXED BY idx_session_entries_ancestry
+          WHERE parent.id = child.parent_id AND parent.session_id = ?
+            AND +parent.sequence < child.sequence
+            AND (child.taken < (SELECT rows FROM read_window)
+                 OR (child.context_closed = 0
+                     AND (child.head IS NOT child.id OR child.state = 'streaming')))
+       )
+       SELECT id, parent_id, sequence, state FROM ancestry
+        WHERE context_closed = 0
+           OR sequence <= (SELECT before_sequence FROM read_window)
+        ORDER BY sequence DESC`, read.before, lineageRowLimit + 1, sessionId, tipId, sessionId)
+        .toArray()
+        .map((raw) => {
+        const decoded = decodeAncestryRow(raw);
+        if (decoded._tag === "Failure")
+            throw unavailable("Stored Session ancestry is invalid");
+        return decoded.success;
+    });
+    const start = read.ancestry.findIndex(({ id }) => id === tipId);
+    if (start === -1)
+        return undefined;
+    const rows = read.ancestry.slice(start);
+    if (range !== undefined) {
+        const deepest = rows.at(-1);
+        if (deepest !== undefined &&
+            deepest.parent_id !== null &&
+            deepest.sequence > range.floor + 1)
+            return undefined;
+        const ceiling = range.ceiling ?? Number.MAX_SAFE_INTEGER;
+        for (let index = 1; index < rows.length; index += 1) {
+            const child = rows[index - 1];
+            const parent = rows[index];
+            if (child !== undefined &&
+                parent !== undefined &&
+                child.parent_id !== parent.id &&
+                range.floor < child.sequence - 1 &&
+                ceiling > parent.sequence)
+                return undefined;
+        }
+    }
+    const encoded = read.encoded.get(tipId);
+    if (encoded !== undefined)
+        return encoded;
+    const value = JSON.stringify(rows);
+    read.encoded.set(tipId, value);
+    return value;
+}
+/** A table over already-walked identities, decoded by SQLite's JSON reader. */
+function ancestryTable(name) {
+    return `${name} AS MATERIALIZED (
+    SELECT json_extract(value, '$.id') AS id,
+           json_extract(value, '$.parent_id') AS parent_id,
+           json_extract(value, '$.sequence') AS sequence,
+           json_extract(value, '$.state') AS state
+      FROM json_each(?)
+  )`;
+}
 const count = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)));
 const decodeLineageCheck = Schema.decodeUnknownResult(Schema.Struct({
     length: count,
@@ -1392,9 +1560,16 @@ const decodeLineageDiagnostic = Schema.decodeUnknownResult(Schema.Struct({ work_
  * the tip while its rows are above it, so only those rows, and the first at
  * or below it, are visited.
  */
-function lineageQuery(owner, lineage, floor, query, ...bindings) {
+function lineageQuery(owner, lineage, range, query, ...bindings) {
+    const ancestry = lineage.walk === "selected"
+        ? readAncestry(owner, lineage.sessionId, lineage.tipId, range)
+        : undefined;
+    if (ancestry !== undefined)
+        return owner.sql
+            .exec(`WITH ${ancestryTable("branch")} ${query}`, ancestry, ...bindings)
+            .toArray();
     return owner.sql
-        .exec(`${lineageWalks[lineage.walk]} ${query}`, lineage.sessionId, lineage.tipId, lineage.sessionId, floor, ...bindings)
+        .exec(`${lineageWalks[lineage.walk]} ${query}`, lineage.sessionId, lineage.tipId, lineage.sessionId, range.floor, ...bindings)
         .toArray();
 }
 /**
@@ -1493,7 +1668,7 @@ export function readSessionLineage(owner, input) {
     });
 }
 function readLineageRange(owner, lineage, oldest, newest) {
-    const rows = Object.freeze(lineageQuery(owner, lineage, oldest - 1, `SELECT ${entryColumns}
+    const rows = Object.freeze(lineageQuery(owner, lineage, { floor: oldest - 1, ceiling: newest }, `SELECT ${entryColumns}
          FROM session_entries
         WHERE session_id = ? AND state != 'streaming'
           AND sequence BETWEEN ? AND ?
@@ -1526,18 +1701,38 @@ const decodeWindowSizes = Schema.decodeUnknownResult(Schema.Struct({
  * walk visits the rows from the tip down to the window, never the history
  * below it. The deepest walked row comes back with the sizes, so a walk that
  * ended at a missing parent above where it meant to stop is refused, never
- * read as the end of history.
+ * read as the end of history. When a read already owns the ancestry, choose
+ * the same bounded candidate identities before consulting their record sizes.
+ * SQLite's octet_length(column) reads the byte count from record metadata,
+ * without loading the text's overflow pages or a payload-length index.
  */
 function readWindowSizes(owner, lineage, from, after, before, rows) {
+    let ancestry = lineage.walk === "selected"
+        ? readAncestry(owner, lineage.sessionId, lineage.tipId)
+        : undefined;
+    if (ancestry !== undefined) {
+        const candidates = sessionReads
+            .get(owner)
+            ?.ancestry?.filter((row) => row.sequence <= lineage.newestSequence &&
+            row.state !== "streaming" &&
+            row.sequence > after &&
+            row.sequence < before);
+        const last = from === "newest" ? candidates?.[rows - 1] : undefined;
+        ancestry = readAncestry(owner, lineage.sessionId, lineage.tipId, {
+            floor: last === undefined ? after : last.sequence - 1,
+            ceiling: before - 1,
+        });
+    }
+    const direction = from === "newest" ? "DESC" : "ASC";
     const ends = `SELECT
          (SELECT json_group_array(json_array(sequence, bytes)) FROM (
-            SELECT sequence, LENGTH(CAST(data_json AS BLOB)) AS bytes
+            SELECT sequence, octet_length(data_json) AS bytes
               FROM session_entries
              WHERE ${from === "newest" ? "" : "session_id = ? AND"}
                    state != 'streaming'
                AND sequence > ? AND sequence < ?
-               AND id IN (SELECT id FROM branch)
-             ORDER BY sequence ${from === "newest" ? "DESC" : "ASC"}
+               AND id IN (SELECT id FROM ${ancestry === undefined ? "branch" : "candidates"})
+             ORDER BY sequence ${direction}
              LIMIT ?)) AS sizes,
          (SELECT parent_id FROM branch ORDER BY sequence ASC LIMIT 1)
            AS deepest_parent,
@@ -1546,9 +1741,18 @@ function readWindowSizes(owner, lineage, from, after, before, rows) {
     const counts = (row) => `CASE WHEN ${row}.state != 'streaming'
                AND ${row}.sequence < ? AND ${row}.sequence > ?
           THEN 1 ELSE 0 END`;
-    const raw = from === "newest"
+    const raw = ancestry !== undefined
         ? owner.sql
-            .exec(`WITH RECURSIVE branch (id, parent_id, sequence, state, taken) AS (
+            .exec(`WITH ${ancestryTable("branch")},
+             candidates AS MATERIALIZED (
+               SELECT id FROM branch
+                WHERE state != 'streaming' AND sequence > ? AND sequence < ?
+                ORDER BY sequence ${direction} LIMIT ?
+             ) ${ends}`, ancestry, after, before, rows, ...(from === "newest" ? [] : [lineage.sessionId]), after, before, rows)
+            .toArray()
+        : from === "newest"
+            ? owner.sql
+                .exec(`WITH RECURSIVE branch (id, parent_id, sequence, state, taken) AS (
                SELECT id, parent_id, sequence, state,
                       ${counts("session_entries")}
                  FROM session_entries
@@ -1556,14 +1760,15 @@ function readWindowSizes(owner, lineage, from, after, before, rows) {
                UNION ALL
                SELECT parent.id, parent.parent_id, parent.sequence, parent.state,
                       child.taken + ${counts("parent")}
-                 FROM session_entries AS parent
-                 JOIN branch AS child ON parent.id = child.parent_id
-                WHERE parent.session_id = ? AND +parent.sequence < child.sequence
+                 FROM branch AS child
+                 CROSS JOIN session_entries AS parent
+                WHERE parent.id = child.parent_id AND parent.session_id = ?
+                  AND +parent.sequence < child.sequence
                   AND child.taken < ? AND child.sequence > ?
              )
              ${ends}`, before, after, lineage.sessionId, lineage.tipId, before, after, lineage.sessionId, rows, after, after, before, rows)
-            .toArray()
-        : lineageQuery(owner, lineage, after, ends, lineage.sessionId, after, before, rows);
+                .toArray()
+            : lineageQuery(owner, lineage, { floor: after }, ends, lineage.sessionId, after, before, rows);
     const decoded = decodeWindowSizes(raw[0]);
     if (decoded._tag === "Failure")
         throw unavailable("Stored Session entry size is invalid");
@@ -1607,7 +1812,7 @@ export function readLineageWindow(owner, lineage, input) {
 }
 /** Whether a complete row with this sequence lies on the lineage. */
 export function lineageHasSequence(owner, lineage, rowSequence) {
-    return (lineageQuery(owner, lineage, rowSequence - 1, `SELECT 1 AS present
+    return (lineageQuery(owner, lineage, { floor: rowSequence - 1, ceiling: rowSequence }, `SELECT 1 AS present
          FROM session_entries
         WHERE session_id = ? AND state != 'streaming' AND sequence = ?
           AND id IN (SELECT id FROM branch)`, lineage.sessionId, rowSequence).length > 0);
@@ -1637,15 +1842,9 @@ export function lineageEntrySequence(owner, lineage, id) {
 function newestLineagePreference(owner, sessionId, tipId) {
     const continues = (row) => `${row}.id NOT IN (SELECT id FROM targets)
      AND ${row}.sequence > (SELECT MIN(sequence) FROM targets)`;
-    const [newest] = walkedTargets(owner.sql
-        .exec(`WITH RECURSIVE targets AS MATERIALIZED (
-           SELECT id, sequence FROM session_entries
+    const [newest] = readTargetIds(owner, sessionId, tipId, `SELECT id, sequence FROM session_entries
             WHERE session_id = ? AND type = 'model_preference'
-              AND state != 'streaming'
-         ),
-         ${targetWalk(continues("child"))}
-         ${walkSteps(continues("walk"))}`, sessionId, sessionId, tipId, sessionId)
-        .toArray());
+              AND state != 'streaming'`, [sessionId], continues);
     return newest === undefined
         ? undefined
         : readEntryRow(owner, sessionId, newest);
@@ -1659,7 +1858,7 @@ function readLineageDocument(owner, lineage, extensionId, name) {
     if (lineage === undefined)
         return undefined;
     // No index finds documents yet, so this still walks the whole lineage.
-    const raw = lineageQuery(owner, lineage, 0, `SELECT ${entryColumns}
+    const raw = lineageQuery(owner, lineage, { floor: 0 }, `SELECT ${entryColumns}
        FROM session_entries
       WHERE session_id = ? AND state != 'streaming' AND type = 'document'
         AND json_extract(data_json, '$.extensionId') = ?
@@ -1676,7 +1875,10 @@ function readLineageDocument(owner, lineage, extensionId, name) {
         throw unavailable("Stored Session document disagrees with its row");
     return entry.valueJson;
 }
-const decodeOldestWorkRow = Schema.decodeUnknownResult(Schema.Struct({ sequence: Schema.NullOr(sequence) }), closed);
+const decodeWorkBounds = Schema.decodeUnknownResult(Schema.Struct({
+    oldest: Schema.NullOr(sequence),
+    newest: Schema.NullOr(sequence),
+}), closed);
 /**
  * Look up, on the lineage, only the facts of the given works. Diagnostics come
  * only from owned terminal fields, never provider message or retry text. The works'
@@ -1691,30 +1893,31 @@ export function readLineageWorkFacts(owner, lineage, workIds) {
             cancellations: new Map(),
         });
     const works = JSON.stringify([...workIds]);
-    const oldest = decodeOldestWorkRow(owner.sql
-        .exec(`SELECT MIN(sequence) AS sequence FROM (
-           SELECT MIN(sequence) AS sequence
+    const bounds = decodeWorkBounds(owner.sql
+        .exec(`SELECT MIN(oldest) AS oldest, MAX(newest) AS newest FROM (
+           SELECT MIN(sequence) AS oldest, MAX(sequence) AS newest
              FROM session_entries INDEXED BY idx_session_entries_work
             WHERE work_id IN (SELECT value FROM json_each(?))
               AND session_id = ?
            UNION ALL
-           SELECT MIN(sequence) FROM session_entries
+           SELECT MIN(sequence), MAX(sequence) FROM session_entries
                   INDEXED BY idx_session_entries_cancellation_target
             WHERE session_id = ? AND type = 'cancellation'
               AND json_extract(data_json, '$.targetWorkId')
                   IN (SELECT value FROM json_each(?))
          )`, works, lineage.sessionId, lineage.sessionId, works)
         .one());
-    if (oldest._tag === "Failure")
+    if (bounds._tag === "Failure")
         throw unavailable("Stored Session work order is invalid");
-    if (oldest.success.sequence === null)
+    if (bounds.success.oldest === null || bounds.success.newest === null)
         return Object.freeze({
             commands: new Set(),
             diagnostics: new Map(),
             cancellations: new Map(),
         });
-    const floor = oldest.success.sequence - 1;
-    const commands = new Set(lineageQuery(owner, lineage, floor, `SELECT DISTINCT work_id
+    const floor = bounds.success.oldest - 1;
+    const range = { floor, ceiling: bounds.success.newest };
+    const commands = new Set(lineageQuery(owner, lineage, range, `SELECT DISTINCT work_id
          FROM session_entries
         WHERE session_id = ? AND sequence > ? AND state != 'streaming' AND type = 'command'
           AND work_id IN (SELECT value FROM json_each(?))
@@ -1725,7 +1928,7 @@ export function readLineageWorkFacts(owner, lineage, workIds) {
         return decoded.success.work_id;
     }));
     const diagnostics = new Map();
-    for (const raw of lineageQuery(owner, lineage, floor, `SELECT work_id, diagnostic FROM (
+    for (const raw of lineageQuery(owner, lineage, range, `SELECT work_id, diagnostic FROM (
        SELECT work_id, sequence,
               json_extract(data_json, '$.diagnostic') AS diagnostic
          FROM session_entries
@@ -1742,7 +1945,7 @@ export function readLineageWorkFacts(owner, lineage, workIds) {
         diagnostics.set(decoded.success.work_id, decoded.success.diagnostic);
     }
     const cancellations = new Map();
-    for (const { entry } of lineageQuery(owner, lineage, floor, `SELECT ${entryColumns}
+    for (const { entry } of lineageQuery(owner, lineage, range, `SELECT ${entryColumns}
        FROM session_entries
       WHERE session_id = ? AND sequence > ? AND state != 'streaming' AND type = 'cancellation'
         AND json_extract(data_json, '$.targetWorkId')
@@ -1771,25 +1974,80 @@ export function readSelectedPath(owner, input) {
  * steps past it; a statement without targets reads only its starting row,
  * so a missing one is still refused.
  */
-function targetWalk(continues) {
-    return `walk (id, parent_id, sequence, state) AS (
+function targetWalk(sessionId, tipId, continues, ancestry) {
+    if (ancestry !== undefined)
+        return {
+            sql: `${ancestryTable("ancestors")},
+        stopped AS (
+          SELECT child.*,
+                 COALESCE(SUM(CASE WHEN ${continues} THEN 0 ELSE 1 END)
+                   OVER (ORDER BY child.sequence DESC
+                     ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), 0) AS stops
+            FROM ancestors AS child
+        ),
+        walk AS (
+          SELECT id, parent_id, sequence, state FROM stopped WHERE stops = 0
+        )`,
+            bindings: [ancestry],
+            recursive: false,
+        };
+    return {
+        sql: `walk (id, parent_id, sequence, state) AS (
        SELECT id, parent_id, sequence, state
          FROM session_entries
         WHERE session_id = ? AND id = ?
        UNION ALL
        SELECT parent.id, parent.parent_id, parent.sequence, parent.state
-         FROM session_entries AS parent
-         JOIN walk AS child ON parent.id = child.parent_id
-        WHERE parent.session_id = ? AND +parent.sequence < child.sequence
+         FROM walk AS child
+         CROSS JOIN session_entries AS parent
+        WHERE parent.id = child.parent_id AND parent.session_id = ?
+          AND +parent.sequence < child.sequence
           AND ${continues}
-     )`;
+     )`,
+        bindings: [sessionId, tipId, sessionId],
+        recursive: true,
+    };
+}
+/**
+ * A shared prefix can answer a target read only if it reaches that read's
+ * stopping point without crossing an omitted gap. Otherwise run the original
+ * target-bounded walk; a cache horizon is not evidence of damaged history.
+ */
+function readTargetIds(owner, sessionId, tipId, targets, bindings, continues) {
+    const ancestry = readAncestry(owner, sessionId, tipId);
+    const run = (shared) => {
+        const walk = targetWalk(sessionId, tipId, continues("child"), shared);
+        return owner.sql
+            .exec(`WITH ${walk.recursive ? "RECURSIVE " : ""}targets AS MATERIALIZED (
+           ${targets}
+         ),
+         ${walk.sql}
+         ${walkSteps(continues("walk"))}`, ...bindings, ...walk.bindings)
+            .toArray();
+    };
+    let raw = run(ancestry);
+    if (ancestry !== undefined) {
+        const last = raw.at(-1);
+        if (last !== undefined) {
+            const deepest = decodeWalkStep(last);
+            if (deepest._tag === "Failure")
+                throw unavailable("Stored Session walk row is invalid");
+            if ((deepest.success.continues === 1 &&
+                deepest.success.parent_id !== null) ||
+                readAncestry(owner, sessionId, tipId, {
+                    floor: deepest.success.sequence - 1,
+                }) === undefined)
+                raw = run(undefined);
+        }
+    }
+    return walkedTargets(raw);
 }
 /**
  * The walked targets, newest first, then the deepest walked row, each with
  * whether the walk meant to pass it. Only these rows reach JavaScript.
  */
 function walkSteps(continues) {
-    return `SELECT id, parent_id, target, continues FROM (
+    return `SELECT id, parent_id, sequence, target, continues FROM (
              SELECT id, parent_id, sequence,
                     id IN (SELECT id FROM targets) AS target,
                     COALESCE((${continues}), 0) AS continues
@@ -1802,6 +2060,7 @@ const flag = Schema.Literals([0, 1]);
 const decodeWalkStep = Schema.decodeUnknownResult(Schema.Struct({
     id: boundedId,
     parent_id: Schema.NullOr(Schema.String),
+    sequence,
     target: flag,
     continues: flag,
 }), closed);
@@ -1846,9 +2105,10 @@ const contextWalk = `WITH RECURSIVE walk (id, parent_id, sequence, state, head)
        UNION ALL
        SELECT parent.id, parent.parent_id, parent.sequence, parent.state,
               COALESCE(child.head, ${compactionHead("parent")})
-         FROM session_entries AS parent
-         JOIN walk AS child ON parent.id = child.parent_id
-        WHERE parent.session_id = ? AND +parent.sequence < child.sequence
+         FROM walk AS child
+         CROSS JOIN session_entries AS parent
+        WHERE parent.id = child.parent_id AND parent.session_id = ?
+          AND +parent.sequence < child.sequence
           AND (child.head IS NOT child.id OR child.state = 'streaming')
      )`;
 /**
@@ -1860,9 +2120,7 @@ const contextWalk = `WITH RECURSIVE walk (id, parent_id, sequence, state, head)
 function readDecidingFacts(owner, sessionId, kept, window, workId) {
     const commands = JSON.stringify(window.flatMap(({ entry }) => entry.kind === "command" ? [entry.workId] : []));
     const continues = (row) => `${row}.sequence > (SELECT MIN(sequence) FROM targets)`;
-    const facts = walkedTargets(owner.sql
-        .exec(`WITH RECURSIVE targets AS MATERIALIZED (
-         SELECT id, sequence FROM session_entries
+    const facts = readTargetIds(owner, sessionId, kept.id, `SELECT id, sequence FROM session_entries
           WHERE session_id = ? AND type = 'compaction' AND work_id = ?
             AND sequence < ? AND state != 'streaming'
          UNION ALL
@@ -1872,11 +2130,7 @@ function readDecidingFacts(owner, sessionId, kept, window, workId) {
           WHERE session_id = ? AND type = 'cancellation'
             AND json_extract(data_json, '$.targetWorkId')
                 IN (SELECT value FROM json_each(?))
-            AND sequence < ? AND state != 'streaming'
-       ),
-       ${targetWalk(continues("child"))}
-       ${walkSteps(continues("walk"))}`, sessionId, workId, kept.sequence, sessionId, commands, kept.sequence, sessionId, kept.id, sessionId)
-        .toArray());
+            AND sequence < ? AND state != 'streaming'`, [sessionId, workId, kept.sequence, sessionId, commands, kept.sequence], continues);
     if (facts.length === 0)
         return Object.freeze([]);
     return Object.freeze(owner.sql
@@ -1895,12 +2149,40 @@ function readDecidingFacts(owner, sessionId, kept, window, workId) {
  */
 function readContextWindow(owner, sessionId, tipId) {
     const failures = lineageFailures.selected;
+    let ancestry = readAncestry(owner, sessionId, tipId);
+    // The seed owns this cache's compaction boundary. An ancestor tip can have an
+    // older boundary of its own (including one in an omitted historical gap).
+    if (sessionReads.get(owner)?.ancestry?.[0]?.id !== tipId)
+        ancestry = undefined;
+    const source = ancestry === undefined
+        ? { sql: contextWalk, bindings: [sessionId, tipId, sessionId] }
+        : {
+            sql: `WITH ${ancestryTable("ancestors")},
+            boundary AS (
+              SELECT sequence, json_extract(data_json, '$.head') AS head
+                FROM session_entries
+               WHERE session_id = ? AND type = 'compaction'
+                 AND state != 'streaming'
+                 AND id IN (SELECT id FROM ancestors)
+               ORDER BY sequence DESC LIMIT 1
+            ),
+            walk AS (
+              SELECT * FROM ancestors
+               WHERE sequence >= COALESCE((
+                 SELECT ancestors.sequence FROM ancestors, boundary
+                  WHERE ancestors.id = boundary.head
+                    AND ancestors.state != 'streaming'
+                    AND ancestors.sequence <= boundary.sequence
+               ), 0)
+            )`,
+            bindings: [ancestry, sessionId],
+        };
     const rows = owner.sql
-        .exec(`${contextWalk}
+        .exec(`${source.sql}
        SELECT ${entryColumns}
          FROM session_entries
         WHERE id IN (SELECT id FROM walk) AND state != 'streaming'
-        ORDER BY sequence ASC`, sessionId, tipId, sessionId)
+        ORDER BY sequence ASC`, ...source.bindings)
         .toArray()
         .map((raw) => parseEntryRow(owner, raw));
     const kept = rows[0];
@@ -1961,7 +2243,7 @@ function readRunContextRows(owner, sessionId, command, current, workId) {
         throw unavailable("Accepted Session command lineage is unavailable");
     const tail = current === undefined
         ? []
-        : lineageQuery(owner, current, command.sequence, `SELECT ${entryColumns}
+        : lineageQuery(owner, current, { floor: command.sequence }, `SELECT ${entryColumns}
              FROM session_entries
             WHERE session_id = ? AND sequence > ? AND state != 'streaming'
               AND id IN (SELECT id FROM branch)
@@ -2325,6 +2607,7 @@ export function acceptSessionCommandOwned(owner, sessionId, input, meta, origin,
         jobId: commandFactId,
         sessionId,
         commandFactId,
+        delivery: input.type === "prompt" ? input.delivery : "followUp",
     });
     return acceptanceFromAdmission(command, "new");
 }