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

package/dist/plugin-cli.js

@@ -1,14 +1,15 @@
 import { spawn } from "node:child_process";
 import { mkdirSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
-import { rynxHome } from "@rynx-ai/core";
-import { createPluginCliInvocationLeaseId, parsePluginCliHostEffect, removePluginRuntimeLease, writePluginRuntimeLease, } from "@rynx-ai/plugin-sdk";
+import { createPluginCliInvocationLeaseId, removePluginRuntimeLease, writePluginRuntimeLease, } from "@rynx-ai/plugin-sdk";
 import { db } from "./db.js";
-import { getPlugin, isRunnablePluginRecord } from "./plugin-store.js";
+import { pluginDataDir, pluginRuntimeCacheDir } from "./plugin-installer.js";
+import { validatePluginPackageSnapshot } from "./plugin-package.js";
+import { getPlugin } from "./plugin-store.js";
 import { loadOrCreateDaemonInstallationIdentitySync } from "./installation-id.js";
 const DEFAULT_TERMINATION_GRACE_MS = 2_000;
 const MAX_TERMINATION_GRACE_MS = 30_000;
-/** Execute one statically declared plugin command in a separate Node process. */
+/** Execute one statically declared, language-neutral plugin command. */
 export async function runPluginCliCommand(pluginId, args, options = {}) {
     const hostEnv = options.env ?? process.env;
     const terminationGraceMs = options.terminationGraceMs ?? DEFAULT_TERMINATION_GRACE_MS;
@@ -21,7 +22,6 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
     let terminationReason;
     let forceKillTimer;
     let abortListener;
-    const effects = new Map();
     if (options.stdin !== undefined && options.stdio !== "pipe") {
         throw new Error("plugin CLI stdin requires piped stdio");
     }
@@ -37,6 +37,13 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
     if (options.signal?.aborted)
         throw pluginCliAbortError(options.signal.reason);
     const installationIdentity = loadOrCreateDaemonInstallationIdentitySync(hostEnv);
+    const verifiedRecord = getPlugin(pluginId);
+    if (!verifiedRecord)
+        throw new Error(`plugin "${pluginId}" is not installed`);
+    const verifiedIntegrity = await validatePluginPackageSnapshot(verifiedRecord.installPath, options.signal ? { signal: options.signal } : {});
+    if (verifiedIntegrity !== verifiedRecord.integrity) {
+        throw new Error(`plugin package integrity changed for "${verifiedRecord.canonicalId}"`);
+    }
     const clearForceKill = () => {
         if (forceKillTimer)
             clearTimeout(forceKillTimer);
@@ -47,24 +54,14 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
         terminationReason ??= reason;
         if (!childIsRunning())
             return;
-        try {
-            child.kill("SIGTERM");
-        }
-        catch {
-            // The close/error event remains authoritative for cleanup.
-        }
+        signalChildTree(child, "SIGTERM");
         if (forceKillTimer)
             return;
         forceKillTimer = setTimeout(() => {
             forceKillTimer = undefined;
             if (!childIsRunning())
                 return;
-            try {
-                child.kill("SIGKILL");
-            }
-            catch {
-                // Completion still waits for close/error; no lease is removed early.
-            }
+            signalChildTree(child, "SIGKILL");
         }, terminationGraceMs);
         forceKillTimer.unref?.();
     };
@@ -81,14 +78,13 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
             const record = getPlugin(pluginId);
             if (!record)
                 throw new Error(`plugin "${pluginId}" is not installed`);
-            if (!isRunnablePluginRecord(record)) {
-                throw new Error(`plugin "${pluginId}" uses the removed legacy format; reinstall it`);
+            if (record.integrity !== verifiedRecord.integrity ||
+                record.installPath !== verifiedRecord.installPath ||
+                record.updatedAt !== verifiedRecord.updatedAt) {
+                throw new Error(`plugin "${pluginId}" changed while its command was being prepared; retry`);
             }
-            // `enabled` controls daemon runtime contributions, not explicit CLI calls.
-            // Keeping commands available lets a user stop/status a managed service before
-            // uninstalling a disabled plugin.
             const command = args[0];
-            const declared = record.manifest.contributions?.commands?.find((entry) => entry.id === command);
+            const declared = record.manifest.commands?.items.find((entry) => entry.id === command);
             if (!command ||
                 command === "--help" ||
                 command === "-h" ||
@@ -98,41 +94,40 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
             if (!declared) {
                 throw new PluginCliUsageError(`plugin "${pluginId}" does not declare command "${command}"\n\n${pluginCommandUsage(record)}`);
             }
-            if (!record.manifest.cliEntry) {
-                throw new Error(`plugin "${pluginId}" declares commands but has no cliEntry`);
+            if (!record.manifest.commands) {
+                throw new Error(`plugin "${pluginId}" declares no CLI command executable`);
             }
             const packageRoot = realpathSync(record.installPath);
-            const cliEntry = realpathSync(path.resolve(packageRoot, record.manifest.cliEntry));
+            const cliEntry = realpathSync(path.resolve(packageRoot, record.manifest.commands.command));
             if (!isPathInside(packageRoot, cliEntry) || !statSync(cliEntry).isFile()) {
-                throw new Error(`plugin "${pluginId}" cliEntry resolves outside its package`);
+                throw new Error(`plugin "${pluginId}" commands.command resolves outside its package`);
             }
-            dataDir = path.join(rynxHome(), "plugin-data", record.name);
+            dataDir = pluginDataDir(record.marketplaceId, record.pluginId);
+            const cacheDir = pluginRuntimeCacheDir(record.marketplaceId, record.pluginId, record.integrity);
             mkdirSync(dataDir, { recursive: true, mode: 0o700 });
-            child = spawn(process.execPath, [cliEntry, ...args], {
+            mkdirSync(cacheDir, { recursive: true, mode: 0o700 });
+            child = spawn(cliEntry, [...args], {
                 cwd: dataDir,
                 env: {
-                    ...hostEnv,
+                    PATH: hostEnv.PATH,
+                    HOME: hostEnv.HOME,
+                    TMPDIR: hostEnv.TMPDIR,
+                    LANG: hostEnv.LANG,
                     RYNX_HOST_INSTALLATION_ID: installationIdentity.installationId,
                     RYNX_HOST_INSTALLATION_PROOF_ALGORITHM: installationIdentity.algorithm,
                     RYNX_HOST_INSTALLATION_PUBLIC_KEY: installationIdentity.publicKey,
-                    RYNX_PLUGIN_ID: record.name,
+                    RYNX_PLUGIN_ID: record.pluginId,
+                    RYNX_PLUGIN_INSTALLATION_ID: record.canonicalId,
                     RYNX_PLUGIN_PACKAGE_ROOT: packageRoot,
                     RYNX_PLUGIN_DATA_DIR: dataDir,
+                    RYNX_PLUGIN_CACHE_DIR: cacheDir,
                 },
                 stdio: options.stdio === "pipe"
-                    ? ["pipe", "pipe", "pipe", "ipc"]
-                    : ["inherit", "inherit", "inherit", "ipc"],
+                    ? ["pipe", "pipe", "pipe"]
+                    : ["inherit", "inherit", "inherit"],
+                detached: process.platform !== "win32",
             });
             completion = new Promise((resolve, reject) => {
-                child.on("message", (message) => {
-                    try {
-                        const effect = parsePluginCliHostEffect(message);
-                        effects.set(effect.effect, effect);
-                    }
-                    catch (error) {
-                        terminateChild(error instanceof Error ? error : new Error(String(error)));
-                    }
-                });
                 child.once("error", (error) => {
                     if (!childIsRunning()) {
                         reject(error);
@@ -172,7 +167,7 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
             leaseId = createPluginCliInvocationLeaseId(child.pid ?? process.pid);
             writePluginRuntimeLease({
                 dataDir,
-                pluginId: record.name,
+                pluginId: record.pluginId,
                 leaseId,
                 installPath: packageRoot,
             });
@@ -193,7 +188,6 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
         const code = await completion;
         return {
             code,
-            effects: code === 0 ? [...effects.values()] : [],
             ...(options.captureOutputBytes !== undefined && stdout && stderr
                 ? {
                     output: {
@@ -210,6 +204,23 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
         cleanup();
     }
 }
+function signalChildTree(child, signal) {
+    if (process.platform !== "win32" && child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        catch {
+            // Fall back to the direct child if its process group already exited.
+        }
+    }
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // Completion still waits for close/error; no lease is removed early.
+    }
+}
 function pluginCliAbortError(reason) {
     const error = new Error(reason instanceof Error && reason.message ? reason.message : "plugin CLI command aborted");
     error.name = reason instanceof Error && reason.name === "TimeoutError"
@@ -246,7 +257,7 @@ function captureStream(stream, limit) {
     };
 }
 export function pluginCommandUsage(record) {
-    const commands = record.manifest.contributions?.commands ?? [];
+    const commands = record.manifest.commands?.items ?? [];
     const lines = [`Usage: rynx plugin ${record.name} <command> [args...]`];
     if (commands.length === 0)
         return [...lines, "", "This plugin declares no CLI commands."].join("\n");

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

@@ -0,0 +1,4 @@
+/** Fixed leases owned by the resident daemon's plugin supervisor. A new daemon
+ * may reclaim these only after it has acquired the exclusive RYNX_HOME owner
+ * lock and before starting any plugin runners. */
+export declare const PLUGIN_HOST_RUNTIME_LEASE_IDS: readonly ["host-runtime", "host-settings"];

package/dist/plugin-host-leases.js

@@ -0,0 +1,7 @@
+/** Fixed leases owned by the resident daemon's plugin supervisor. A new daemon
+ * may reclaim these only after it has acquired the exclusive RYNX_HOME owner
+ * lock and before starting any plugin runners. */
+export const PLUGIN_HOST_RUNTIME_LEASE_IDS = [
+    "host-runtime",
+    "host-settings",
+];

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

@@ -1,4 +1,4 @@
-import { type AgentCapabilities, type AgentSessionStore, type ConversationRuntime, type SessionRegistry } from "@rynx-ai/core";
+import { 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";
@@ -12,6 +12,23 @@ export interface PluginAgentCatalogHost {
         session: PluginSessionExecutionSnapshot;
     }): Promise<PluginResolvedSessionExecution>;
 }
+/** Mutable launch selectors are accepted only at the Host boundary. The
+ * resolver turns them into immutable Session-owned snapshots before a registry
+ * row is created; none of these selectors are persisted on the Session. */
+export interface PluginSessionLaunchSelection {
+    projectId?: string;
+    managedCwd?: string;
+    agent?: string;
+    config?: AgentSpec;
+    provider?: AgentRuntimeId;
+    model?: string;
+    reasoningEffort?: string;
+    title?: string;
+}
+export interface PluginResolvedSessionLaunch {
+    workspace: SessionWorkspaceSnapshot;
+    execution: ResolvedExecutionSnapshot;
+}
 export interface PluginHostServices {
     installationId: string;
     installationProof: {
@@ -24,16 +41,33 @@ export interface PluginHostServices {
     sessionStore: AgentSessionStore;
     sessionRegistry: SessionRegistry;
     agentCatalog: PluginAgentCatalogHost;
+    sessionLaunch: {
+        resolve(input: PluginSessionLaunchSelection): Promise<PluginResolvedSessionLaunch>;
+    };
     interruptSession?(sessionId: string): Promise<boolean>;
     resolveSessionInteraction?(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
         disposition: PluginSessionInteractionResolveDisposition;
     }>;
+    sessionFork?(input: {
+        sourceSessionId: string;
+        operationId: string;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+        disposition: "created" | "replayed";
+    }>;
 }
 export interface PluginHostRpcOptions {
+    /** Manifest id returned by host.info. */
     pluginId: string;
+    /** Marketplace-qualified principal used for ownership and proof scopes. */
+    principalId?: string;
     daemonInstanceId: string;
-    grants: readonly PluginCapability[];
+    capabilities: readonly PluginCapability[];
     services: PluginHostServices;
+    /** Canonical plugin-owned root permitted for the Workspace plugin's isolated
+     * Session directory. Omitted for every other plugin. */
+    managedWorkspaceRoot?: string;
     /** Resolving this promise is the stream's backpressure acknowledgement. */
     emit(event: PluginHostEvent): void | Promise<void>;
 }
@@ -46,18 +80,22 @@ export interface PluginHostRpcOptions {
  */
 export declare class PluginHostRpc {
     private readonly pluginId;
+    private readonly principalId;
     private readonly daemonInstanceId;
-    private readonly grants;
+    private readonly capabilities;
     private readonly services;
+    private readonly managedWorkspaceRoot;
     private readonly emit;
     private readonly activeRuns;
     private readonly activeSessionRuns;
     private readonly activeRunsByOperation;
     private disposed;
     constructor(options: PluginHostRpcOptions);
-    call(method: string, params: unknown): Promise<unknown>;
+    call(method: string, params: unknown, signal?: AbortSignal): Promise<unknown>;
     dispose(): Promise<void>;
     private ensureSession;
+    private resolveManagedWorkspace;
+    private sessionEnsureResult;
     private runSession;
     private pumpRun;
     private releaseRun;

package/dist/plugin-host-rpc.js

@@ -1,8 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
-import { AgentRuntimeError, agentSpecSchema, SteerController, } from "@rynx-ai/core";
+import { realpath } 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";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
-import { ensurePluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
+import { ensurePluginSessionLaunch, replayPluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
 import { createControlLink } from "./control-link-store.js";
 const MAX_MESSAGE_LENGTH = 1_000_000;
 /** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
@@ -43,9 +45,11 @@ const METHOD_CAPABILITY = {
  */
 export class PluginHostRpc {
     pluginId;
+    principalId;
     daemonInstanceId;
-    grants;
+    capabilities;
     services;
+    managedWorkspaceRoot;
     emit;
     activeRuns = new Map();
     activeSessionRuns = new Map();
@@ -53,14 +57,19 @@ export class PluginHostRpc {
     disposed = false;
     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.grants = new Set(options.grants);
+        this.capabilities = new Set(options.capabilities);
         this.services = options.services;
+        this.managedWorkspaceRoot = options.managedWorkspaceRoot
+            ? path.resolve(options.managedWorkspaceRoot)
+            : undefined;
         this.emit = options.emit;
     }
-    async call(method, params) {
+    async call(method, params, signal) {
         if (this.disposed)
             throw new PluginHostCallError("HOST_CLOSED", "plugin host is closed");
+        throwIfHostCallAborted(signal);
         if (method === "host.info") {
             return {
                 pluginId: this.pluginId,
@@ -71,14 +80,14 @@ export class PluginHostRpc {
                     publicKey: this.services.installationProof.publicKey,
                 },
                 protocolVersion: 1,
-                grants: [...this.grants],
+                capabilities: [...this.capabilities],
             };
         }
         const capability = METHOD_CAPABILITY[method];
         if (!capability)
             throw new PluginHostCallError("METHOD_NOT_FOUND", `unknown host method: ${method}`);
-        if (!this.grants.has(capability)) {
-            throw new PluginHostCallError("CAPABILITY_DENIED", `host method ${method} requires capability ${capability}`);
+        if (!this.capabilities.has(capability)) {
+            throw new PluginHostCallError("CAPABILITY_NOT_DECLARED", `host method ${method} is missing manifest capability ${capability}`);
         }
         try {
             switch (method) {
@@ -87,7 +96,7 @@ export class PluginHostRpc {
                     return {
                         algorithm: this.services.installationProof.algorithm,
                         publicKey: this.services.installationProof.publicKey,
-                        signature: this.services.installationProof.sign(this.pluginId, challenge),
+                        signature: this.services.installationProof.sign(this.principalId, challenge),
                     };
                 }
                 case "agent.catalog.list":
@@ -97,9 +106,9 @@ export class PluginHostRpc {
                 case "agent.execution.resolve":
                     return await this.resolveAgentExecution(params);
                 case "session.ensure":
-                    return this.ensureSession(params);
+                    return await this.ensureSession(params);
                 case "session.run":
-                    return await this.runSession(params);
+                    return await this.runSession(params, signal);
                 case "session.steer":
                     return this.steerSession(params);
                 case "session.interrupt":
@@ -161,21 +170,79 @@ export class PluginHostRpc {
             }
         }
     }
-    ensureSession(params) {
+    async ensureSession(params) {
         const input = record(params);
         const scopeId = requiredString(input.scopeId, "scopeId", 512);
         const operationId = requiredString(input.operationId, "operationId", 512);
-        const session = sessionLaunchMeta(input.session);
-        const requestHash = hashCanonicalJson(session);
-        return ensurePluginSessionLaunch({
-            pluginId: this.pluginId,
+        const parsedSelection = sessionLaunchSelection(input.session);
+        const selection = parsedSelection.managedCwd
+            ? {
+                ...parsedSelection,
+                managedCwd: await this.resolveManagedWorkspace(parsedSelection.managedCwd),
+            }
+            : parsedSelection;
+        const requestHash = hashCanonicalJson(selection);
+        const replay = replayPluginSessionLaunch({
+            pluginId: this.principalId,
             scopeId,
             operationId,
             requestHash,
-            session,
         });
+        if (replay)
+            return this.sessionEnsureResult(replay);
+        const resolved = await this.services.sessionLaunch.resolve(selection);
+        const ensured = ensurePluginSessionLaunch({
+            pluginId: this.principalId,
+            scopeId,
+            operationId,
+            requestHash,
+            session: {
+                workspace: sessionWorkspaceSnapshotSchema.parse(resolved.workspace),
+                execution: resolvedExecutionSnapshotSchema.parse(resolved.execution),
+                ...(selection.title ? { title: selection.title } : {}),
+            },
+        });
+        return this.sessionEnsureResult(ensured);
+    }
+    async resolveManagedWorkspace(directory) {
+        const root = this.managedWorkspaceRoot;
+        if (!root) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd is reserved for the built-in Workspace plugin");
+        }
+        if (!path.isAbsolute(directory)) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd must be absolute");
+        }
+        let canonicalRoot;
+        let canonicalDirectory;
+        try {
+            [canonicalRoot, canonicalDirectory] = await Promise.all([
+                realpath(root),
+                realpath(directory),
+            ]);
+        }
+        catch {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd must be an existing plugin-managed directory");
+        }
+        const relative = path.relative(canonicalRoot, canonicalDirectory);
+        if (relative === ".." ||
+            relative.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relative)) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd escapes the plugin-managed workspace root");
+        }
+        return canonicalDirectory;
+    }
+    sessionEnsureResult(result) {
+        const session = this.ownedSession(result.sessionId);
+        return {
+            ...result,
+            execution: {
+                provider: session.execution.provider,
+                model: session.execution.model,
+                reasoningEffort: session.execution.reasoningEffort,
+            },
+        };
     }
-    async runSession(params) {
+    async runSession(params, signal) {
         const input = record(params);
         const sessionId = requiredSessionId(input);
         const operationId = optionalString(input.operationId, "operationId", 512);
@@ -191,6 +258,12 @@ export class PluginHostRpc {
         }
         const message = requiredText(input.message, "message", MAX_MESSAGE_LENGTH);
         const abort = new AbortController();
+        const cancel = () => abort.abort(signal?.reason);
+        if (signal?.aborted) {
+            cancel();
+            throwIfHostCallAborted(signal);
+        }
+        signal?.addEventListener("abort", cancel, { once: true });
         const steer = new SteerController();
         const runId = randomUUID();
         const run = {
@@ -210,23 +283,23 @@ export class PluginHostRpc {
             started = await this.services.conversationRuntime.runLive({
                 message,
                 threadId: sessionId,
-                provider: optionalRuntimeValue(input.provider),
-                model: optionalString(input.model, "model", 256) ?? session.model,
-                reasoningEffort: optionalString(input.reasoningEffort, "reasoningEffort", 128) ?? session.reasoningEffort,
-                cwd: optionalString(input.cwd, "cwd", 16_384),
-                agentName: optionalAgentId(input.agent, "agent") ?? session.agent,
-                agentSpec: session.config,
+                workspace: session.workspace,
+                execution: session.execution,
                 signal: abort.signal,
                 steer,
-                developerInstructions: optionalString(input.developerInstructions, "developerInstructions", 200_000),
             });
         }
         catch (error) {
             this.releaseRun(run);
             throw error;
         }
-        if (this.disposed || this.activeRuns.get(runId) !== run) {
+        finally {
+            signal?.removeEventListener("abort", cancel);
+        }
+        if (signal?.aborted || this.disposed || this.activeRuns.get(runId) !== run) {
+            abort.abort(signal?.reason);
             this.releaseRun(run);
+            throwIfHostCallAborted(signal);
             throw new PluginHostCallError("HOST_CLOSED", "plugin host is closed");
         }
         // Let the RPC transport write the request response before stream events are
@@ -438,11 +511,18 @@ export class PluginHostRpc {
     }
     async forkSession(params) {
         const input = record(params);
-        const fromSessionId = requiredString(input.fromSessionId, "fromSessionId", 512);
-        const toSessionId = requiredString(input.toSessionId, "toSessionId", 512);
-        this.ownedSession(fromSessionId);
-        this.ownedSession(toSessionId);
-        return await this.services.capabilities.forkSession(fromSessionId, toSessionId);
+        const sourceSessionId = requiredString(input.sourceSessionId, "sourceSessionId", 512);
+        const operationId = requiredString(input.operationId, "operationId", 512);
+        const title = optionalString(input.title, "title", 1_000);
+        this.ownedSession(sourceSessionId);
+        if (!this.services.sessionFork) {
+            throw new PluginHostCallError("HOST_CALL_FAILED", "Session fork is unavailable");
+        }
+        return await this.services.sessionFork({
+            sourceSessionId,
+            operationId: `${this.principalId}:${operationId}`,
+            ...(title ? { title } : {}),
+        });
     }
     setSessionTitle(params) {
         const input = record(params);
@@ -466,7 +546,7 @@ export class PluginHostRpc {
         this.ownedSession(sessionId);
         const ttlSeconds = optionalPositiveNumber(input.ttlSeconds, "ttlSeconds");
         return createControlLink({
-            pluginId: this.pluginId,
+            pluginId: this.principalId,
             sessionId,
             ...(ttlSeconds === undefined ? {} : { ttlMs: ttlSeconds * 1_000 }),
         });
@@ -479,9 +559,24 @@ export class PluginHostRpc {
         return session;
     }
     isOwned(session) {
-        return session.source === `plugin:${this.pluginId}`;
+        const seen = new Set();
+        let current = session;
+        while (current && !seen.has(current.id)) {
+            if (current.source === `plugin:${this.principalId}`)
+                return true;
+            seen.add(current.id);
+            current = current.forkedFromSessionId
+                ? this.services.sessionRegistry.get(current.forkedFromSessionId)
+                : undefined;
+        }
+        return false;
     }
 }
+function throwIfHostCallAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw new PluginHostCallError("REQUEST_CANCELLED", "plugin host request was cancelled");
+}
 export class PluginHostCallError extends PluginRunnerError {
     retryable;
     data;
@@ -512,17 +607,32 @@ function toHostCallError(error) {
     }
     return new PluginHostCallError("HOST_CALL_FAILED", error instanceof Error ? error.message : String(error));
 }
-function sessionLaunchMeta(value) {
+function sessionLaunchSelection(value) {
     const input = record(value);
     assertJsonValue(input, "session");
+    const projectId = optionalString(input.projectId, "session.projectId", 512);
+    const managedCwd = optionalString(input.managedCwd, "session.managedCwd", 16_384);
     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(agent)) +
+        Number(Boolean(config)) +
+        Number(Boolean(provider)) >
+        1) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.agent, session.config, and session.provider are mutually exclusive");
+    }
     return {
+        ...(projectId ? { projectId } : {}),
+        ...(managedCwd ? { managedCwd } : {}),
         ...(agent ? { agent } : {}),
         ...(config ? { config } : {}),
+        ...(provider ? { provider } : {}),
         ...(model ? { model } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
         ...(title ? { title } : {}),