pi-session-mcp 0.11.9 → 0.12.1

package/dist/session-registry.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { PiSessionCreationError } from "./pi-adapter.js";
 const REGISTRY_ERROR_MESSAGES = {
+    writer_session_lost: "Writer session was lost",
+    base_not_applicable: "Base is only applicable to coding sessions on container workspaces",
     unknown_workspace: "Unknown workspace",
     writer_uncollected: "Writer is not at its collected baseline",
     writer_busy: "Writer already has an open coding session",
@@ -58,7 +60,7 @@ export class SessionRegistry {
         this.onTurnTerminal = options.onTurnTerminal;
         this.options = { preflightDeadlineMs: options.preflightDeadlineMs ?? PREFLIGHT_DEADLINE_MS, abortDeadlineMs: options.abortDeadlineMs ?? ABORT_DEADLINE_MS, closeCleanupDeadlineMs: options.closeCleanupDeadlineMs ?? CLOSE_CLEANUP_DEADLINE_MS, shutdownDeadlineMs: options.shutdownDeadlineMs ?? SHUTDOWN_DEADLINE_MS };
     }
-    async start(workspace, executionProfile) {
+    async start(workspace, executionProfile, options = {}) {
         if (this.stopping)
             throw new RegistryError("server_stopping");
         const cwd = this.workspaces.get(workspace);
@@ -66,8 +68,8 @@ export class SessionRegistry {
             throw new RegistryError("unknown_workspace");
         // Track registration and orphan cleanup too, not just the raw adapter promise.
         const start = this.writerGuard && executionProfile.permissionProfile === "coding"
-            ? this.guardedCreate(cwd, workspace, executionProfile)
-            : this.createAndRegister(cwd, workspace, executionProfile);
+            ? this.guardedCreate(cwd, workspace, executionProfile, options)
+            : this.createAndRegister(cwd, workspace, executionProfile, options);
         this.pendingStarts.add(start);
         try {
             return await start;
@@ -76,7 +78,7 @@ export class SessionRegistry {
             this.pendingStarts.delete(start);
         }
     }
-    async guardedCreate(cwd, workspace, executionProfile) {
+    async guardedCreate(cwd, workspace, executionProfile, options) {
         const previous = this.codingAdmissions.get(workspace) ?? Promise.resolve();
         let release;
         const admission = new Promise((resolve) => { release = resolve; });
@@ -89,7 +91,7 @@ export class SessionRegistry {
             await this.writerGuard.check(workspace, open);
             if (this.stopping)
                 throw new RegistryError("server_stopping");
-            return await this.createAndRegister(cwd, workspace, executionProfile);
+            return await this.createAndRegister(cwd, workspace, executionProfile, options);
         }
         finally {
             release();
@@ -97,8 +99,8 @@ export class SessionRegistry {
                 this.codingAdmissions.delete(workspace);
         }
     }
-    async createAndRegister(cwd, workspace, executionProfile) {
-        const handle = await Promise.resolve().then(() => this.adapter.create({ cwd, executionProfile, signal: this.shutdownController.signal }));
+    async createAndRegister(cwd, workspace, executionProfile, options) {
+        const handle = await Promise.resolve().then(() => this.adapter.create({ cwd, workspace, ...(options.base === undefined ? {} : { base: options.base }), executionProfile, signal: this.shutdownController.signal }));
         try {
             if (this.stopping)
                 throw new RegistryError("server_stopping");
@@ -108,6 +110,7 @@ export class SessionRegistry {
                 id: randomUUID(), workspace, executionProfile: executionProfile.alias, profile: executionProfile.permissionProfile,
                 provider: handle.appliedSelection.provider, model: handle.appliedSelection.model,
                 thinkingLevel: handle.appliedSelection.thinkingLevel, state: "idle", createdAt: time, updatedAt: time,
+                ...(handle.placement ? { writer: handle.placement.writer, base: { ...handle.placement.base } } : {}),
                 handle, operation: Promise.resolve(), disposed: false, turns: new Map(), order: [],
             };
             this.sessions.set(entry.id, entry);
@@ -130,6 +133,8 @@ export class SessionRegistry {
     async prompt(id, text) {
         const entry = this.require(id);
         return this.serial(entry, async () => {
+            if (entry.handle.isLost?.())
+                throw new RegistryError("writer_session_lost");
             if (entry.state === "running" || entry.abortPromise)
                 throw new RegistryError("session_running");
             if (entry.state === "closing" || entry.state === "closed")
@@ -189,7 +194,7 @@ export class SessionRegistry {
             const result = await this.withTimeout(Promise.race([
                 preflight.then((value) => ({ kind: "preflight", value })),
                 operation.then(() => ({ kind: "operation" }), () => ({ kind: "operation" })),
-            ]), this.options.preflightDeadlineMs, { kind: "timeout" });
+            ]), entry.handle.deadlines?.preflightMs ?? this.options.preflightDeadlineMs, { kind: "timeout" });
             if (result.kind === "timeout") {
                 this.quarantineTimedOutPreflight(entry, turn, operation, previous);
                 throw new RegistryError("prompt_timeout");
@@ -224,7 +229,7 @@ export class SessionRegistry {
             }
             return this.view(entry);
         });
-        const result = await this.withTimeout(operation.then((session) => ({ kind: "completed", session }), () => ({ kind: "failed" })), this.options.abortDeadlineMs, { kind: "timeout" });
+        const result = await this.withTimeout(operation.then((session) => ({ kind: "completed", session }), () => ({ kind: "failed" })), entry.handle.deadlines?.abortMs ?? this.options.abortDeadlineMs, { kind: "timeout" });
         if (result.kind === "timeout")
             throw new RegistryError("abort_timeout");
         if (result.kind === "failed")
@@ -253,7 +258,7 @@ export class SessionRegistry {
                 turn.completedAt = time;
                 this.notifyTerminal(existing, turn, "close");
                 const abortPromise = this.beginAbort(existing, turn);
-                await this.withTimeout(abortPromise.then(() => undefined, () => undefined), this.options.closeCleanupDeadlineMs, undefined);
+                await this.withTimeout(abortPromise.then(() => undefined, () => undefined), existing.handle.deadlines?.cleanupMs ?? this.options.closeCleanupDeadlineMs, undefined);
             }
             existing.turn = undefined;
             existing.turnPromise = undefined;
@@ -289,7 +294,7 @@ export class SessionRegistry {
         const normalized = normalize(outcome.assistantText);
         turn.state = "completed";
         turn.assistantText = normalized.text;
-        turn.truncated = normalized.truncated;
+        turn.truncated = normalized.truncated || outcome.truncated === true;
     }
     else if (outcome.status === "aborted")
         turn.state = "aborted";
@@ -394,7 +399,7 @@ export class SessionRegistry {
     async disposeHandle(handle) {
         try {
             const cleanup = Promise.resolve(handle.dispose()).then(() => undefined, () => undefined);
-            await this.withTimeout(cleanup, this.options.closeCleanupDeadlineMs, undefined);
+            await this.withTimeout(cleanup, handle.deadlines?.cleanupMs ?? this.options.closeCleanupDeadlineMs, undefined);
         }
         catch { /* Cleanup errors must never expose adapter internals. */ }
     }

package/dist/setup-cli.js

@@ -81,7 +81,7 @@ export function parseSetupArgs(argv) {
             customizeSkill = value;
             continue;
         }
-        if (["--repo", "--mode", "--accept-host-writes", "--writers", "--lifecycle", "--profiles", "--image", "--network", "--cache"].includes(argument)) {
+        if (["--repo", "--mode", "--accept-host-writes", "--writers", "--lifecycle", "--profiles", "--image", "--network", "--cache", "--tags"].includes(argument)) {
             if (modeFlags.has(argument))
                 throw new Error("repo_argument_repeated");
             modeFlags.add(argument);
@@ -124,8 +124,13 @@ export function parseSetupArgs(argv) {
                         throw new Error("network_invalid");
                     container.network = value;
                     break;
+                case "--tags":
+                    if (value !== "none" && value !== "reachable")
+                        throw new Error("tags_invalid");
+                    container.tags = value;
+                    break;
                 case "--cache":
-                    if (value !== "none" && value !== "go")
+                    if (value !== "none" && value !== "go" && value !== "uv")
                         throw new Error("cache_invalid");
                     container.cache = value;
                     break;

package/dist/setup-hooks.js

@@ -33,8 +33,6 @@ export const WAKE_TIMEOUT_MARGIN_SECONDS = 60;
 export const WAKE_MATCHER = [
     "mcp__pi-session-mcp__pi_session_prompt",
     "mcp__pi-session-mcp__pi_turn_get",
-    "mcp__pi-coding-.*__pi_session_prompt",
-    "mcp__pi-coding-.*__pi_turn_get",
 ].join("|");
 /** A command referencing this program path marks an entry as pi-session-mcp's. */
 const WAKE_PROGRAM = /\/dist\/wake-main\.js(?=$|[\s"'])/;

package/dist/setup-modes.js

@@ -60,7 +60,13 @@ export async function changeExecutionMode(configPath, request, dependencies = {}
             return done("failed", "container_profiles_required");
         if (request.mode === "container" && !await runtimeUsable())
             return done("failed", "container_runtime_unavailable");
-        const entry = mode === "host" ? { mode, acceptHostWrites: true } : mode === "container" ? { ...request.container, mode } : { mode };
+        const entry = mode === "host" ? { mode, acceptHostWrites: true } : mode === "container" ? (() => {
+            const existing = current.workspaces[request.alias];
+            const previousBase = existing?.mode === "container" ? existing.base : undefined;
+            const requestedBase = request.baseRef?.replace(/^refs\/heads\//, "");
+            const base = requestedBase ?? previousBase ?? request.container?.base;
+            return { ...request.container, mode, ...(base === undefined ? {} : { base }) };
+        })() : { mode };
         let proposed;
         try {
             proposed = executionModesSchema.parse({ schemaVersion: 1, workspaces: { ...raw.workspaces, [request.alias]: entry } });

package/dist/setup-process.d.ts

@@ -24,7 +24,9 @@ export declare const MCP_SERVER_SHUTDOWN_GRACE_MS = 2000;
 /** Runs only an explicit executable/argv pair, with bounded output and termination. */
 export declare function createProcessRunner(options?: ProcessRunnerOptions): CommandRunner;
 /** Generalized bounded stdio transport for a generated writer wrapper. */
-export declare function createCommandMcpStdioLauncher(command: readonly [string, ...string[]], env: NodeJS.ProcessEnv): (signal: AbortSignal) => Promise<McpStdioProcess>;
+export declare function createCommandMcpStdioLauncher(command: readonly [string, ...string[]], env: NodeJS.ProcessEnv, options?: {
+    inheritFds?: readonly number[];
+}): (signal: AbortSignal) => Promise<McpStdioProcess>;
 export interface McpLauncherOptions {
     readonly nodePath: string;
     readonly entryPath: string;

package/dist/setup-process.js

@@ -56,7 +56,7 @@ export function createProcessRunner(options = {}) {
             if (!table)
                 return { exitCode: 126, stdout: "", stderr: "" };
             return new Promise((resolve) => {
-                const child = spawn(command, [...args], { stdio: ["ignore", "pipe", "pipe"], env: runOptions?.env ? { ...(options.env ?? process.env), ...runOptions.env } : options.env, cwd: runOptions?.cwd, detached: process.platform !== "win32" });
+                const child = spawn(command, [...args], { stdio: ["ignore", "pipe", "pipe", ...(runOptions?.inheritFds ?? [])], env: runOptions?.env ? { ...(options.env ?? process.env), ...runOptions.env } : options.env, cwd: runOptions?.cwd, detached: process.platform !== "win32" });
                 let stdout = "";
                 let stderr = "";
                 let overflow = false;
@@ -132,9 +132,9 @@ export function createProcessRunner(options = {}) {
         } };
 }
 /** Generalized bounded stdio transport for a generated writer wrapper. */
-export function createCommandMcpStdioLauncher(command, env) {
+export function createCommandMcpStdioLauncher(command, env, options) {
     return async (signal) => {
-        const child = spawn(command[0], command.slice(1), { stdio: ["pipe", "pipe", "pipe"], env, detached: process.platform !== "win32" });
+        const child = spawn(command[0], command.slice(1), { stdio: ["pipe", "pipe", "pipe", ...(options?.inheritFds ?? [])], env, detached: process.platform !== "win32" });
         let buffer = "", closed = false, overflow = false;
         child.stdout.on("data", (chunk) => { if (!overflow) {
             buffer += chunk.toString("utf8");
@@ -415,7 +415,8 @@ export async function acquireSetupGuardian(lockFd, timeoutMs, signal, validateFe
     } });
     const runner = {
         run(command, args, runSignal, runOptions) {
-            if (runOptions?.env !== undefined || released || unsafe || pending || runSignal?.aborted || !child.connected)
+            // The guardian child cannot pass descriptors through; refuse instead of dropping a caller's lease.
+            if (runOptions?.env !== undefined || runOptions?.inheritFds !== undefined || released || unsafe || pending || runSignal?.aborted || !child.connected)
                 return Promise.resolve({ exitCode: 126, stdout: "", stderr: "" });
             const id = nextId++;
             return new Promise((resolve) => {

package/dist/setup-writers.d.ts

@@ -6,8 +6,11 @@ import { type OwnershipStore } from "./setup-ownership.js";
 import { type SetupResult } from "./setup-result.js";
 import { type WriterRegistrationAdapter } from "./client-adapters/writer-registration.js";
 import { verifyMcpCapabilities } from "./client-adapters/mcp-verifier.js";
+import { acquireWriterLease } from "./writer-lease.js";
+import { ensureWriterAbsent } from "./writer-fence.js";
 import * as lifecycle from "./writer-lifecycle.js";
 import * as acceptance from "./writer-acceptance.js";
+export declare const SETUP_LEASE_WAIT_MS = 10000;
 export type WriterOperation = "collect" | "reset" | "recreate" | "finish" | "remove" | "verify";
 export interface WriterOptions {
     apply: boolean;
@@ -29,6 +32,8 @@ export interface WriterSetupDependencies {
     verify?: typeof verifyMcpCapabilities;
     launch?: typeof createCommandMcpStdioLauncher;
     lock?: typeof acquireOverrideLock;
+    lease?: typeof acquireWriterLease;
+    ensureAbsent?: typeof ensureWriterAbsent;
     containerRuntime?: () => Promise<boolean>;
 }
 /** Serializes planning, destructive-work refusal, mode commit and writer reconciliation. */