@abot-ai/runtime 1.3.0 → 1.4.0

package/dist/src/cli/host-companion-entry.d.ts

@@ -0,0 +1,8 @@
+import type { Readable } from "node:stream";
+import { runHostCompanionCli } from "./host-companion.js";
+/** Installer-only setup receives secrets over stdin; login startup uses host run. */
+export declare function runHostCompanionEntry(args: string[], options?: Readonly<{
+    input?: Readable;
+    cliPath?: string;
+    runCli?: typeof runHostCompanionCli;
+}>): Promise<void>;

package/dist/src/cli/host-companion-entry.js

@@ -0,0 +1,70 @@
+import { stdin } from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { isNativeCredential } from "../../plugins/system/source/companion/native-state.js";
+import { isHostRecord } from "../../plugins/system/source/companion/protocol.js";
+import { runHostCompanionCli } from "./host-companion.js";
+const SETUP_INPUT_LIMIT_BYTES = 16_384;
+const SETUP_INPUT_TIMEOUT_MS = 10_000;
+async function readSetupInput(input) {
+    const chunks = [];
+    let length = 0;
+    const deadline = setTimeout(() => {
+        input.destroy(new Error("Host setup input timed out."));
+    }, SETUP_INPUT_TIMEOUT_MS);
+    try {
+        for await (const chunk of input) {
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            length += bytes.length;
+            if (length > SETUP_INPUT_LIMIT_BYTES)
+                throw new Error("Host setup input exceeds the size limit.");
+            chunks.push(bytes);
+        }
+        try {
+            return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        }
+        catch {
+            throw new Error("Host setup requires a JSON object on standard input.");
+        }
+    }
+    finally {
+        clearTimeout(deadline);
+    }
+}
+function readSetupRequest(value) {
+    if (!isHostRecord(value))
+        throw new Error("Invalid host setup request.");
+    if (Object.keys(value).some((key) => !["url", "code"].includes(key)))
+        throw new Error("Unexpected host setup fields.");
+    if (typeof value.url !== "string")
+        throw new Error("Missing Runtime URL.");
+    if (value.url.length === 0 || value.url.length > 4_096)
+        throw new Error("Invalid Runtime URL length.");
+    if (!isNativeCredential(value.code))
+        throw new Error("Invalid pairing code.");
+    return { url: value.url, code: value.code };
+}
+/** Installer-only setup receives secrets over stdin; login startup uses host run. */
+export async function runHostCompanionEntry(args, options = {}) {
+    const cliPath = options.cliPath ?? fileURLToPath(import.meta.url);
+    const runCli = options.runCli ?? runHostCompanionCli;
+    if (args[0] === "setup") {
+        if (args.length !== 1)
+            throw new Error("Host setup accepts JSON on standard input, not arguments.");
+        const setup = readSetupRequest(await readSetupInput(options.input ?? stdin));
+        await runCli(["connect", "--url", setup.url], {
+            cliPath,
+            pairingCode: setup.code,
+        });
+        return;
+    }
+    if (args[0] !== "host")
+        throw new Error("Use setup or host <run|status|disconnect|uninstall>.");
+    await runCli(args.slice(1), { cliPath });
+}
+if (process.argv[1] &&
+    import.meta.url === pathToFileURL(process.argv[1]).href) {
+    void runHostCompanionEntry(process.argv.slice(2)).catch((error) => {
+        console.error(error instanceof Error ? error.message : "Host companion failed.");
+        process.exitCode = 1;
+    });
+}

package/dist/src/cli/host-companion-startup.d.ts

@@ -0,0 +1,4 @@
+import { type NativeAutostartOptions } from "../../plugins/system/source/companion/autostart.js";
+import type { NativeHostState } from "../../plugins/system/source/companion/native-state.js";
+/** Startup can be resumed without consuming another grant or changing the saved pairing. */
+export declare function completeHostCompanionStartup(state: NativeHostState, startup: NativeAutostartOptions, hostId: string): Promise<void>;

package/dist/src/cli/host-companion-startup.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import { installNativeAutostart, } from "../../plugins/system/source/companion/autostart.js";
+async function startDetachedCompanion(options) {
+    const child = spawn(options.nodePath, [options.cliPath, "host", "run"], {
+        cwd: options.homeDir,
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+    });
+    child.unref();
+}
+async function waitForNativeConnection(state, hostId) {
+    const deadline = Date.now() + 10_000;
+    do {
+        if (await state.isConnected(hostId))
+            return true;
+        await delay(200);
+    } while (Date.now() < deadline);
+    return false;
+}
+/** Startup can be resumed without consuming another grant or changing the saved pairing. */
+export async function completeHostCompanionStartup(state, startup, hostId) {
+    const installed = await installNativeAutostart(startup);
+    if (!installed.started)
+        await startDetachedCompanion(startup);
+    const connected = await waitForNativeConnection(state, hostId);
+    console.log(connected
+        ? "Host companion connected. It will start automatically when you log in."
+        : "Host companion installed for login startup. It is waiting for the local Runtime to reconnect.");
+}

package/dist/src/cli/host-companion.d.ts

@@ -0,0 +1,5 @@
+export type HostCompanionCliOptions = Readonly<{
+    cliPath?: string;
+    pairingCode?: string;
+}>;
+export declare function runHostCompanionCli(args: string[], options?: HostCompanionCliOptions): Promise<void>;

package/dist/src/cli/host-companion.js

@@ -0,0 +1,203 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { fileURLToPath } from "node:url";
+import { nativeAutostartFile, uninstallNativeAutostart, } from "../../plugins/system/source/companion/autostart.js";
+import { normalizeNativeRuntimeUrl, resolveNativeRuntimeAddress, } from "../../plugins/system/source/companion/native-address.js";
+import { readNativeHostIdentity } from "../../plugins/system/source/companion/native-identity.js";
+import { connectNativeHost } from "../../plugins/system/source/companion/native-session.js";
+import { createNativeHostState, } from "../../plugins/system/source/companion/native-state.js";
+import { runNativeHostSupervisor } from "../../plugins/system/source/companion/native-supervisor.js";
+import { isProcessOwnerAlive, requireCurrentProcessOwnerIdentity, } from "../../plugins/system/source/companion/process-owner-identity.js";
+import { acquireFileLock } from "../runtime/adapters/long-term-memory/file-lock/acquisition.js";
+import { ensurePrivateRuntimeDirectory } from "../runtime/local-host/private-directory.js";
+import { assertPrivateRuntimeAccess } from "../runtime/local-host/private-access.js";
+import { completeHostCompanionStartup } from "./host-companion-startup.js";
+function printHostHelp() {
+    console.log([
+        "Usage:",
+        "  abot host connect --url http://localhost:5177",
+        "  abot host status",
+        "  abot host disconnect",
+        "  abot host uninstall",
+        "  abot host run",
+        "",
+        "Connect asks for a one-time code from ABot Settings, saves a private credential,",
+        "and starts the companion now and at future Windows/macOS user logins.",
+        "Run is the foreground companion used by the login registration.",
+        "Disconnect/uninstall stop the registration and remove this computer's credential.",
+        "Revoke the host in ABot Settings to remove Runtime-side pairing too.",
+    ].join("\n"));
+}
+function nativeState() {
+    return createNativeHostState(join(homedir(), ".abot", "host-companion"), {
+        ensureDirectory: ensurePrivateRuntimeDirectory,
+        assertFile: (path, stat) => assertPrivateRuntimeAccess(path, stat, "host_companion_state_not_private"),
+    });
+}
+function autostartOptions(state, options = {}) {
+    return {
+        platform: process.platform,
+        homeDir: homedir(),
+        appData: process.env.APPDATA,
+        uid: process.getuid?.(),
+        nodePath: process.execPath,
+        cliPath: options.cliPath ?? fileURLToPath(new URL("./bin.js", import.meta.url)),
+        stateDir: state.directory,
+    };
+}
+async function readPairingCode() {
+    const prompt = createInterface({ input: stdin, output: stdout });
+    try {
+        return (await prompt.question("One-time pairing code: ")).trim();
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function withStopSignals(operation) {
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        await operation(controller.signal);
+    }
+    finally {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+    }
+}
+function hasConflictingSavedRuntime(saved, url) {
+    if (!saved)
+        return false;
+    return saved.url !== url;
+}
+async function connectHost(args, state, options) {
+    if (args.length !== 2 || args[0] !== "--url")
+        throw new Error("Usage: abot host connect --url http://localhost:5177");
+    const startup = autostartOptions(state, options);
+    nativeAutostartFile(startup);
+    const url = normalizeNativeRuntimeUrl(args[1]);
+    await resolveNativeRuntimeAddress(url);
+    const saved = await state.read();
+    if (hasConflictingSavedRuntime(saved, url))
+        throw new Error("A Runtime is already paired. Use 'abot host disconnect' before pairing another.");
+    if (saved) {
+        await completeHostCompanionStartup(state, startup, saved.hostId);
+        return;
+    }
+    const code = options.pairingCode ?? (await readPairingCode());
+    let pairedHostId;
+    let interrupted = false;
+    await withStopSignals(async (signal) => {
+        const connection = new AbortController();
+        const stop = () => connection.abort();
+        signal.addEventListener("abort", stop, { once: true });
+        try {
+            if (signal.aborted)
+                stop();
+            await connectNativeHost({
+                url,
+                authorization: code,
+                identity: readNativeHostIdentity(),
+                signal: connection.signal,
+                onPaired: async (hostId, credential) => {
+                    await state.write({ version: 1, url, hostId, credential });
+                    pairedHostId = hostId;
+                },
+                onReady: () => {
+                    throw new Error("Pairing must finish before an authenticated native connection becomes ready.");
+                },
+            });
+        }
+        finally {
+            interrupted = signal.aborted;
+            signal.removeEventListener("abort", stop);
+        }
+    });
+    if (interrupted)
+        throw new Error("Host setup was interrupted before startup installation.");
+    if (!pairedHostId)
+        throw new Error("Pairing did not complete. Check ABot Settings and use a fresh pairing code.");
+    await completeHostCompanionStartup(state, startup, pairedHostId);
+}
+async function runHost(state) {
+    if (!(await state.read()))
+        return;
+    const ownerIdentity = await requireCurrentProcessOwnerIdentity();
+    let release;
+    try {
+        release = await acquireFileLock(join(state.directory, "agent"), {
+            waitMs: 0,
+            releaseMode: "synchronous",
+            ownerIdentity,
+            processIsAlive: isProcessOwnerAlive,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message === "long_term_memory_store_lock_timeout")
+            return;
+        throw error;
+    }
+    try {
+        await withStopSignals((signal) => runNativeHostSupervisor({
+            state,
+            identity: readNativeHostIdentity(),
+            signal,
+        }));
+    }
+    finally {
+        await release();
+    }
+}
+async function disconnectHost(state) {
+    await state.remove();
+    await uninstallNativeAutostart(autostartOptions(state));
+    const ownerIdentity = await requireCurrentProcessOwnerIdentity();
+    const release = await acquireFileLock(join(state.directory, "agent"), {
+        waitMs: 5_000,
+        releaseMode: "synchronous",
+        ownerIdentity,
+        processIsAlive: isProcessOwnerAlive,
+    });
+    await release();
+    console.log("Host companion stopped. Login startup and the saved credential were removed.");
+}
+export async function runHostCompanionCli(args, options = {}) {
+    const [command, ...rest] = args;
+    if (!command || ["help", "--help", "-h"].includes(command)) {
+        printHostHelp();
+        return;
+    }
+    const state = nativeState();
+    if (command === "connect") {
+        await connectHost(rest, state, options);
+        return;
+    }
+    if (rest.length > 0)
+        throw new Error(`Unknown host argument: ${rest[0]}`);
+    if (command === "run") {
+        await runHost(state);
+        return;
+    }
+    if (command === "disconnect" || command === "uninstall") {
+        await disconnectHost(state);
+        return;
+    }
+    if (command === "status") {
+        const saved = await state.read();
+        console.log(JSON.stringify(saved
+            ? {
+                paired: true,
+                url: saved.url,
+                hostId: saved.hostId,
+                connected: await state.isConnected(saved.hostId),
+            }
+            : { paired: false, connected: false }, null, 2));
+        return;
+    }
+    throw new Error(`Unknown host command: ${command}`);
+}

package/dist/src/model-gateway/server/configuration.js

@@ -27,7 +27,10 @@ export function resolveModelGatewayPort(environment = process.env) {
     return Number(parsedUrl.port || "80");
 }
 export function configureModelGateway(options) {
-    const runtimeConfig = loadRuntimeConfig({ rootDir: process.cwd() });
+    const runtimeConfig = loadRuntimeConfig({
+        rootDir: options.rootDir ?? process.cwd(),
+        configPath: options.configPath,
+    });
     const modelPolicy = options.modelPolicy ??
         createRequestModelPolicy({
             platformPolicy: runtimeConfig.models,

package/dist/src/model-gateway/server/contracts.d.ts

@@ -11,6 +11,8 @@ export type ModelGatewayInvocationContext = Readonly<{
     abortSignal?: AbortSignal;
 }>;
 export type ModelGatewayHandlerOptions = {
+    rootDir?: string;
+    configPath?: string;
     fetchImpl?: GatewayFetch;
     modelPolicy?: ModelGatewayPolicyConfig;
     ollamaUrl?: string;

package/dist/src/plugin-contract/entrypoint.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput } from "../capabilities/tool-types.js";
+import type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput, ToolModuleDeclaration, ToolModuleRequestPreparation } from "../capabilities/tool-types.js";
 import type { ToolNormalInvocationContract } from "../capabilities/normal-invocation/contracts.js";
 export type RuntimePluginLoadContext = {
     id: string;
@@ -27,8 +27,10 @@ export type RuntimePluginLoadContext = {
 export type RuntimePluginEntrypoint = Readonly<{
     handlers: Readonly<Record<string, ToolImplementation>>;
     adapters?: Readonly<Record<string, ToolCallAdapter>>;
+    /** Observe availability once before any model sees this request's catalog. */
+    prepareRequest?: ToolModuleRequestPreparation;
 }>;
 export type RuntimePluginEntrypointFactory = (context: RuntimePluginLoadContext & Readonly<{
     pluginRoot: string;
 }>) => RuntimePluginEntrypoint;
-export type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput, ToolNormalInvocationContract, };
+export type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput, ToolModuleDeclaration, ToolModuleRequestPreparation, ToolNormalInvocationContract, };

package/dist/src/plugin-contract/manifest.d.ts

@@ -12,6 +12,7 @@ export type AgentPluginOperationManifest = Readonly<{
     payload?: ToolNormalInvocationPayload;
 }>;
 export type AgentPluginCapabilityManifest = Readonly<{
+    requiredPermissionMode?: import("../capabilities/tool-permission-mode.js").ToolRequiredPermissionMode;
     description: string;
     routingCapability: ToolRoutingCapability;
     controlsRefinement?: "mechanical_when_complete";

package/dist/src/runtime/adapters/config-file-transaction.d.ts

@@ -0,0 +1,46 @@
+/** Configuration activation can hold this lock throughout shutdown and restart.
+ * Cooperating writers wait for release; dead owners remain reclaimable.
+ */
+export declare const CONFIG_FILE_LOCK_OPTIONS: Readonly<{
+    waitMs: number;
+}>;
+type JsonConfig = Record<string, unknown>;
+export type ConfigFileReadOptions = Readonly<{
+    allowMalformedJson?: boolean;
+}>;
+export type InvalidConfigJson = Readonly<{
+    raw: string;
+    message: string;
+}>;
+export type ConfigFileSnapshot = Readonly<{
+    config: JsonConfig;
+    invalidJson?: InvalidConfigJson;
+    exists: boolean;
+    revision: string;
+}>;
+export type ConfigFileExpectation = Readonly<{
+    expectedConfig?: JsonConfig;
+    expectedRevision?: string;
+}>;
+export type ConfigFileCommit = Readonly<{
+    revision: string;
+    backupPath?: string;
+}>;
+export type ConfigFileTransaction = Readonly<{
+    path: string;
+    snapshot: ConfigFileSnapshot;
+    write(config: JsonConfig, expectation?: ConfigFileExpectation): Promise<ConfigFileCommit>;
+}>;
+export declare class ConfigFileConflictError extends Error {
+    readonly code = "config_changed";
+    constructor();
+}
+/** Existing targets and missing children of symlinked directories share one lock. */
+export declare function canonicalConfigFilePath(path: string): Promise<string>;
+export declare function readConfigFileSnapshot(path: string, options?: ConfigFileReadOptions): Promise<ConfigFileSnapshot>;
+/** All cooperating config writers hold this lock from read through commit.
+ * Revision checks also reject completed external edits; advisory locks cannot
+ * exclude an external editor that writes between the final check and rename.
+ */
+export declare function withConfigFileTransaction<T>(path: string, operation: (transaction: ConfigFileTransaction) => Promise<T>, options?: ConfigFileReadOptions): Promise<T>;
+export {};

package/dist/src/runtime/adapters/config-file-transaction.js

@@ -0,0 +1,158 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { isRecord } from "../config/utils.js";
+import { withFileLock } from "./long-term-memory/file-lock.js";
+/** Configuration activation can hold this lock throughout shutdown and restart.
+ * Cooperating writers wait for release; dead owners remain reclaimable.
+ */
+export const CONFIG_FILE_LOCK_OPTIONS = Object.freeze({
+    waitMs: Number.POSITIVE_INFINITY,
+});
+export class ConfigFileConflictError extends Error {
+    code = "config_changed";
+    constructor() {
+        super("Configuration changed since it was loaded. Refresh Configuration before saving again.");
+    }
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+/** Existing targets and missing children of symlinked directories share one lock. */
+export async function canonicalConfigFilePath(path) {
+    const absolute = resolve(path);
+    try {
+        return await realpath(absolute);
+    }
+    catch (error) {
+        if (!isMissingFile(error))
+            throw error;
+        const parent = dirname(absolute);
+        if (parent === absolute)
+            throw error;
+        return join(await canonicalConfigFilePath(parent), basename(absolute));
+    }
+}
+function configRevision(path, raw) {
+    const hash = createHash("sha256").update(path).update("\0");
+    if (raw === undefined)
+        return hash.update("missing").digest("hex");
+    return hash.update("present:").update(raw).digest("hex");
+}
+function parseSnapshotConfig(raw, options) {
+    if (raw === undefined)
+        return { config: {} };
+    const text = raw.toString("utf8");
+    try {
+        const config = JSON.parse(text);
+        if (!isRecord(config))
+            throw new Error("Configuration must contain a JSON object.");
+        return { config };
+    }
+    catch (error) {
+        if (!options.allowMalformedJson)
+            throw error;
+        return {
+            config: {},
+            invalidJson: {
+                raw: text,
+                message: "This file is not a valid JSON object. Correct its Raw JSON and save the file to repair it.",
+            },
+        };
+    }
+}
+async function readSnapshot(path, options = {}) {
+    let raw;
+    try {
+        raw = await readFile(path);
+    }
+    catch (error) {
+        if (!isMissingFile(error))
+            throw error;
+    }
+    return {
+        ...parseSnapshotConfig(raw, options),
+        exists: raw !== undefined,
+        revision: configRevision(path, raw),
+        raw,
+    };
+}
+export async function readConfigFileSnapshot(path, options = {}) {
+    const { raw: _raw, ...snapshot } = await readSnapshot(await canonicalConfigFilePath(path), options);
+    return snapshot;
+}
+function requireExpectedSnapshot(snapshot, expectation) {
+    if (snapshot.invalidJson && expectation.expectedRevision === undefined)
+        throw new ConfigFileConflictError();
+    if (expectation.expectedRevision !== undefined &&
+        expectation.expectedRevision !== snapshot.revision)
+        throw new ConfigFileConflictError();
+    if (expectation.expectedConfig !== undefined &&
+        !isDeepStrictEqual(expectation.expectedConfig, snapshot.config))
+        throw new ConfigFileConflictError();
+}
+async function requireUnchangedFile(path, revision, options) {
+    if ((await readSnapshot(path, options)).revision !== revision)
+        throw new ConfigFileConflictError();
+}
+/** All cooperating config writers hold this lock from read through commit.
+ * Revision checks also reject completed external edits; advisory locks cannot
+ * exclude an external editor that writes between the final check and rename.
+ */
+export async function withConfigFileTransaction(path, operation, options = {}) {
+    const canonicalPath = await canonicalConfigFilePath(path);
+    await mkdir(dirname(canonicalPath), { recursive: true });
+    return withFileLock(`${canonicalPath}.config.lock`, async () => {
+        let current = await readSnapshot(canonicalPath, options);
+        return operation({
+            path: canonicalPath,
+            get snapshot() {
+                return current;
+            },
+            async write(config, expectation = {}) {
+                requireExpectedSnapshot(current, expectation);
+                await requireUnchangedFile(canonicalPath, current.revision, options);
+                const token = randomUUID();
+                const temporaryPath = `${canonicalPath}.${token}.tmp`;
+                const backupPath = current.exists
+                    ? `${canonicalPath}.${new Date().toISOString().replace(/[:.]/gu, "-")}.${token}.bak`
+                    : undefined;
+                const mode = current.exists
+                    ? (await stat(canonicalPath)).mode & 0o777
+                    : 0o600;
+                const raw = Buffer.from(`${JSON.stringify(config, null, 2)}\n`, "utf8");
+                try {
+                    if (backupPath)
+                        await writeFile(backupPath, current.raw, {
+                            encoding: "utf8",
+                            mode,
+                            flag: "wx",
+                        });
+                    await writeFile(temporaryPath, raw, {
+                        encoding: "utf8",
+                        mode,
+                        flag: "wx",
+                    });
+                    await chmod(temporaryPath, mode);
+                    await requireUnchangedFile(canonicalPath, current.revision, options);
+                    await rename(temporaryPath, canonicalPath);
+                }
+                catch (error) {
+                    await rm(temporaryPath, { force: true }).catch(() => undefined);
+                    throw error;
+                }
+                current = {
+                    config,
+                    exists: true,
+                    revision: configRevision(canonicalPath, raw),
+                    raw,
+                };
+                return {
+                    revision: current.revision,
+                    ...(backupPath ? { backupPath } : {}),
+                };
+            },
+        });
+    }, CONFIG_FILE_LOCK_OPTIONS);
+}

package/dist/src/runtime/adapters/configured-skill-provider.js

@@ -1,5 +1,5 @@
 import { createSkillsContextProvider, } from "../context/skills-context.js";
-import { loadBundledRuntimePlugins, loadConfiguredRuntimePlugins, } from "../plugins/loader.js";
+import { loadRuntimeCapabilityPlugins } from "../plugins/runtime-capability-plugins.js";
 function unique(values) {
     return [...new Set(values.filter((value) => value.trim().length > 0))];
 }
@@ -46,14 +46,14 @@ export function createRuntimePluginSkillProvider(options) {
 /** Loads the config-selected plugin catalog and projects only its skills. */
 export function createConfiguredSkillProvider(options) {
     return createProviderFromPlugins({
-        plugins: loadConfiguredRuntimePlugins(options.config),
+        plugins: loadRuntimeCapabilityPlugins(options.config),
         listToolDefinitions: options.listToolDefinitions,
     });
 }
 /** Uses the same bundled plugin manifests as the unconfigured tool registry. */
 export function createBundledPluginSkillProvider(options = {}) {
     return createProviderFromPlugins({
-        plugins: loadBundledRuntimePlugins(),
+        plugins: loadRuntimeCapabilityPlugins(),
         listToolDefinitions: options.listToolDefinitions,
     });
 }

package/dist/src/runtime/adapters/in-memory-session-store.js

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import { assertSessionProjectUnchanged, copySessionProject, } from "../../sessions/project-binding.js";
 import { assertValidSessionArtifactPathInputs, upsertSessionArtifactPaths, } from "../../sessions/artifact-paths.js";
 import { clientVisibleMessages, compactRequestEvents, filterMessagesAfter, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, toSnapshotMessage, toSnapshotRequest, } from "../../sessions/record/projection.js";
 import { assertValidRequestId, assertValidSessionId, createContextEntryId, defaultCreateMessageId, pruneSupersededContextEntries, } from "../../sessions/record/rules.js";
@@ -40,15 +42,19 @@ class InMemorySessionStore {
             this.sessions.set(session.id, cloneSession(session));
         }
     }
-    async getOrCreateSession(sessionId) {
+    async getOrCreateSession(sessionId, options = {}) {
         assertValidSessionId(sessionId);
         const existing = this.sessions.get(sessionId);
         if (existing) {
+            assertSessionProjectUnchanged(existing, options.project);
             return cloneSession(existing);
         }
         const timestamp = toIso(this.now);
         const session = {
             id: sessionId,
+            ...(options.project
+                ? { project: copySessionProject(options.project) }
+                : {}),
             title: sessionId,
             createdAt: timestamp,
             updatedAt: timestamp,
@@ -87,6 +93,7 @@ class InMemorySessionStore {
         }
         return {
             sessionId,
+            ...(session.project ? { project: session.project } : {}),
             title: session.title,
             messages: filterMessagesAfter(clientVisibleMessages(session.messages), options.afterMessageId).map((message) => toSnapshotMessage(sessionId, message, session.requests ?? [])),
             requests: options.includeRequests === false
@@ -106,6 +113,7 @@ class InMemorySessionStore {
             return {
                 requestId,
                 sessionId: request.sessionId,
+                ...(request.generation ? { generation: request.generation } : {}),
                 events: request.events
                     .filter((event) => event.seqNo > normalizedAfterSeq)
                     .map(toClientReplayEvent),
@@ -262,6 +270,8 @@ class InMemorySessionStore {
             const request = {
                 requestId,
                 sessionId,
+                // Only an explicit new stream establishes a request lifetime.
+                generation: randomUUID(),
                 status: "streaming",
                 createdAt: timestamp,
                 updatedAt: timestamp,