@nurix/nustack 0.10.0-dev.18 → 0.10.0-dev.20

package/dist/lib/session-engine/supervisor.js

@@ -0,0 +1,315 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { ClaudeSession } from "./claudeAdapter.js";
+import { FRAME_VERSION, parseInboundFrame, serializeFrame, } from "./frames.js";
+import { inspectSession, reclaimSession } from "./prune.js";
+import { sessionRegistryPath, readSessionRegistry, updateSessionRegistry } from "./registry.js";
+import { createSessionWorktree } from "./worktree.js";
+function defaultProbeClaude(env) {
+    return new Promise((resolve) => {
+        execFile("claude", ["--version"], { env, timeout: 5_000 }, (error, stdout) => {
+            if (error)
+                resolve({ found: false, version: null });
+            else
+                resolve({ found: true, version: stdout.trim() });
+        });
+    });
+}
+export class SessionSupervisor {
+    options;
+    env;
+    sessions = new Map();
+    closingSessions = new Set();
+    shuttingDown = false;
+    resolveDone = null;
+    lines = null;
+    registryWrites = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+        this.env = options.env ?? process.env;
+    }
+    emit(frame) {
+        this.options.output.write(serializeFrame(frame));
+    }
+    status(sessionId, status, message = null) {
+        this.emit({ v: FRAME_VERSION, type: "session.status", sessionId, status, message });
+    }
+    error(sessionId, code, message) {
+        this.emit({ v: FRAME_VERSION, type: "session.error", sessionId, code, message });
+    }
+    async boundProjectOf(projectPath) {
+        try {
+            const parsed = JSON.parse(await readFile(path.join(projectPath, ".nustack", "workspace.json"), "utf8"));
+            const id = parsed?.workspaceId;
+            return typeof id === "string" && id.trim() ? id.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async moveSessionRow(record, to) {
+        const client = this.options.sessions;
+        if (!client || !record.projectId)
+            return;
+        try {
+            await client.transitionSession(record.projectId, record.sessionId, to);
+        }
+        catch {
+        }
+    }
+    async updateRegistry(mutate) {
+        const run = () => updateSessionRegistry(this.env, mutate);
+        this.registryWrites = this.registryWrites.then(run, run);
+        return this.registryWrites;
+    }
+    async run() {
+        const probe = this.options.probeClaude ?? (() => defaultProbeClaude(this.env));
+        const claude = await probe();
+        this.emit({ v: FRAME_VERSION, type: "engine.hello", engineVersion: this.options.engineVersion, claude });
+        const lines = createInterface({ input: this.options.input });
+        this.lines = lines;
+        lines.on("line", (line) => {
+            if (line.trim() === "")
+                return;
+            const parsed = parseInboundFrame(line);
+            if (!parsed.ok) {
+                this.error(null, parsed.error.code, parsed.error.message);
+                return;
+            }
+            void this.handle(parsed.frame);
+        });
+        await new Promise((resolve) => {
+            this.resolveDone = resolve;
+            lines.on("close", () => void this.shutdown());
+        });
+    }
+    async handle(frame) {
+        switch (frame.type) {
+            case "engine.shutdown":
+                await this.shutdown();
+                return;
+            case "session.open":
+                await this.openSession(frame.sessionId, frame.projectPath, frame.permissionMode, frame.isolated, frame.resumeSessionId);
+                return;
+            case "session.turn": {
+                const session = this.sessions.get(frame.sessionId);
+                if (!session)
+                    return this.error(frame.sessionId, "SESSION_UNKNOWN", `no open session ${frame.sessionId}`);
+                session.adapter.sendTurn(frame.text);
+                this.status(frame.sessionId, "running");
+                return;
+            }
+            case "session.approval": {
+                const session = this.sessions.get(frame.sessionId);
+                if (!session)
+                    return this.error(frame.sessionId, "SESSION_UNKNOWN", `no open session ${frame.sessionId}`);
+                session.adapter.respondApproval(frame.requestId, frame.verdict);
+                return;
+            }
+            case "session.interrupt": {
+                const session = this.sessions.get(frame.sessionId);
+                if (!session)
+                    return this.error(frame.sessionId, "SESSION_UNKNOWN", `no open session ${frame.sessionId}`);
+                session.adapter.interrupt();
+                return;
+            }
+            case "session.close": {
+                const session = this.sessions.get(frame.sessionId);
+                if (!session)
+                    return this.error(frame.sessionId, "SESSION_UNKNOWN", `no open session ${frame.sessionId}`);
+                this.closingSessions.add(frame.sessionId);
+                session.adapter.stop();
+                return;
+            }
+            case "session.list":
+                await this.sendRoster();
+                return;
+            case "session.reclaim":
+                await this.reclaimRow(frame.sessionId);
+                return;
+        }
+    }
+    async openSession(sessionId, projectPath, permissionMode, isolated, resumeSessionId) {
+        if (this.sessions.has(sessionId))
+            return this.error(sessionId, "SESSION_ALREADY_OPEN", `session ${sessionId} is already open`);
+        this.status(sessionId, "starting");
+        const worktree = await createSessionWorktree(projectPath, sessionId, this.env, isolated === true);
+        const record = {
+            sessionId,
+            projectPath,
+            worktreePath: worktree.worktreePath,
+            branch: worktree.branch,
+            provider: "claude-code",
+            providerSessionId: null,
+            createdAt: new Date().toISOString(),
+            status: "open",
+            nustack: 1,
+            projectId: await this.boundProjectOf(projectPath),
+            permissionMode: permissionMode ?? null,
+            baseBranch: worktree.baseBranch,
+            baseCommit: worktree.baseCommit,
+            enginePid: process.pid,
+            closedAt: null,
+        };
+        const adapterOptions = {
+            cwd: worktree.worktreePath,
+            permissionMode,
+            resumeSessionId,
+            env: this.env,
+            onEvent: (event) => {
+                this.emit({ v: FRAME_VERSION, type: "session.event", sessionId, event });
+                if (typeof event === "object" && event !== null && event.type === "result") {
+                    this.status(sessionId, "ready");
+                }
+            },
+            onApprovalRequest: (request) => {
+                this.emit({
+                    v: FRAME_VERSION,
+                    type: "session.approvalRequest",
+                    sessionId,
+                    requestId: request.requestId,
+                    toolName: request.toolName,
+                    displayName: request.displayName,
+                    toolInput: request.toolInput,
+                    description: request.description,
+                });
+            },
+            onProtocolError: (code, message) => this.error(sessionId, code, message),
+            onSessionId: (vendorSessionId) => {
+                record.providerSessionId = vendorSessionId;
+                void this.updateRegistry((sessions) => sessions.map((row) => (row.sessionId === sessionId ? { ...row, providerSessionId: vendorSessionId } : row)));
+                const client = this.options.sessions;
+                if (client && record.projectId) {
+                    void client.setVendorSessionId(record.projectId, sessionId, vendorSessionId).catch(() => undefined);
+                }
+            },
+            onExit: (code) => {
+                const wasExpected = this.closingSessions.delete(sessionId) || this.shuttingDown;
+                this.sessions.delete(sessionId);
+                if (!wasExpected)
+                    this.error(sessionId, "ADAPTER_FAILED", `claude exited unexpectedly (code ${String(code)})`);
+                this.emit({ v: FRAME_VERSION, type: "session.closed", sessionId });
+                void this.updateRegistry((sessions) => sessions.map((row) => row.sessionId === sessionId ? { ...row, status: "closed", closedAt: new Date().toISOString() } : row));
+                void this.moveSessionRow(record, wasExpected ? "done" : "failed");
+            },
+        };
+        const create = this.options.createAdapter ?? ((opts) => new ClaudeSession(opts));
+        let adapter;
+        try {
+            adapter = create(adapterOptions);
+        }
+        catch (error) {
+            return this.error(sessionId, "ADAPTER_FAILED", error instanceof Error ? error.message : String(error));
+        }
+        this.sessions.set(sessionId, { adapter, record });
+        await this.updateRegistry((sessions) => [...sessions.filter((row) => row.sessionId !== sessionId), record]);
+        if (this.options.sessions && record.projectId) {
+            try {
+                await this.options.sessions.createSession(record.projectId, {
+                    id: sessionId,
+                    startedBy: "person",
+                    substrate: "device",
+                    mode: "synchronous",
+                    nustack: 1,
+                    vendor: "claude_code",
+                    renderer: "claude_transcript",
+                    status: "created",
+                });
+            }
+            catch {
+            }
+        }
+        this.emit({
+            v: FRAME_VERSION,
+            type: "session.opened",
+            sessionId,
+            projectPath,
+            worktreePath: worktree.worktreePath,
+            branch: worktree.branch,
+            isolated: worktree.isolated,
+        });
+        this.status(sessionId, "ready");
+    }
+    async sendRoster() {
+        const { records, dropped } = await readSessionRegistry(this.env);
+        const rows = [];
+        for (const record of records) {
+            const attached = this.sessions.has(record.sessionId);
+            const facts = await inspectSession(record, this.env);
+            const reclaimable = !attached && facts.reclaimable;
+            const reason = attached ? "this engine is running it — close the session first" : facts.reason;
+            rows.push({
+                sessionId: record.sessionId,
+                projectPath: record.projectPath,
+                worktreePath: record.worktreePath,
+                branch: record.branch,
+                createdAt: record.createdAt,
+                status: record.status,
+                closedAt: record.closedAt ?? null,
+                permissionMode: record.permissionMode ?? null,
+                baseBranch: record.baseBranch ?? null,
+                attached,
+                liveElsewhere: !attached && record.status === "open" && typeof record.enginePid === "number" && !facts.stale,
+                isolated: facts.isolated,
+                checkoutPresent: facts.checkoutPresent,
+                worktreePresent: facts.worktreePresent,
+                branchExists: facts.branchExists,
+                reading: facts.reading,
+                dirty: facts.dirty,
+                stale: facts.stale,
+                reclaimable,
+                reason,
+            });
+        }
+        this.emit({
+            v: FRAME_VERSION,
+            type: "session.roster",
+            registryPath: sessionRegistryPath(this.env),
+            unreadable: dropped,
+            sessions: rows,
+        });
+    }
+    async reclaimRow(sessionId) {
+        if (this.sessions.has(sessionId)) {
+            return this.error(sessionId, "SESSION_ATTACHED", `session ${sessionId} is open in this engine — close it first`);
+        }
+        const { records } = await readSessionRegistry(this.env);
+        const record = records.find((row) => row.sessionId === sessionId);
+        if (!record)
+            return this.error(sessionId, "SESSION_UNKNOWN", `no session ${sessionId} in this machine's registry`);
+        const reclaim = this.registryWrites.then(() => reclaimSession(record, {}, this.env), () => reclaimSession(record, {}, this.env));
+        this.registryWrites = reclaim.then(() => undefined, () => undefined);
+        try {
+            const outcome = await reclaim;
+            this.emit({
+                v: FRAME_VERSION,
+                type: "session.reclaimed",
+                sessionId,
+                removedWorktree: outcome.removedWorktree,
+                deletedBranch: outcome.deletedBranch,
+                droppedRow: outcome.droppedRow,
+                reason: outcome.reason,
+            });
+        }
+        catch (error) {
+            this.error(sessionId, "RECLAIM_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async shutdown() {
+        if (this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        const held = [...this.sessions.keys()];
+        for (const [, session] of this.sessions)
+            session.adapter.stop();
+        this.sessions.clear();
+        if (held.length > 0) {
+            const closedAt = new Date().toISOString();
+            await this.updateRegistry((sessions) => sessions.map((row) => (held.includes(row.sessionId) && row.status === "open" ? { ...row, status: "closed", closedAt } : row)));
+        }
+        this.lines?.close();
+        this.resolveDone?.();
+    }
+}

package/dist/lib/session-engine/worktree.js

@@ -0,0 +1,56 @@
+import { execFile } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export const ENGINE_SESSION_BRANCH_PREFIX = "nustack/session-";
+export function sessionsHome(env = process.env) {
+    const override = env.NUSTACK_SESSIONS_HOME;
+    if (override && override !== "")
+        return override;
+    return path.join(os.homedir(), ".nustack", "sessions");
+}
+export const LEGACY_ENGINE_BRANCH_PREFIX = "nustack/lane-";
+export function legacyEngineHome(env = process.env) {
+    const override = env.NUSTACK_LEGACY_ENGINE_HOME;
+    if (override && override !== "")
+        return override;
+    return path.join(os.homedir(), ".nustack", "lanes");
+}
+function git(args, cwd) {
+    return gitOutcome(args, cwd).then((outcome) => (outcome.ok ? outcome.stdout : null));
+}
+export function gitOutcome(args, cwd) {
+    return new Promise((resolve) => {
+        const failed = (error) => {
+            resolve({ ok: false, code: null, stdout: "", stderr: error instanceof Error ? error.message : String(error) });
+        };
+        try {
+            execFile("git", args, { cwd, timeout: 15_000 }, (error, stdout, stderr) => {
+                const raw = error?.code;
+                const code = error ? (typeof raw === "number" ? raw : null) : 0;
+                resolve({ ok: !error, code, stdout: stdout.trim(), stderr: stderr.trim() });
+            });
+        }
+        catch (error) {
+            failed(error);
+        }
+    });
+}
+export async function createSessionWorktree(projectPath, sessionId, env = process.env, isolate = false) {
+    const inPlace = { worktreePath: projectPath, branch: null, isolated: false, baseBranch: null, baseCommit: null };
+    if (!isolate)
+        return inPlace;
+    const isRepo = await git(["rev-parse", "--is-inside-work-tree"], projectPath);
+    if (isRepo !== "true")
+        return inPlace;
+    const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], projectPath);
+    const baseBranch = head === null || head === "HEAD" ? null : head;
+    const baseCommit = await git(["rev-parse", "HEAD"], projectPath);
+    const branch = `${ENGINE_SESSION_BRANCH_PREFIX}${sessionId}`;
+    const worktreePath = path.join(sessionsHome(env), "worktrees", sessionId);
+    await mkdir(path.dirname(worktreePath), { recursive: true });
+    const added = await git(["worktree", "add", worktreePath, "-b", branch], projectPath);
+    if (added === null)
+        return inPlace;
+    return { worktreePath, branch, isolated: true, baseBranch, baseCommit };
+}

package/dist/lib/sessions/outsideSessions.js

@@ -9,7 +9,7 @@ function vendorOf(provider) {
 const AT_REST = new Set(["done", "failed", "cancelled"]);
 export async function recordOutsideSessions(client, input) {
     const now = input.now ?? Date.now;
-    const laneIds = new Set((input.laneSessionIds ?? []).filter((id) => Boolean(id)));
+    const engineIds = new Set((input.engineSessionIds ?? []).filter((id) => Boolean(id)));
     const report = { created: 0, finished: 0, skipped: 0, failed: 0 };
     for (const transcript of input.transcripts) {
         if (!transcript.projectId) {
@@ -23,14 +23,14 @@ export async function recordOutsideSessions(client, input) {
         }
         const stale = now() - transcript.modifiedMs >= STOPPED_GROWING_MS;
         const vendorSessionId = transcript.vendorSessionId?.trim() || null;
-        const isLane = vendorSessionId !== null && laneIds.has(vendorSessionId);
+        const isEngineSession = vendorSessionId !== null && engineIds.has(vendorSessionId);
         try {
             const { created, session } = await client.createSession(transcript.projectId, {
                 id: transcript.sessionKey,
                 startedBy: "person",
                 substrate: "device",
                 mode: "synchronous",
-                origin: isLane ? "inside" : "outside",
+                nustack: isEngineSession ? 1 : 0,
                 vendor: kinds.vendor,
                 renderer: kinds.renderer,
                 status: stale ? "done" : "running",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nurix/nustack",
-  "version": "0.10.0-dev.18",
+  "version": "0.10.0-dev.20",
   "description": "The nustack CLI — bootstrap NuStack services into a repo via the NuStack discovery plane.",
   "type": "module",
   "private": false,
@@ -26,15 +26,16 @@
     "commander": "^14.0.0"
   },
   "optionalDependencies": {
-    "@nurix/codegraph": "0.2.1"
+    "@nurix/codegraph": "0.2.1",
+    "@nurix/logscope": "0.1.0"
   },
   "devDependencies": {
     "@ngneat/falso": "^8.0.2",
     "@types/node": "^22.19.20",
     "typescript": "^5.7.2",
     "vitest": "^4.1.11",
-    "@nurix/nustack.studio": "0.0.0",
-    "@nurix/nustack.ui": "0.0.0"
+    "@nurix/nustack.ui": "0.0.0",
+    "@nurix/nustack.studio": "0.0.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/commands/lane.js

@@ -1,12 +0,0 @@
-import { LaneSupervisor } from "../lib/lanes/supervisor.js";
-import { sessionsClientFromEnv } from "../lib/sessions/client.js";
-export async function runLaneServe(engineVersion) {
-    const supervisor = new LaneSupervisor({
-        input: process.stdin,
-        output: process.stdout,
-        engineVersion,
-        sessions: sessionsClientFromEnv(process.env),
-    });
-    await supervisor.run();
-    process.exit(0);
-}

package/dist/lib/lanes/supervisor.js

@@ -1,247 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { createInterface } from "node:readline";
-import { ClaudeLane } from "./claudeAdapter.js";
-import { FRAME_VERSION, parseInboundFrame, serializeFrame, } from "./frames.js";
-import { createLaneWorktree, lanesHome } from "./worktree.js";
-function defaultProbeClaude(env) {
-    return new Promise((resolve) => {
-        execFile("claude", ["--version"], { env, timeout: 5_000 }, (error, stdout) => {
-            if (error)
-                resolve({ found: false, version: null });
-            else
-                resolve({ found: true, version: stdout.trim() });
-        });
-    });
-}
-export class LaneSupervisor {
-    options;
-    env;
-    lanes = new Map();
-    closingLanes = new Set();
-    shuttingDown = false;
-    resolveDone = null;
-    lines = null;
-    registryWrites = Promise.resolve();
-    constructor(options) {
-        this.options = options;
-        this.env = options.env ?? process.env;
-    }
-    emit(frame) {
-        this.options.output.write(serializeFrame(frame));
-    }
-    status(laneId, status, message = null) {
-        this.emit({ v: FRAME_VERSION, type: "lane.status", laneId, status, message });
-    }
-    error(laneId, code, message) {
-        this.emit({ v: FRAME_VERSION, type: "lane.error", laneId, code, message });
-    }
-    registryPath() {
-        return path.join(lanesHome(this.env), "registry.json");
-    }
-    async boundProjectOf(projectPath) {
-        try {
-            const parsed = JSON.parse(await readFile(path.join(projectPath, ".nustack", "workspace.json"), "utf8"));
-            const id = parsed?.workspaceId;
-            return typeof id === "string" && id.trim() ? id.trim() : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async moveLaneSession(record, to) {
-        const client = this.options.sessions;
-        if (!client || !record.projectId)
-            return;
-        try {
-            await client.transitionSession(record.projectId, record.laneId, to);
-        }
-        catch {
-        }
-    }
-    async updateRegistry(mutate) {
-        const run = async () => {
-            const file = this.registryPath();
-            let lanes = [];
-            try {
-                const parsed = JSON.parse(await readFile(file, "utf8"));
-                if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.lanes)) {
-                    lanes = parsed.lanes;
-                }
-            }
-            catch {
-            }
-            await mkdir(path.dirname(file), { recursive: true });
-            await writeFile(file, JSON.stringify({ v: 1, lanes: mutate(lanes) }, null, 2) + "\n", "utf8");
-        };
-        this.registryWrites = this.registryWrites.then(run, run);
-        return this.registryWrites;
-    }
-    async run() {
-        const probe = this.options.probeClaude ?? (() => defaultProbeClaude(this.env));
-        const claude = await probe();
-        this.emit({ v: FRAME_VERSION, type: "engine.hello", engineVersion: this.options.engineVersion, claude });
-        const lines = createInterface({ input: this.options.input });
-        this.lines = lines;
-        lines.on("line", (line) => {
-            if (line.trim() === "")
-                return;
-            const parsed = parseInboundFrame(line);
-            if (!parsed.ok) {
-                this.error(null, parsed.error.code, parsed.error.message);
-                return;
-            }
-            void this.handle(parsed.frame);
-        });
-        await new Promise((resolve) => {
-            this.resolveDone = resolve;
-            lines.on("close", () => void this.shutdown());
-        });
-    }
-    async handle(frame) {
-        switch (frame.type) {
-            case "engine.shutdown":
-                await this.shutdown();
-                return;
-            case "lane.open":
-                await this.openLane(frame.laneId, frame.projectPath, frame.permissionMode, frame.isolated, frame.resumeSessionId);
-                return;
-            case "lane.turn": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.sendTurn(frame.text);
-                this.status(frame.laneId, "running");
-                return;
-            }
-            case "lane.approval": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.respondApproval(frame.requestId, frame.verdict);
-                return;
-            }
-            case "lane.interrupt": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.interrupt();
-                return;
-            }
-            case "lane.close": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                this.closingLanes.add(frame.laneId);
-                lane.adapter.stop();
-                return;
-            }
-        }
-    }
-    async openLane(laneId, projectPath, permissionMode, isolated, resumeSessionId) {
-        if (this.lanes.has(laneId))
-            return this.error(laneId, "LANE_ALREADY_OPEN", `lane ${laneId} is already open`);
-        this.status(laneId, "starting");
-        const worktree = await createLaneWorktree(projectPath, laneId, this.env, isolated === true);
-        const record = {
-            laneId,
-            projectPath,
-            worktreePath: worktree.worktreePath,
-            branch: worktree.branch,
-            provider: "claude-code",
-            providerSessionId: null,
-            createdAt: new Date().toISOString(),
-            status: "open",
-            projectId: await this.boundProjectOf(projectPath),
-        };
-        const adapterOptions = {
-            cwd: worktree.worktreePath,
-            permissionMode,
-            resumeSessionId,
-            env: this.env,
-            onEvent: (event) => {
-                this.emit({ v: FRAME_VERSION, type: "lane.event", laneId, event });
-                if (typeof event === "object" && event !== null && event.type === "result") {
-                    this.status(laneId, "ready");
-                }
-            },
-            onApprovalRequest: (request) => {
-                this.emit({
-                    v: FRAME_VERSION,
-                    type: "lane.approvalRequest",
-                    laneId,
-                    requestId: request.requestId,
-                    toolName: request.toolName,
-                    displayName: request.displayName,
-                    toolInput: request.toolInput,
-                    description: request.description,
-                });
-            },
-            onProtocolError: (code, message) => this.error(laneId, code, message),
-            onSessionId: (sessionId) => {
-                record.providerSessionId = sessionId;
-                void this.updateRegistry((lanes) => lanes.map((row) => (row.laneId === laneId ? { ...row, providerSessionId: sessionId } : row)));
-                const client = this.options.sessions;
-                if (client && record.projectId) {
-                    void client.setVendorSessionId(record.projectId, laneId, sessionId).catch(() => undefined);
-                }
-            },
-            onExit: (code) => {
-                const wasExpected = this.closingLanes.delete(laneId) || this.shuttingDown;
-                this.lanes.delete(laneId);
-                if (!wasExpected)
-                    this.error(laneId, "ADAPTER_FAILED", `claude exited unexpectedly (code ${String(code)})`);
-                this.emit({ v: FRAME_VERSION, type: "lane.closed", laneId });
-                void this.updateRegistry((lanes) => lanes.map((row) => (row.laneId === laneId ? { ...row, status: "closed" } : row)));
-                void this.moveLaneSession(record, wasExpected ? "done" : "failed");
-            },
-        };
-        const create = this.options.createAdapter ?? ((opts) => new ClaudeLane(opts));
-        let adapter;
-        try {
-            adapter = create(adapterOptions);
-        }
-        catch (error) {
-            return this.error(laneId, "ADAPTER_FAILED", error instanceof Error ? error.message : String(error));
-        }
-        this.lanes.set(laneId, { adapter, record });
-        await this.updateRegistry((lanes) => [...lanes.filter((row) => row.laneId !== laneId), record]);
-        if (this.options.sessions && record.projectId) {
-            try {
-                await this.options.sessions.createSession(record.projectId, {
-                    id: laneId,
-                    startedBy: "person",
-                    substrate: "device",
-                    mode: "synchronous",
-                    origin: "inside",
-                    vendor: "claude_code",
-                    renderer: "claude_transcript",
-                    status: "created",
-                });
-            }
-            catch {
-            }
-        }
-        this.emit({
-            v: FRAME_VERSION,
-            type: "lane.opened",
-            laneId,
-            projectPath,
-            worktreePath: worktree.worktreePath,
-            branch: worktree.branch,
-            isolated: worktree.isolated,
-        });
-        this.status(laneId, "ready");
-    }
-    async shutdown() {
-        if (this.shuttingDown)
-            return;
-        this.shuttingDown = true;
-        for (const [, lane] of this.lanes)
-            lane.adapter.stop();
-        this.lanes.clear();
-        this.lines?.close();
-        this.resolveDone?.();
-    }
-}