@rynx-ai/daemon 0.1.11-beta.2 → 0.1.11-beta.4

package/dist/maintenance-lease.js

@@ -0,0 +1,250 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+const LEASE_SCHEMA_VERSION = 1;
+// The detached updater can spend 24h waiting for idle before cutover begins.
+// Once accepted, retain a separate bounded recovery window long enough for the
+// package switch and rollback even if the updater is killed at its outer limit.
+const DEFAULT_LEASE_TTL_MS = 30 * 60 * 60 * 1_000;
+const EXPIRY_RETRY_MS = 1_000;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const LEASE_TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,256}$/;
+export function maintenanceLeaseFile(env = process.env) {
+    return join(rynxHome(env), "maintenance-lease.json");
+}
+/**
+ * Cross-process admission fence used only during daemon replacement.
+ *
+ * The raw bearer token is never persisted. The bounded expiry means a crashed
+ * upgrader cannot leave the daemon permanently unavailable, while atomic rename
+ * ensures a replacement daemon sees either the complete lease or no lease.
+ */
+export class MaintenanceLeaseStore {
+    filePath;
+    now;
+    ttlMs;
+    syncDirectory;
+    onExpired;
+    lease;
+    expiryTimer;
+    constructor(options = {}) {
+        this.filePath = options.filePath ?? maintenanceLeaseFile();
+        this.now = options.now ?? (() => Date.now());
+        this.ttlMs = options.ttlMs ?? DEFAULT_LEASE_TTL_MS;
+        this.syncDirectory = options.syncDirectory ?? fsyncDirectory;
+        this.onExpired = options.onExpired ?? (() => undefined);
+        if (!Number.isSafeInteger(this.ttlMs) || this.ttlMs <= 0) {
+            throw new Error("maintenance lease TTL must be a positive safe integer");
+        }
+        this.lease = this.readPersistedLease();
+        this.scheduleExpiry();
+    }
+    isActive() {
+        if (!this.lease)
+            return false;
+        if (this.lease.expiresAt > this.now())
+            return true;
+        this.expire();
+        return false;
+    }
+    isHeldBy(token) {
+        let tokenHash;
+        try {
+            tokenHash = hashLeaseToken(token);
+        }
+        catch {
+            return false;
+        }
+        return Boolean(this.isActive()
+            && this.lease
+            && hashesEqual(this.lease.tokenHash, tokenHash));
+    }
+    acquire(token) {
+        const tokenHash = hashLeaseToken(token);
+        if (this.isActive()) {
+            if (this.lease && hashesEqual(this.lease.tokenHash, tokenHash)) {
+                const createdAt = this.now();
+                const renewed = {
+                    schemaVersion: LEASE_SCHEMA_VERSION,
+                    tokenHash,
+                    createdAt,
+                    expiresAt: createdAt + this.ttlMs,
+                };
+                // Fail closed in memory if persistence reaches an indeterminate I/O
+                // outcome; the caller sees the error, but this process must not reopen
+                // admission around a lease file that may already have been renamed.
+                this.lease = renewed;
+                try {
+                    this.writePersistedLease(renewed);
+                }
+                finally {
+                    this.scheduleExpiry();
+                }
+                return false;
+            }
+            throw new Error("a different maintenance lease is already active");
+        }
+        const createdAt = this.now();
+        const lease = {
+            schemaVersion: LEASE_SCHEMA_VERSION,
+            tokenHash,
+            createdAt,
+            expiresAt: createdAt + this.ttlMs,
+        };
+        this.lease = lease;
+        try {
+            this.writePersistedLease(lease);
+        }
+        finally {
+            this.scheduleExpiry();
+        }
+        return true;
+    }
+    release(token) {
+        if (!this.isActive())
+            return "not_active";
+        const lease = this.lease;
+        if (!lease)
+            return "not_active";
+        let tokenHash;
+        try {
+            tokenHash = hashLeaseToken(token);
+        }
+        catch {
+            return "denied";
+        }
+        if (!hashesEqual(lease.tokenHash, tokenHash))
+            return "denied";
+        this.clear();
+        return "released";
+    }
+    readPersistedLease() {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(this.filePath, "utf8"));
+        }
+        catch (error) {
+            if (error
+                && typeof error === "object"
+                && "code" in error
+                && error.code === "ENOENT")
+                return undefined;
+            throw new Error("maintenance lease state is unreadable", { cause: error });
+        }
+        if (!isPersistedLease(parsed, this.ttlMs)) {
+            throw new Error("maintenance lease state is invalid");
+        }
+        if (parsed.expiresAt <= this.now()) {
+            this.clearFile();
+            return undefined;
+        }
+        return parsed;
+    }
+    writePersistedLease(lease) {
+        const parent = dirname(this.filePath);
+        mkdirSync(parent, { recursive: true, mode: 0o700 });
+        const temporary = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+        let descriptor;
+        try {
+            descriptor = openSync(temporary, "wx", 0o600);
+            writeFileSync(descriptor, `${JSON.stringify(lease)}\n`, "utf8");
+            fsyncSync(descriptor);
+            closeSync(descriptor);
+            descriptor = undefined;
+            renameSync(temporary, this.filePath);
+            this.syncDirectory(parent);
+        }
+        finally {
+            if (descriptor !== undefined)
+                closeSync(descriptor);
+            rmSync(temporary, { force: true });
+        }
+    }
+    clear() {
+        this.clearFile();
+        this.lease = undefined;
+        this.cancelExpiry();
+    }
+    clearFile() {
+        rmSync(this.filePath, { force: true });
+        this.syncDirectory(dirname(this.filePath));
+    }
+    expire() {
+        this.clear();
+        this.onExpired();
+    }
+    scheduleExpiry(delayOverride) {
+        this.cancelExpiry();
+        if (!this.lease)
+            return;
+        const delay = delayOverride ?? Math.max(0, this.lease.expiresAt - this.now());
+        this.expiryTimer = setTimeout(() => {
+            this.expiryTimer = undefined;
+            if (!this.lease)
+                return;
+            if (this.lease.expiresAt > this.now()) {
+                this.scheduleExpiry();
+                return;
+            }
+            try {
+                this.expire();
+            }
+            catch {
+                // Keep the in-memory fence and retry cleanup. A failed durability
+                // operation must not turn an expired lease into open admission.
+                this.scheduleExpiry(EXPIRY_RETRY_MS);
+            }
+        }, Math.min(delay, MAX_TIMER_DELAY_MS));
+        this.expiryTimer.unref?.();
+    }
+    cancelExpiry() {
+        if (this.expiryTimer)
+            clearTimeout(this.expiryTimer);
+        this.expiryTimer = undefined;
+    }
+}
+function fsyncDirectory(directory) {
+    let descriptor;
+    try {
+        descriptor = openSync(directory, "r");
+        fsyncSync(descriptor);
+    }
+    catch (error) {
+        if (error
+            && typeof error === "object"
+            && "code" in error
+            && error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function hashLeaseToken(token) {
+    if (!LEASE_TOKEN_PATTERN.test(token)) {
+        throw new Error("maintenance lease token must be 32-256 base64url characters");
+    }
+    return createHash("sha256").update(token, "utf8").digest("hex");
+}
+function hashesEqual(left, right) {
+    const leftBuffer = Buffer.from(left, "hex");
+    const rightBuffer = Buffer.from(right, "hex");
+    return leftBuffer.length === rightBuffer.length
+        && timingSafeEqual(leftBuffer, rightBuffer);
+}
+function isPersistedLease(value, maximumTtlMs) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return candidate.schemaVersion === LEASE_SCHEMA_VERSION
+        && typeof candidate.tokenHash === "string"
+        && /^[a-f0-9]{64}$/.test(candidate.tokenHash)
+        && Number.isSafeInteger(candidate.createdAt)
+        && Number.isSafeInteger(candidate.expiresAt)
+        && candidate.createdAt >= 0
+        && candidate.expiresAt > candidate.createdAt
+        && candidate.expiresAt - candidate.createdAt <= maximumTtlMs;
+}

package/dist/plugin-host-rpc.d.ts

@@ -1,4 +1,4 @@
-import { type AgentSpec, type AgentCapabilities, type AgentRuntimeId, type AgentSessionStore, type ConversationRuntime, type ResolvedExecutionSnapshot, type SessionRegistry, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+import { type AdmissionReservation, type AgentSpec, type AgentCapabilities, type AgentRuntimeId, type AgentSessionStore, type ConversationRuntime, type ResolvedExecutionSnapshot, type SessionRegistry, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
 import { type PluginAgentSummary, type PluginCapability, type PluginHostEvent, type PluginResolvedSessionExecution, type PluginSessionExecutionSnapshot, type PluginSessionInteractionResolveDisposition } from "@rynx-ai/plugin-sdk";
 import type { SessionInteractionResolution } from "@rynx-ai/protocol";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
@@ -18,6 +18,7 @@ export interface PluginAgentCatalogHost {
 export interface PluginSessionLaunchSelection {
     projectId?: string;
     managedCwd?: string;
+    workspace?: SessionWorkspaceSnapshot;
     agent?: string;
     config?: AgentSpec;
     provider?: AgentRuntimeId;
@@ -45,6 +46,7 @@ export interface PluginHostServices {
         resolve(input: PluginSessionLaunchSelection): Promise<PluginResolvedSessionLaunch>;
     };
     interruptSession?(sessionId: string): Promise<boolean>;
+    terminateSession?(sessionId: string): Promise<boolean>;
     resolveSessionInteraction?(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
         disposition: PluginSessionInteractionResolveDisposition;
     }>;
@@ -56,6 +58,8 @@ export interface PluginHostServices {
         sessionId: string;
         disposition: "created" | "replayed";
     }>;
+    admissionOpen?: () => boolean;
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 export interface PluginHostRpcOptions {
     /** Manifest id returned by host.info. */
@@ -63,6 +67,8 @@ export interface PluginHostRpcOptions {
     /** Marketplace-qualified principal used for ownership and proof scopes. */
     principalId?: string;
     daemonInstanceId: string;
+    productVersion: string;
+    cliVersion: string;
     capabilities: readonly PluginCapability[];
     services: PluginHostServices;
     /** Canonical plugin-owned root permitted for the Workspace plugin's isolated
@@ -70,6 +76,8 @@ export interface PluginHostRpcOptions {
     managedWorkspaceRoot?: string;
     /** Resolving this promise is the stream's backpressure acknowledgement. */
     emit(event: PluginHostEvent): void | Promise<void>;
+    /** Bounded graceful-stop window used while disposing this Host. */
+    disposeForceAfterMs?: number;
 }
 /**
  * One authenticated plugin's capability-gated Host RPC surface.
@@ -82,21 +90,28 @@ export declare class PluginHostRpc {
     private readonly pluginId;
     private readonly principalId;
     private readonly daemonInstanceId;
+    private readonly productVersion;
+    private readonly cliVersion;
     private readonly capabilities;
     private readonly services;
     private readonly managedWorkspaceRoot;
     private readonly emit;
+    private readonly disposeForceAfterMs;
     private readonly activeRuns;
     private readonly activeSessionRuns;
     private readonly activeRunsByOperation;
     private disposed;
+    private disposePromise?;
     constructor(options: PluginHostRpcOptions);
     call(method: string, params: unknown, signal?: AbortSignal): Promise<unknown>;
     dispose(): Promise<void>;
     private ensureSession;
+    private ensureSessionAdmitted;
     private resolveManagedWorkspace;
+    private resolveWorkspaceSnapshot;
     private sessionEnsureResult;
     private runSession;
+    private runSessionAdmitted;
     private pumpRun;
     private releaseRun;
     private steerSession;
@@ -110,6 +125,9 @@ export declare class PluginHostRpc {
     private withOwnedSession;
     private resolveSessionInteraction;
     private forkSession;
+    private forkSessionAdmitted;
+    private reserveAdmission;
+    private withAdmission;
     private setSessionTitle;
     private resolveAgentExecution;
     private issueControlLink;

package/dist/plugin-host-rpc.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { realpath } from "node:fs/promises";
+import { realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { AgentRuntimeError, agentSpecSchema, resolvedExecutionSnapshotSchema, sessionWorkspaceSnapshotSchema, SteerController, } from "@rynx-ai/core";
 import { PLUGIN_HOST_MAX_ACTIVE_RUNS, } from "@rynx-ai/plugin-sdk";
@@ -47,24 +47,31 @@ export class PluginHostRpc {
     pluginId;
     principalId;
     daemonInstanceId;
+    productVersion;
+    cliVersion;
     capabilities;
     services;
     managedWorkspaceRoot;
     emit;
+    disposeForceAfterMs;
     activeRuns = new Map();
     activeSessionRuns = new Map();
     activeRunsByOperation = new Map();
     disposed = false;
+    disposePromise;
     constructor(options) {
         this.pluginId = requiredString(options.pluginId, "pluginId", 64);
         this.principalId = requiredString(options.principalId ?? options.pluginId, "principalId", 160);
         this.daemonInstanceId = requiredString(options.daemonInstanceId, "daemonInstanceId", 128);
+        this.productVersion = requiredString(options.productVersion, "productVersion", 128);
+        this.cliVersion = requiredString(options.cliVersion, "cliVersion", 128);
         this.capabilities = new Set(options.capabilities);
         this.services = options.services;
         this.managedWorkspaceRoot = options.managedWorkspaceRoot
             ? path.resolve(options.managedWorkspaceRoot)
             : undefined;
         this.emit = options.emit;
+        this.disposeForceAfterMs = options.disposeForceAfterMs ?? 10_000;
     }
     async call(method, params, signal) {
         if (this.disposed)
@@ -75,6 +82,8 @@ export class PluginHostRpc {
                 pluginId: this.pluginId,
                 installationId: this.services.installationId,
                 daemonInstanceId: this.daemonInstanceId,
+                productVersion: this.productVersion,
+                cliVersion: this.cliVersion,
                 installationProof: {
                     algorithm: this.services.installationProof.algorithm,
                     publicKey: this.services.installationProof.publicKey,
@@ -151,51 +160,85 @@ export class PluginHostRpc {
         }
     }
     async dispose() {
-        if (this.disposed)
-            return;
+        if (this.disposePromise)
+            return this.disposePromise;
         this.disposed = true;
         const runs = [...this.activeRuns.values()];
-        this.activeRuns.clear();
-        this.activeSessionRuns.clear();
-        this.activeRunsByOperation.clear();
-        for (const run of runs) {
-            run.interruptRequested = true;
-            if (run.interruptResult && await run.interruptResult.catch(() => false))
-                continue;
-            if (this.services.interruptSession) {
-                await this.services.interruptSession(run.sessionId).catch(() => false);
-            }
-            else {
-                run.abort.abort();
+        this.disposePromise = (async () => {
+            const stopped = await Promise.allSettled(runs.map(async (run) => {
+                if (this.activeRuns.get(run.runId) !== run)
+                    return;
+                run.interruptRequested = true;
+                const graceful = run.interruptResult ?? (this.services.interruptSession
+                    ? Promise.resolve().then(() => this.services.interruptSession(run.sessionId))
+                    : Promise.resolve().then(() => {
+                        run.abort.abort();
+                        return false;
+                    }));
+                const authoritative = forceStoppedInterrupt(graceful, this.disposeForceAfterMs, () => this.services.terminateSession?.(run.sessionId) ?? Promise.resolve(false));
+                run.interruptResult = authoritative;
+                if (!(await authoritative)) {
+                    throw new Error(`could not prove Session ${run.sessionId} stopped`);
+                }
+                this.releaseRun(run);
+            }));
+            const failures = stopped
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            if (failures.length > 0) {
+                throw new AggregateError(failures, "plugin Host could not stop every active run");
             }
-        }
+        })();
+        return this.disposePromise;
     }
     async ensureSession(params) {
+        return this.withAdmission(() => this.ensureSessionAdmitted(params));
+    }
+    async ensureSessionAdmitted(params) {
         const input = record(params);
         const scopeId = requiredString(input.scopeId, "scopeId", 512);
         const operationId = requiredString(input.operationId, "operationId", 512);
         const parsedSelection = sessionLaunchSelection(input.session);
+        if (parsedSelection.managedCwd && !this.managedWorkspaceRoot) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd is reserved for the built-in Workspace plugin");
+        }
+        const rawRequestHash = hashCanonicalJson(parsedSelection);
+        const replay = replayPluginSessionLaunch({
+            pluginId: this.principalId,
+            scopeId,
+            operationId,
+            requestHash: rawRequestHash,
+            allowRequestHashMismatch: true,
+        });
+        if (replay)
+            return this.sessionEnsureResult(replay);
         const selection = parsedSelection.managedCwd
             ? {
                 ...parsedSelection,
                 managedCwd: await this.resolveManagedWorkspace(parsedSelection.managedCwd),
             }
-            : parsedSelection;
+            : parsedSelection.workspace
+                ? {
+                    ...parsedSelection,
+                    workspace: await this.resolveWorkspaceSnapshot(parsedSelection.workspace),
+                }
+                : parsedSelection;
         const requestHash = hashCanonicalJson(selection);
-        const replay = replayPluginSessionLaunch({
+        const canonicalReplay = replayPluginSessionLaunch({
             pluginId: this.principalId,
             scopeId,
             operationId,
             requestHash,
         });
-        if (replay)
-            return this.sessionEnsureResult(replay);
+        if (canonicalReplay)
+            return this.sessionEnsureResult(canonicalReplay);
         const resolved = await this.services.sessionLaunch.resolve(selection);
         const ensured = ensurePluginSessionLaunch({
             pluginId: this.principalId,
             scopeId,
             operationId,
             requestHash,
+            rawRequestHash,
             session: {
                 workspace: sessionWorkspaceSnapshotSchema.parse(resolved.workspace),
                 execution: resolvedExecutionSnapshotSchema.parse(resolved.execution),
@@ -231,6 +274,33 @@ export class PluginHostRpc {
         }
         return canonicalDirectory;
     }
+    async resolveWorkspaceSnapshot(workspace) {
+        const directories = [workspace.cwd, ...workspace.allowedDirs];
+        if (directories.some((directory) => !path.isAbsolute(directory))) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.workspace paths must be absolute");
+        }
+        let canonical;
+        try {
+            canonical = await Promise.all(directories.map(async (directory) => {
+                const resolved = await realpath(directory);
+                if (!(await stat(resolved)).isDirectory()) {
+                    throw new Error("not a directory");
+                }
+                return resolved;
+            }));
+        }
+        catch {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.workspace paths must be existing directories");
+        }
+        const parsed = sessionWorkspaceSnapshotSchema.safeParse({
+            cwd: canonical[0],
+            allowedDirs: canonical.slice(1),
+        });
+        if (!parsed.success) {
+            throw new PluginHostCallError("INVALID_PARAMS", `invalid session.workspace: ${parsed.error.issues[0]?.message ?? "invalid snapshot"}`);
+        }
+        return parsed.data;
+    }
     sessionEnsureResult(result) {
         const session = this.ownedSession(result.sessionId);
         return {
@@ -243,6 +313,9 @@ export class PluginHostRpc {
         };
     }
     async runSession(params, signal) {
+        return this.withAdmission(() => this.runSessionAdmitted(params, signal));
+    }
+    async runSessionAdmitted(params, signal) {
         const input = record(params);
         const sessionId = requiredSessionId(input);
         const operationId = optionalString(input.operationId, "operationId", 512);
@@ -411,6 +484,10 @@ export class PluginHostRpc {
     async interruptRun(params) {
         const input = record(params);
         const run = this.activeRunByIdentity(input);
+        const forceAfterMs = optionalPositiveNumber(input.forceAfterMs, "forceAfterMs");
+        if (forceAfterMs !== undefined && forceAfterMs > 30_000) {
+            throw new PluginHostCallError("INVALID_PARAMS", "forceAfterMs must not exceed 30000");
+        }
         if (run.interruptResult) {
             return { interrupted: await run.interruptResult };
         }
@@ -418,7 +495,7 @@ export class PluginHostRpc {
         // the authoritative stop is pending wait for its result: true suppresses
         // them, while false/error lets genuine native progress/terminal continue.
         run.interruptRequested = true;
-        const interruptResult = this.services.interruptSession
+        const graceful = this.services.interruptSession
             // ConversationRuntime wires AbortSignal to this same native operation.
             // Invoke it directly once so this boolean is the authoritative result;
             // aborting first would trigger a duplicate, unobserved interrupt.
@@ -429,6 +506,9 @@ export class PluginHostRpc {
                 // effort and cannot prove that native execution stopped.
                 return false;
             });
+        const interruptResult = forceAfterMs === undefined
+            ? graceful
+            : forceStoppedInterrupt(graceful, forceAfterMs, () => this.services.terminateSession?.(run.sessionId) ?? Promise.resolve(false));
         run.interruptResult = interruptResult;
         try {
             const interrupted = await interruptResult;
@@ -510,6 +590,9 @@ export class PluginHostRpc {
         return await resolve(sessionId, interactionId, resolution);
     }
     async forkSession(params) {
+        return this.withAdmission(() => this.forkSessionAdmitted(params));
+    }
+    async forkSessionAdmitted(params) {
         const input = record(params);
         const sourceSessionId = requiredString(input.sourceSessionId, "sourceSessionId", 512);
         const operationId = requiredString(input.operationId, "operationId", 512);
@@ -524,6 +607,24 @@ export class PluginHostRpc {
             ...(title ? { title } : {}),
         });
     }
+    reserveAdmission() {
+        const reservation = this.services.admissionReserve?.();
+        if (reservation)
+            return reservation;
+        if (!this.services.admissionReserve && this.services.admissionOpen?.() !== false) {
+            return { release() { } };
+        }
+        throw new PluginHostCallError("HOST_CALL_FAILED", "daemon maintenance is in progress", true);
+    }
+    async withAdmission(operation) {
+        const reservation = this.reserveAdmission();
+        try {
+            return await operation();
+        }
+        finally {
+            reservation.release();
+        }
+    }
     setSessionTitle(params) {
         const input = record(params);
         const sessionId = requiredSessionId(input);
@@ -612,14 +713,15 @@ function sessionLaunchSelection(value) {
     assertJsonValue(input, "session");
     const projectId = optionalString(input.projectId, "session.projectId", 512);
     const managedCwd = optionalString(input.managedCwd, "session.managedCwd", 16_384);
+    const workspace = optionalSessionWorkspace(input.workspace);
     const agent = optionalAgentId(input.agent, "session.agent");
     const config = input.config === undefined ? undefined : agentSpecSchema.parse(input.config);
     const provider = optionalRuntimeValue(input.provider);
     const model = optionalString(input.model, "session.model", 256);
     const reasoningEffort = optionalString(input.reasoningEffort, "session.reasoningEffort", 128);
     const title = optionalString(input.title, "session.title", 1_000);
-    if (Number(Boolean(projectId)) + Number(Boolean(managedCwd)) > 1) {
-        throw new PluginHostCallError("INVALID_PARAMS", "session.projectId and session.managedCwd are mutually exclusive");
+    if (Number(Boolean(projectId)) + Number(Boolean(managedCwd)) + Number(Boolean(workspace)) > 1) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.projectId, session.managedCwd, and session.workspace are mutually exclusive");
     }
     if (Number(Boolean(agent)) +
         Number(Boolean(config)) +
@@ -630,6 +732,7 @@ function sessionLaunchSelection(value) {
     return {
         ...(projectId ? { projectId } : {}),
         ...(managedCwd ? { managedCwd } : {}),
+        ...(workspace ? { workspace } : {}),
         ...(agent ? { agent } : {}),
         ...(config ? { config } : {}),
         ...(provider ? { provider } : {}),
@@ -638,6 +741,17 @@ function sessionLaunchSelection(value) {
         ...(title ? { title } : {}),
     };
 }
+function optionalSessionWorkspace(value) {
+    if (value === undefined)
+        return undefined;
+    const input = record(value);
+    const cwd = requiredPathString(input.cwd, "session.workspace.cwd", 16_384);
+    if (!Array.isArray(input.allowedDirs) || input.allowedDirs.length === 0) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.workspace.allowedDirs must be a non-empty string array");
+    }
+    const allowedDirs = input.allowedDirs.map((directory, index) => requiredPathString(directory, `session.workspace.allowedDirs[${index}]`, 16_384));
+    return { cwd, allowedDirs };
+}
 function sessionExecutionSnapshot(value) {
     const input = record(value);
     const runtime = optionalRuntimeValue(input.runtime);
@@ -718,6 +832,15 @@ function requiredString(value, label, maxLength) {
     }
     return value.trim();
 }
+function requiredPathString(value, label, maxLength) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} is required`);
+    }
+    if (value.length > maxLength) {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} is too long`);
+    }
+    return value;
+}
 function requiredText(value, label, maxLength) {
     if (typeof value !== "string" || !value.trim()) {
         throw new PluginHostCallError("INVALID_PARAMS", `${label} is required`);
@@ -758,6 +881,23 @@ function optionalPositiveNumber(value, label) {
     }
     return value;
 }
+async function forceStoppedInterrupt(graceful, forceAfterMs, terminate) {
+    let timer;
+    const graceExpired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), forceAfterMs);
+        timer.unref?.();
+    });
+    try {
+        if (await Promise.race([graceful.catch(() => false), graceExpired])) {
+            return true;
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+    return terminate();
+}
 function assertJsonValue(value, label, seen = new Set()) {
     if (value === null || typeof value === "string" || typeof value === "boolean")
         return;