@neuralnomads/codenomad-dev 0.18.0-dev-20260628-e8623d31 → 0.18.0-dev-20260709-ca06bd99

package/dist/permissions/auto-accept-manager.test.js

@@ -0,0 +1,528 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { EventBus } from "../events/bus";
+import { AutoAcceptManager } from "./auto-accept-manager";
+const noopLogger = {
+    debug() { },
+    info() { },
+    warn() { },
+    error() { },
+    trace() { },
+    isLevelEnabled() {
+        return false;
+    },
+    child() {
+        return noopLogger;
+    },
+};
+function publishInstanceEvent(bus, instanceId, event) {
+    bus.publish({ type: "instance.event", instanceId, event: { ...event } });
+}
+/** Publish a `session.*` event using the real OpenCode shape (`properties.info`). */
+function publishSession(bus, instanceId, eventType, info) {
+    publishInstanceEvent(bus, instanceId, { type: eventType, properties: { info: { ...info } } });
+}
+describe("AutoAcceptManager session tree", () => {
+    it("ingests session.updated to build the parent chain", () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "master", parentID: null });
+        publishSession(bus, "inst", "session.updated", { id: "child", parentID: "master" });
+        assert.equal(manager.isEnabled("inst", "master"), false);
+        manager.toggle("inst", "child");
+        assert.equal(manager.isEnabled("inst", "child"), true);
+        assert.equal(manager.isEnabled("inst", "master"), true);
+        manager.stop();
+    });
+    it("treats a session with revert as a fork root", () => {
+        const bus = new EventBus(noopLogger);
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier() });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "master", parentID: null });
+        publishSession(bus, "inst", "session.updated", {
+            id: "fork",
+            parentID: "master",
+            revert: { messageID: "m", partID: "p" },
+        });
+        manager.toggle("inst", "fork");
+        assert.equal(manager.isEnabled("inst", "fork"), true);
+        assert.equal(manager.isEnabled("inst", "master"), false);
+        manager.stop();
+    });
+    it("session.deleted removes the tree entry but keeps the toggle", () => {
+        const bus = new EventBus(noopLogger);
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier() });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "master", parentID: null });
+        manager.toggle("inst", "master");
+        publishSession(bus, "inst", "session.deleted", { id: "master" });
+        // toggle is independent of the tree (survives deletion)
+        assert.equal(manager.isEnabled("inst", "master"), true);
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager permission interception", () => {
+    it("auto-replies to a v2 permission on an enabled family", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const accepted = [];
+        bus.on("yolo.autoAccepted", (e) => accepted.push(e));
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "master", parentID: null });
+        publishSession(bus, "inst", "session.updated", { id: "child", parentID: "master" });
+        manager.toggle("inst", "child"); // enable the whole family root
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-1", sessionID: "child", action: "edit", resources: ["a.ts"] },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        const call = replier.calls[0];
+        assert.equal(call.instanceId, "inst");
+        assert.equal(call.permissionId, "perm-1");
+        assert.equal(call.sessionId, "child");
+        assert.equal(call.source, "v2");
+        assert.equal(call.reply, "once");
+        assert.equal(accepted.length, 1);
+        assert.equal(accepted[0].permissionId, "perm-1");
+        manager.stop();
+    });
+    it("auto-replies to a legacy permission.asked event", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.asked",
+            properties: { id: "perm-2", sessionID: "solo", type: "bash" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        assert.equal(replier.calls[0].source, "legacy");
+        assert.equal(replier.calls[0].permissionId, "perm-2");
+        manager.stop();
+    });
+    it("does not reply when the family is disabled", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-3", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        manager.stop();
+    });
+    it("ignores permission events without an id or sessionID", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        publishInstanceEvent(bus, "inst", { type: "permission.v2.asked", properties: { sessionID: "solo" } });
+        publishInstanceEvent(bus, "inst", { type: "permission.v2.asked", properties: { id: "x" } });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        manager.stop();
+    });
+    it("deduplicates repeated emission of the same permission", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        for (let i = 0; i < 3; i++) {
+            publishInstanceEvent(bus, "inst", {
+                type: "permission.v2.asked",
+                properties: { id: "perm-dup", sessionID: "solo" },
+            });
+        }
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        manager.stop();
+    });
+    it("clears in-flight tracking after the reply resolves so it can retry", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-retry", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-retry", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 2);
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager state events", () => {
+    it("publishes yolo.stateChanged with the new enabled value on toggle", () => {
+        const bus = new EventBus(noopLogger);
+        const changes = [];
+        bus.on("yolo.stateChanged", (e) => changes.push(e));
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier() });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "master", parentID: null });
+        manager.toggle("inst", "master");
+        manager.toggle("inst", "master");
+        assert.equal(changes.length, 2);
+        assert.equal(changes[0].enabled, true);
+        assert.equal(changes[1].enabled, false);
+        assert.equal(changes[0].sessionId, "master");
+        assert.equal(changes[0].instanceId, "inst");
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager lifecycle", () => {
+    it("clearInstance drops tree and enabled state for the instance", () => {
+        const bus = new EventBus(noopLogger);
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier() });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "master", parentID: null });
+        manager.toggle("inst", "master");
+        manager.clearInstance("inst");
+        assert.equal(manager.isEnabled("inst", "master"), false);
+        manager.stop();
+    });
+    it("clears state when the workspace stops", () => {
+        const bus = new EventBus(noopLogger);
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier() });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "master", parentID: null });
+        manager.toggle("inst", "master");
+        bus.publish({ type: "workspace.stopped", workspaceId: "inst" });
+        assert.equal(manager.isEnabled("inst", "master"), false);
+        manager.stop();
+    });
+    it("stop() unsubscribes so no further events are processed", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        manager.stop();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "p", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+    });
+});
+describe("AutoAcceptManager pending permissions drain", () => {
+    it("drains a pending permission that arrived before enable", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        // permission arrives while yolo is OFF
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-pending", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        // enabling yolo should drain the pending permission
+        manager.toggle("inst", "solo");
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        assert.equal(replier.calls[0].permissionId, "perm-pending");
+        manager.stop();
+    });
+    it("drains pending permissions for the same family only", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "root-a", parentID: null });
+        publishSession(bus, "inst", "session.updated", { id: "root-b", parentID: null });
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-a", sessionID: "root-a" },
+        });
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-b", sessionID: "root-b" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        manager.toggle("inst", "root-a");
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        assert.equal(replier.calls[0].permissionId, "perm-a");
+        manager.stop();
+    });
+    it("does not re-drain already-auto-accepted permissions", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-1", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        // toggling off then on should not re-drain the already-replied permission
+        manager.toggle("inst", "solo"); // off
+        manager.toggle("inst", "solo"); // on — drain runs but pending set is empty
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        manager.stop();
+    });
+    it("re-drains pending when late session ancestry joins an enabled family", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        // master exists, yolo enabled on master
+        publishSession(bus, "inst", "session.updated", { id: "master", parentID: null });
+        manager.toggle("inst", "master");
+        // child permission arrives BEFORE child's session ancestry is known.
+        // At this point "child" is unknown to the tree, so it resolves as its
+        // own root and the permission is NOT auto-accepted.
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-late", sessionID: "child" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        // child session ancestry arrives — child.parentID = "master".
+        // ingestSession → upsertSession → migrateEnabledRoots makes "child"
+        // resolve to "master" (enabled). drainPending should fire and accept
+        // the previously-pending permission.
+        publishSession(bus, "inst", "session.updated", { id: "child", parentID: "master" });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        assert.equal(replier.calls[0].permissionId, "perm-late");
+        assert.equal(replier.calls[0].sessionId, "child");
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager permission replied cleanup", () => {
+    it("removes a pending permission on permission.v2.replied", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-x", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        // user manually replies → replied event cleans up pending
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.replied",
+            properties: { id: "perm-x" },
+        });
+        // enabling yolo now should NOT drain the already-replied permission
+        manager.toggle("inst", "solo");
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        manager.stop();
+    });
+    it("removes a pending permission on legacy permission.replied", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.asked",
+            properties: { id: "perm-y", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.replied",
+            properties: { requestID: "perm-y" },
+        });
+        manager.toggle("inst", "solo");
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager clearInstance clears pending", () => {
+    it("drops pending permissions on clearInstance", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-z", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        manager.clearInstance("inst");
+        // re-create session and enable — pending set should be empty
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager permission.updated source inference", () => {
+    it("preserves the original v2 source when permission.updated arrives", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        // yolo is OFF — permission goes to pending with source "v2"
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-v2", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        // enable yolo, then send permission.updated — should keep source "v2"
+        manager.toggle("inst", "solo");
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.updated",
+            properties: { id: "perm-v2", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 1);
+        assert.equal(replier.calls[0].source, "v2");
+        manager.stop();
+    });
+    it("skips permission.updated for a permission not in pending", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        // permission.updated for a permission that was never asked (not in pending)
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.updated",
+            properties: { id: "perm-unknown", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager replier failure handling", () => {
+    it("keeps permission pending and does not emit autoAccepted on failure", async () => {
+        const bus = new EventBus(noopLogger);
+        const autoAccepted = [];
+        bus.on("yolo.autoAccepted", (e) => autoAccepted.push(e));
+        const failingReplier = async () => {
+            throw new Error("connection refused");
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: failingReplier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-fail", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        assert.equal(autoAccepted.length, 0);
+        // permission should still be pending (enabling again would try again)
+        manager.toggle("inst", "solo"); // off
+        manager.toggle("inst", "solo"); // on — drain retries
+        await flushMicrotasks();
+        assert.equal(autoAccepted.length, 0);
+        manager.stop();
+    });
+    it("stops retrying after MAX_REPLY_ATTEMPTS", async () => {
+        const bus = new EventBus(noopLogger);
+        let callCount = 0;
+        const failingReplier = async () => {
+            callCount++;
+            throw new Error("timeout");
+        };
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: failingReplier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-stuck", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        const attemptsAfterFirst = callCount;
+        // trigger drains via session events
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        await flushMicrotasks();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        await flushMicrotasks();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        await flushMicrotasks();
+        // should have attempted at most MAX_REPLY_ATTEMPTS times total
+        assert.ok(callCount <= 3, `expected at most 3 attempts, got ${callCount}`);
+        assert.equal(callCount, attemptsAfterFirst + 2); // 2 more retries (total 3), then stops
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager workspace.error cleanup", () => {
+    it("clears state when the workspace errors", () => {
+        const bus = new EventBus(noopLogger);
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier: makeRecordingReplier() });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        manager.toggle("inst", "solo");
+        assert.equal(manager.isEnabled("inst", "solo"), true);
+        bus.publish({ type: "workspace.error", workspace: { id: "inst" } });
+        assert.equal(manager.isEnabled("inst", "solo"), false);
+        manager.stop();
+    });
+});
+describe("AutoAcceptManager session.deleted clears pending", () => {
+    it("removes pending permissions for a deleted session", async () => {
+        const bus = new EventBus(noopLogger);
+        const replier = makeRecordingReplier();
+        const manager = new AutoAcceptManager({ eventBus: bus, logger: noopLogger, replier });
+        manager.start();
+        publishSession(bus, "inst", "session.updated", { id: "solo", parentID: null });
+        // permission arrives while yolo is OFF → goes to pending
+        publishInstanceEvent(bus, "inst", {
+            type: "permission.v2.asked",
+            properties: { id: "perm-doomed", sessionID: "solo" },
+        });
+        await flushMicrotasks();
+        // session deleted → pending should be cleared
+        publishSession(bus, "inst", "session.deleted", { id: "solo" });
+        // enabling yolo should not drain the deleted session's permission
+        manager.toggle("inst", "solo");
+        await flushMicrotasks();
+        assert.equal(replier.calls.length, 0);
+        manager.stop();
+    });
+});
+function makeRecordingReplier() {
+    const calls = [];
+    const replier = async (reply) => {
+        calls.push(reply);
+    };
+    return Object.assign(replier, { calls });
+}
+function flushMicrotasks() {
+    return new Promise((resolve) => setImmediate(resolve));
+}

package/dist/permissions/auto-accept-store.js

@@ -0,0 +1,115 @@
+/**
+ * In-memory permission auto-accept (Yolo) state, owned by the server.
+ *
+ * This is a faithful port of the previous frontend implementation
+ * (`packages/ui/src/stores/permission-auto-accept.ts`) so the inheritance
+ * semantics are preserved exactly:
+ *   - state is keyed by the resolved *family root* session id
+ *   - a session with a `revert` snapshot is treated as its own root (fork)
+ *   - enabling any session enables its whole family root and vice-versa
+ *
+ * No persistence: state is lost on server restart, matching the "no
+ * persistence for now" milestone.
+ */
+/**
+ * Resolve the family-root session id for `sessionId` by walking the parent
+ * chain. Mirrors `resolvePermissionAutoAcceptFamilyRoot` from the UI so
+ * inheritance behaviour does not change.
+ */
+export function resolveFamilyRoot(sessionId, getSession) {
+    let currentId = sessionId;
+    let lastKnownId = sessionId;
+    const seen = new Set();
+    while (currentId && !seen.has(currentId)) {
+        seen.add(currentId);
+        const session = getSession(currentId);
+        if (!session)
+            return lastKnownId;
+        lastKnownId = session.id;
+        if (session.revert)
+            return session.id;
+        if (!session.parentId)
+            return session.id;
+        currentId = session.parentId;
+    }
+    return currentId || sessionId;
+}
+export class AutoAcceptStore {
+    constructor() {
+        /** instanceId -> set of enabled family-root session ids */
+        this.enabled = new Map();
+        /** instanceId -> (sessionId -> info) */
+        this.sessions = new Map();
+    }
+    isEnabled(instanceId, sessionId) {
+        const root = this.familyRoot(instanceId, sessionId);
+        return this.enabled.get(instanceId)?.has(root) ?? false;
+    }
+    setEnabled(instanceId, sessionId, enabled) {
+        const root = this.familyRoot(instanceId, sessionId);
+        let roots = this.enabled.get(instanceId);
+        if (!roots) {
+            if (!enabled)
+                return;
+            roots = new Set();
+            this.enabled.set(instanceId, roots);
+        }
+        if (enabled) {
+            roots.add(root);
+        }
+        else {
+            roots.delete(root);
+            if (roots.size === 0) {
+                this.enabled.delete(instanceId);
+            }
+        }
+    }
+    toggle(instanceId, sessionId) {
+        const next = !this.isEnabled(instanceId, sessionId);
+        this.setEnabled(instanceId, sessionId, next);
+        return next;
+    }
+    upsertSession(instanceId, info) {
+        let tree = this.sessions.get(instanceId);
+        if (!tree) {
+            tree = new Map();
+            this.sessions.set(instanceId, tree);
+        }
+        tree.set(info.id, {
+            id: info.id,
+            parentId: info.parentId ?? null,
+            revert: info.revert,
+        });
+        this.migrateEnabledRoots(instanceId);
+    }
+    removeSession(instanceId, sessionId) {
+        this.sessions.get(instanceId)?.delete(sessionId);
+    }
+    clearInstance(instanceId) {
+        this.sessions.delete(instanceId);
+        this.enabled.delete(instanceId);
+    }
+    /** Resolves the family-root session id for the given session. */
+    familyRoot(instanceId, sessionId) {
+        const tree = this.sessions.get(instanceId);
+        return resolveFamilyRoot(sessionId, (id) => tree?.get(id));
+    }
+    /**
+     * Re-resolves every enabled family root for an instance after the session
+     * tree changes (new session, updated parent/revert). If a root now resolves
+     * to a different id, the enabled entry is migrated so toggles survive late
+     * ancestry discovery.
+     */
+    migrateEnabledRoots(instanceId) {
+        const roots = this.enabled.get(instanceId);
+        if (!roots || roots.size === 0)
+            return;
+        for (const oldRoot of Array.from(roots)) {
+            const newRoot = this.familyRoot(instanceId, oldRoot);
+            if (newRoot !== oldRoot) {
+                roots.delete(oldRoot);
+                roots.add(newRoot);
+            }
+        }
+    }
+}