@someonegg/agent-hub 0.0.0-stage → 0.7.0

package/dist/server/server/management/operation-service.js

@@ -0,0 +1,307 @@
+import { randomUUID } from "node:crypto";
+import { paneBindings } from "../interaction/pane-binding-manager.js";
+import { attachCommand } from "../interaction/tmux-launcher.js";
+import { AssociationError, } from "./operation-state.js";
+import { SessionLaunchExecutor } from "./session-launch-executor.js";
+import { SessionLifecycleExecutor } from "./session-lifecycle-executor.js";
+import { LAUNCH_ATTACH_DELAY_MS, SessionLaunchError, } from "./session-manager.js";
+export class ManagementError extends Error {
+    status;
+    code;
+    constructor(status, message, code = "management_error") {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+export class OperationService {
+    sessions;
+    interaction;
+    managers;
+    now;
+    waitMs;
+    #entries = new Map();
+    #requests = new Map();
+    #active = new Map();
+    #results = new Map();
+    #timer;
+    #closed = false;
+    #launch;
+    #lifecycle;
+    constructor(sessions, interaction, managers, options = {}) {
+        this.sessions = sessions;
+        this.interaction = interaction;
+        this.managers = managers;
+        const { now = Date.now, waitMs = { create: 60_000, exit: 30_000, archive: 30_000, delete: 30_000 }, bindings = paneBindings, runtime, uploads, } = options;
+        this.now = now;
+        this.waitMs = waitMs;
+        const control = {
+            pending: (entry) => this.#pending(entry),
+            transition: (entry, context, deadline) => this.#transition(entry, context, deadline),
+            finish: (entry, status, error) => this.#finish(entry, status, error),
+            error: (entry, error) => this.#error(entry, error),
+            timeout: (entry) => this.#timeout(entry),
+            observe: (entry) => this.#observe(entry),
+        };
+        this.#launch = new SessionLaunchExecutor(sessions, interaction, managers, bindings, control, now, waitMs, runtime);
+        this.#lifecycle = new SessionLifecycleExecutor(sessions, interaction, managers, control, now, waitMs, uploads);
+        this.#timer = setInterval(() => {
+            void this.poll();
+        }, 1_000);
+        this.#timer.unref();
+    }
+    create(input) {
+        if (input.resumeSessionId !== undefined)
+            return this.#resume(input);
+        let agent;
+        try {
+            agent = this.managers.resolveCreateAgent(input.agent);
+        }
+        catch (error) {
+            throw new ManagementError(400, error.message);
+        }
+        const fingerprint = JSON.stringify([
+            agent,
+            "create",
+            input.projectDirectory,
+            input.taskName?.trim() || null,
+            input.workingDirectory ?? input.projectDirectory,
+            input.worktree,
+            input.yolo ?? false,
+        ]);
+        const duplicate = this.#duplicate(input.requestId, fingerprint);
+        if (duplicate)
+            return { ...duplicate };
+        const entry = this.#new("create", null);
+        entry.metadata.mode = "new";
+        entry.agent = agent;
+        this.#requests.set(input.requestId, { fingerprint, operationId: entry.metadata.operationId });
+        void this.#launch.create(entry, input);
+        return this.#project(entry);
+    }
+    #resume(input) {
+        if (Object.keys(input).some((key) => !["resumeSessionId", "yolo", "requestId"].includes(key)) ||
+            !input.resumeSessionId.trim())
+            throw new ManagementError(400, "Resume accepts only resumeSessionId, yolo and requestId");
+        const sessionId = input.resumeSessionId;
+        const fingerprint = JSON.stringify(["resume", sessionId, input.yolo ?? false]);
+        const duplicate = this.#duplicate(input.requestId, fingerprint);
+        if (duplicate)
+            return { ...duplicate };
+        if (this.#active.has(sessionId))
+            throw new ManagementError(409, "Another management operation is running for this session");
+        const entry = this.#new("create", sessionId);
+        entry.metadata.mode = "resume";
+        this.#active.set(sessionId, entry);
+        this.interaction.setBusy(sessionId, true);
+        this.#requests.set(input.requestId, { fingerprint, operationId: entry.metadata.operationId });
+        void this.#launch.resume(entry, input);
+        return this.#project(entry);
+    }
+    async assertSupported(type, sessionId) {
+        if (type !== "archive")
+            return;
+        const session = (await this.sessions.managementSnapshot()).byId.get(sessionId);
+        if (session && typeof this.managers.get(session.origin.agent).archive !== "function")
+            throw new ManagementError(409, "Operation is not supported by this session source", "operation_not_supported");
+    }
+    manage(type, sessionId) {
+        const active = this.#active.get(sessionId);
+        if (active) {
+            if (active.metadata.type !== type)
+                throw new ManagementError(409, "Another management operation is running for this session");
+            return this.#project(active);
+        }
+        const entry = this.#new(type, sessionId);
+        this.#active.set(sessionId, entry);
+        this.interaction.setBusy(sessionId, true);
+        this.#transition(entry, { kind: "manage", phase: "resolving" }, this.now() +
+            (type === "exit" ? (this.waitMs.exit ?? this.waitMs.archive) : this.waitMs[type]));
+        void this.#lifecycle.manage(entry, type, sessionId);
+        return this.#project(entry);
+    }
+    async get(id) {
+        this.#prune();
+        const operation = this.#results.get(id) ?? this.#lookup(id);
+        return operation ? { ...operation } : null;
+    }
+    async poll() {
+        if (this.#closed)
+            return;
+        this.#prune();
+        const checks = [];
+        for (const entry of this.#entries.values()) {
+            this.#timeout(entry);
+            if (!this.#pending(entry))
+                continue;
+            const context = entry.stage;
+            if (context.kind === "create" &&
+                context.phase === "observing" &&
+                this.now() - context.startedAt >= LAUNCH_ATTACH_DELAY_MS) {
+                this.#attach(entry, attachCommand(context.target.socketPath, `ahub-${entry.metadata.operationId}`));
+            }
+            if ((context.kind === "create" && context.phase === "observing") ||
+                context.kind === "exiting" ||
+                ((context.kind === "archive" || context.kind === "delete") &&
+                    context.phase === "confirming")) {
+                checks.push(this.#observe(entry));
+            }
+        }
+        await Promise.all(checks);
+    }
+    close() {
+        clearInterval(this.#timer);
+        for (const entry of this.#entries.values())
+            this.#finish(entry, "unknown", "Server stopped tracking the operation");
+        this.#closed = true;
+    }
+    #observe(entry) {
+        if (entry.checking)
+            return entry.checking;
+        entry.checking = this.#check(entry).finally(() => {
+            entry.checking = undefined;
+        });
+        return entry.checking;
+    }
+    async #check(entry) {
+        if (!this.#pending(entry))
+            return;
+        try {
+            if (entry.stage.kind === "create")
+                await this.#launch.observe(entry);
+            else
+                await this.#lifecycle.observe(entry);
+        }
+        catch (error) {
+            // Read failures never prove disappearance or justify another command.
+            if (error instanceof AssociationError)
+                this.#finish(entry, "unknown", error.message);
+        }
+        this.#timeout(entry);
+    }
+    #transition(entry, context, deadline = entry.stage?.deadline ?? null) {
+        if (!this.#pending(entry))
+            return;
+        const previous = operationPhase(entry.stage);
+        entry.stage = { ...context, deadline };
+        if (context.kind === "create" && context.phase === "observing")
+            entry.metadata.target = context.target;
+        if (previous !== operationPhase(entry.stage))
+            entry.metadata.updatedAt = new Date(this.now()).toISOString();
+    }
+    #lookup(id) {
+        const entry = this.#entries.get(id);
+        return entry ? this.#project(entry) : undefined;
+    }
+    #project(entry) {
+        if (entry.result)
+            return { ...entry.result };
+        const context = entry.stage;
+        if (!context)
+            throw new Error("Pending operation has no execution stage");
+        return { ...entry.metadata, phase: operationPhase(context), status: "pending", error: null };
+    }
+    #attach(entry, command) {
+        if (!this.#pending(entry) || entry.metadata.attachCommand === command)
+            return;
+        entry.metadata.attachCommand = command;
+        entry.metadata.updatedAt = new Date(this.now()).toISOString();
+    }
+    #pending(entry) {
+        return !this.#closed && !entry.result && entry.stage !== null;
+    }
+    #timeout(entry) {
+        if (this.#pending(entry) &&
+            entry.stage.deadline !== null &&
+            this.now() >= entry.stage.deadline) {
+            this.#finish(entry, "unknown", entry.metadata.type === "create"
+                ? "No agent session detected. Tracking has stopped. Attach to tmux or refresh the session list to check the result; creating again may start another session."
+                : "Timed out; result is unknown. Refresh the session list before submitting again.");
+        }
+    }
+    #error(entry, error) {
+        if (error instanceof SessionLaunchError) {
+            this.#attach(entry, error.attachCommand);
+            if (error.target)
+                entry.metadata.target = error.target;
+            this.#finish(entry, error.outcome === "unknown" ? "unknown" : "failed", error.message);
+            return;
+        }
+        const timedOut = !!error &&
+            typeof error === "object" &&
+            (("killed" in error && error.killed) || ("code" in error && error.code === "timeout"));
+        this.#finish(entry, timedOut ? "unknown" : "failed", error instanceof Error ? error.message : String(error));
+    }
+    #finish(entry, status, error) {
+        if (entry.result)
+            return;
+        const context = entry.stage;
+        if (context?.kind === "create" && context.phase === "observing" && status === "unknown") {
+            entry.metadata.attachCommand = attachCommand(context.target.socketPath, `ahub-${entry.metadata.operationId}`);
+        }
+        entry.metadata.updatedAt = new Date(this.now()).toISOString();
+        entry.result = Object.freeze({ ...this.#project(entry), status, error });
+        entry.stage = null;
+        this.#results.set(entry.metadata.operationId, entry.result);
+        this.#entries.delete(entry.metadata.operationId);
+        const sessionId = entry.metadata.sessionId;
+        if (sessionId && this.#active.get(sessionId) === entry) {
+            this.#active.delete(sessionId);
+            this.interaction.setBusy(sessionId, false);
+        }
+    }
+    #new(type, sessionId) {
+        if (this.#closed)
+            throw new ManagementError(503, "Server stopped tracking operations");
+        this.#prune();
+        const timestamp = new Date(this.now()).toISOString();
+        const entry = {
+            metadata: {
+                attachCommand: null,
+                operationId: randomUUID(),
+                type,
+                sessionId,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+            },
+            agent: this.managers.defaultAgent,
+            stage: type === "create"
+                ? { kind: "create", phase: "resolving", deadline: null }
+                : { kind: "manage", phase: "resolving", deadline: null },
+        };
+        this.#entries.set(entry.metadata.operationId, entry);
+        return entry;
+    }
+    #duplicate(requestId, fingerprint) {
+        if (!/^[A-Za-z0-9_-]{8,128}$/.test(requestId))
+            throw new ManagementError(400, "requestId must contain 8–128 letters, digits, underscores or hyphens");
+        this.#prune();
+        const record = this.#requests.get(requestId);
+        if (record && record.fingerprint !== fingerprint)
+            throw new ManagementError(409, "requestId was already used with different parameters");
+        return record
+            ? (this.#results.get(record.operationId) ?? this.#lookup(record.operationId))
+            : undefined;
+    }
+    #prune() {
+        const now = this.now();
+        for (const [id, operation] of this.#results) {
+            if (now - Date.parse(operation.updatedAt) >= 30 * 60_000)
+                this.#results.delete(id);
+        }
+        for (const [requestId, record] of this.#requests) {
+            if (!this.#entries.has(record.operationId) && !this.#results.has(record.operationId))
+                this.#requests.delete(requestId);
+        }
+    }
+}
+function operationPhase(context) {
+    if (context.kind === "exiting")
+        return context.task.phase;
+    if (context.kind === "archive")
+        return context.phase === "confirming" ? "confirming_archive" : "archiving";
+    if (context.kind === "delete")
+        return context.phase === "confirming" ? "confirming_delete" : "deleting";
+    return null;
+}
+//# sourceMappingURL=operation-service.js.map

package/dist/server/server/management/operation-state.js

@@ -0,0 +1,3 @@
+export class AssociationError extends Error {
+}
+//# sourceMappingURL=operation-state.js.map

package/dist/server/server/management/session-exit-service.js

@@ -0,0 +1,50 @@
+export class SessionExitService {
+    interaction;
+    now;
+    timing;
+    constructor(interaction, now = Date.now, timing = { eofDelayMs: 3_200, killDelayMs: 9_000 }) {
+        this.interaction = interaction;
+        this.now = now;
+        this.timing = timing;
+    }
+    start(sessionId, target, capability, assertActive) {
+        const steps = [
+            ...capability.exitSteps().map((step) => ({ ...step, keys: [...step.keys] })),
+            { keys: ["C-d"], delayMs: this.timing.eofDelayMs },
+        ];
+        let index = 0;
+        let due = this.now() + steps[0].delayMs;
+        let killed = false;
+        let phase = "sending_exit";
+        return {
+            get phase() {
+                return phase;
+            },
+            advance: async () => {
+                assertActive();
+                const state = await this.interaction.inspectTarget(target, sessionId);
+                assertActive();
+                if (state === "exited")
+                    return true;
+                if (this.now() < due || killed)
+                    return false;
+                const step = steps[index];
+                if (step) {
+                    await this.interaction.sendExitKeys(target, sessionId, step.keys, assertActive);
+                    assertActive();
+                    index++;
+                    phase = index < steps.length - 1 ? "sending_exit" : "waiting_exit";
+                    due = this.now() + (steps[index]?.delayMs ?? this.timing.killDelayMs);
+                }
+                else {
+                    // Claim before awaiting: an uncertain kill is never retried.
+                    killed = true;
+                    await this.interaction.killTarget(target, sessionId, assertActive);
+                    assertActive();
+                }
+                return false;
+            },
+        };
+    }
+}
+//# sourceMappingURL=session-exit-service.js.map

package/dist/server/server/management/session-launch-executor.js

@@ -0,0 +1,164 @@
+import { AssociationError, } from "./operation-state.js";
+/** Adapter launch and association checks; OperationService owns idempotency and occupancy. */
+export class SessionLaunchExecutor {
+    sessions;
+    interaction;
+    managers;
+    bindings;
+    control;
+    now;
+    waitMs;
+    runtime;
+    constructor(sessions, interaction, managers, bindings, control, now, waitMs, runtime) {
+        this.sessions = sessions;
+        this.interaction = interaction;
+        this.managers = managers;
+        this.bindings = bindings;
+        this.control = control;
+        this.now = now;
+        this.waitMs = waitMs;
+        this.runtime = runtime;
+    }
+    async create(entry, input) {
+        try {
+            const manager = this.managers.get(entry.agent);
+            const project = await manager.resolveDirectory(input.projectDirectory);
+            const working = input.workingDirectory === undefined || input.workingDirectory === input.projectDirectory
+                ? project
+                : await manager.resolveDirectory(input.workingDirectory);
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, { kind: "create", phase: "launching" });
+            const target = await manager.launch({
+                operationId: entry.metadata.operationId,
+                workingDirectory: working.directory,
+                worktree: input.worktree,
+                yolo: input.yolo ?? false,
+                projectDirectory: project.directory,
+                ...(input.taskName?.trim() ? { taskName: input.taskName.trim() } : {}),
+            });
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, {
+                kind: "create",
+                phase: "observing",
+                project: project.directory,
+                target,
+                startedAt: this.now(),
+            }, this.now() + this.waitMs.create);
+        }
+        catch (error) {
+            this.control.error(entry, error);
+        }
+    }
+    async resume(entry, input) {
+        const sessionId = input.resumeSessionId;
+        try {
+            if (!this.runtime)
+                throw new Error("Resume is unavailable");
+            const snapshot = await this.sessions.managementSnapshot();
+            const session = snapshot.byId.get(sessionId);
+            if (!session)
+                throw new Error("Session not found");
+            const attempt = this.bindings.latest(session.id);
+            const replacement = this.bindings.replacement(session.id);
+            const capability = await this.runtime.evaluate(session);
+            if (!capability.resume.allowed)
+                throw new Error(capability.resume.reason);
+            entry.agent = session.origin.agent;
+            entry.resumeNativeId = session.sourceId ?? undefined;
+            const manager = this.managers.get(entry.agent);
+            const directory = capability.directory;
+            if (attempt !== this.bindings.latest(session.id) ||
+                replacement !== this.bindings.replacement(session.id))
+                throw new Error("Session binding changed during validation");
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, { kind: "create", phase: "launching" });
+            const target = await manager.launch({
+                operationId: entry.metadata.operationId,
+                workingDirectory: directory,
+                worktree: false,
+                yolo: input.yolo ?? false,
+                resumeNativeId: session.sourceId,
+                projectDirectory: session.projectDirectory,
+                ...(session.taskName ? { taskName: session.taskName } : {}),
+            });
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, {
+                kind: "create",
+                phase: "observing",
+                target,
+                project: session.projectDirectory ?? directory,
+                startedAt: this.now(),
+            }, this.now() + this.waitMs.create);
+        }
+        catch (error) {
+            this.control.error(entry, error);
+        }
+    }
+    async observe(entry) {
+        const snapshot = await this.sessions.managementSnapshot();
+        if (!this.control.pending(entry))
+            return;
+        const context = entry.stage;
+        if (context.kind !== "create" || context.phase !== "observing")
+            return;
+        const matches = snapshot.sessions.filter((session) => {
+            const attempt = this.bindings.latest(session.id);
+            return (session.origin.agent === entry.agent &&
+                attempt?.valid &&
+                attempt.operationId === entry.metadata.operationId);
+        });
+        if (matches.length > 1)
+            throw new AssociationError("Multiple sessions claimed this operation ID");
+        const match = matches[0];
+        if (!match)
+            return;
+        if (entry.metadata.mode === "resume" &&
+            (match.id !== entry.metadata.sessionId ||
+                match.archived ||
+                match.sourceId !== entry.resumeNativeId ||
+                !match.sourceId))
+            throw new AssociationError("Resume did not bind the original session");
+        const attempt = this.bindings.latest(match.id);
+        if (!attempt?.valid ||
+            attempt.socketPath !== context.target.socketPath ||
+            attempt.sessionName !== context.target.sessionName ||
+            match.projectDirectory !== context.project) {
+            throw new AssociationError("Binding does not match the launched target/project");
+        }
+        const binding = await this.interaction.describe(match.id);
+        if (!this.control.pending(entry))
+            return;
+        if (binding?.supported && binding.state === "unknown")
+            return;
+        if (!binding?.supported || binding.state !== "connected")
+            throw new AssociationError("The new session binding failed validation");
+        const matchesTarget = await this.interaction.matchesTarget(match.id, context.target);
+        if (!this.control.pending(entry))
+            return;
+        if (!matchesTarget)
+            throw new AssociationError("Binding does not match the launched target");
+        entry.metadata.sessionId = match.id;
+        if (this.managers.get(entry.agent).interruptAfterBinding) {
+            try {
+                await this.interaction.interruptLaunch(context.target, match.id, () => {
+                    if (!this.control.pending(entry))
+                        throw new Error("Launch operation is no longer active");
+                    if (this.bindings.latest(match.id) !== attempt)
+                        throw new Error("Launch binding changed before interrupt");
+                });
+            }
+            catch (error) {
+                this.control.finish(entry, "unknown", error instanceof Error ? error.message : String(error));
+                return;
+            }
+            if (!this.control.pending(entry))
+                return;
+        }
+        this.control.finish(entry, "succeeded", null);
+    }
+}
+//# sourceMappingURL=session-launch-executor.js.map

package/dist/server/server/management/session-lifecycle-executor.js

@@ -0,0 +1,158 @@
+import { SessionExitService } from "./session-exit-service.js";
+/** Exit, archive and delete execution, including confirmation of native effects. */
+export class SessionLifecycleExecutor {
+    sessions;
+    interaction;
+    managers;
+    control;
+    now;
+    waitMs;
+    uploads;
+    #exit;
+    constructor(sessions, interaction, managers, control, now, waitMs, uploads) {
+        this.sessions = sessions;
+        this.interaction = interaction;
+        this.managers = managers;
+        this.control = control;
+        this.now = now;
+        this.waitMs = waitMs;
+        this.uploads = uploads;
+        this.#exit = new SessionExitService(interaction, now);
+    }
+    async manage(entry, type, sessionId) {
+        try {
+            const snapshot = await this.sessions.managementSnapshot();
+            if (!this.control.pending(entry))
+                return;
+            const session = snapshot.byId.get(sessionId);
+            if (!session) {
+                if (type === "delete") {
+                    this.control.finish(entry, "succeeded", null);
+                    this.#cleanup(sessionId);
+                    return;
+                }
+                throw new Error("Session not found");
+            }
+            entry.agent = session.origin.agent;
+            const manager = this.managers.get(entry.agent);
+            if (type === "archive" && typeof manager.archive !== "function")
+                throw new Error("operation_not_supported: Operation is not supported by this session source");
+            if (type === "archive" && session.archived) {
+                this.control.finish(entry, "succeeded", null);
+                return;
+            }
+            if (type === "exit") {
+                await this.#startExit(entry, sessionId, null);
+                return;
+            }
+            const nativeId = session.sourceId;
+            if (!nativeId?.trim())
+                throw new Error("Session has no valid native identity");
+            await this.#startExit(entry, sessionId, { type, nativeId });
+            if (this.control.pending(entry))
+                await this.control.observe(entry);
+        }
+        catch (error) {
+            this.control.error(entry, error);
+        }
+    }
+    async observe(entry) {
+        if (!this.control.pending(entry))
+            return;
+        let context = entry.stage;
+        if (context.kind === "exiting") {
+            try {
+                // Refresh adapter bindings before observing or acting on the fixed target.
+                await this.sessions.managementSnapshot();
+                if (!this.control.pending(entry))
+                    return;
+                const phase = context.task.phase;
+                const exited = await context.task.advance();
+                if (!this.control.pending(entry))
+                    return;
+                if (phase !== context.task.phase)
+                    entry.metadata.updatedAt = new Date(this.now()).toISOString();
+                if (!exited)
+                    return;
+                if (context.next === null) {
+                    this.control.finish(entry, "succeeded", null);
+                    return;
+                }
+                await this.#nativeOperation(entry, context.next);
+                if (!this.control.pending(entry))
+                    return;
+            }
+            catch (error) {
+                if (this.control.pending(entry))
+                    this.control.finish(entry, "unknown", error instanceof Error ? error.message : String(error));
+                return;
+            }
+        }
+        const snapshot = await this.sessions.managementSnapshot();
+        if (!this.control.pending(entry))
+            return;
+        context = entry.stage;
+        if ((context.kind === "archive" || context.kind === "delete") &&
+            context.phase === "confirming") {
+            const matches = this.#matches(snapshot, entry, context.nativeId);
+            if ((context.kind === "archive" && matches.length === 1 && matches[0]?.archived) ||
+                (context.kind === "delete" && matches.length === 0)) {
+                this.control.finish(entry, "succeeded", null);
+                if (context.kind === "delete" && entry.metadata.sessionId)
+                    this.#cleanup(entry.metadata.sessionId);
+            }
+        }
+    }
+    #cleanup(id) {
+        void Promise.resolve()
+            .then(() => this.uploads?.cleanup(id))
+            .catch((error) => {
+            console.error("Session attachment cleanup failed", { sessionId: id, error });
+        });
+    }
+    async #startExit(entry, sessionId, next) {
+        const target = await this.interaction.resolveTarget(sessionId);
+        if (!this.control.pending(entry))
+            return;
+        if (!target) {
+            if (next === null)
+                this.control.finish(entry, "succeeded", null);
+            else
+                await this.#nativeOperation(entry, next);
+            return;
+        }
+        const task = this.#exit.start(sessionId, target, this.managers.get(entry.agent), () => {
+            this.control.timeout(entry);
+            if (!this.control.pending(entry))
+                throw new Error("Exit operation is no longer active");
+        });
+        this.control.transition(entry, { kind: "exiting", task, next }, this.now() + (this.waitMs.exit ?? this.waitMs.archive));
+        await this.control.observe(entry);
+    }
+    async #nativeOperation(entry, { type, nativeId }) {
+        if (!this.control.pending(entry))
+            return;
+        this.control.transition(entry, type === "archive"
+            ? { kind: type, phase: "archiving", nativeId }
+            : { kind: type, phase: "deleting", nativeId }, this.now() + 25_000);
+        try {
+            const manager = this.managers.get(entry.agent);
+            if (type === "archive")
+                await manager.archive(nativeId);
+            else
+                await manager.delete(nativeId);
+            if (!this.control.pending(entry))
+                return;
+            this.control.transition(entry, { kind: type, phase: "confirming", nativeId }, this.now() + this.waitMs[type]);
+        }
+        catch (error) {
+            if (!this.control.pending(entry))
+                return;
+            this.control.error(entry, error);
+        }
+    }
+    #matches(snapshot, entry, nativeId) {
+        return snapshot.sessions.filter((session) => session.origin.agent === entry.agent && session.sourceId === nativeId);
+    }
+}
+//# sourceMappingURL=session-lifecycle-executor.js.map