@abot-ai/runtime 1.3.1 → 1.4.0

package/dist/src/runtime/capabilities/file-output-root-identity.js

@@ -0,0 +1,146 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, realpathSync, statSync, } from "node:fs";
+import { join } from "node:path";
+import { createFileOutputRootId, hasStableFileOutputRootIdentity, parseToolFileOutputRootIdentity, } from "../../capabilities/file-output-presentation.js";
+import { initializeFileOutputRootMarker } from "./file-output-root-marker-creation.js";
+const markerName = ".abot-file-output-root";
+const markerPrefix = "abot-file-output-root-v1\n";
+const markerSize = Buffer.byteLength(markerPrefix) + 64 + 1;
+function rootIdentityUnavailable() {
+    throw new Error("Stable file-output root identity is unavailable.");
+}
+function sameRootInstance(left, right) {
+    if (left.dev !== right.dev)
+        return false;
+    if (left.ino !== right.ino)
+        return false;
+    return left.birthtimeNs === right.birthtimeNs;
+}
+function matchesCommittedRootIdentity(opened, expected) {
+    if (expected === undefined)
+        return true;
+    const identity = parseToolFileOutputRootIdentity(expected);
+    if (!identity)
+        return false;
+    if (opened.dev.toString() !== identity.device)
+        return false;
+    if (opened.ino.toString() !== identity.inode)
+        return false;
+    return opened.birthtimeNs.toString() === identity.birthtimeNs;
+}
+function sameMarkerVersion(left, right) {
+    if (!sameRootInstance(left, right))
+        return false;
+    if (left.size !== right.size)
+        return false;
+    if (left.mtimeNs !== right.mtimeNs)
+        return false;
+    return left.ctimeNs === right.ctimeNs;
+}
+function canonicalRootIdentity(canonicalRoot) {
+    if (realpathSync(canonicalRoot) !== canonicalRoot)
+        rootIdentityUnavailable();
+    const identity = statSync(canonicalRoot, { bigint: true });
+    if (!identity.isDirectory())
+        rootIdentityUnavailable();
+    return identity;
+}
+function canReadRootMarker(identity) {
+    if (!identity.isFile())
+        return false;
+    if (identity.nlink !== 1n)
+        return false;
+    return identity.size === BigInt(markerSize);
+}
+function parseRootMarker(bytes) {
+    const text = bytes.toString("utf8");
+    if (!text.startsWith(markerPrefix))
+        rootIdentityUnavailable();
+    const token = text.slice(markerPrefix.length, -1);
+    if (!/^[a-f0-9]{64}$/u.test(token))
+        rootIdentityUnavailable();
+    if (!text.endsWith("\n"))
+        rootIdentityUnavailable();
+    return token;
+}
+function requireSafeRootMarkerOpen() {
+    if (typeof constants.O_NOFOLLOW !== "number")
+        rootIdentityUnavailable();
+    if (typeof constants.O_NONBLOCK !== "number")
+        rootIdentityUnavailable();
+    if (typeof constants.O_DIRECTORY !== "number")
+        rootIdentityUnavailable();
+}
+function readRootMarker(markerPath) {
+    requireSafeRootMarkerOpen();
+    const handle = openSync(markerPath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const before = fstatSync(handle, { bigint: true });
+        if (!canReadRootMarker(before))
+            rootIdentityUnavailable();
+        const bytes = Buffer.alloc(markerSize + 1);
+        const length = readSync(handle, bytes, 0, bytes.length, 0);
+        if (length !== markerSize)
+            rootIdentityUnavailable();
+        const after = fstatSync(handle, { bigint: true });
+        if (!sameMarkerVersion(before, after))
+            rootIdentityUnavailable();
+        const current = lstatSync(markerPath, { bigint: true });
+        if (!canReadRootMarker(current))
+            rootIdentityUnavailable();
+        if (!sameMarkerVersion(after, current))
+            rootIdentityUnavailable();
+        return parseRootMarker(bytes.subarray(0, length));
+    }
+    finally {
+        closeSync(handle);
+    }
+}
+function hasFilesystemErrorCode(error, code) {
+    if (!(error instanceof Error))
+        return false;
+    return error.code === code;
+}
+function captureRootMarker(markerPath, canonicalRoot, rootHandle) {
+    try {
+        return readRootMarker(markerPath);
+    }
+    catch (error) {
+        if (!hasFilesystemErrorCode(error, "ENOENT"))
+            throw error;
+    }
+    initializeFileOutputRootMarker(canonicalRoot, rootHandle);
+    return readRootMarker(markerPath);
+}
+function rootBoundIdentity(location, canonicalRoot, readMarker, expectedIdentity) {
+    requireSafeRootMarkerOpen();
+    const handle = openSync(canonicalRoot, constants.O_RDONLY |
+        constants.O_DIRECTORY |
+        constants.O_NOFOLLOW |
+        constants.O_NONBLOCK);
+    try {
+        const before = fstatSync(handle, { bigint: true });
+        if (!hasStableFileOutputRootIdentity(before))
+            rootIdentityUnavailable();
+        if (!matchesCommittedRootIdentity(before, expectedIdentity))
+            rootIdentityUnavailable();
+        const current = canonicalRootIdentity(canonicalRoot);
+        if (!sameRootInstance(before, current))
+            rootIdentityUnavailable();
+        const token = readMarker(join(canonicalRoot, markerName), canonicalRoot, handle);
+        const after = canonicalRootIdentity(canonicalRoot);
+        if (!sameRootInstance(before, after))
+            rootIdentityUnavailable();
+        return createFileOutputRootId(location, canonicalRoot, after, token);
+    }
+    finally {
+        closeSync(handle);
+    }
+}
+/** Host presentation capture only. Creates a marker once; never overwrites it. */
+export function captureFileOutputRootId(location, canonicalRoot, expectedIdentity) {
+    return rootBoundIdentity(location, canonicalRoot, captureRootMarker, expectedIdentity);
+}
+/** Preview authorization is read-only: missing or invalid markers stay invalid. */
+export function readFileOutputRootId(location, canonicalRoot) {
+    return rootBoundIdentity(location, canonicalRoot, readRootMarker);
+}

package/dist/src/runtime/capabilities/file-output-root-marker-creation.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The isolated process pins cwd to the inherited directory authority before
+ * creating the fixed marker name. No pathname-based write happens in the host.
+ */
+export declare function initializeFileOutputRootMarker(canonicalRoot: string, rootHandle: number): void;

package/dist/src/runtime/capabilities/file-output-root-marker-creation.js

@@ -0,0 +1,63 @@
+import { spawnSync } from "node:child_process";
+import { directoryAuthorityScript } from "../../shared/directory-authority/bootstrap.js";
+import { authorityEnvironment, decodeAuthorityResult, encodeAuthorityRequest, } from "../../shared/directory-authority/protocol.js";
+/** Serialized trusted task; cwd is verified against the inherited root fd. */
+function createMarkerInHeldDirectory() {
+    const fs = require("node:fs");
+    const { randomBytes } = require("node:crypto");
+    const name = ".abot-file-output-root";
+    const { constants } = fs;
+    function isExistingMarker(error) {
+        if (!(error instanceof Error))
+            return false;
+        if (!("code" in error))
+            return false;
+        return error.code === "EEXIST";
+    }
+    let handle;
+    try {
+        handle = fs.openSync(name, constants.O_WRONLY |
+            constants.O_CREAT |
+            constants.O_EXCL |
+            constants.O_NOFOLLOW, 0o600);
+    }
+    catch (error) {
+        if (isExistingMarker(error))
+            return;
+        throw error;
+    }
+    try {
+        const token = randomBytes(32).toString("hex");
+        fs.writeFileSync(handle, `abot-file-output-root-v1\n${token}\n`, "ascii");
+    }
+    finally {
+        fs.closeSync(handle);
+    }
+}
+/**
+ * The isolated process pins cwd to the inherited directory authority before
+ * creating the fixed marker name. No pathname-based write happens in the host.
+ */
+export function initializeFileOutputRootMarker(canonicalRoot, rootHandle) {
+    const outputLimit = 4096;
+    const result = spawnSync(process.execPath, [
+        "--input-type=commonjs",
+        "-e",
+        directoryAuthorityScript("task", outputLimit, createMarkerInHeldDirectory),
+    ], {
+        cwd: canonicalRoot,
+        env: authorityEnvironment(),
+        stdio: ["pipe", "pipe", "pipe", rootHandle],
+        input: encodeAuthorityRequest({}),
+        encoding: "utf8",
+        maxBuffer: outputLimit,
+        timeout: 5000,
+        killSignal: "SIGKILL",
+        windowsHide: true,
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0)
+        throw new Error("Root marker creation failed.");
+    decodeAuthorityResult(result.stdout);
+}

package/dist/src/runtime/capabilities/request-bound-tool-registry.d.ts

@@ -7,5 +7,6 @@ import type { ToolRegistry } from "../ports.js";
 export declare function bindRequestToolRegistry(params: Readonly<{
     registry: ToolRegistry;
     modelInvoker: ToolModelInvoker;
+    requestWorkingDirectory?: string;
     requestAttachments?: readonly ToolRequestAttachment[];
 }>): ToolRegistry;

package/dist/src/runtime/capabilities/request-bound-tool-registry.js

@@ -1,3 +1,4 @@
+import { bindRequestWorkingDirectory } from "./request-working-directory.js";
 import { projectAvailableTools } from "./tool-availability.js";
 /**
  * Adds trusted request services to an already config-filtered Tool Registry.
@@ -45,13 +46,17 @@ export function bindRequestToolRegistry(params) {
                     ? { requestAttachments: params.requestAttachments }
                     : {}),
             };
-            return registry.prepareSharedState
+            const prepared = registry.prepareSharedState
                 ? registry.prepareSharedState(requestState)
                 : requestState;
+            return bindRequestWorkingDirectory(prepared, params.requestWorkingDirectory);
         },
         execute: (call, options) => registry.execute(call, {
             ...options,
             modelInvoker: params.modelInvoker,
+            ...(params.requestWorkingDirectory !== undefined
+                ? { requestWorkingDirectory: params.requestWorkingDirectory }
+                : {}),
         }),
     });
 }

package/dist/src/runtime/capabilities/request-module-preparation.d.ts

@@ -0,0 +1,3 @@
+import type { ToolModuleDeclaration } from "../../capabilities/tool-types.js";
+/** Config selection precedes observation. A plugin may narrow, never add authority. */
+export declare function prepareRequestToolModules(modules: readonly ToolModuleDeclaration[]): Promise<readonly ToolModuleDeclaration[]>;

package/dist/src/runtime/capabilities/request-module-preparation.js

@@ -0,0 +1,102 @@
+import { isDeepStrictEqual } from "node:util";
+import { validateToolModuleDeclarations } from "../../capabilities/tool-definition-validator.js";
+/** Config selection precedes observation. A plugin may narrow, never add authority. */
+export async function prepareRequestToolModules(modules) {
+    const selectedModules = validateToolModuleDeclarations(modules);
+    const groups = new Map();
+    for (const module of selectedModules) {
+        if (!module.prepareRequest)
+            continue;
+        const selected = groups.get(module.prepareRequest) ?? [];
+        selected.push(module);
+        groups.set(module.prepareRequest, selected);
+    }
+    const prepared = new Map();
+    await Promise.all([...groups].map(async ([prepare, selected]) => {
+        const inputs = Object.freeze(selected.map(captureSelectedModule));
+        const output = validateToolModuleDeclarations(await prepare(inputs));
+        assertPreparedAuthorityIsNarrowed(selected, output);
+        for (const module of output) {
+            const { prepareRequest: _prepare, ...bound } = module;
+            prepared.set(module.definition.name, bound);
+        }
+    }));
+    return selectedModules.flatMap((module) => {
+        if (!module.prepareRequest)
+            return [module];
+        const bound = prepared.get(module.definition.name);
+        return bound ? [bound] : [];
+    });
+}
+function captureSelectedModule(module) {
+    return Object.freeze({
+        definition: freezeContract(structuredClone(module.definition)),
+        normalInvocation: freezeContract(structuredClone(module.normalInvocation)),
+        implementation: module.implementation,
+        ...(module.adapter
+            ? { adapter: Object.freeze({ ...module.adapter }) }
+            : {}),
+    });
+}
+function freezeContract(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    for (const child of Object.values(value))
+        freezeContract(child);
+    return Object.freeze(value);
+}
+function assertPreparedAuthorityIsNarrowed(selected, prepared) {
+    const byName = new Map(selected.map((module) => [module.definition.name, module]));
+    for (const module of prepared) {
+        const source = byName.get(module.definition.name);
+        if (!source)
+            throw new Error("Request preparation returned an unselected tool");
+        if (!isDeepStrictEqual(source.definition, module.definition)) {
+            throw new Error(`Request preparation changed tool authority: ${module.definition.name}`);
+        }
+        if (source.normalInvocation.version !== module.normalInvocation.version) {
+            throw new Error("Request preparation changed invocation version");
+        }
+        const operations = new Map(source.normalInvocation.operations.map((operation) => [
+            operation.operationId,
+            operation,
+        ]));
+        for (const operation of module.normalInvocation.operations) {
+            const original = operations.get(operation.operationId);
+            if (!original)
+                throw new Error("Request preparation returned an undeclared operation");
+            assertOperationAuthorityIsNarrowed(original, operation);
+        }
+    }
+}
+function assertOperationAuthorityIsNarrowed(original, prepared) {
+    const { summary: _summary, input: originalInput, ...originalAuthority } = original;
+    const { summary: _preparedSummary, input: preparedInput, ...preparedAuthority } = prepared;
+    if (!isDeepStrictEqual(originalAuthority, preparedAuthority)) {
+        throw new Error(`Request preparation changed operation authority: ${original.operationId}`);
+    }
+    const { properties: originalProperties, ...originalShape } = originalInput;
+    const { properties: preparedProperties, ...preparedShape } = preparedInput;
+    if (!isDeepStrictEqual(originalShape, preparedShape)) {
+        throw new Error("Request preparation changed input shape");
+    }
+    if (!isDeepStrictEqual(Object.keys(originalProperties).sort(), Object.keys(preparedProperties).sort())) {
+        throw new Error("Request preparation changed input controls");
+    }
+    for (const [name, property] of Object.entries(preparedProperties)) {
+        if (!isNarrowedInputProperty(originalProperties[name], property)) {
+            throw new Error(`Request preparation widened input control: ${name}`);
+        }
+    }
+}
+function isNarrowedInputProperty(original, prepared) {
+    if (!("enum" in original))
+        return isDeepStrictEqual(original, prepared);
+    if (!("enum" in prepared))
+        return false;
+    const { enum: originalValues, ...originalShape } = original;
+    const { enum: preparedValues, ...preparedShape } = prepared;
+    if (!isDeepStrictEqual(originalShape, preparedShape))
+        return false;
+    return preparedValues.every((value) => originalValues.includes(value));
+}

package/dist/src/runtime/capabilities/request-permission-catalog.d.ts

@@ -0,0 +1,10 @@
+import { type ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
+import type { RegisteredToolNormalInvocation, ToolDefinition } from "../../capabilities/tool-types.js";
+import type { ToolRegistry } from "../ports.js";
+/** One lazy registration snapshot; any declared restriction wins across projections. */
+export declare function captureRequestPermissionCatalog(registry: ToolRegistry, mode: ToolPermissionMode): Readonly<{
+    listDefinitions: () => ToolDefinition[];
+    listNormalInvocations: () => readonly RegisteredToolNormalInvocation[] | undefined;
+    getDefinition: (name: string) => ToolDefinition | undefined;
+    isRequestToolAvailable: (name: string) => boolean;
+}>;

package/dist/src/runtime/capabilities/request-permission-catalog.js

@@ -0,0 +1,50 @@
+import { permitsRequiredToolMode, } from "../../capabilities/tool-permission-mode.js";
+/** One lazy registration snapshot; any declared restriction wins across projections. */
+export function captureRequestPermissionCatalog(registry, mode) {
+    const definitions = Object.freeze([...registry.listDefinitions()]);
+    const definitionByName = new Map(definitions.map((definition) => [definition.name, definition]));
+    let registrations;
+    let resolvedRegistrations = false;
+    const registeredAllowedNames = new Set();
+    const registeredDeniedNames = new Set();
+    const permitsDefinition = (definition) => permitsRequiredToolMode(mode, definition.requiredPermissionMode);
+    const permitsRegistration = (registration) => {
+        const definition = definitionByName.get(registration.toolName);
+        if (definition && !permitsDefinition(definition))
+            return false;
+        return permitsDefinition(registration.definition);
+    };
+    function resolveRegistrations() {
+        if (resolvedRegistrations)
+            return registrations;
+        const source = registry.listNormalInvocations?.();
+        if (source === undefined) {
+            resolvedRegistrations = true;
+            return undefined;
+        }
+        for (const registration of source) {
+            const names = permitsRegistration(registration)
+                ? registeredAllowedNames
+                : registeredDeniedNames;
+            names.add(registration.toolName);
+        }
+        registrations = Object.freeze(source.filter(permitsRegistration));
+        resolvedRegistrations = true;
+        return registrations;
+    }
+    function isRequestToolAvailable(name) {
+        resolveRegistrations();
+        if (registeredDeniedNames.has(name))
+            return false;
+        const definition = definitionByName.get(name);
+        if (definition)
+            return permitsDefinition(definition);
+        return registeredAllowedNames.has(name);
+    }
+    return Object.freeze({
+        listDefinitions: () => definitions.filter(({ name }) => isRequestToolAvailable(name)),
+        listNormalInvocations: resolveRegistrations,
+        getDefinition: (name) => isRequestToolAvailable(name) ? definitionByName.get(name) : undefined,
+        isRequestToolAvailable,
+    });
+}

package/dist/src/runtime/capabilities/request-permission-tool-registry.d.ts

@@ -0,0 +1,4 @@
+import { type ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
+import type { ToolRegistry } from "../ports.js";
+/** Captures user authority once; all discovery and execution use the same gate. */
+export declare function restrictToolRegistryToRequestMode(registry: ToolRegistry, mode: ToolPermissionMode): ToolRegistry;

package/dist/src/runtime/capabilities/request-permission-tool-registry.js

@@ -0,0 +1,61 @@
+import { captureRequestPermissionCatalog } from "./request-permission-catalog.js";
+/** Captures user authority once; all discovery and execution use the same gate. */
+export function restrictToolRegistryToRequestMode(registry, mode) {
+    const catalog = captureRequestPermissionCatalog(registry, mode);
+    const isRequestToolAvailable = catalog.isRequestToolAvailable;
+    const rejectUnavailableTool = (tool) => ({
+        ok: false,
+        tool,
+        output: "This tool is unavailable for the captured request permission mode.",
+        producedNewInformation: false,
+        error: "This tool is unavailable for the captured request permission mode.",
+        errorCode: "tool_permission_mode_required",
+    });
+    const bindAuthority = (state) => ({
+        ...state,
+        requestContext: Object.freeze({
+            agentMode: state?.requestContext?.agentMode ?? "fast",
+            ...state?.requestContext,
+            toolPermissionMode: mode,
+        }),
+    });
+    const implementations = {};
+    for (const [name, implementation] of Object.entries(registry.getImplementations())) {
+        if (!isRequestToolAvailable(name))
+            continue;
+        implementations[name] = (params, context) => implementation(params, {
+            ...context,
+            sharedState: bindAuthority(context?.sharedState),
+        });
+    }
+    return Object.freeze({
+        listDefinitions: catalog.listDefinitions,
+        ...(registry.listNormalInvocations
+            ? {
+                listNormalInvocations: () => catalog.listNormalInvocations(),
+            }
+            : {}),
+        getDefinition: catalog.getDefinition,
+        ...(registry.getAdapter
+            ? {
+                getAdapter: (name) => isRequestToolAvailable(name)
+                    ? registry.getAdapter(name)
+                    : undefined,
+            }
+            : {}),
+        hasToolsAvailable: () => catalog.listDefinitions().length > 0 ||
+            (catalog.listNormalInvocations()?.length ?? 0) > 0,
+        getImplementations: () => ({ ...implementations }),
+        prepareSharedState: (state) => bindAuthority(registry.prepareSharedState
+            ? registry.prepareSharedState(state)
+            : state),
+        execute: (call, options) => {
+            if (!isRequestToolAvailable(call.tool))
+                return Promise.resolve(rejectUnavailableTool(call.tool));
+            return registry.execute(call, {
+                ...options,
+                sharedState: bindAuthority(options?.sharedState),
+            });
+        },
+    });
+}

package/dist/src/runtime/capabilities/request-runtime-tool-registry.d.ts

@@ -1,3 +1,4 @@
+import type { ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
 import type { BoundRequestModelInvocationContext } from "../request/contracts.js";
 import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
@@ -8,7 +9,9 @@ import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
  */
 export declare function createRequestRuntimeToolRegistry(params: Readonly<{
     request: BoundRequestModelInvocationContext;
+    toolPermissionMode?: ToolPermissionMode;
     requestAttachments?: readonly ToolRequestAttachment[];
     runtimeConfig?: RuntimeConfig;
+    requestWorkingDirectory?: string;
     toolRegistryOverride?: ToolRegistry;
 }>): ToolRegistry;

package/dist/src/runtime/capabilities/request-runtime-tool-registry.js

@@ -1,3 +1,4 @@
+import { restrictToolRegistryToRequestMode } from "./request-permission-tool-registry.js";
 import { createRequestToolModelInvoker } from "../adapters/request-tool-model-invoker.js";
 import { createConfiguredToolRegistry } from "./configured-tool-registry.js";
 import { bindRequestToolRegistry } from "./request-bound-tool-registry.js";
@@ -7,10 +8,12 @@ import { bindRequestToolRegistry } from "./request-bound-tool-registry.js";
  * This boundary contains no orchestration-policy selection.
  */
 export function createRequestRuntimeToolRegistry(params) {
+    const registry = restrictToolRegistryToRequestMode(params.toolRegistryOverride ??
+        createConfiguredToolRegistry(params.runtimeConfig, []), params.toolPermissionMode ?? "ask");
     return bindRequestToolRegistry({
-        registry: params.toolRegistryOverride ??
-            createConfiguredToolRegistry(params.runtimeConfig, []),
+        registry,
         modelInvoker: createRequestToolModelInvoker(params.request),
+        requestWorkingDirectory: params.requestWorkingDirectory,
         ...(params.requestAttachments
             ? { requestAttachments: params.requestAttachments }
             : {}),

package/dist/src/runtime/capabilities/request-working-directory.d.ts

@@ -0,0 +1,3 @@
+import type { ToolExecutionSharedState } from "../../capabilities/tool-types.js";
+/** The immutable session root replaces only agent_work, never shared namespaces. */
+export declare function bindRequestWorkingDirectory(state: ToolExecutionSharedState, directory?: string): ToolExecutionSharedState;

package/dist/src/runtime/capabilities/request-working-directory.js

@@ -0,0 +1,12 @@
+import { isAbsolute } from "node:path";
+/** The immutable session root replaces only agent_work, never shared namespaces. */
+export function bindRequestWorkingDirectory(state, directory) {
+    if (directory === undefined)
+        return state;
+    if (!isAbsolute(directory))
+        throw new TypeError("request_working_directory_absolute_required");
+    return {
+        ...state,
+        runtimePaths: { ...state.runtimePaths, agentWorkDir: directory },
+    };
+}

package/dist/src/runtime/composition.d.ts

@@ -1,4 +1,5 @@
 import type WebSocket from "ws";
+import type { RuntimeProjectService } from "./projects/contracts.js";
 import type { EventSinkFactory, ModelGatewayClient, RuntimeConfig, RuntimeHost, SessionStore, ToolRegistry } from "./ports.js";
 import type { RuntimeAttachmentStore } from "./attachments/store.js";
 import type { RequestHandlerOptions, RunRequestMessage } from "./request/contracts.js";
@@ -10,6 +11,7 @@ import type { RequestSteeringAppendResult } from "./request/request-steering.js"
 export type RuntimeEnvironmentServices = Readonly<{
     config: RuntimeConfig;
     sessions: SessionStore;
+    projects?: RuntimeProjectService;
     attachments: RuntimeAttachmentStore;
     tools: ToolRegistry;
     models: ModelGatewayClient;

package/dist/src/runtime/config/runner/loader.d.ts

@@ -1,4 +1,8 @@
 import type { RequestRunnerConfig } from "./contracts.js";
+/** Explicit configuration application refreshes only its selected runner. */
+export declare function invalidateRequestRunnerConfig(params: {
+    configPath: string;
+}): () => void;
 export declare function loadRequestRunnerConfig(params: {
     configPath: string;
 }): RequestRunnerConfig;

package/dist/src/runtime/config/runner/loader.js

@@ -3,12 +3,32 @@ import { isAbsolute, resolve } from "node:path";
 import { deepFreezeConfig, formatConfigError } from "./validation.js";
 import { parseRequestRunnerConfig } from "./versioned-config.js";
 const configCache = new Map();
-export function loadRequestRunnerConfig(params) {
-    const configuredPath = params.configPath.trim();
+function requestRunnerConfigCachePath(value) {
+    const configuredPath = value.trim();
     if (!configuredPath || !isAbsolute(configuredPath)) {
         throw new Error("runtime request runner configPath must be an absolute path resolved from runtime config");
     }
-    const configPath = resolve(configuredPath);
+    return resolve(configuredPath);
+}
+/** Explicit configuration application refreshes only its selected runner. */
+export function invalidateRequestRunnerConfig(params) {
+    const configPath = requestRunnerConfigCachePath(params.configPath);
+    const previous = configCache.get(configPath);
+    configCache.delete(configPath);
+    let restored = false;
+    return () => {
+        if (restored)
+            return;
+        restored = true;
+        if (previous === undefined) {
+            configCache.delete(configPath);
+            return;
+        }
+        configCache.set(configPath, previous);
+    };
+}
+export function loadRequestRunnerConfig(params) {
+    const configPath = requestRunnerConfigCachePath(params.configPath);
     const cached = configCache.get(configPath);
     if (cached) {
         return cached;

package/dist/src/runtime/context/capability-brief-budget.d.ts

@@ -0,0 +1,18 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { RequestContextBudget } from "./request-context-contracts.js";
+import type { projectRequestContext } from "./request-context.js";
+type ContextInput = Parameters<typeof projectRequestContext>[0];
+/** Headroom for one passive brief without evicting existing request context. */
+export declare function resolveCapabilityBriefHeadroom(params: Readonly<{
+    context: ContextInput;
+    additionalBudgetMessages?: readonly ChatMessage[];
+}>): number;
+/** Computes capacity from concrete messages plus any not-yet-added reserves. */
+export declare function resolveCapabilityBriefMessageHeadroom(params: Readonly<{
+    messages: readonly ChatMessage[];
+    budget: RequestContextBudget;
+    format?: Readonly<{
+        schema: unknown;
+    }>;
+}>): number;
+export {};

package/dist/src/runtime/context/capability-brief-budget.js

@@ -0,0 +1,38 @@
+import { assessRequestMessagesBudget } from "./request-context-budget.js";
+/** Headroom for one passive brief without evicting existing request context. */
+export function resolveCapabilityBriefHeadroom(params) {
+    const { context } = params;
+    const messages = [
+        { role: "system", content: context.instructions },
+        ...(context.priorConversationMessages ?? []),
+        ...context.historyMessages,
+        ...(context.referenceMessages ?? []),
+        ...(context.referenceParts?.flatMap((part) => part.messages) ?? []),
+        ...(context.continuationMessages ?? []),
+        ...(context.continuationParts?.flatMap((part) => part.messages) ?? []),
+        {
+            role: "user",
+            content: context.prompt,
+            ...(context.attachments ? { attachments: context.attachments } : {}),
+        },
+        ...(params.additionalBudgetMessages ?? []),
+    ];
+    return resolveCapabilityBriefMessageHeadroom({
+        messages,
+        budget: context.budget,
+        ...(context.format ? { format: context.format } : {}),
+    });
+}
+/** Computes capacity from concrete messages plus any not-yet-added reserves. */
+export function resolveCapabilityBriefMessageHeadroom(params) {
+    const { budget } = assessRequestMessagesBudget(params);
+    // Reserve instructions not yet inserted against both the 70% threshold
+    // and the input ceiling. Strictly below: admission triggers on >=.
+    const instructionReserve = params.budget.configuredInstructionReserveTokens ?? 0;
+    const compactionHeadroom = budget.compactionTriggerInputTokens -
+        1 -
+        budget.estimatedInputTokens -
+        instructionReserve;
+    const admissionHeadroom = budget.availableInputTokens - budget.estimatedInputTokens;
+    return Math.max(0, Math.min(compactionHeadroom, admissionHeadroom));
+}