pipane 0.1.5 → 0.1.6

package/dist/server/server/server.js

@@ -9,10 +9,9 @@
  * switched to that session, and runs one turn. After the turn completes,
  * the process is released back to the pool.
  *
- * Session lifecycle is managed by SessionLifecycle (single source of truth
- * for session→process mappings and status). Process spawning and pooling
- * is handled by ProcessPool. The WsHandler routes WebSocket commands to
- * these modules.
+ * Each session is owned by a serialized SessionActor registered in
+ * SessionRegistry. ProcessPool owns exclusive process leases, and WsHandler
+ * only routes transport commands and publishes actor state.
  */
 import express from "express";
 import { createServer } from "node:http";
@@ -22,25 +21,24 @@ import { hostname } from "node:os";
 import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync, watch } from "node:fs";
 import { WebSocketServer, WebSocket } from "ws";
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { resolvePiLaunch } from "./pi-launch.js";
 import { checkCommandAvailable, makePiNotFoundMessage } from "./pi-runtime.js";
 import { registerRestApi } from "./rest-api.js";
-import { SessionLifecycle } from "./session-lifecycle.js";
+import { SessionRegistry } from "./session-registry.js";
 import { ProcessPool } from "./process-pool.js";
 import { WsHandler } from "./ws-handler.js";
-import { LoadTraceStore } from "./load-trace-store.js";
 import { LocalSettingsStore } from "./local-settings.js";
 import { fetchLatestVersion, compareSemver } from "./update-check.js";
+import { resolveUsageExtensionPath } from "./bundled-extensions.js";
 const DEFAULT_PORT = process.env.NODE_ENV === "production" ? "8222" : "18111";
-const PORT = parseInt(process.env.PORT || DEFAULT_PORT, 10);
+const REQUESTED_PORT = parseInt(process.env.PORT || DEFAULT_PORT, 10);
+const INSTANCE_ID = process.env.PIPANE_INSTANCE_ID || null;
 const PI_CWD = process.env.PI_CWD || process.cwd();
 // Quiet mode: only show URLs unless --verbose or PIPANE_VERBOSE=1
 const VERBOSE = process.argv.includes("--verbose") || process.env.PIPANE_VERBOSE === "1";
 if (!VERBOSE) {
     const origLog = console.log;
-    const origError = console.error;
-    const origWarn = console.warn;
     // Suppress all console output; we'll use _log for the few lines we want
     console.log = () => { };
     console.error = () => { };
@@ -59,6 +57,7 @@ const PI_LAUNCH = resolvePiLaunch(PI_CLI);
 const PI_AVAILABLE = checkCommandAvailable(PI_LAUNCH.command);
 const PI_MAX_PROCESSES = parseInt(process.env.PI_MAX_PROCESSES || "24", 10);
 const PI_PREWARM_COUNT = parseInt(process.env.PI_PREWARM_COUNT || "2", 10);
+const USAGE_EXTENSION_ENABLED = process.env.PIPANE_USAGE_EXTENSION !== "0";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Read own version from package.json
 const PKG_JSON_PATH = path.resolve(__dirname, "../../../package.json");
@@ -74,7 +73,6 @@ const PKG_NAME = "pipane";
 const AUTH_COOKIE_NAME = "pipane_auth";
 const AUTH_TOKEN = process.env.PIPANE_AUTH_TOKEN || randomBytes(24).toString("base64url");
 const PUBLIC_HOSTNAME = process.env.PI_PUBLIC_HOSTNAME || hostname();
-const AUTH_URL = `http://${PUBLIC_HOSTNAME}:${PORT}/auth?token=${encodeURIComponent(AUTH_TOKEN)}`;
 function parseCookies(header) {
     const out = {};
     if (!header)
@@ -159,36 +157,26 @@ app.use((req, res, next) => {
     }
     res.status(401).type("html").send("<h3>Unauthorized</h3><p>Open the one-time auth URL shown in the pipane terminal.</p>");
 });
-const traceStore = new LoadTraceStore();
-const localSettingsStore = new LocalSettingsStore();
-app.use((req, res, next) => {
-    const traceId = typeof req.headers["x-pi-trace-id"] === "string" ? req.headers["x-pi-trace-id"] : "";
-    if (!traceId) {
-        next();
-        return;
-    }
-    const start = performance.now();
-    res.on("finish", () => {
-        traceStore.record(traceId, {
-            ts: new Date().toISOString(),
-            source: "backend",
-            kind: "span",
-            name: `http ${req.method} ${req.path}`,
-            durationMs: Number((performance.now() - start).toFixed(2)),
-            attrs: {
-                statusCode: res.statusCode,
-            },
-        });
-    });
-    next();
+// A harness can provide a unique ID and verify that it reached the child it
+// launched, rather than an unrelated process that happened to acquire a port.
+app.get("/api/debug/health", (_req, res) => {
+    res.json({ ok: true, instanceId: INSTANCE_ID, pid: process.pid });
 });
+const localSettingsStore = new LocalSettingsStore();
+const registry = new SessionRegistry();
 // Serve static files in production
 const clientDist = path.resolve(__dirname, "../../client");
 app.use(express.static(clientDist));
 // Register REST endpoints
 registerRestApi(app, {
-    traceStore,
     localSettingsStore,
+    runSessionMutation: (sessionPath, operation, mutation) => {
+        const actor = registry.get(sessionPath);
+        return actor.enqueue(operation, async () => {
+            actor.assertAvailable(operation);
+            await mutation();
+        });
+    },
     onLocalSettingsReloaded: () => {
         wss.clients.forEach((client) => {
             if (client.readyState === WebSocket.OPEN) {
@@ -203,13 +191,16 @@ registerRestApi(app, {
 // ============================================================================
 // Core modules
 // ============================================================================
-const lifecycle = new SessionLifecycle();
-// Resolve canvas extension path relative to project root
+// Resolve bundled extension entrypoints once at startup.
 const canvasExtension = path.resolve(__dirname, "../../../extensions/canvas.ts");
+const usageExtension = resolveUsageExtensionPath();
 const pool = new ProcessPool({
     command: PI_LAUNCH.command,
     baseArgs: () => {
         const args = [...PI_LAUNCH.baseArgs, "--mode", "rpc"];
+        if (USAGE_EXTENSION_ENABLED) {
+            args.push("-e", usageExtension);
+        }
         if (localSettingsStore.canvasEnabled) {
             args.push("-e", canvasExtension);
         }
@@ -219,12 +210,8 @@ const pool = new ProcessPool({
     maxProcesses: PI_MAX_PROCESSES,
     prewarmCount: PI_PREWARM_COUNT,
     onProcessExit: (proc) => {
-        // If the process was attached to a session, handle the crash
-        const sessionPath = lifecycle.getAttachedSessionForProcess(proc);
-        if (sessionPath) {
-            console.log(`[pool] pi#${proc.id} crashed while attached to ${path.basename(sessionPath)} — marking done`);
-            lifecycle.crash(sessionPath);
-        }
+        // WsHandler owns attached-session snapshots and listener bookkeeping.
+        wsHandler.handleProcessExit(proc);
         // Replenish the pool for the default cwd
         if (PI_AVAILABLE) {
             pool.prewarm(PI_CWD);
@@ -232,7 +219,7 @@ const pool = new ProcessPool({
     },
 });
 const wsHandler = new WsHandler({
-    lifecycle,
+    registry,
     pool,
     defaultCwd: PI_CWD,
     piLaunch: PI_LAUNCH,
@@ -242,7 +229,6 @@ const wsHandler = new WsHandler({
         }
     },
     isRequestAuthorized: (req) => isAuthorizedRequest(req),
-    traceStore,
 });
 // Register WS handler
 wsHandler.register(wss);
@@ -320,8 +306,7 @@ function startSessionsWatcher() {
             clearTimeout(debounceTimer);
         debounceTimer = setTimeout(() => {
             const fullPath = path.join(SESSIONS_DIR, lastChangedFile);
-            // Notify the message cache — it will re-read from disk if changed
-            // and push session_messages to the subscribed client if needed.
+            // Re-read detached session state and push it to active subscribers.
             wsHandler.notifySessionFileChanged(fullPath);
             // Also notify all WS clients about the file change (for sidebar refresh)
             wss.clients.forEach((client) => {
@@ -348,7 +333,10 @@ if (PI_AVAILABLE) {
 else {
     console.log(`[pi] ${makePiNotFoundMessage(PI_LAUNCH.command)}`);
 }
-server.listen(PORT, async () => {
+server.listen(REQUESTED_PORT, async () => {
+    const address = server.address();
+    const port = address && typeof address !== "string" ? address.port : REQUESTED_PORT;
+    const authUrl = `http://${PUBLIC_HOSTNAME}:${port}/auth?token=${encodeURIComponent(AUTH_TOKEN)}`;
     log("");
     log("        _                        ");
     log("  _ __ (_)_ __   __ _ _ __   ___ ");
@@ -358,8 +346,8 @@ server.listen(PORT, async () => {
     log(" |_|     |_|                      ");
     log(`  v${PKG_VERSION}`);
     log("");
-    log(`  Local:  http://localhost:${PORT}`);
-    log(`  Remote: ${AUTH_URL}`);
+    log(`  Local:  http://localhost:${port}`);
+    log(`  Remote: ${authUrl}`);
     if (!process.env.PIPANE_AUTH_TOKEN) {
         log(`\n  Auth token is random and changes on restart.`);
         log(`  Set PIPANE_AUTH_TOKEN to use a fixed token.`);

package/dist/server/server/session-actor.js

@@ -0,0 +1,202 @@
+const LEGAL_TRANSITIONS = {
+    detached: ["attaching"],
+    attaching: ["ready", "failed", "releasing"],
+    ready: ["starting", "releasing", "failed"],
+    starting: ["running", "settling", "releasing", "failed"],
+    running: ["settling", "releasing", "failed"],
+    settling: ["releasing", "failed"],
+    releasing: ["detached"],
+    failed: ["releasing"],
+};
+/**
+ * Serialized owner of one session's mutable runtime state.
+ *
+ * Long-running turns do not hold the command mailbox: prompt startup commits the
+ * `starting` phase and returns, Pi events are enqueued as internal commands, and
+ * final settlement is enqueued separately. This leaves steer/abort responsive
+ * while preventing compact/fork/rename from overlapping the turn.
+ */
+export class SessionActor {
+    sessionPath;
+    _phase = "detached";
+    _lease;
+    _session;
+    _turnGeneration = 0;
+    _steeringQueue = [];
+    _turnEventCleanup;
+    commandTail = Promise.resolve();
+    emitEvent;
+    constructor(sessionPath, emitEvent) {
+        this.sessionPath = sessionPath;
+        this.emitEvent = emitEvent;
+    }
+    get phase() { return this._phase; }
+    get process() { return this._lease?.process; }
+    get session() { return this._session; }
+    get turnGeneration() { return this._turnGeneration; }
+    get steeringQueue() { return this._steeringQueue; }
+    get isAttached() { return this._lease !== undefined; }
+    get isTurnActive() {
+        return this._phase === "starting" || this._phase === "running" || this._phase === "settling";
+    }
+    /** Serialize one command or internal event for this session. */
+    enqueue(operation, fn) {
+        const run = this.commandTail.then(fn);
+        this.commandTail = run.then(() => undefined, () => undefined);
+        return run.catch((error) => {
+            if (error instanceof Error) {
+                error.message = `[${operation}] ${error.message}`;
+            }
+            throw error;
+        });
+    }
+    assertAvailable(operation) {
+        if (this.isTurnActive) {
+            throw new Error(`Cannot ${operation} while session turn is ${this._phase}`);
+        }
+        if (this._phase !== "detached" && this._phase !== "ready") {
+            throw new Error(`Cannot ${operation} while session is ${this._phase}`);
+        }
+    }
+    attach(lease, session) {
+        if (this._phase !== "detached" || this._lease) {
+            throw new Error(`Session is already owned in phase ${this._phase}`);
+        }
+        this.transition("attaching");
+        this._lease = lease;
+        this._session = session;
+        this.transition("ready");
+        this.emitEvent({ type: "attached", proc: lease.process });
+    }
+    beginTurn() {
+        if (this._phase !== "ready" || !this._lease || !this._session) {
+            throw new Error(`Cannot start turn while session is ${this._phase}`);
+        }
+        this._turnGeneration += 1;
+        this.transition("starting");
+        return this._turnGeneration;
+    }
+    setTurnEventCleanup(generation, cleanup) {
+        if (generation !== this._turnGeneration || !this.isTurnActive) {
+            cleanup();
+            return;
+        }
+        this._turnEventCleanup?.();
+        this._turnEventCleanup = cleanup;
+    }
+    owns(proc, generation) {
+        return this.process === proc && (generation === undefined || generation === this._turnGeneration);
+    }
+    async applyProcessEvent(proc, generation, event, replacementMessages) {
+        return this.enqueue("process event", () => {
+            if (!this.owns(proc, generation) || !this._session) {
+                return { accepted: false, changed: false, started: false, ended: false, settled: false };
+            }
+            let started = false;
+            let ended = false;
+            let settled = false;
+            if (event.type === "agent_start") {
+                started = true;
+                if (this._phase === "starting")
+                    this.transition("running");
+            }
+            if (event.type === "agent_end") {
+                ended = true;
+                if (this._phase === "starting" || this._phase === "running")
+                    this.transition("settling");
+                this.clearSteering();
+            }
+            if (event.type === "agent_settled") {
+                started = true;
+                ended = true;
+                settled = true;
+                if (this._phase === "starting" || this._phase === "running")
+                    this.transition("settling");
+            }
+            let changed = this._session.applyEvent(event);
+            if (replacementMessages) {
+                this._session.replaceMessages(replacementMessages);
+                changed = true;
+            }
+            if (event.type === "message_end" && event.message?.role === "user") {
+                const text = typeof event.message.content === "string"
+                    ? event.message.content
+                    : (event.message.content || [])
+                        .filter((content) => content.type === "text")
+                        .map((content) => content.text)
+                        .join(" ");
+                this.dequeueSteering(text);
+            }
+            return { accepted: true, changed, started, ended, settled };
+        });
+    }
+    enqueueSteering(message) {
+        this._steeringQueue = [...this._steeringQueue, message];
+        this.syncSteeringQueue();
+    }
+    removeSteeringByIndex(index) {
+        if (index < 0 || index >= this._steeringQueue.length)
+            return false;
+        this._steeringQueue = this._steeringQueue.filter((_, itemIndex) => itemIndex !== index);
+        this.syncSteeringQueue();
+        return true;
+    }
+    dequeueSteering(text) {
+        const index = this._steeringQueue.indexOf(text);
+        if (index === -1)
+            return false;
+        this._steeringQueue = this._steeringQueue.filter((_, itemIndex) => itemIndex !== index);
+        this.syncSteeringQueue();
+        return true;
+    }
+    clearSteering() {
+        if (this._steeringQueue.length === 0)
+            return;
+        this._steeringQueue = [];
+        this.syncSteeringQueue();
+    }
+    markFailed() {
+        if (this._phase === "detached" || this._phase === "releasing" || this._phase === "failed")
+            return;
+        this.transition("failed");
+    }
+    /**
+     * Release all runtime ownership. Safe to call once the actor command holding
+     * the current mutation reaches a terminal path.
+     */
+    detach() {
+        const lease = this._lease;
+        const liveSession = this._session;
+        if (!lease || !liveSession)
+            return undefined;
+        if (this._phase !== "releasing")
+            this.transition("releasing");
+        this._turnEventCleanup?.();
+        this._turnEventCleanup = undefined;
+        if (this._steeringQueue.length > 0) {
+            this._steeringQueue = [];
+            this.emitEvent({ type: "steering_queue_update", queue: [] });
+        }
+        const proc = lease.process;
+        this._lease = undefined;
+        this._session = undefined;
+        lease.release();
+        this.transition("detached");
+        this.emitEvent({ type: "detached", proc });
+        return { proc, liveSession };
+    }
+    syncSteeringQueue() {
+        if (this._session)
+            this._session.steeringQueue = [...this._steeringQueue];
+        this.emitEvent({ type: "steering_queue_update", queue: [...this._steeringQueue] });
+    }
+    transition(next) {
+        if (next === this._phase)
+            return;
+        if (!LEGAL_TRANSITIONS[this._phase].includes(next)) {
+            throw new Error(`Illegal session transition ${this._phase} -> ${next}`);
+        }
+        this._phase = next;
+        this.emitEvent({ type: "phase_change", phase: next });
+    }
+}

package/dist/server/server/session-index.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
-import { getAgentDir, parseSessionEntries } from "@mariozechner/pi-coding-agent";
+import { getAgentDir, parseSessionEntries } from "@earendil-works/pi-coding-agent";
+import { resolveWorktreeName } from "./worktree-name.js";
 const CACHE_FORMAT_VERSION = 1;
 const DEFAULT_EXTRACTOR_VERSION = "2";
 export class SessionIndex {
@@ -8,12 +9,14 @@ export class SessionIndex {
     extractorVersion;
     cacheFilePath;
     cwdDisplayFormatter;
+    worktreeNameResolver;
     inMemoryCache;
     constructor(opts) {
         this.agentDir = opts?.agentDir ?? getAgentDir();
         this.extractorVersion = opts?.extractorVersion ?? DEFAULT_EXTRACTOR_VERSION;
         this.cacheFilePath = path.join(this.agentDir, "cache", "pipane-session-index-v1.json");
         this.cwdDisplayFormatter = opts?.cwdDisplayFormatter;
+        this.worktreeNameResolver = opts?.worktreeNameResolver ?? resolveWorktreeName;
     }
     async listSessions() {
         const files = this.listSessionFiles();
@@ -80,7 +83,20 @@ export class SessionIndex {
                 // on read-only agent dirs or transient filesystem errors.
             }
         }
-        return sessions;
+        const worktreeNames = new Map();
+        return sessions.map((session) => {
+            let worktreeName = worktreeNames.get(session.cwd);
+            if (!worktreeName) {
+                try {
+                    worktreeName = this.worktreeNameResolver(session.cwd) || "root";
+                }
+                catch {
+                    worktreeName = "root";
+                }
+                worktreeNames.set(session.cwd, worktreeName);
+            }
+            return { ...session, worktreeName };
+        });
     }
     async invalidateAll() {
         this.inMemoryCache = null;

package/dist/server/server/session-jsonl.js

@@ -12,7 +12,7 @@
  * from jsonl-sync.ts.
  */
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { parseSessionEntries, buildSessionContext, } from "@mariozechner/pi-coding-agent";
+import { buildContextEntries, buildSessionContext, parseSessionEntries, sessionEntryToContextMessages, } from "@earendil-works/pi-coding-agent";
 import { createHash } from "node:crypto";
 import { computeSyncOp } from "../shared/jsonl-sync.js";
 /** Synchronous SHA-256 hash (server-only, uses node:crypto). */
@@ -52,8 +52,21 @@ export class SessionJsonl {
         this._steeringQueue = q;
         this.rebuildJson();
     }
-    // Expose model for ws-handler
+    // Expose controls for ws-handler reconciliation.
     get model() { return this._model; }
+    get thinkingLevel() { return this._thinkingLevel; }
+    /** Atomically replace the effective model/thinking state reported by pi. */
+    setControlState(model, thinkingLevel) {
+        const sameModel = this._model?.provider === model?.provider
+            && this._model?.modelId === model?.modelId;
+        if (sameModel && this._thinkingLevel === thinkingLevel)
+            return false;
+        this._model = model;
+        this._thinkingLevel = thinkingLevel;
+        this._version++;
+        this.rebuildJson();
+        return true;
+    }
     // Expose messages for post-detach snapshot
     get messages() { return this._messages; }
     /**
@@ -109,6 +122,15 @@ export class SessionJsonl {
                 }
                 return false;
             }
+            case "thinking_level_changed": {
+                const level = event.level ?? event.thinkingLevel;
+                if (typeof level !== "string" || level === this._thinkingLevel)
+                    return false;
+                this._thinkingLevel = level;
+                this._version++;
+                this.rebuildJson();
+                return true;
+            }
             case "tool_execution_start": {
                 const toolCallId = event.toolCallId;
                 if (toolCallId && !this._pendingToolCalls.includes(toolCallId)) {
@@ -212,6 +234,22 @@ export class SessionJsonl {
     }
 }
 // ── Disk reader ────────────────────────────────────────────────────────────
+/**
+ * Build the messages in chronological display order.
+ *
+ * Pi's LLM context intentionally puts the latest compaction summary before the
+ * retained pre-compaction messages. In the conversation timeline, however, the
+ * compaction happened after those retained messages. Restoring append order
+ * keeps the completed marker where the user ran /compact while still omitting
+ * the older messages replaced by the summary.
+ */
+export function buildSessionDisplayMessages(entries) {
+    const sessionEntries = entries.filter((entry) => entry.type !== "session");
+    const entryOrder = new Map(sessionEntries.map((entry, index) => [entry, index]));
+    return [...buildContextEntries(sessionEntries)]
+        .sort((left, right) => (entryOrder.get(left) ?? 0) - (entryOrder.get(right) ?? 0))
+        .flatMap(sessionEntryToContextMessages);
+}
 /**
  * Read a session from disk and return a serialized SessionState JSON + hash.
  */
@@ -223,8 +261,9 @@ export function readSessionFromDisk(sessionPath) {
         if (existsSync(sessionPath)) {
             const content = readFileSync(sessionPath, "utf8");
             const entries = parseSessionEntries(content);
-            const context = buildSessionContext(entries);
-            messages = context.messages ?? [];
+            const sessionEntries = entries.filter((entry) => entry.type !== "session");
+            const context = buildSessionContext(sessionEntries);
+            messages = buildSessionDisplayMessages(entries);
             model = context.model ?? null;
             thinkingLevel = context.thinkingLevel ?? "off";
         }
@@ -240,10 +279,14 @@ export function readSessionFromDisk(sessionPath) {
         thinkingLevel,
         steeringQueue: [],
     };
-    const json = JSON.stringify(state);
-    const hash = computeHashSync(json);
+    const { json, hash } = serializeSessionState(state);
     return { json, hash, state };
 }
+/** Serialize a canonical session state using the wire protocol's hash format. */
+export function serializeSessionState(state) {
+    const json = JSON.stringify(state);
+    return { json, hash: computeHashSync(json) };
+}
 /**
  * Get the file size of a session file. Returns 0 if the file doesn't exist.
  */

package/dist/server/server/session-registry.js

@@ -0,0 +1,67 @@
+import { SessionActor } from "./session-actor.js";
+/** Registry and process index for per-session actors. */
+export class SessionRegistry {
+    actors = new Map();
+    actorsByProcess = new Map();
+    statuses = new Map();
+    listeners = new Set();
+    get(sessionPath) {
+        let actor = this.actors.get(sessionPath);
+        if (!actor) {
+            actor = new SessionActor(sessionPath, (event) => this.handleActorEvent(actor, event));
+            this.actors.set(sessionPath, actor);
+        }
+        return actor;
+    }
+    find(sessionPath) {
+        return this.actors.get(sessionPath);
+    }
+    getActorForProcess(proc) {
+        return this.actorsByProcess.get(proc);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getAllStatuses() {
+        return Object.fromEntries(this.statuses);
+    }
+    getAllSteeringQueues() {
+        const queues = {};
+        for (const [sessionPath, actor] of this.actors) {
+            if (actor.steeringQueue.length > 0)
+                queues[sessionPath] = [...actor.steeringQueue];
+        }
+        return queues;
+    }
+    get attachedCount() {
+        return this.actorsByProcess.size;
+    }
+    handleActorEvent(actor, event) {
+        switch (event.type) {
+            case "attached":
+                this.actorsByProcess.set(event.proc, actor);
+                this.statuses.set(actor.sessionPath, "running");
+                this.emit({ type: "status_change", sessionPath: actor.sessionPath, status: "running" });
+                this.emit({ type: "session_attached", sessionPath: actor.sessionPath, procId: event.proc.id });
+                break;
+            case "detached":
+                if (this.actorsByProcess.get(event.proc) === actor)
+                    this.actorsByProcess.delete(event.proc);
+                this.statuses.set(actor.sessionPath, "done");
+                this.emit({ type: "status_change", sessionPath: actor.sessionPath, status: "done" });
+                this.emit({ type: "session_detached", sessionPath: actor.sessionPath, procId: event.proc.id });
+                break;
+            case "phase_change":
+                this.emit({ type: "phase_change", sessionPath: actor.sessionPath, phase: event.phase });
+                break;
+            case "steering_queue_update":
+                this.emit({ type: "steering_queue_update", sessionPath: actor.sessionPath, queue: event.queue });
+                break;
+        }
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+}

package/dist/server/server/worktree-name.js

@@ -0,0 +1,39 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+/**
+ * Return a short label for the Git checkout containing cwd.
+ *
+ * A linked worktree has a .git file whose target contains a `commondir`
+ * pointer. Regular checkouts (and non-Git directories) are labelled `root`.
+ */
+export function resolveWorktreeName(cwd) {
+    if (!cwd)
+        return "root";
+    let dir = path.resolve(cwd);
+    while (true) {
+        const gitPath = path.join(dir, ".git");
+        if (existsSync(gitPath)) {
+            try {
+                const stat = statSync(gitPath);
+                if (stat.isDirectory())
+                    return "root";
+                if (!stat.isFile())
+                    return "root";
+                const marker = readFileSync(gitPath, "utf8").trim();
+                if (!marker.startsWith("gitdir: "))
+                    return "root";
+                const gitDir = path.resolve(dir, marker.slice("gitdir: ".length).trim());
+                if (!existsSync(path.join(gitDir, "commondir")))
+                    return "root";
+                return path.basename(dir) || "root";
+            }
+            catch {
+                return "root";
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return "root";
+        dir = parent;
+    }
+}