@openrig/cli 0.5.8 → 0.5.9

package/daemon/dist/domain/seat-lifecycle-service.js

@@ -1,5 +1,8 @@
-import { getNodeInventory } from "./node-inventory.js";
-import { parseSessionName } from "./session-name.js";
+import { deriveCanonicalFromEntry, getNodeInventory } from "./node-inventory.js";
+import { deriveSessionName, parseSessionName } from "./session-name.js";
+import { rebindAndVerifyPaneIdentity } from "./seat-attention-reconciler.js";
+import { observeSolePane } from "./pane-binding-observation.js";
+import { createHash } from "node:crypto";
 /**
  * S5 (OPR.0.5.4.7) — the seat-lifecycle verb surface: set-model, single-seat stop,
  * dead-session clean. One coherent design (KI-5.3-9):
@@ -23,6 +26,11 @@ export class SeatLifecycleService {
     sessionRegistry;
     eventBus;
     tmuxAdapter;
+    nodeLauncher;
+    startupOrchestrator;
+    runtimeAdapters;
+    occupantInvalidator;
+    activityOracle;
     constructor(deps) {
         if (deps.db !== deps.rigRepo.db)
             throw new Error("SeatLifecycleService: rigRepo must share the same db handle");
@@ -35,6 +43,11 @@ export class SeatLifecycleService {
         this.sessionRegistry = deps.sessionRegistry;
         this.eventBus = deps.eventBus;
         this.tmuxAdapter = deps.tmuxAdapter;
+        this.nodeLauncher = deps.nodeLauncher ?? null;
+        this.startupOrchestrator = deps.startupOrchestrator ?? null;
+        this.runtimeAdapters = deps.runtimeAdapters ?? {};
+        this.occupantInvalidator = deps.occupantInvalidator ?? null;
+        this.activityOracle = deps.activityOracle ?? null;
     }
     async setModel(input) {
         const required = this.requireReason(input.reason);
@@ -106,32 +119,7 @@ export class SeatLifecycleService {
                 guidance: "A dead seat with stale records is returned to launchable with: rig seat clean",
             };
         }
-        // Kill exactly this seat's own tmux session — structurally single-seat.
-        const kill = await this.tmuxAdapter.killSession(session.session_name);
-        if (kill && !kill.ok && kill.code !== "session_not_found") {
-            return {
-                ok: false,
-                code: "tmux_probe_failed",
-                message: `tmux kill-session for "${session.session_name}" failed: ${kill.message ?? kill.code}`,
-            };
-        }
-        let persisted = null;
-        const tx = this.db.transaction(() => {
-            this.sessionRegistry.updateStatus(session.id, "exited");
-            this.sessionRegistry.clearBinding(resolved.nodeId);
-            persisted = this.eventBus.persistWithinTransaction({
-                type: "session.stopped",
-                rigId: seat.rigId,
-                nodeId: seat.nodeId,
-                sessionName: session.session_name,
-                reason: input.reason.trim(),
-                operator: input.operator ?? null,
-            });
-        });
-        tx();
-        if (persisted)
-            this.eventBus.notifySubscribers(persisted);
-        return { ok: true, seat, sessionName: session.session_name, sessionId: session.id };
+        return this.stopManagedTmuxSeat(resolved, session, input.reason, input.operator);
     }
     async cleanSeat(input) {
         const required = this.requireReason(input.reason);
@@ -209,7 +197,492 @@ export class SeatLifecycleService {
             this.eventBus.notifySubscribers(persisted);
         return { ok: true, seat, actions: { sessionsExited, bindingCleared: binding !== null } };
     }
+    /** Deliberately replace exactly one managed seat with a blank native occupant. */
+    async launchFresh(input) {
+        const required = this.requireReason(input.reason);
+        if (required)
+            return required;
+        if (input.fresh !== true) {
+            return {
+                ok: false,
+                code: "fresh_required",
+                message: "Explicit fresh launch requires fresh=true (--fresh); no continuity mode is inferred.",
+            };
+        }
+        const resolved = this.resolveSeat(input.seatRef);
+        if ("code" in resolved)
+            return resolved;
+        const seat = this.describe(resolved);
+        const rig = this.rigRepo.getRig(seat.rigId);
+        const node = rig?.nodes.find((candidate) => candidate.id === seat.nodeId);
+        if (!rig || !node) {
+            return { ok: false, code: "seat_not_found", message: `Seat "${input.seatRef}" no longer exists.`, guidance: SEAT_LOOKUP_GUIDANCE };
+        }
+        if (!this.nodeLauncher || !this.startupOrchestrator) {
+            return { ok: false, code: "launch_unavailable", message: "Fresh-launch services are unavailable in this daemon." };
+        }
+        const startup = this.readStartupContext(node.id, node.cwd ?? ".");
+        if (!startup.ok)
+            return startup.refusal;
+        if (!node.runtime || startup.context.runtime !== node.runtime) {
+            return {
+                ok: false,
+                code: "startup_context_runtime_mismatch",
+                message: `Persisted startup context runtime '${startup.context.runtime}' does not match current node runtime '${node.runtime ?? "missing"}'.`,
+            };
+        }
+        const adapter = this.runtimeAdapters[node.runtime];
+        if (!adapter) {
+            return {
+                ok: false,
+                code: "runtime_adapter_missing",
+                message: `No runtime adapter is available for '${node.runtime}'.`,
+            };
+        }
+        const canonicalSessionName = deriveCanonicalFromEntry(resolved.entry)
+            ?? deriveSessionName(seat.rigName, seat.logicalId);
+        const retiringRows = this.nonTerminalSessions(node.id);
+        if (retiringRows.some((row) => row.origin === "claimed")) {
+            return {
+                ok: false,
+                code: "claimed_session",
+                message: `Seat "${input.seatRef}" has an adopted/operator-owned occupant; fresh launch refuses even with --stop.`,
+                guidance: "Stop the adopted process yourself, then run rig seat clean before launching fresh.",
+            };
+        }
+        const supersededSessionIds = retiringRows.map((row) => row.id);
+        const retiringGeneration = this.sessionRegistry.currentOccupantTenure(node.id)?.generationUuid ?? null;
+        const canonicalProbe = await this.probeLiveness(canonicalSessionName, "fresh launch refuses rather than overwrite a possibly-live canonical session");
+        if ("code" in canonicalProbe)
+            return canonicalProbe;
+        if (canonicalProbe.state === "present") {
+            const currentSession = this.latestSession(node.id);
+            const currentBinding = this.sessionRegistry.getBindingForNode(node.id);
+            const currentManaged = currentSession !== null
+                && !TERMINAL_SESSION_STATUSES.has(currentSession.status)
+                && currentSession.origin !== "claimed"
+                && currentSession.session_name === canonicalSessionName
+                && currentBinding?.tmuxSession === canonicalSessionName;
+            if (!currentManaged) {
+                return {
+                    ok: false,
+                    code: "unmanaged_session_collision",
+                    message: `Canonical tmux session "${canonicalSessionName}" exists but is not owned by this seat's current managed rows; refusing to overwrite it.`,
+                };
+            }
+            if (!input.stop) {
+                return {
+                    ok: false,
+                    code: "session_live",
+                    message: `Seat "${input.seatRef}" is live; fresh launch refuses without --stop.`,
+                    guidance: "Re-run with --stop to end exactly this managed occupant, or use rig handover to carry context.",
+                };
+            }
+            const observedPane = await observeSolePane(this.tmuxAdapter, canonicalSessionName);
+            if (!observedPane.ok && observedPane.code === "tmux_unavailable") {
+                return {
+                    ok: false,
+                    code: "tmux_probe_failed",
+                    message: `${observedPane.detail}; fresh launch refuses rather than kill without live occupant identity.`,
+                };
+            }
+            if (!observedPane.ok || observedPane.pane !== currentBinding?.tmuxPane) {
+                return {
+                    ok: false,
+                    code: "unmanaged_session_collision",
+                    message: `Canonical tmux session "${canonicalSessionName}" is live, but its pane does not match this seat's current managed binding; refusing to stop it.`,
+                };
+            }
+            const stopped = await this.stopManagedTmuxSeat(resolved, currentSession, input.reason, input.operator);
+            if (!stopped.ok)
+                return stopped;
+        }
+        // Reuse clean's exhaustive, positive-absence gate for stale/history rows.
+        const remaining = this.nonTerminalSessions(node.id);
+        const binding = this.sessionRegistry.getBindingForNode(node.id);
+        if (remaining.length > 0 || binding !== null) {
+            const cleaned = await this.cleanSeat({
+                seatRef: canonicalSessionName,
+                reason: input.reason,
+                operator: input.operator,
+            });
+            if (!cleaned.ok)
+                return cleaned;
+        }
+        // The stop/clean composition may have taken time; buy absence again at the
+        // mutation boundary. NodeLauncher also refuses duplicate_session and never kills it.
+        const finalProbe = await this.probeLiveness(canonicalSessionName, "fresh launch refuses rather than race a canonical-session collision");
+        if ("code" in finalProbe)
+            return finalProbe;
+        if (finalProbe.state === "present") {
+            return {
+                ok: false,
+                code: "unmanaged_session_collision",
+                message: `Canonical tmux session "${canonicalSessionName}" appeared before launch; refusing to overwrite it.`,
+            };
+        }
+        // Historical rows remain append-only but no longer look current.
+        for (const sessionId of supersededSessionIds)
+            this.sessionRegistry.markSuperseded(sessionId);
+        this.occupantInvalidator?.invalidateRetiringOccupant({
+            retiringSessionName: canonicalSessionName,
+            successorSessionName: canonicalSessionName,
+            ...(retiringGeneration ? { retiringGeneration } : {}),
+        });
+        const launch = await this.nodeLauncher.launchNode(seat.rigId, seat.logicalId, {
+            sessionName: canonicalSessionName,
+            cwd: node.cwd ?? undefined,
+            occupantKind: "fresh",
+        });
+        if (!launch.ok) {
+            return { ok: false, code: "launch_failed", message: launch.message };
+        }
+        const observedGeneration = this.sessionRegistry.currentOccupantTenure(node.id)?.generationUuid ?? null;
+        const generation = observedGeneration && observedGeneration !== retiringGeneration
+            ? observedGeneration
+            : null;
+        if (!generation) {
+            const compensation = await this.compensateFailedFreshLaunch({
+                seat,
+                launch,
+                supersededSessionIds,
+                retiringGeneration,
+                newGeneration: null,
+                startupPolicyHash: startup.context.hash,
+                model: node.model,
+                reason: input.reason,
+                operator: input.operator,
+                errors: ["new occupant generation was not persisted"],
+            });
+            return compensation === "zero"
+                ? { ok: false, code: "startup_failed", status: "failed", message: "Fresh launch could not persist a new occupant generation; the new session was rolled back." }
+                : { ok: false, code: "attention_required", status: "attention_required", message: "Fresh launch could not persist a new occupant generation and the new process could not be confirmed stopped; the seat requires attention.", sessionName: canonicalSessionName, sessionId: launch.session.id };
+        }
+        this.activityOracle?.declareOccupantSwap(node.id, generation);
+        const launchPosture = this.rigRepo.getNodePolicyProvenance(node.id)?.launchPosture
+            ?? this.rigRepo.getRigPolicyProvenance(seat.rigId)?.launchPosture
+            ?? "floor";
+        const startupResult = await this.startupOrchestrator.startNode({
+            rigId: seat.rigId,
+            nodeId: node.id,
+            sessionId: launch.session.id,
+            binding: {
+                ...launch.binding,
+                cwd: node.cwd ?? ".",
+                model: node.model ?? undefined,
+                codexConfigProfile: node.codexConfigProfile ?? undefined,
+                launchPosture,
+            },
+            adapter,
+            plan: startup.context.plan,
+            resolvedStartupFiles: startup.context.resolvedStartupFiles,
+            startupActions: startup.context.startupActions,
+            isRestore: false,
+            sessionName: canonicalSessionName,
+            allowFreshFallback: false,
+        });
+        if (!startupResult.ok && startupResult.startupStatus === "failed") {
+            const compensation = await this.compensateFailedFreshLaunch({
+                seat,
+                launch,
+                supersededSessionIds,
+                retiringGeneration,
+                newGeneration: generation,
+                startupPolicyHash: startup.context.hash,
+                model: node.model,
+                reason: input.reason,
+                operator: input.operator,
+                errors: startupResult.errors,
+            });
+            return compensation === "zero"
+                ? {
+                    ok: false,
+                    code: "startup_failed",
+                    status: "failed",
+                    message: `Fresh startup failed and was rolled back to zero live session/binding: ${startupResult.errors.join("; ")}`,
+                }
+                : {
+                    ok: false,
+                    code: "attention_required",
+                    status: "attention_required",
+                    message: `Fresh startup failed and the new process could not be confirmed stopped; the seat requires attention: ${startupResult.errors.join("; ")}`,
+                    sessionName: canonicalSessionName,
+                    sessionId: launch.session.id,
+                    generation,
+                };
+        }
+        const identity = await rebindAndVerifyPaneIdentity({
+            db: this.db,
+            sessionRegistry: this.sessionRegistry,
+            tmux: this.tmuxAdapter,
+            nodeId: node.id,
+            sessionName: canonicalSessionName,
+            runtime: node.runtime,
+            expectedResumeToken: this.sessionResumeToken(launch.session.id),
+        });
+        const attentionRequired = !startupResult.ok || !identity.ok;
+        if (!identity.ok)
+            this.sessionRegistry.updateStartupStatus(launch.session.id, "attention_required");
+        let persisted = null;
+        const tx = this.db.transaction(() => {
+            this.db.prepare(`
+        UPDATE nodes SET
+          occupant_lifecycle = 'active',
+          continuity_outcome = 'fresh',
+          handover_result = NULL,
+          previous_occupant = ?,
+          handover_at = ?
+        WHERE id = ?
+      `).run(retiringRows.at(-1)?.session_name ?? null, new Date().toISOString(), node.id);
+            const nativeSessionId = this.sessionResumeToken(launch.session.id);
+            persisted = this.eventBus.persistWithinTransaction({
+                type: "seat.fresh_launched",
+                rigId: seat.rigId,
+                nodeId: node.id,
+                logicalId: seat.logicalId,
+                sessionName: canonicalSessionName,
+                sessionId: launch.session.id,
+                supersededSessionIds,
+                retiringGeneration,
+                newGeneration: generation,
+                nativeSessionId,
+                ...(nativeSessionId ? {} : { nativeSessionIdReason: "scrape_miss" }),
+                model: node.model,
+                startupPolicyHash: startup.context.hash,
+                reason: input.reason.trim(),
+                operator: input.operator ?? null,
+                status: attentionRequired ? "attention_required" : "ready",
+            });
+        });
+        tx();
+        if (persisted)
+            this.eventBus.notifySubscribers(persisted);
+        if (attentionRequired) {
+            return {
+                ok: false,
+                code: startupResult.ok ? "runtime_identity_unverified" : "attention_required",
+                status: "attention_required",
+                message: startupResult.ok
+                    ? `Fresh occupant started but runtime identity requires attention: ${identity.ok ? "unknown" : identity.detail}`
+                    : `Fresh occupant started but startup requires attention: ${startupResult.errors.join("; ")}`,
+                sessionName: canonicalSessionName,
+                sessionId: launch.session.id,
+                generation,
+            };
+        }
+        return {
+            ok: true,
+            seat,
+            status: "ready",
+            sessionName: canonicalSessionName,
+            sessionId: launch.session.id,
+            generation,
+            model: node.model,
+            startupPolicyHash: startup.context.hash,
+            supersededSessionIds,
+        };
+    }
     // -- shared internals --
+    async stopManagedTmuxSeat(resolved, session, reason, operator) {
+        const seat = this.describe(resolved);
+        const kill = await this.tmuxAdapter.killSession(session.session_name);
+        if (kill && !kill.ok && kill.code !== "session_not_found") {
+            return {
+                ok: false,
+                code: "tmux_probe_failed",
+                message: `tmux kill-session for "${session.session_name}" failed: ${kill.message ?? kill.code}`,
+            };
+        }
+        let persisted = null;
+        const tx = this.db.transaction(() => {
+            this.sessionRegistry.updateStatus(session.id, "exited");
+            this.sessionRegistry.clearBinding(resolved.nodeId);
+            persisted = this.eventBus.persistWithinTransaction({
+                type: "session.stopped",
+                rigId: seat.rigId,
+                nodeId: seat.nodeId,
+                sessionName: session.session_name,
+                reason: reason.trim(),
+                operator: operator ?? null,
+            });
+        });
+        tx();
+        if (persisted)
+            this.eventBus.notifySubscribers(persisted);
+        return { ok: true, seat, sessionName: session.session_name, sessionId: session.id };
+    }
+    nonTerminalSessions(nodeId) {
+        return this.db.prepare("SELECT id, session_name, status, origin FROM sessions WHERE node_id = ? ORDER BY created_at, id").all(nodeId).filter((row) => !TERMINAL_SESSION_STATUSES.has(row.status));
+    }
+    sessionResumeToken(sessionId) {
+        const row = this.db.prepare("SELECT resume_token FROM sessions WHERE id = ?").get(sessionId);
+        return row?.resume_token?.trim() || null;
+    }
+    readStartupContext(nodeId, cwd) {
+        const row = this.db.prepare("SELECT projection_entries_json, resolved_files_json, startup_actions_json, runtime FROM node_startup_context WHERE node_id = ?").get(nodeId);
+        if (!row) {
+            return {
+                ok: false,
+                refusal: {
+                    ok: false,
+                    code: "startup_context_missing",
+                    message: `Persisted startup context is missing for node ${nodeId}; fresh launch refuses to invent an empty startup policy.`,
+                },
+            };
+        }
+        let rawEntries;
+        let rawFiles;
+        let rawActions;
+        try {
+            rawEntries = JSON.parse(row.projection_entries_json);
+            rawFiles = JSON.parse(row.resolved_files_json);
+            rawActions = JSON.parse(row.startup_actions_json);
+        }
+        catch (error) {
+            return this.malformedStartupContext(nodeId, `JSON parse failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!Array.isArray(rawEntries) || !Array.isArray(rawFiles) || !Array.isArray(rawActions) || !row.runtime?.trim()) {
+            return this.malformedStartupContext(nodeId, "projection entries, resolved files, and startup actions must be arrays and runtime must be non-empty");
+        }
+        const entries = [];
+        for (const raw of rawEntries) {
+            if (!isRecord(raw)
+                || !isProjectionCategory(raw["category"])
+                || !hasStrings(raw, ["effectiveId", "sourceSpec", "sourcePath", "resourcePath", "absolutePath"])
+                || !isOptionalString(raw["resourceType"])
+                || !isOptionalString(raw["target"])
+                || !isOptionalOneOf(raw["mergeStrategy"], ["managed_block", "append"])
+                || !isOptionalOneOf(raw["pluginType"], ["claude", "codex", "auto"])) {
+                return this.malformedStartupContext(nodeId, "projection_entries_json contains an invalid entry");
+            }
+            // S04 owns the live ambient skill set. Replaying the older catalog
+            // selection here could reinstall a skill that work-install removed.
+            if (raw["category"] === "skill")
+                continue;
+            entries.push({
+                category: raw["category"],
+                effectiveId: raw["effectiveId"],
+                sourceSpec: raw["sourceSpec"],
+                sourcePath: raw["sourcePath"],
+                resourcePath: raw["resourcePath"],
+                absolutePath: raw["absolutePath"],
+                classification: "safe_projection",
+                ...(typeof raw["resourceType"] === "string" ? { resourceType: raw["resourceType"] } : {}),
+                ...(typeof raw["mergeStrategy"] === "string" ? { mergeStrategy: raw["mergeStrategy"] } : {}),
+                ...(typeof raw["target"] === "string" ? { target: raw["target"] } : {}),
+                ...(typeof raw["pluginType"] === "string" ? { pluginType: raw["pluginType"] } : {}),
+            });
+        }
+        const resolvedStartupFiles = [];
+        for (const raw of rawFiles) {
+            if (!isRecord(raw)
+                || !hasStrings(raw, ["path", "absolutePath", "ownerRoot"])
+                || !isOneOf(raw["deliveryHint"], ["auto", "guidance_merge", "skill_install", "send_text"])
+                || typeof raw["required"] !== "boolean"
+                || !isStringArrayOf(raw["appliesOn"], ["fresh_start", "restore"])
+                || !isOptionalOneOf(raw["kind"], ["file"])) {
+                return this.malformedStartupContext(nodeId, "resolved_files_json contains an invalid entry");
+            }
+            resolvedStartupFiles.push({
+                path: raw["path"],
+                absolutePath: raw["absolutePath"],
+                ownerRoot: raw["ownerRoot"],
+                deliveryHint: raw["deliveryHint"],
+                required: raw["required"],
+                appliesOn: raw["appliesOn"],
+                ...(raw["kind"] === "file" ? { kind: "file" } : {}),
+            });
+        }
+        const startupActions = [];
+        for (const raw of rawActions) {
+            if (!isRecord(raw)
+                || !isOneOf(raw["type"], ["slash_command", "send_text"])
+                || typeof raw["value"] !== "string"
+                || !isOneOf(raw["phase"], ["after_files", "after_ready"])
+                || !isStringArrayOf(raw["appliesOn"], ["fresh_start", "restore"])
+                || typeof raw["idempotent"] !== "boolean"
+                || !isOptionalOneOf(raw["builtin"], ["session_identity"])) {
+                return this.malformedStartupContext(nodeId, "startup_actions_json contains an invalid entry");
+            }
+            startupActions.push({
+                type: raw["type"],
+                value: raw["value"],
+                phase: raw["phase"],
+                appliesOn: raw["appliesOn"],
+                idempotent: raw["idempotent"],
+                ...(raw["builtin"] === "session_identity" ? { builtin: "session_identity" } : {}),
+            });
+        }
+        const startupFiles = resolvedStartupFiles.map((file) => ({
+            kind: file.kind,
+            path: file.path,
+            deliveryHint: file.deliveryHint,
+            required: file.required,
+            appliesOn: file.appliesOn,
+        }));
+        const plan = {
+            runtime: row.runtime,
+            cwd,
+            entries,
+            startup: { files: startupFiles, actions: startupActions },
+            conflicts: [],
+            noOps: [],
+            diagnostics: [],
+        };
+        const hash = createHash("sha256")
+            .update(JSON.stringify([row.projection_entries_json, row.resolved_files_json, row.startup_actions_json, row.runtime]))
+            .digest("hex");
+        return { ok: true, context: { plan, resolvedStartupFiles, startupActions, runtime: row.runtime, hash } };
+    }
+    malformedStartupContext(nodeId, detail) {
+        return {
+            ok: false,
+            refusal: {
+                ok: false,
+                code: "startup_context_malformed",
+                message: `Persisted startup context is malformed for node ${nodeId}: ${detail}.`,
+            },
+        };
+    }
+    async compensateFailedFreshLaunch(input) {
+        const kill = await this.tmuxAdapter.killSession(input.launch.sessionName);
+        const stopped = !kill || kill.ok || kill.code === "session_not_found";
+        const errors = stopped
+            ? input.errors
+            : [...input.errors, `tmux kill-session failed: ${kill.message ?? kill.code}`];
+        let persisted = null;
+        const tx = this.db.transaction(() => {
+            if (stopped) {
+                this.sessionRegistry.updateStatus(input.launch.session.id, "exited");
+                this.sessionRegistry.clearBinding(input.seat.nodeId);
+                this.db.prepare("UPDATE nodes SET occupant_lifecycle = 'unknown', continuity_outcome = 'failed' WHERE id = ?").run(input.seat.nodeId);
+            }
+            else {
+                this.sessionRegistry.updateStartupStatus(input.launch.session.id, "attention_required");
+                this.db.prepare("UPDATE nodes SET occupant_lifecycle = 'active', continuity_outcome = 'fresh' WHERE id = ?").run(input.seat.nodeId);
+            }
+            persisted = this.eventBus.persistWithinTransaction({
+                type: "seat.fresh_launch_failed",
+                rigId: input.seat.rigId,
+                nodeId: input.seat.nodeId,
+                logicalId: input.seat.logicalId,
+                sessionName: input.launch.sessionName,
+                sessionId: input.launch.session.id,
+                supersededSessionIds: input.supersededSessionIds,
+                retiringGeneration: input.retiringGeneration,
+                newGeneration: input.newGeneration,
+                model: input.model,
+                startupPolicyHash: input.startupPolicyHash,
+                reason: input.reason.trim(),
+                operator: input.operator ?? null,
+                errors,
+            });
+        });
+        tx();
+        if (persisted)
+            this.eventBus.notifySubscribers(persisted);
+        return stopped ? "zero" : "attention";
+    }
     /**
      * The ONE liveness read both mutating verbs share (fix r1, row 9baac99f):
      * the CLASSIFIED probeSession, never the collapsed hasSession view.
@@ -304,9 +777,32 @@ export class SeatLifecycleService {
         if (parsed.kind === "canonical") {
             const localRef = parsed.member;
             const rigs = this.rigRepo.findRigsByName(parsed.rig);
-            return rigs.flatMap((rig) => getNodeInventory(this.db, rig.id).filter((entry) => entry.canonicalSessionName === ref || entry.logicalId === localRef));
+            return rigs.flatMap((rig) => getNodeInventory(this.db, rig.id).filter((entry) => entry.canonicalSessionName === ref
+                || deriveCanonicalFromEntry(entry) === ref
+                || entry.logicalId === localRef));
         }
         return this.rigRepo.listRigs().flatMap((rig) => getNodeInventory(this.db, rig.id).filter((entry) => entry.canonicalSessionName === ref || entry.logicalId === ref));
     }
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasStrings(value, keys) {
+    return keys.every((key) => typeof value[key] === "string" && value[key].trim().length > 0);
+}
+function isProjectionCategory(value) {
+    return isOneOf(value, ["skill", "guidance", "subagent", "plugin", "runtime_resource"]);
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function isOneOf(value, allowed) {
+    return typeof value === "string" && allowed.includes(value);
+}
+function isOptionalOneOf(value, allowed) {
+    return value === undefined || isOneOf(value, allowed);
+}
+function isStringArrayOf(value, allowed) {
+    return Array.isArray(value) && value.every((entry) => isOneOf(entry, allowed));
+}
 //# sourceMappingURL=seat-lifecycle-service.js.map