@abot-ai/runtime 1.9.0 → 2.0.0

package/dist/src/runtime/long-term-memory/onboarding/service.js

@@ -1,7 +1,8 @@
+import { buildRemovedEmbeddingProfile, buildSavedEmbeddingProfile } from "./saved-profiles.js";
 import { buildModelConfig } from "../../config/builders.js";
 import { validateRuntimeConfigFile } from "../../config/validation.js";
-import { buildDisabledMemoryConfig, buildEnabledMemoryConfig, DEFAULT_MEMORY_EMBEDDING_PROFILE_ID, projectOnboardingStatus, requireConfiguredProvider, } from "./configuration.js";
-const PROFILE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
+import { buildDisabledMemoryConfig, buildEnabledMemoryConfig, projectOnboardingStatus, requireConfiguredProvider, } from "./configuration.js";
+import { readEmbeddingProfileId } from "./embedding-profile-id.js";
 export function createLongTermMemoryOnboardingService(dependencies) {
     return Object.freeze({
         async status() {
@@ -24,7 +25,7 @@ export function createLongTermMemoryOnboardingService(dependencies) {
             const snapshot = await dependencies.repository.read();
             const providerId = requireText(input.providerId, "providerId");
             const model = requireText(input.model, "model");
-            const profileId = readProfileId(input.profileId);
+            const profileId = readEmbeddingProfileId(input.profileId);
             const abortSignal = input.abortSignal ?? new AbortController().signal;
             abortSignal.throwIfAborted();
             requireConfiguredProvider(snapshot.config, providerId);
@@ -51,6 +52,42 @@ export function createLongTermMemoryOnboardingService(dependencies) {
                 probe: Object.freeze({ ...probe }),
             });
         },
+        async saveProfile(input) {
+            const snapshot = await dependencies.repository.read();
+            const providerId = requireText(input.providerId, "providerId");
+            const model = requireText(input.model, "model");
+            const label = requireText(input.label, "profile_label");
+            const abortSignal = input.abortSignal ?? new AbortController().signal;
+            abortSignal.throwIfAborted();
+            requireConfiguredProvider(snapshot.config, providerId);
+            const candidate = buildSavedEmbeddingProfile({ config: snapshot.config, providerId, model, label });
+            validateRuntimeConfigFile(candidate.config, snapshot.path);
+            abortSignal.throwIfAborted();
+            const persisted = await dependencies.repository.write(candidate.config, snapshot.config);
+            return Object.freeze({
+                status: projectOnboardingStatus(candidate.config),
+                profileId: candidate.profileId,
+                configPath: persisted.configPath,
+                ...(persisted.backupPath ? { backupPath: persisted.backupPath } : {}),
+            });
+        },
+        async removeProfile(input) {
+            const snapshot = await dependencies.repository.read();
+            const profileId = requireText(input.profileId, "profileId");
+            const abortSignal = input.abortSignal ?? new AbortController().signal;
+            abortSignal.throwIfAborted();
+            const candidate = buildRemovedEmbeddingProfile(snapshot.config, profileId);
+            validateRuntimeConfigFile(candidate, snapshot.path);
+            abortSignal.throwIfAborted();
+            const persisted = await dependencies.repository.write(candidate, snapshot.config);
+            return Object.freeze({
+                removed: true,
+                status: projectOnboardingStatus(candidate),
+                profileId,
+                configPath: persisted.configPath,
+                ...(persisted.backupPath ? { backupPath: persisted.backupPath } : {}),
+            });
+        },
         async disable() {
             const snapshot = await dependencies.repository.read();
             const candidate = buildDisabledMemoryConfig(snapshot.config);
@@ -72,13 +109,6 @@ function requireModelPolicy(config, configPath) {
     }
     return modelPolicy;
 }
-function readProfileId(value) {
-    const profileId = value?.trim() || DEFAULT_MEMORY_EMBEDDING_PROFILE_ID;
-    if (!PROFILE_ID_PATTERN.test(profileId)) {
-        throw new Error("long_term_memory_embedding_profile_id_invalid");
-    }
-    return profileId;
-}
 function requireText(value, field) {
     const normalized = value.trim();
     if (!normalized) {

package/dist/src/runtime/model/input-token-count.js

@@ -11,6 +11,7 @@ export async function countModelInputTokens(params) {
         messages: params.messages,
         agentMode: params.request.agentMode,
         modelStep: params.modelStep,
+        ...(params.request.reasoningPreference ? { reasoningPreference: params.request.reasoningPreference } : {}),
         ...(params.request.modelPreference
             ? { modelPreference: params.request.modelPreference }
             : {}),

package/dist/src/runtime/model/invoke-step.js

@@ -7,6 +7,7 @@ import { appendRequestSteeringContext } from "../request/request-steering-contex
 import { createModelStepAbort } from "../steps/model-step-timeout.js";
 import { acceptModelStepOutput } from "./model-step-acceptance.js";
 import { createModelContextAssessment } from "./model-context-assessment.js";
+import { admitOptionalModelContext } from "./optional-context-admission.js";
 import { invokeModelProvider, projectModelProviderFailureDiagnostics, } from "./provider-failure.js";
 import { isModelStepCompactionEligible, resolveModelContextAdmission, } from "./model-context-budget.js";
 import { resolveModelStepTimeout, } from "./model-step-timeout-policy.js";
@@ -155,6 +156,7 @@ class ModelStepInvocation {
             runnerConfig: request.runnerConfig,
             modelStep: params.modelStep,
             messages: params.messages,
+            configuredInstructionPolicy: params.configuredInstructionPolicy,
         });
         const compactionTriggerEligible = isModelStepCompactionEligible(params);
         const contextCompaction = compactionTriggerEligible
@@ -171,6 +173,7 @@ class ModelStepInvocation {
             runnerConfig: request.runnerConfig,
             agentMode: request.agentMode,
             modelStep: params.modelStep,
+            ...(request.reasoningPreference ? { reasoningPreference: request.reasoningPreference } : {}),
             ...(request.modelPreference
                 ? { modelPreference: request.modelPreference }
                 : {}),
@@ -184,6 +187,14 @@ class ModelStepInvocation {
             assertCurrent,
         });
         let assessment = await assess(messages);
+        if (params.optionalContextProjection) {
+            const optional = await admitOptionalModelContext({
+                messages, assessment, project: params.optionalContextProjection, assess, assertCurrent,
+                diagnostic: { requestId: request.requestId, modelStep: params.modelStep },
+            });
+            messages = [...optional.messages];
+            assessment = optional.assessment;
+        }
         const invocationId = this.input.nextInvocationId();
         if (requiresContextCompaction(compactionTriggerEligible, assessment)) {
             const admitted = await admitCompactedContext({
@@ -389,6 +400,7 @@ class ModelStepAttempt {
             messages: this.input.messages,
             agentMode: request.agentMode,
             modelStep: params.modelStep,
+            ...(request.reasoningPreference ? { reasoningPreference: request.reasoningPreference } : {}),
             ...(request.modelPreference
                 ? { modelPreference: request.modelPreference }
                 : {}),

package/dist/src/runtime/model/invoke-structured-step.d.ts

@@ -1,7 +1,8 @@
 import type { ChatMessage, ModelGatewayJsonSchemaFormat } from "../../model-gateway/types.js";
 import type { ModelStep } from "../../shared/model-steps.js";
+import type { ConfiguredStepInstructionPolicy } from "../config/runner/step-instructions.js";
 import type { BoundRequestModelInvocationContext } from "../request/contracts.js";
-import type { ModelStepContextCompactionController } from "./model-step-port.js";
+import type { ModelStepContextCompactionController, ModelStepOptionalContextProjection } from "./model-step-port.js";
 export type StructuredModelValidationIssue = Readonly<{
     code: string;
     path: string;
@@ -38,6 +39,8 @@ export declare function invokeStructuredModelStep<T>(params: {
     boundSteeringVersion?: number;
     invalidOutputReason: string;
     contextRetention?: "exact";
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
+    optionalContextProjection?: ModelStepOptionalContextProjection;
     contextCompaction?: ModelStepContextCompactionController;
     parse: (text: string, abortSignal: AbortSignal) => StructuredModelParseResult<T> | Promise<StructuredModelParseResult<T>>;
 }): Promise<T>;

package/dist/src/runtime/model/invoke-structured-step.js

@@ -32,6 +32,10 @@ export async function invokeStructuredModelStep(params) {
             boundSteeringVersion: params.boundSteeringVersion,
             format: params.format,
             contextRetention: params.contextRetention,
+            configuredInstructionPolicy: params.configuredInstructionPolicy,
+            ...(params.optionalContextProjection
+                ? { optionalContextProjection: params.optionalContextProjection }
+                : {}),
             ...(params.contextCompaction
                 ? { contextCompaction: params.contextCompaction }
                 : {}),

package/dist/src/runtime/model/model-catalog.d.ts

@@ -7,6 +7,9 @@ export type RuntimeModelCatalogProfile = {
     provider: string;
     model: string;
     supportsThinking: boolean;
+    reasoningControls?: {
+        budgetTokens: boolean;
+    };
     capabilities: ModelGatewayProfileCapabilities;
     supportsImageInput: boolean;
 };

package/dist/src/runtime/model/model-catalog.js

@@ -1,3 +1,4 @@
+import { supportsModelReasoningBudget } from "../../shared/model-reasoning.js";
 import { MODEL_STEPS } from "../../shared/model-steps.js";
 import { loadRequestRunnerConfig } from "../config/runner/loader.js";
 import { createRequestModelPolicy } from "../config/runner/model-policy.js";
@@ -28,6 +29,7 @@ export function projectRuntimeModelCatalog(modelPolicy) {
             provider: providerConfig.type,
             model: profile.model,
             supportsThinking: profile.supportsThinking === true,
+            ...(supportsModelReasoningBudget({ provider: providerConfig.type, supportsThinking: profile.supportsThinking }) ? { reasoningControls: { budgetTokens: true } } : {}),
             capabilities: profile.capabilities ?? {
                 inputModalities: ["text"],
                 outputModalities: ["text"],

package/dist/src/runtime/model/model-context-budget.d.ts

@@ -1,13 +1,17 @@
+import type { ModelReasoningPreference } from "../../shared/model-reasoning.js";
 import type { ModelGatewayFormat, ModelGatewayPolicyConfig, ModelPreference, ResolvedModelInvocation } from "../../model-gateway/types.js";
 import type { AgentMode } from "../../shared/types.js";
 import type { ModelStep } from "../../shared/model-steps.js";
 import type { RequestRunnerConfig } from "../config/runner/contracts.js";
+import { type ConfiguredStepInstructionPolicy } from "../config/runner/step-instructions.js";
 import type { RequestContextBudget } from "../context/request-context-contracts.js";
 export declare function resolveModelContextBudget(params: {
     runnerConfig: RequestRunnerConfig;
     agentMode: AgentMode;
     modelStep: ModelStep;
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
     modelPreference?: ModelPreference;
+    reasoningPreference?: ModelReasoningPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
 }): RequestContextBudget;
 export type ResolvedModelContextAdmission = Readonly<{
@@ -20,6 +24,7 @@ export declare function resolveModelContextAdmission(params: {
     agentMode: AgentMode;
     modelStep: ModelStep;
     modelPreference?: ModelPreference;
+    reasoningPreference?: ModelReasoningPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
     requestFormat?: ModelGatewayFormat;
 }): ResolvedModelContextAdmission;

package/dist/src/runtime/model/model-context-budget.js

@@ -5,6 +5,7 @@ export function resolveModelContextBudget(params) {
     const configuredInstructionReserveTokens = estimateConfiguredStepInstructionReserveTokens({
         runnerConfig: params.runnerConfig,
         modelStep: params.modelStep,
+        configuredInstructionPolicy: params.configuredInstructionPolicy,
         ...(admission.budget.tokenEstimation
             ? { tokenEstimation: admission.budget.tokenEstimation }
             : {}),
@@ -21,6 +22,7 @@ export function resolveModelContextAdmission(params) {
         agentMode: params.agentMode,
         modelStep: params.modelStep,
         ...(params.requestFormat === undefined ? {} : { format: params.requestFormat }),
+        ...(params.reasoningPreference ? { reasoningPreference: params.reasoningPreference } : {}),
         ...(params.modelPreference
             ? { modelPreference: params.modelPreference }
             : {}),

package/dist/src/runtime/model/model-step-port.d.ts

@@ -1,5 +1,6 @@
 import type { ChatMessage } from "../../model-gateway/types.js";
 import type { ModelStep } from "../../shared/model-steps.js";
+import type { ConfiguredStepInstructionPolicy } from "../config/runner/step-instructions.js";
 import type { ModelStepContextCompactionController } from "./context-compaction-contracts.js";
 export type { ModelStepCompactionScope, ModelStepCompactionStage, ModelStepCompactionStageOutcome, ModelStepContextCompactionController, ModelStepContextCompactionPreparation, } from "./context-compaction-contracts.js";
 export type ModelStepOutputDiagnostics = Readonly<{
@@ -13,6 +14,8 @@ export type ModelStepOutputDiagnostics = Readonly<{
     providerOutputTokens?: number;
     providerTotalTokens?: number;
 }>;
+/** Removes only caller-owned optional context; mandatory messages stay exact. */
+export type ModelStepOptionalContextProjection = (messages: readonly ChatMessage[]) => readonly ChatMessage[];
 export type ModelStepInvocationInput<T> = Readonly<{
     modelStep: ModelStep;
     messages: ChatMessage[];
@@ -22,6 +25,10 @@ export type ModelStepInvocationInput<T> = Readonly<{
     format?: "json" | Record<string, unknown>;
     /** Exact input bypasses compaction, but must fit the shared input budget. */
     contextRetention?: "exact";
+    /** Isolated internal phases may omit the semantic step's configured guidance. */
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
+    /** Pure optional omission after full-envelope assessment; never compacts or persists. */
+    optionalContextProjection?: ModelStepOptionalContextProjection;
     contextCompaction?: ModelStepContextCompactionController;
     /** Async validators must forward this attempt signal to their own work. */
     accept(text: string, diagnostics: ModelStepOutputDiagnostics, abortSignal: AbortSignal): T | Promise<T>;

package/dist/src/runtime/model/optional-context-admission.d.ts

@@ -0,0 +1,18 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { RequestMessagesBudgetAssessment } from "../context/request-context-budget.js";
+import type { ModelStepOptionalContextProjection } from "./model-step-port.js";
+type OptionalContextEnvelope = Readonly<{
+    messages: readonly ChatMessage[];
+    assessment: RequestMessagesBudgetAssessment;
+}>;
+/** Optional references yield at the existing pressure threshold, even for exact input. */
+export declare function admitOptionalModelContext(params: OptionalContextEnvelope & Readonly<{
+    project?: ModelStepOptionalContextProjection;
+    assess(messages: readonly ChatMessage[]): Promise<RequestMessagesBudgetAssessment>;
+    assertCurrent(): void;
+    diagnostic: Readonly<{
+        requestId: string;
+        modelStep: string;
+    }>;
+}>): Promise<OptionalContextEnvelope>;
+export {};

package/dist/src/runtime/model/optional-context-admission.js

@@ -0,0 +1,23 @@
+import { traceDebug } from "../observability/debug-logger.js";
+import { requiresContextCompaction } from "./context-compaction-admission.js";
+/** Optional references yield at the existing pressure threshold, even for exact input. */
+export async function admitOptionalModelContext(params) {
+    if (!params.project)
+        return params;
+    if (!requiresContextCompaction(true, params.assessment))
+        return params;
+    params.assertCurrent();
+    const messages = params.project(params.messages);
+    if (messages === params.messages)
+        return params;
+    params.assertCurrent();
+    const assessment = await params.assess(messages);
+    params.assertCurrent();
+    traceDebug("runtime.context", "optional_context.projected", {
+        ...params.diagnostic,
+        beforeMessageCount: params.messages.length,
+        afterMessageCount: messages.length,
+        fits: assessment.fits,
+    });
+    return { messages, assessment };
+}

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

@@ -4,7 +4,7 @@ import type { AgentMode, ModelReasoningLevel, ModelStep } from "../shared/types.
 import type { ContextBuckets, ModelContextMessage } from "../sessions/context-window.js";
 import type { SessionArtifactPathInput, SessionContextEntryKind, SessionDeleteResult, SessionListResult, SessionMessageDeleteResult, SessionMessageGrounding, SessionMessageObservationMeta, SessionMessageRole, SessionMessageSource, SessionMessageTaskType, SessionMessagesClearResult, SessionRecord, SessionRequestReplay, SessionSnapshot, SessionThinkingTraceEntry } from "../sessions/types.js";
 import type { SessionMemoryRepository } from "../sessions/memory/contracts.js";
-import type { ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult, ModelGatewayEmbeddingParams, ModelGatewayEmbeddingResult, ModelGatewayPolicyConfig, ModelPreference, ModelTokenUsage } from "../model-gateway/types.js";
+import type { ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult, ModelGatewayEmbeddingParams, ModelGatewayEmbeddingResult, ModelGatewayPolicyConfig, ModelPreference, ModelReasoningPreference, ModelTokenUsage } from "../model-gateway/types.js";
 import type { RuntimeAttachmentStore } from "./attachments/store.js";
 import type { RuntimeAttachmentReference } from "../shared/attachments.js";
 import type { StreamCallbacks } from "../model-gateway/client-stream-parser.js";
@@ -220,6 +220,7 @@ export type ModelGatewayInvokeParams = StreamCallbacks & {
     modelOverride?: string;
     reasoningOverride?: ModelReasoningLevel;
     modelPreference?: ModelPreference;
+    reasoningPreference?: ModelReasoningPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
     abortSignal: AbortSignal;
     debugRequestId?: string;
@@ -233,6 +234,7 @@ export type ModelGatewayRawInvokeParams = {
     modelOverride?: string;
     reasoningOverride?: ModelReasoningLevel;
     modelPreference?: ModelPreference;
+    reasoningPreference?: ModelReasoningPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
     abortSignal: AbortSignal;
     debugRequestId?: string;

package/dist/src/runtime/projects/contracts.d.ts

@@ -2,6 +2,10 @@ import type { SessionProject } from "../../sessions/project-binding.js";
 export type RuntimeProject = SessionProject & Readonly<{
     createdAt: string;
 }>;
+export type RuntimeProjectCatalog = Readonly<{
+    projects: readonly RuntimeProject[];
+    deletedProjectIds: readonly string[];
+}>;
 export type ProjectFolder = Readonly<{
     name: string;
     path: string;
@@ -19,6 +23,8 @@ export type ProjectFolderPage = Readonly<{
 }>;
 export type RuntimeProjectService = Readonly<{
     list: () => Promise<readonly RuntimeProject[]>;
+    catalog: () => Promise<RuntimeProjectCatalog>;
+    delete: (projectId: string) => Promise<void>;
     get: (id: string) => Promise<RuntimeProject | null>;
     create: (input: {
         name?: string;

package/dist/src/runtime/projects/registry-format.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeProjectCatalog } from "./contracts.js";
+/** Legacy arrays have no removals; versioned catalogs retain explicit deletions. */
+export declare function readProjectCatalog(input: unknown): RuntimeProjectCatalog;

package/dist/src/runtime/projects/registry-format.js

@@ -0,0 +1,50 @@
+import { copySessionProject } from "../../sessions/project-binding.js";
+function isCatalogRecord(value) {
+    if (!value)
+        return false;
+    if (Array.isArray(value))
+        return false;
+    return typeof value === "object";
+}
+function hasCatalogFields(value) {
+    return Object.keys(value).every((key) => ["version", "projects", "deletedProjectIds"].includes(key));
+}
+function hasDeletedProjectIds(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (!value.every((id) => typeof id === "string" && id.trim().length > 0))
+        return false;
+    return new Set(value).size === value.length;
+}
+function readProjects(input) {
+    const projects = input.map((entry) => {
+        const record = entry;
+        const project = copySessionProject(record);
+        if (typeof record.createdAt !== "string")
+            throw new Error("project_registry_created_at_invalid");
+        return { ...project, createdAt: record.createdAt };
+    });
+    if (new Set(projects.map((project) => project.id)).size !== projects.length)
+        throw new Error("project_registry_duplicate_id");
+    return projects;
+}
+/** Legacy arrays have no removals; versioned catalogs retain explicit deletions. */
+export function readProjectCatalog(input) {
+    if (Array.isArray(input))
+        return { projects: readProjects(input), deletedProjectIds: [] };
+    if (!isCatalogRecord(input))
+        throw new Error("project_registry_invalid");
+    if (input.version !== 1)
+        throw new Error("project_registry_version_invalid");
+    if (!hasCatalogFields(input))
+        throw new Error("project_registry_fields_invalid");
+    if (!Array.isArray(input.projects))
+        throw new Error("project_registry_projects_invalid");
+    if (!hasDeletedProjectIds(input.deletedProjectIds))
+        throw new Error("project_registry_deleted_ids_invalid");
+    const projects = readProjects(input.projects);
+    const deleted = new Set(input.deletedProjectIds);
+    if (projects.some((project) => deleted.has(project.id)))
+        throw new Error("project_registry_active_deleted_conflict");
+    return { projects, deletedProjectIds: [...input.deletedProjectIds] };
+}

package/dist/src/runtime/projects/repository.d.ts

@@ -1,10 +1,13 @@
-import type { RuntimeProject } from "./contracts.js";
-/** One environment owner serializes updates; rename publishes a complete registry. */
+import type { RuntimeProject, RuntimeProjectCatalog } from "./contracts.js";
+/** One environment owner serializes updates; rename publishes a complete catalog. */
 export declare class FileProjectRepository {
     private readonly filename;
     private tail;
     constructor(filename: string);
-    list(): Promise<RuntimeProject[]>;
+    catalog(): Promise<RuntimeProjectCatalog>;
+    list(): Promise<readonly RuntimeProject[]>;
     create(project: RuntimeProject): Promise<RuntimeProject>;
+    delete(projectId: string): Promise<void>;
+    private mutate;
     private save;
 }

package/dist/src/runtime/projects/repository.js

@@ -1,49 +1,56 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { copySessionProject } from "../../sessions/project-binding.js";
-/** One environment owner serializes updates; rename publishes a complete registry. */
+import { readProjectCatalog } from "./registry-format.js";
+/** One environment owner serializes updates; rename publishes a complete catalog. */
 export class FileProjectRepository {
     filename;
     tail = Promise.resolve();
     constructor(filename) {
         this.filename = filename;
     }
-    async list() {
+    async catalog() {
         try {
-            const input = JSON.parse(await readFile(this.filename, "utf8"));
-            if (!Array.isArray(input))
-                throw new Error("project_registry_invalid");
-            return input.map((entry) => {
-                const project = copySessionProject(entry);
-                if (typeof entry.createdAt !== "string")
-                    throw new Error("project_registry_created_at_invalid");
-                return { ...project, createdAt: entry.createdAt };
-            });
+            return readProjectCatalog(JSON.parse(await readFile(this.filename, "utf8")));
         }
         catch (error) {
             if (error.code === "ENOENT")
-                return [];
+                return { projects: [], deletedProjectIds: [] };
             throw error;
         }
     }
+    async list() {
+        return (await this.catalog()).projects;
+    }
     create(project) {
-        const result = this.tail.then(async () => {
-            const projects = await this.list();
-            const existing = projects.find((entry) => entry.directory === project.directory);
+        return this.mutate(async (catalog) => {
+            const existing = catalog.projects.find((entry) => entry.directory === project.directory);
             if (existing)
                 return existing;
-            await this.save([...projects, project]);
+            await this.save({ ...catalog, projects: [...catalog.projects, project] });
             return project;
         });
+    }
+    delete(projectId) {
+        return this.mutate(async (catalog) => {
+            if (catalog.deletedProjectIds.includes(projectId))
+                return;
+            await this.save({
+                projects: catalog.projects.filter((project) => project.id !== projectId),
+                deletedProjectIds: [...catalog.deletedProjectIds, projectId],
+            });
+        });
+    }
+    mutate(apply) {
+        const result = this.tail.then(async () => apply(await this.catalog()));
         this.tail = result.then(() => undefined, () => undefined);
         return result;
     }
-    async save(projects) {
+    async save(catalog) {
         await mkdir(dirname(this.filename), { recursive: true });
         const temporary = `${this.filename}.${process.pid}.${randomUUID()}.tmp`;
         try {
-            await writeFile(temporary, JSON.stringify(projects, null, 2), "utf8");
+            await writeFile(temporary, JSON.stringify({ version: 1, ...catalog }, null, 2), "utf8");
             await rename(temporary, this.filename);
         }
         catch (error) {

package/dist/src/runtime/projects/service.js

@@ -4,11 +4,22 @@ import { copySessionProject } from "../../sessions/project-binding.js";
 import { FileProjectRepository } from "./repository.js";
 import { browseProjectFolders, projectDisplayName, resolveProjectDirectory, } from "./folders.js";
 import { ProjectOperationError, } from "./contracts.js";
+function hasProjectDeleteTarget(value) {
+    if (typeof value !== "string")
+        return false;
+    return value.trim().length > 0;
+}
 export function createRuntimeProjectService(config, sessions) {
     const repository = new FileProjectRepository(join(config.paths.runtimeDir, "projects", "registry.json"));
     const get = async (id) => (await repository.list()).find((project) => project.id === id) ?? null;
     return Object.freeze({
         list: () => repository.list(),
+        catalog: () => repository.catalog(),
+        async delete(projectId) {
+            if (!hasProjectDeleteTarget(projectId))
+                throw new ProjectOperationError("project_id_required", "Select a project to delete.");
+            await repository.delete(projectId);
+        },
         get,
         async create(input) {
             const directory = await resolveProjectDirectory(input.directory);

package/dist/src/runtime/request/approval-wait/preflight.js

@@ -74,6 +74,7 @@ export async function validateApprovalResume(services, snapshot, current) {
                 rawAttachments: [],
                 rawAgentMode: snapshot.seed.agentMode,
                 rawModelPreference: snapshot.seed.modelPreference,
+                rawReasoningPreference: snapshot.seed.reasoningPreference,
                 toolPermissionMode: snapshot.seed.toolPermissionMode,
             },
             temporalContext: snapshot.seed.temporalContext ?? captureRequestTemporalContext(),

package/dist/src/runtime/request/approval-wait/snapshot.d.ts

@@ -11,7 +11,7 @@ import type { RequestToolResources } from "../../capabilities/request-tool-resou
 import type { RequestApprovalContinuation } from "../approval-continuation.js";
 export declare const REQUEST_APPROVAL_SNAPSHOT = "request_approval_snapshot_v1";
 /** Frozen data consumed by the existing request constructor; no service objects. */
-export type PersistedRequestSeed = Pick<RequestExecutionSeed, "requestId" | "sessionId" | "sessionKind" | "prompt" | "temporalContext" | "historyMessages" | "sessionArtifactPaths" | "shouldGenerateSessionTitle" | "runnerConfig" | "executionPolicySelection" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy" | "toolPermissionMode" | "memoryRecallLimit">;
+export type PersistedRequestSeed = Pick<RequestExecutionSeed, "requestId" | "sessionId" | "sessionKind" | "prompt" | "temporalContext" | "historyMessages" | "sessionArtifactPaths" | "shouldGenerateSessionTitle" | "runnerConfig" | "executionPolicySelection" | "attachments" | "agentMode" | "modelPreference" | "reasoningPreference" | "modelPolicy" | "toolPermissionMode" | "memoryRecallLimit">;
 export type RequestApprovalSnapshot = Readonly<{
     kind: typeof REQUEST_APPROVAL_SNAPSHOT;
     originalPrompt: string;

package/dist/src/runtime/request/approval-wait/snapshot.js

@@ -15,6 +15,7 @@ export function snapshotRequestSeed(seed) {
         attachments: seed.attachments,
         agentMode: seed.agentMode,
         modelPreference: seed.modelPreference,
+        reasoningPreference: seed.reasoningPreference,
         modelPolicy: seed.modelPolicy,
         toolPermissionMode: seed.toolPermissionMode,
         memoryRecallLimit: seed.memoryRecallLimit,

package/dist/src/runtime/request/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { ModelReasoningPreference } from "../../shared/model-reasoning.js";
 import type { KnowledgeSkillStore } from "../knowledge-skills/store.js";
 import type { RequestToolResources } from "../capabilities/request-tool-resources.js";
 import type { CapabilityApprovalGate } from "../orchestration/worker-capabilities/approval-contracts.js";
@@ -29,6 +30,7 @@ export type RunRequestMessage = {
     text?: string;
     agentMode?: unknown;
     modelPreference?: unknown;
+    reasoningPreference?: unknown;
     toolPermissionMode?: unknown;
     attachments?: unknown;
 };
@@ -79,6 +81,7 @@ export type RequestExecutionSeed = Readonly<{
     attachments?: ModelGatewayAttachment[];
     agentMode: AgentMode;
     modelPreference?: ModelPreference;
+    reasoningPreference?: ModelReasoningPreference;
     modelPolicy?: ModelGatewayPolicyConfig;
     modelGatewayClient: Pick<ModelGatewayClient, "invoke" | "invokeRaw" | "countInputTokens">;
     contextCompactionStore?: RequestContextCompactionStore;
@@ -128,6 +131,7 @@ export type RequestModelRuntime = Readonly<{
     modelInvocationScope?: RequestExecutionSeed["modelInvocationScope"];
     runnerConfig: RequestExecutionSeed["runnerConfig"];
     modelPreference?: RequestExecutionSeed["modelPreference"];
+    reasoningPreference?: RequestExecutionSeed["reasoningPreference"];
     modelPolicy?: RequestExecutionSeed["modelPolicy"];
     modelGatewayClient: RequestExecutionSeed["modelGatewayClient"];
 }>;
@@ -155,7 +159,7 @@ export type RequestPresentation = Readonly<{
     onAnswerToken: RequestExecutionSeed["onAnswerToken"];
 }>;
 /** The exact request-owned surface required by model invocation. */
-export type RequestModelInvocationView = Readonly<Pick<RequestExecutionSeed, "requestId" | "toolResources" | "modelInvocationScope" | "runnerConfig" | "agentMode" | "modelPreference" | "modelPolicy" | "modelGatewayClient" | "requestSteering" | "abortSignal" | "onThinkingDelta" | "onThinkingTrace">>;
+export type RequestModelInvocationView = Readonly<Pick<RequestExecutionSeed, "requestId" | "toolResources" | "modelInvocationScope" | "runnerConfig" | "agentMode" | "modelPreference" | "reasoningPreference" | "modelPolicy" | "modelGatewayClient" | "requestSteering" | "abortSignal" | "onThinkingDelta" | "onThinkingTrace">>;
 /**
  * Nominal marker for a request that already owns its single model-step port.
  * It is non-enumerable on canonical request views, so it cannot enter model or

package/dist/src/runtime/request/execution-facets.js

@@ -40,6 +40,7 @@ export function createRequestSeedFacets(seed) {
             ? { modelInvocationScope: seed.modelInvocationScope }
             : {}),
         runnerConfig: seed.runnerConfig,
+        ...(seed.reasoningPreference ? { reasoningPreference: seed.reasoningPreference } : {}),
         ...(seed.modelPreference !== undefined
             ? { modelPreference: seed.modelPreference }
             : {}),
@@ -101,6 +102,7 @@ export function createModelInvocationView(facets) {
         requestId: enumerableGetter(() => facets.identity.requestId),
         runnerConfig: enumerableGetter(() => facets.model.runnerConfig),
         agentMode: enumerableGetter(() => facets.input.agentMode),
+        ...(facets.model.reasoningPreference ? { reasoningPreference: enumerableGetter(() => facets.model.reasoningPreference) } : {}),
         ...(facets.model.modelPreference !== undefined
             ? {
                 modelPreference: enumerableGetter(() => facets.model.modelPreference),

package/dist/src/runtime/request/execution-payload-artifact-policy.d.ts

@@ -0,0 +1,3 @@
+import type { ExecutionPolicyAuthoritySnapshot } from "../orchestration/role-calls/index.js";
+/** The frozen request policy owns implicit payload evidence collection. */
+export declare function allowsAutomaticPayloadArtifactLoading(authority: ExecutionPolicyAuthoritySnapshot | undefined): boolean;

package/dist/src/runtime/request/execution-payload-artifact-policy.js

@@ -0,0 +1,6 @@
+/** The frozen request policy owns implicit payload evidence collection. */
+export function allowsAutomaticPayloadArtifactLoading(authority) {
+    if (authority?.id === "execution-agent-v1")
+        return false;
+    return true;
+}

package/dist/src/runtime/request/execution-payload-compacted-evidence.js

@@ -12,6 +12,7 @@ export function projectExecutionPayloadCompactedEvidence(request, context, resul
         prompt: request.prompt,
         objective: projectExecutionCompactionObjective(request.prompt, context.root.updates),
         callId: context.root.callId,
+        updates: context.root.updates,
         store: request.contextCompactionStore,
         results,
     });