@sema-agent/core 7.54.0 → 7.54.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 7.54.1 — 2026-10-20
+
+**Hard-breaking changes:** none. **Closed sets:** none (`invalid_session` is an existing code). **Exports:** +0 / −0 names; no type or signature change. **Behavior:** a session log whose parent chain loops back on itself is refused `invalid_session` by `getPathToRoot` and by the resume-at ancestry scan, where each used to hold the thread until the process aborted; the shared store kit gains one `[tree]` case that says so. Present in every earlier version.
+
+**Packages:** `@sema-agent/mods-kernel` is re-cut at 7.54.1 beside core — packages are cut with core at the same version (`scripts/verify-packages.mjs`) — with contents identical to 7.54.0 (no kernel source changed in this patch).
+
+### `getPathToRoot` and the resume-at ancestry scan refuse a parent chain that loops back on itself instead of walking it forever (#2239; fix; a log that could not be read at all; hard-breaking: none; closed sets: none; exports: +0 / −0) (@server)
+
+- **Before (v7.54.0; the same in every earlier version).** `BaseSessionStorage.getPathToRoot` followed `parentId` upward with no memory of the entries it had stepped onto. A log in which an entry is its own parent, or two entries are each other's parent, or a leaf walks into such a pair, never reached a root: the walk is synchronous, so it held the whole thread (no timer, timeout or abort could run) while the path it was building grew until the process aborted out of memory (measured on a 256 MB heap: about 13 s, then `SIGABRT`). Every bundled storage (memory, file) and the example adapters inherit this one walk. The resume-at phase had a second walk of the same kind: with `resumeAtMode: "before"` it climbs the target's ancestors, one awaited read at a time, until it finds a conversation message; a log whose ancestry above the target is only non-message entries that loop (for example two labels that parent each other) never ended it, and because each read resolves as a microtask the loop starved timers as well. A store that implements the storage interface directly with a walk of its own had no kit case to say a looping log must not be walked.
+- **Now.** Both walks take one small guard (`ParentChainGuard`, internal; not a package export) that remembers the entries a walk has stepped onto. An entry stepped onto twice ends the walk with `SessionError("invalid_session", "Entry <id> is its own ancestor (parent chain cycles at <id>)")`, naming the entry the chain came back to (for a leaf outside the loop, the first loop entry the walk reached; for the resume-at scan the target itself counts as stepped onto, so a loop that closes through it is refused before any branch is written). Claude Code's own chain builder stops at the repeat and returns the part it had walked (cli296.js:250676:3080); this engine refuses instead, because a loop is a damaged log and a truncated history would read as a shorter conversation (stricter, completeness-first; open to veto). A declared floor still ends the walk at the floor without reading its parent, so a loop that closes through the floor, or lies above it, is not walked and nothing is refused; a floor the walk never meets does not shield the loop. A chain with no loop reads exactly as before (a 1 000-entry chain returns whole, root first). `sessionStoreContract` gains the case `[tree] a parent chain that loops back on itself …`: an entry that is its own parent, two entries that parent each other, a leaf that walks into such a pair, and a ring of three must each read `invalid_session` naming an entry of the loop, within 2 s; a backend that refuses the looping write itself is stricter than the rule and passes.
+- **Who is hurt.** Nobody who reads a sound log. A host that wrote a looping log (a hand-edited or damaged file, or a store with no write-time check) now sees `invalid_session` on the read where it saw a stalled thread and then an aborted process. A store that implements `SessionStore` directly and walks the parent chain itself fails the new kit case until its walk refuses a loop (the server's SQL store is the known consumer: it retires its own guarded walker for this one in its 7.134.0).
+- **Compensation.** None needed. A store that wants the engine's walk extends `BaseSessionStorage`; one that keeps its own walk adds a visited set (or a depth bound) and the refusal above, and runs the kit.
+- **Pins.** `test/backlog2239-session-path-cycle.test.ts` L1–L5 (each walk runs in a child process, because a walk that never returns holds its whole thread and no in-process timeout could fire; red on v7.54.0 as "no answer in 2 s" for L1, L2, L3 and the off-path floor of L5), L6 (the resume-at scan: a loop above the target hangs on v7.54.0; a loop through the target and the two controls), L7 (the guard) and K1–K2 (the kit case on the bundled memory and file lanes; six wrong walks each redden it).
+
 ## 7.54.0 — 2026-10-19
 
 ### A table of the faces kept alive for compatibility, a gate that keeps it honest, and one ruler per word (#1336, #2100; release tooling and src comments only; behavior change: none; hard-breaking: none; closed sets: none; exports: none; members: none)

package/dist/core/runner/prepare-acquire-reconcile.d.ts

@@ -8,16 +8,15 @@
  * (resume-at validation + rebranch + reconcile re-run as one unit against the fresh view) — pinned
  * in `prepare-task-phase-pins`.
  *
- * Ownership: on SUCCESS the acquired session's ownership transfers whole
- * to the caller (the driver's forgetOnThrow / the Runner's finish own the cleanup from then on);
+ * Ownership: on SUCCESS the acquired session's ownership transfers whole to the caller (the driver's forgetOnThrow / the Runner's finish own the cleanup from then on);
  * every failure path INSIDE this phase drops its own cached view first (`forget`, never `release` —
  * audit B-17: release deletes the history on the default store), so a throw here never strands a
  * cached view and never hands out a half-acquired resource.
  *
  * Throws pass through unchanged: `resume.session_not_found` (requireExisting fail-loud mapping),
- * the `resume_at.*` target-validation refusals, and — after the bounded re-wake budget — the
- * session conflict itself. A throw after a `resumeAt` branch landed first writes that branch back
- * (`settleBranchWriteBack`); on success the branch is handed over with the session.
+ * the `resume_at.*` target-validation refusals, `invalid_session` for a log whose parent links loop back, and — after the
+ * bounded re-wake budget — the session conflict itself. A throw after a `resumeAt` branch landed first writes that branch
+ * back (`settleBranchWriteBack`); on success the branch is handed over with the session.
  */
 import { StoredSession } from "../session.js";
 import type { AcquiredSession, SessionStore } from "../session.js";

package/dist/core/runner/prepare-acquire-reconcile.js

@@ -1,5 +1,5 @@
 import { StoredSession, isSessionConflict } from "../session.js";
-import { SessionError } from "../../internal/harness.js";
+import { ParentChainGuard, SessionError } from "../../internal/harness.js";
 import { readMember } from "../thrown-value.js";
 import { userAttachmentOf } from "../../internal/llm.js";
 import { lastAttachmentFrameOf } from "../user-attachment.js";
@@ -77,12 +77,14 @@ export async function prepareAcquireReconcile(input) {
                         e.code = "resume_at.before_target_not_user";
                         throw e;
                     }
-                    let ancestorId = entry.parentId;
-                    let sawConversationAbove = false;
+                    let ancestorId = entry.parentId, sawConversationAbove = false;
+                    const chain = new ParentChainGuard();
+                    chain.stepOnto(entry.id);
                     while (ancestorId !== null) {
                         const ancestor = await session.getEntry(ancestorId);
                         if (!ancestor)
                             break;
+                        chain.stepOnto(ancestor.id);
                         if (ancestor.type === "message" || ancestor.type === "custom_message") {
                             sawConversationAbove = true;
                             break;

package/dist/core/store-contracts/session-store-contract.js

@@ -62,6 +62,22 @@ async function rejectsWithConflict(fn, what) {
     const miss = conflictMiss(await thrownBy(fn, what));
     assert.equal(miss, undefined, `${what}: ${miss}`);
 }
+const LOOP_WALK_BUDGET_MS = 2000;
+async function refusedAsLoop(storage, leafId, loopMembers, what) {
+    let timer;
+    const expiry = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new assert.AssertionError({ message: `${what}: no answer within ${LOOP_WALK_BUDGET_MS} ms — the walk does not end on a parent chain that loops back on itself` })), LOOP_WALK_BUDGET_MS);
+    });
+    const settled = Promise.resolve()
+        .then(() => storage.getPathToRoot(leafId))
+        .then((path) => ({ path }), (err) => ({ err }));
+    const outcome = await Promise.race([settled, expiry]).finally(() => clearTimeout(timer));
+    if ("path" in outcome)
+        assert.fail(`${what}: a parent chain that loops back on itself answered a path of ${outcome.path.length} entries instead of refusing`);
+    assert.equal(readMember(outcome.err, "code"), "invalid_session", `${what}: the refusal must carry code invalid_session`);
+    const sentence = String(readMember(outcome.err, "message"));
+    assert.ok(loopMembers.some((id) => sentence.includes(id)), `${what}: the refusal must name an entry of the loop (${loopMembers.join(" / ")}), got "${sentence}"`);
+}
 function rowOf(rows, sessionId) {
     return rows.find((r) => r.sessionId === sessionId);
 }
@@ -275,6 +291,34 @@ async function runSessionStoreContract(make, hooks) {
         const head = (await session.getStorage().getPathToRoot("e1"))[0];
         assert.ok(head.parentId === null || head.id === session.getStorage().getFloorId?.(), "a path's head is a root or the declared floor");
     });
+    run("[tree] a parent chain that loops back on itself — an entry that is its own parent, two entries that parent each other, a leaf that walks into such a pair — reads invalid_session naming an entry of the loop, and the walk ends (also for a ring of three)", async (store) => {
+        const { session } = await store.acquire(freshId());
+        await append(session, userEntry("e1", null));
+        const accepted = async (...entries) => {
+            try {
+                for (const e of entries)
+                    await append(session, e);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
+        const storage = session.getStorage();
+        if (await accepted(userEntry("kit-loop-self", "kit-loop-self"))) {
+            await refusedAsLoop(storage, "kit-loop-self", ["kit-loop-self"], "the path from an entry that is its own parent");
+        }
+        if (await accepted(userEntry("kit-loop-p", "kit-loop-q"), userEntry("kit-loop-q", "kit-loop-p"))) {
+            await refusedAsLoop(storage, "kit-loop-q", ["kit-loop-p", "kit-loop-q"], "the path from one of two entries that parent each other");
+            if (await accepted(userEntry("kit-loop-t", "kit-loop-p"))) {
+                await refusedAsLoop(storage, "kit-loop-t", ["kit-loop-p", "kit-loop-q"], "the path from a leaf outside the loop that walks into it");
+            }
+        }
+        if (await accepted(userEntry("kit-ring-1", "kit-ring-3"), userEntry("kit-ring-2", "kit-ring-1"), userEntry("kit-ring-3", "kit-ring-2"))) {
+            await refusedAsLoop(storage, "kit-ring-3", ["kit-ring-1", "kit-ring-2", "kit-ring-3"], "the path from one of three entries that parent each other in a ring");
+        }
+        assert.deepEqual(await pathIds(session, "e1"), ["e1"], "a path that does not touch the loop still reads");
+    });
     run("[tree] the write CAS: an append or setLeafId whose expectedLeafId is stale is refused with the engine's conflict and writes nothing", async (store) => {
         const { session } = await store.acquire(freshId());
         const storage = session.getStorage();

package/dist/engine/session/parent-chain-guard.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The memory of one walk up a session log's parent chain, shared by every walk that follows `parentId`. An entry the
+ * walk stands on twice means the parent links loop, which no ancestry can contain: the walk is refused
+ * `invalid_session` naming that entry instead of being followed again. One guard per walk.
+ */
+export declare class ParentChainGuard {
+    private readonly stepped;
+    /** Records that the walk now stands on `id`; throws `invalid_session` when it already stood there. */
+    stepOnto(id: string): void;
+}

package/dist/engine/session/parent-chain-guard.js

@@ -0,0 +1,10 @@
+import { SessionError } from "../harness/types.js";
+export class ParentChainGuard {
+    stepped = new Set();
+    stepOnto(id) {
+        if (this.stepped.has(id)) {
+            throw new SessionError("invalid_session", `Entry ${id} is its own ancestor (parent chain cycles at ${id})`);
+        }
+        this.stepped.add(id);
+    }
+}

package/dist/engine/session/storage-base.js

@@ -1,4 +1,5 @@
 import { SessionError, } from "../harness/types.js";
+import { ParentChainGuard } from "./parent-chain-guard.js";
 import { uuidv7 } from "./uuid.js";
 function updateLabelCache(labelsById, entry) {
     if (entry.type !== "label") {
@@ -111,11 +112,13 @@ export class BaseSessionStorage {
             return [];
         }
         const path = [];
+        const chain = new ParentChainGuard();
         let current = this.byId.get(leafId);
         if (!current) {
             throw new SessionError("not_found", `Entry ${leafId} not found`);
         }
         while (current) {
+            chain.stepOnto(current.id);
             path.push(current);
             if (current.id === this.floorId) {
                 break;

package/dist/internal/harness.d.ts

@@ -23,6 +23,7 @@ export { BaseSessionStorage, leafIdAfterEntry } from "../engine/session/storage-
 export { InMemorySessionStorage } from "../engine/session/memory-storage.js";
 export { InMemorySessionRepo } from "../engine/session/memory-repo.js";
 export { uuidv7 } from "../engine/session/uuid.js";
+export { ParentChainGuard } from "../engine/session/parent-chain-guard.js";
 export { readToolCallArguments } from "../engine/loop/agent-loop.js";
 export { SessionError } from "../engine/harness/types.js";
 export type { AnnouncedListingSnapshot, AnnouncedListingSnapshotInput, AnnouncedMcpFailure } from "../engine/harness/types.js";

package/dist/internal/harness.js

@@ -11,6 +11,7 @@ export { BaseSessionStorage, leafIdAfterEntry } from "../engine/session/storage-
 export { InMemorySessionStorage } from "../engine/session/memory-storage.js";
 export { InMemorySessionRepo } from "../engine/session/memory-repo.js";
 export { uuidv7 } from "../engine/session/uuid.js";
+export { ParentChainGuard } from "../engine/session/parent-chain-guard.js";
 export { readToolCallArguments } from "../engine/loop/agent-loop.js";
 export { SessionError } from "../engine/harness/types.js";
 export { normalizeGitAnnouncement } from "../engine/harness/types.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.54.0",
+  "version": "7.54.1",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",

package/wire-changes/core@7.54.1.json

@@ -0,0 +1,37 @@
+{
+  "repo": "core",
+  "version": "7.54.1",
+  "from": "371ab636fb4dc957f79229a654ff6c2fe840c9a3",
+  "to": "v7.54.1",
+  "added": [],
+  "removed": [],
+  "changed": [],
+  "narrowed": [],
+  "closedSetMembers": [],
+  "closedSetsUnreadable": [],
+  "typeKeys": [],
+  "typeKeysUnreadableArms": [],
+  "typeKeysFlattenedCount": 237,
+  "signatures": [],
+  "declarationMoves": [],
+  "mintMoves": [],
+  "criteriaObserves": [
+    {
+      "kind": "typeMember",
+      "name": "SessionError.code",
+      "assertions": [
+        "G1.a",
+        "G1.b"
+      ]
+    }
+  ],
+  "consumersHint": {
+    "cli": [],
+    "server": [],
+    "sdk": [],
+    "note": "scanned cli@5028feb7 server@41b72695 sdk@e8794dc — a name listed is MENTIONED there today, which is evidence of consumption, not proof of it"
+  },
+  "breakingCount": 0,
+  "breakingItems": [],
+  "toResolvedAt": "854e82a40701de98758a3f8a41e62431cf67facd"
+}