@abot-ai/runtime 1.9.0 → 2.0.0

package/dist/src/runtime/context/semantic-compaction/generation-contracts.d.ts

@@ -1,5 +1,5 @@
 import type { ModelStep } from "../../../shared/model-steps.js";
-import type { SemanticCompactionCheckpoint, SemanticCompactionCheckpointBinding, SemanticCompactionSource } from "./contracts.js";
+import type { SemanticCompactionCheckpoint, SemanticCompactionCheckpointBinding, SemanticCompactionDigest, SemanticCompactionSource } from "./contracts.js";
 import type { BoundRequestModelInvocationContext, RequestExecutionSeed } from "../../request/contracts.js";
 import type { SuperCompactionFailureOwner } from "../super-compaction-failure-owner.js";
 export type SemanticCompactionGenerationParams = Readonly<{
@@ -11,6 +11,8 @@ export type SemanticCompactionGenerationParams = Readonly<{
     /** Invocation-local freshness binding; never part of a saved checkpoint. */
     boundSteeringVersion?: number;
     previous?: SemanticCompactionCheckpoint;
+    /** Verified EA predecessor evidence only; exclusive with previous and never persisted. */
+    inheritedSourceDigests?: readonly SemanticCompactionDigest[];
     /** Model step that will consume the checkpoint. */
     consumer?: ModelStep;
     sources: readonly SemanticCompactionSource[];

package/dist/src/runtime/context/semantic-compaction/generation-input.js

@@ -1,11 +1,12 @@
 import { SEMANTIC_COMPACTION_EVIDENCE_SCOPE } from "./evidence-scope.js";
-import { SEMANTIC_COMPACTION_INSTRUCTIONS } from "./prompt.js";
+import { resolveSemanticCompactionInstructions } from "./execution-evidence-instructions.js";
 import { bindSemanticCompactionSourceSlots } from "./source-slots.js";
+import { resolvePriorCompactionSourceDigests } from "./inherited-source-digests.js";
 export function buildSemanticCompactionMessages(params) {
     return [
         Object.freeze({
             role: "system",
-            content: SEMANTIC_COMPACTION_INSTRUCTIONS,
+            content: resolveSemanticCompactionInstructions(params.binding.allowedConsumers),
         }),
         Object.freeze({
             role: "user",
@@ -15,12 +16,14 @@ export function buildSemanticCompactionMessages(params) {
                 currentRequest: params.request.prompt,
                 active: projectActiveAssignment(params),
                 ...(params.previous
+                    ? { previousContinuation: params.previous.continuation }
+                    : {}),
+                ...(resolvePriorCompactionSourceDigests(params).length > 0
                     ? {
-                        previousContinuation: params.previous.continuation,
-                        previousSourceDigests: bindSemanticCompactionSourceSlots(params.previous.sourceDigests),
+                        previousSourceDigests: bindSemanticCompactionSourceSlots(resolvePriorCompactionSourceDigests(params)),
                     }
                     : {}),
-                newSources: bindSemanticCompactionSourceSlots(params.sources, params.previous?.sourceDigests.length ?? 0),
+                newSources: bindSemanticCompactionSourceSlots(params.sources, resolvePriorCompactionSourceDigests(params).length),
             }),
         }),
     ];
@@ -30,7 +33,7 @@ export function buildSemanticCompactionSliceMessages(params, slice, state) {
         Object.freeze({
             role: "system",
             content: [
-                SEMANTIC_COMPACTION_INSTRUCTIONS,
+                resolveSemanticCompactionInstructions(params.binding.allowedConsumers),
                 "The supplied source is one exact contiguous UTF-8 range of a larger canonical source.",
                 "Return all replacement source digests and one replacement continuation. For the sliced source, preserve every previously supplied range plus this range; do not treat ranges as separate sources. partialSourceFold is the latest summary of the covered ranges and replaces the older checkpoint for this generation.",
             ].join("\n"),
@@ -42,11 +45,13 @@ export function buildSemanticCompactionSliceMessages(params, slice, state) {
                 evidenceScope: SEMANTIC_COMPACTION_EVIDENCE_SCOPE,
                 currentRequest: params.request.prompt,
                 active: projectActiveAssignment(params),
-                ...(params.previous && !state
+                ...(resolvePriorCompactionSourceDigests(params).length > 0 && !state
                     ? {
                         previousCheckpoint: {
-                            continuation: params.previous.continuation,
-                            sourceDigests: bindSemanticCompactionSourceSlots(params.previous.sourceDigests),
+                            ...(params.previous
+                                ? { continuation: params.previous.continuation }
+                                : {}),
+                            sourceDigests: bindSemanticCompactionSourceSlots(resolvePriorCompactionSourceDigests(params)),
                         },
                     }
                     : {}),
@@ -59,7 +64,7 @@ export function buildSemanticCompactionSliceMessages(params, slice, state) {
                         },
                     }
                     : {}),
-                sourceSlice: bindSemanticCompactionSourceSlots([slice], params.previous?.sourceDigests.length ?? 0)[0],
+                sourceSlice: bindSemanticCompactionSourceSlots([slice], resolvePriorCompactionSourceDigests(params).length)[0],
             }),
         }),
     ];

package/dist/src/runtime/context/semantic-compaction/inherited-source-digests.d.ts

@@ -0,0 +1,8 @@
+import { type SemanticCompactionCheckpoint, type SemanticCompactionDigest, type SemanticCompactionSource } from "./contracts.js";
+import type { SemanticCompactionGenerationParams } from "./generation-contracts.js";
+/** The EA owner validates predecessor lineage; generation verifies its exact sources. */
+export declare function assertInheritedCompactionSourceDigests(params: SemanticCompactionGenerationParams): void;
+/** Inherited evidence carries no old objective-dependent continuation. */
+export declare function resolvePriorCompactionSourceDigests(params: SemanticCompactionGenerationParams): readonly SemanticCompactionDigest[];
+/** After the first fold, only the real candidate bound to the new objective survives. */
+export declare function projectCompactionBatchParams(params: SemanticCompactionGenerationParams, previous: SemanticCompactionCheckpoint | undefined, sources: readonly SemanticCompactionSource[]): SemanticCompactionGenerationParams;

package/dist/src/runtime/context/semantic-compaction/inherited-source-digests.js

@@ -0,0 +1,76 @@
+import { createSemanticCompactionSha256Fingerprint, isSemanticCompactionSha256Fingerprint, SEMANTIC_COMPACTION_ID_MAX_LENGTH, } from "./contracts.js";
+/** The EA owner validates predecessor lineage; generation verifies its exact sources. */
+export function assertInheritedCompactionSourceDigests(params) {
+    const inherited = params.inheritedSourceDigests;
+    if (inherited === undefined)
+        return;
+    if (params.previous !== undefined)
+        throw new Error("context_compaction_inheritance_previous_conflict");
+    if (!hasExclusiveExecutionCompactionConsumers(params.binding.allowedConsumers))
+        throw new Error("context_compaction_inheritance_consumer_invalid");
+    if (!Number.isSafeInteger(params.sourceRevision) || params.sourceRevision < 0)
+        throw new Error("context_compaction_inheritance_revision_invalid");
+    if (!Array.isArray(inherited) || inherited.length === 0)
+        throw new Error("context_compaction_inheritance_sources_invalid");
+    const store = params.request.contextCompactionStore;
+    if (!store)
+        throw new Error("context_compaction_store_required");
+    const newSourceRefs = new Set(params.sources.map(({ sourceRef }) => sourceRef));
+    const inheritedRefs = new Set();
+    for (const digest of inherited) {
+        if (!isWellFormedInheritedSourceDigest(digest))
+            throw new Error("context_compaction_inheritance_digest_invalid");
+        if (inheritedRefs.has(digest.sourceRef) || newSourceRefs.has(digest.sourceRef))
+            throw new Error("context_compaction_inheritance_source_overlap");
+        const source = store.materializeSource(digest.sourceRef, digest.sourceFingerprint);
+        if (!hasExactInheritedSourceIdentity(source, digest))
+            throw new Error("context_compaction_inheritance_source_missing");
+        inheritedRefs.add(digest.sourceRef);
+    }
+}
+/** Inherited evidence carries no old objective-dependent continuation. */
+export function resolvePriorCompactionSourceDigests(params) {
+    return params.previous?.sourceDigests ?? params.inheritedSourceDigests ?? [];
+}
+/** After the first fold, only the real candidate bound to the new objective survives. */
+export function projectCompactionBatchParams(params, previous, sources) {
+    return Object.freeze({
+        ...params,
+        previous,
+        inheritedSourceDigests: previous ? undefined : params.inheritedSourceDigests,
+        sources,
+    });
+}
+function hasExclusiveExecutionCompactionConsumers(consumers) {
+    if (consumers.length === 0)
+        return false;
+    return consumers.every(isExecutionCompactionConsumer);
+}
+function isExecutionCompactionConsumer(consumer) {
+    return consumer === "execution.decision" || consumer === "execution.response";
+}
+function isWellFormedInheritedSourceDigest(digest) {
+    if (!digest || typeof digest !== "object")
+        return false;
+    if (typeof digest.sourceRef !== "string")
+        return false;
+    if (!digest.sourceRef.trim())
+        return false;
+    if (digest.sourceRef !== digest.sourceRef.trim())
+        return false;
+    if (digest.sourceRef.length > SEMANTIC_COMPACTION_ID_MAX_LENGTH)
+        return false;
+    if (!isSemanticCompactionSha256Fingerprint(digest.sourceFingerprint))
+        return false;
+    if (typeof digest.digest !== "string" || !digest.digest.trim())
+        return false;
+    return digest.digest === digest.digest.trim();
+}
+function hasExactInheritedSourceIdentity(source, digest) {
+    if (!source || source.sourceRef !== digest.sourceRef)
+        return false;
+    if (source.sourceFingerprint !== digest.sourceFingerprint)
+        return false;
+    return (createSemanticCompactionSha256Fingerprint(source.content) ===
+        digest.sourceFingerprint);
+}

package/dist/src/runtime/context/semantic-compaction/replacement-budget.js

@@ -1,8 +1,10 @@
 import { resolveModelContextAdmission } from "../../model/model-context-budget.js";
+import { assertInheritedCompactionSourceDigests, resolvePriorCompactionSourceDigests, } from "./inherited-source-digests.js";
 const CHECKPOINT_CONTEXT_WINDOW_SHARE = 0.3;
 /** A shared checkpoint must fit every declared consumer, starting with its caller. */
 export function prepareReplacementCompactionBudget(params, sources = params.sources) {
-    const expectedSources = Object.freeze([...(params.previous?.sourceDigests ?? []), ...sources].map(({ sourceRef, sourceFingerprint }) => Object.freeze({ sourceRef, sourceFingerprint })));
+    assertInheritedCompactionSourceDigests(params);
+    const expectedSources = Object.freeze([...resolvePriorCompactionSourceDigests(params), ...sources].map(({ sourceRef, sourceFingerprint }) => Object.freeze({ sourceRef, sourceFingerprint })));
     const allowedConsumers = [...new Set(params.binding.allowedConsumers)];
     const consumer = params.consumer ??
         (allowedConsumers.length === 1 ? allowedConsumers[0] : undefined);

package/dist/src/runtime/context/semantic-compaction/run.js

@@ -1,3 +1,4 @@
+import { assertInheritedCompactionSourceDigests, projectCompactionBatchParams, resolvePriorCompactionSourceDigests, } from "./inherited-source-digests.js";
 import { registerSemanticCompactionSources } from "./generation-source-registration.js";
 import { projectConfiguredStepMessages } from "../../config/runner/step-instructions.js";
 import { assessRequestMessagesBudget, resolveRequestBudgetInputTokens, } from "../request-context-budget.js";
@@ -46,7 +47,7 @@ export async function generateSemanticCompactionCandidate(params) {
         modelStep: CONTEXT_COMPACTION_MODEL_STEP,
         scopeId: params.scopeId,
         sourceRevision: params.sourceRevision,
-        previousCoveredSourceCount: params.previous?.sourceDigests.length ?? 0,
+        previousCoveredSourceCount: resolvePriorCompactionSourceDigests(params).length,
         newSourceCount: params.sources.length,
         inputCharacterCount: prepared.messages.reduce((total, message) => total + message.content.length, 0),
     });
@@ -78,7 +79,7 @@ export async function generateSemanticCompactionCandidate(params) {
             coveredSourceCount: candidate.sourceDigests.length,
             replacementCheckpoint: true,
             digestMode: "rolling_replacement",
-            previousDigestCharacters: semanticCompactionDigestTotalLength(params.previous?.sourceDigests ?? []),
+            previousDigestCharacters: semanticCompactionDigestTotalLength(resolvePriorCompactionSourceDigests(params)),
             replacementDigestCharacters: semanticCompactionDigestTotalLength(candidate.sourceDigests),
             durationMs: Date.now() - startedAt,
         });
@@ -102,6 +103,7 @@ export async function generateSemanticCompactionCandidate(params) {
  * returned checkpoint still contains exactly one digest for the full source.
  */
 export async function generateSemanticCompactionCandidateBatched(params) {
+    assertInheritedCompactionSourceDigests(params);
     registerSemanticCompactionSources(params);
     let candidate = params.previous;
     let nextSourceIndex = 0;
@@ -109,11 +111,7 @@ export async function generateSemanticCompactionCandidateBatched(params) {
         let selectedParams;
         for (let endSourceIndex = Math.min(params.sources.length, nextSourceIndex + SEMANTIC_COMPACTION_BATCH_SOURCE_MAX_COUNT); endSourceIndex > nextSourceIndex; endSourceIndex -= 1) {
             const batch = Object.freeze(params.sources.slice(nextSourceIndex, endSourceIndex));
-            const batchParams = Object.freeze({
-                ...params,
-                ...(candidate ? { previous: candidate } : { previous: undefined }),
-                sources: batch,
-            });
+            const batchParams = projectCompactionBatchParams(params, candidate, batch);
             if ((await assessSemanticCompactionInputForAdmission(batchParams)).fits) {
                 selectedParams = batchParams;
                 break;
@@ -125,11 +123,7 @@ export async function generateSemanticCompactionCandidateBatched(params) {
             continue;
         }
         const source = params.sources[nextSourceIndex];
-        const slicedParams = Object.freeze({
-            ...params,
-            ...(candidate ? { previous: candidate } : { previous: undefined }),
-            sources: Object.freeze([source]),
-        });
+        const slicedParams = projectCompactionBatchParams(params, candidate, Object.freeze([source]));
         candidate = await generateSemanticCompactionSlicedSource(slicedParams, source);
         nextSourceIndex += 1;
     }

package/dist/src/runtime/knowledge-skills/builtins/computer-use.js

@@ -1,7 +1,7 @@
 export const COMPUTER_USE_SKILL = Object.freeze({
     skillId: "computer-use",
     name: "Computer Use",
-    description: "Performing and explaining desktop tasks: observe, act, and verify results.",
+    description: "Tasks requiring observation or interaction with a graphical desktop application.",
     content: `# Computer Use
 
 Use this reference when completing the current task requires observing or interacting with a desktop application. It is procedural documentation under the user's request, your assigned objective and existing permissions. It does not make a desktop available or authorize additional actions. Use the currently offered tool schemas for exact inputs and supported operations.

package/dist/src/runtime/knowledge-skills/builtins/technical-work.js

@@ -7,13 +7,31 @@ export const TECHNICAL_WORK_SKILL = Object.freeze({
 Use this guidance for building, changing, debugging or verifying software, scripts and configuration. Apply only what the current request or assigned task needs. It adds no work, permissions or tool availability.
 
 ## Ground the work
-Identify the requested outcome and acceptance criteria. Inspect the relevant implementation, interfaces, data and existing checks. Distinguish observed facts from assumptions; obtain focused observations when essential details are missing.
+Identify the requested outcome and acceptance criteria. Ground decisions in the relevant implementation, interfaces, data and existing checks. Reuse available context before fetching more. Distinguish observed facts from assumptions; obtain focused observations when essential details are missing.
+
+## Plan around outcomes
+- Plan the requested outcomes, not a standard development ceremony. Include only work needed to satisfy the request; do not add exploration, review or validation phases by habit.
+- Give each planned outcome a clear completion condition. Identify the smallest relevant verification needed, if any, and what uncertainty it resolves. Avoid open-ended instructions such as "validate the project" or "check all files."
+- Keep focused verification with the implementation it supports. Create a separate verification task only for an explicit requirement or a concrete risk not covered by those checks, such as integration between components. State its scope and completion condition.
+- Build on established facts and completed work. Do not schedule re-reading successfully written content or repeating valid checks without a specific information gap, relevant change or uncertain result.
+- In delegated work, request the changes made, checks performed, their results and remaining gaps. Evaluate that evidence before commissioning another inspection; retrieve only what is missing for the next decision.
+- Extend the plan only for a concrete unmet requirement, failed check or newly discovered risk—not merely because more inspection is possible.
+
+## Read selectively
+- Treat file reads, tool calls and returned text as expensive resources. Before reading, identify the concrete information gap it must resolve. Skip reads whose answer is already available in context.
+- Reuse content already available in context, including the portions you successfully wrote or patched. Treat it as current unless there is evidence of a subsequent change. Do not re-read it merely to confirm a successful edit, refresh your memory or prepare the final report. Read again only where needed content is missing or incomplete, a tool result is uncertain, or there is evidence of an intervening change.
+- For follow-up tasks, start from known files, symbols and sections rather than restarting exploration. Retrieve only the relevant sections and enough surrounding context to understand dependencies and edit safely.
+- Prefer available targeted retrieval tools: read a known range directly; use scoped symbol/text search when the location is unknown. Reuse sufficient search output without fetching the same content again. Do not search again for locations already known.
+- Expand scope only for a specific unresolved question or dependency. Whole-file reads are justified when broader context is necessary, not simply because a file is involved. Batch related lookups when supported and prefer one sufficient bounded retrieval over many tiny calls.
 
 ## Make focused changes
 Choose the smallest coherent change that meets the request. Preserve unrelated work and reuse established patterns. Use offered capabilities and confirmed prerequisites; do not assume a particular operating system, runtime or dependency is available.
 
 ## Verify proportionately
-- Default to focused code checks and relevant unit/integration tests. Browser end-to-end tests, UI/responsive audits, or new test infrastructure require an explicit user request for that level of testing; a request for a working or responsive product alone is not sufficient.
+A successful write establishes the saved content, not its correctness. Avoiding redundant reads does not replace relevant verification.
+- Default to focused code checks and relevant existing unit/integration tests.
+- Perform browser interaction testing only when the user explicitly requests that level of testing. Without that request, do not run browser interaction checks, browser end-to-end tests or UI/responsive audits, and do not create a DOM mock, simulated browser or custom interaction harness as a substitute. A request to build a working, connected or responsive product does not authorize these checks.
+- New test infrastructure also requires an explicit user request. Keep verification within the requested scope; do not add interaction testing to turn an unverified browser outcome into a successful one. Do not present unrequested browser testing as an unmet acceptance criterion or a reason to continue working.
 - Check unknown prerequisites before dependent verification.
 - Use small, independently diagnostic checks; reuse passing results until relevant changes.
 - Diagnose a failed check before changing the product.

package/dist/src/runtime/knowledge-skills/builtins/what-can-i-do.d.ts

@@ -0,0 +1,2 @@
+import type { KnowledgeSkillDocument } from "../store.js";
+export declare const WHAT_CAN_I_DO_SKILL: KnowledgeSkillDocument;

package/dist/src/runtime/knowledge-skills/builtins/what-can-i-do.js

@@ -0,0 +1,27 @@
+export const WHAT_CAN_I_DO_SKILL = Object.freeze({
+    skillId: "what-can-i-do",
+    name: "What Can I Do?",
+    description: "ABot abilities, tools and plugins overview; not requests to perform a task.",
+    content: `# What Can I Do?
+
+Explain what ABot can help the user accomplish, in the user's language. Give a short, practical overview suited to their question. Include useful actions as well as conversational help; a generic description of a language model misses ABot's purpose.
+
+## Useful work
+ABot combines writing, explanation, translation, summarization and coding assistance with actions through enabled tools. Depending on the configured tools and permissions, supported work includes:
+
+- Research public websites and recent news, compare sources and prepare a sourced summary.
+- Read, search, create and edit files within the configured workspace; save useful results as documents or project files.
+- Inspect code and configuration, develop scripts, and run supported commands or checks.
+- Work with connected desktop applications through Computer Use, with explicit approval for the target and task.
+- Schedule recurring tasks or build reusable automation drafts in ABot Studio.
+
+Choose a few relevant examples rather than reciting every area. Distinguish writing an explanation or draft from actually searching, saving, scheduling or operating an application.
+
+## Describe the current installation honestly
+The examples above describe supported uses of ABot, not a verified inventory of this installation. Current request metadata and discovery results determine which tools are enabled. Availability does not prove a connected account, permission, successful execution or unrestricted computer/file access.
+
+For a broad introduction, describe these areas with a brief qualification that actions depend on enabled tools. If the user asks for the exact current tools or plugins, use supplied current metadata or the offered capability_brief / describe_available_tools discovery operation when the current role can invoke it. If that information is unavailable, state the limit; do not invent a list or conclude that no tools exist.
+
+Explaining an ability does not authorize demonstrating it. Do not inspect a desktop, change files, activate an automation or load unrelated Skills merely to introduce yourself. Keep any separately requested action within its normal workflow and permissions.
+`,
+});

package/dist/src/runtime/knowledge-skills/catalog.js

@@ -2,6 +2,7 @@ import { SKILL_CREATOR } from "./builtins/skill-creator.js";
 import { ABOT_STUDIO_SKILL } from "./builtins/abot-studio.js";
 import { COMPUTER_USE_SKILL } from "./builtins/computer-use.js";
 import { TECHNICAL_WORK_SKILL } from "./builtins/technical-work.js";
+import { WHAT_CAN_I_DO_SKILL } from "./builtins/what-can-i-do.js";
 import { createKnowledgeSkillStore } from "./store.js";
 /** Packaged read-only documents; independent of installed or enabled plugins. */
 export const builtinKnowledgeSkillStore = createKnowledgeSkillStore([
@@ -9,4 +10,5 @@ export const builtinKnowledgeSkillStore = createKnowledgeSkillStore([
     COMPUTER_USE_SKILL,
     SKILL_CREATOR,
     TECHNICAL_WORK_SKILL,
+    WHAT_CAN_I_DO_SKILL,
 ]);

package/dist/src/runtime/local-application.d.ts

@@ -157,6 +157,9 @@ export declare function createLocalRuntimeApplication(config?: RuntimeConfig, op
                 }>[];
                 models: {
                     provider?: string | undefined;
+                    reasoningControls?: {
+                        budgetTokens: boolean;
+                    } | undefined;
                     id: string;
                     label: string;
                 }[];
@@ -289,6 +292,8 @@ export declare function createLocalRuntimeApplication(config?: RuntimeConfig, op
         };
         projects: Readonly<{
             list: () => Promise<readonly import("./projects/contracts.js").RuntimeProject[]>;
+            catalog: () => Promise<import("./projects/contracts.js").RuntimeProjectCatalog>;
+            delete: (projectId: string) => Promise<void>;
             get: (id: string) => Promise<import("./projects/contracts.js").RuntimeProject | null>;
             create: (input: {
                 name?: string;

package/dist/src/runtime/local-host/app-service-dispatch.d.ts

@@ -1,6 +1,6 @@
 import type { RuntimeEnvironmentServices } from "../composition.js";
 export declare const LOCAL_SESSION_METHODS: readonly ["getOrCreateSession", "createAssistantConversation", "getAllSessions", "listSessions", "getSessionById", "getSessionSnapshot", "getRequestReplayById", "updateSessionTitle", "updateSessionRuntimeMode", "appendMessage", "appendContextEntry", "upsertArtifactPaths", "startRequestStream", "appendRequestEvent", "deleteSession", "deleteSessionWithStats", "resetSession", "clearSessionMessages", "deleteMessage", "deleteMessageWithStats", "compareAndSwapSessionMemoryCheckpoint"];
-export declare const LOCAL_PROJECT_METHODS: readonly ["list", "get", "create", "browseFolders", "createSession"];
+export declare const LOCAL_PROJECT_METHODS: readonly ["list", "catalog", "delete", "get", "create", "browseFolders", "createSession"];
 export declare const LOCAL_ATTACHMENT_METHODS: readonly ["saveAttachment", "validateAttachmentReferences", "resolveAttachment", "deleteAttachment", "deleteSessionAttachments"];
 export declare const LOCAL_SCHEDULER_METHODS: readonly ["tick", "create", "list", "get", "update", "pause", "resume", "cancel", "runNow", "deleteSession", "listRuns"];
 export declare const LOCAL_AUTOMATION_METHODS: readonly ["list", "create", "createDraftPlan", "applyDraftPlan", "getDraft", "deleteDraft", "archive", "restore", "getPublishedDefinition", "updateDraft", "getSavedAgent", "listSavedAgents", "saveAgentFromDraft", "validate", "catalog", "getGrant", "replaceGrant", "publish", "activate", "pause", "runNow", "listRuns", "getRun", "getStepEvidence", "stopRun", "rerun"];

package/dist/src/runtime/local-host/app-service-dispatch.js

@@ -23,6 +23,8 @@ export const LOCAL_SESSION_METHODS = [
 ];
 export const LOCAL_PROJECT_METHODS = [
     "list",
+    "catalog",
+    "delete",
     "get",
     "create",
     "browseFolders",

package/dist/src/runtime/local-host/client-services.d.ts

@@ -153,6 +153,9 @@ export declare function createLocalServiceClients(call: LocalRuntimeCallHandler)
             }>[];
             models: {
                 provider?: string | undefined;
+                reasoningControls?: {
+                    budgetTokens: boolean;
+                } | undefined;
                 id: string;
                 label: string;
             }[];
@@ -285,6 +288,8 @@ export declare function createLocalServiceClients(call: LocalRuntimeCallHandler)
     };
     projects: Readonly<{
         list: () => Promise<readonly import("../projects/contracts.js").RuntimeProject[]>;
+        catalog: () => Promise<import("../projects/contracts.js").RuntimeProjectCatalog>;
+        delete: (projectId: string) => Promise<void>;
         get: (id: string) => Promise<import("../projects/contracts.js").RuntimeProject | null>;
         create: (input: {
             name?: string;

package/dist/src/runtime/local-host/saved-approvals.js

@@ -293,6 +293,7 @@ export class SavedRequestApprovals {
                 text: snapshot.originalPrompt,
                 agentMode: snapshot.seed.agentMode,
                 modelPreference: snapshot.seed.modelPreference,
+                reasoningPreference: snapshot.seed.reasoningPreference,
                 toolPermissionMode: snapshot.seed.toolPermissionMode,
             }, {
                 ...options,

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

@@ -1,9 +1,10 @@
+import { listSavedEmbeddingProfiles, matchingEmbeddingProfileLabel, readSavedEmbeddingProfiles } from "./saved-profiles.js";
 import { isRecord } from "../../config/utils.js";
 export const DEFAULT_MEMORY_EMBEDDING_PROFILE_ID = "memory-embedding";
 export function projectOnboardingStatus(config) {
     const memory = isRecord(config.longTermMemory) ? config.longTermMemory : {};
     const profileId = readText(memory.embeddingProfileId);
-    const embeddingProfiles = readEmbeddingProfiles(config);
+    const embeddingProfiles = readSavedEmbeddingProfiles(config);
     const profile = profileId ? embeddingProfiles[profileId] : undefined;
     const providerId = isRecord(profile) ? readText(profile.provider) : undefined;
     const model = isRecord(profile) ? readText(profile.model) : undefined;
@@ -11,6 +12,7 @@ export function projectOnboardingStatus(config) {
         enabled: memory.enabled === true,
         emitClientEvents: memory.emitClientEvents === true,
         providers: listConfiguredProviders(config),
+        embeddingProfiles: listSavedEmbeddingProfiles(config),
         ...(profileId ? { profileId } : {}),
         ...(providerId ? { providerId } : {}),
         ...(model ? { model } : {}),
@@ -21,7 +23,7 @@ export function buildEnabledMemoryConfig(params) {
     const memory = isRecord(params.config.longTermMemory)
         ? params.config.longTermMemory
         : {};
-    const profiles = readEmbeddingProfiles(params.config);
+    const profiles = readSavedEmbeddingProfiles(params.config);
     const existingProfile = profiles[params.profileId];
     const existingOptions = readMatchingProfileOptions({
         profile: existingProfile,
@@ -35,7 +37,7 @@ export function buildEnabledMemoryConfig(params) {
             embeddingProfiles: {
                 ...profiles,
                 [params.profileId]: {
-                    label: "Long-term memory embeddings",
+                    label: matchingEmbeddingProfileLabel(existingProfile, params.providerId, params.model) ?? "Long-term memory embeddings",
                     provider: params.providerId,
                     model: params.model,
                     ...(existingOptions ? { options: existingOptions } : {}),
@@ -89,10 +91,6 @@ export function requireConfiguredProvider(config, providerId) {
         throw new Error(`long_term_memory_provider_not_configured:${providerId}`);
     }
 }
-function readEmbeddingProfiles(config) {
-    const models = isRecord(config.models) ? config.models : {};
-    return isRecord(models.embeddingProfiles) ? models.embeddingProfiles : {};
-}
 function readText(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }

package/dist/src/runtime/long-term-memory/onboarding/contracts.d.ts

@@ -3,6 +3,21 @@ export type LongTermMemoryOnboardingProvider = Readonly<{
     id: string;
     type: string;
 }>;
+export type SavedMemoryEmbeddingProfile = Readonly<{
+    id: string;
+    label: string;
+    providerId: string;
+    model: string;
+}>;
+export type LongTermMemoryEmbeddingProfileSaveResult = Readonly<{
+    status: LongTermMemoryOnboardingStatus;
+    profileId: string;
+    configPath: string;
+    backupPath?: string;
+}>;
+export type LongTermMemoryEmbeddingProfileRemoveResult = LongTermMemoryEmbeddingProfileSaveResult & Readonly<{
+    removed: true;
+}>;
 export type LongTermMemoryOnboardingStatus = Readonly<{
     enabled: boolean;
     emitClientEvents: boolean;
@@ -10,6 +25,7 @@ export type LongTermMemoryOnboardingStatus = Readonly<{
     providerId?: string;
     model?: string;
     providers: readonly LongTermMemoryOnboardingProvider[];
+    embeddingProfiles: readonly SavedMemoryEmbeddingProfile[];
 }>;
 export type LongTermMemoryOnboardingResult = Readonly<{
     status: LongTermMemoryOnboardingStatus;
@@ -48,5 +64,15 @@ export type LongTermMemoryOnboardingService = Readonly<{
         emitClientEvents?: boolean;
         abortSignal?: AbortSignal;
     }>): Promise<LongTermMemoryOnboardingResult>;
+    saveProfile(input: Readonly<{
+        providerId: string;
+        model: string;
+        label: string;
+        abortSignal?: AbortSignal;
+    }>): Promise<LongTermMemoryEmbeddingProfileSaveResult>;
+    removeProfile(input: Readonly<{
+        profileId: string;
+        abortSignal?: AbortSignal;
+    }>): Promise<LongTermMemoryEmbeddingProfileRemoveResult>;
     disable(): Promise<LongTermMemoryOnboardingResult>;
 }>;

package/dist/src/runtime/long-term-memory/onboarding/embedding-profile-id.d.ts

@@ -0,0 +1 @@
+export declare function readEmbeddingProfileId(value: string | undefined): string;

package/dist/src/runtime/long-term-memory/onboarding/embedding-profile-id.js

@@ -0,0 +1,8 @@
+import { DEFAULT_MEMORY_EMBEDDING_PROFILE_ID } from "./configuration.js";
+const PROFILE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
+export function readEmbeddingProfileId(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;
+}

package/dist/src/runtime/long-term-memory/onboarding/saved-profiles.d.ts

@@ -0,0 +1,17 @@
+import type { RuntimeConfigFile } from "../../config/types.js";
+import type { SavedMemoryEmbeddingProfile } from "./contracts.js";
+export declare function readSavedEmbeddingProfiles(config: RuntimeConfigFile): Record<string, unknown>;
+export declare function listSavedEmbeddingProfiles(config: RuntimeConfigFile): readonly SavedMemoryEmbeddingProfile[];
+/** A saved choice is independent of the active memory binding and credentials. */
+export declare function buildSavedEmbeddingProfile(params: {
+    config: RuntimeConfigFile;
+    providerId: string;
+    model: string;
+    label: string;
+}): {
+    config: RuntimeConfigFile;
+    profileId: string;
+};
+export declare function matchingEmbeddingProfileLabel(profile: unknown, providerId: string, model: string): string | undefined;
+/** Remove a saved choice, never its provider or stored memory data. */
+export declare function buildRemovedEmbeddingProfile(config: RuntimeConfigFile, profileId: string): RuntimeConfigFile;

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

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import { isRecord } from "../../config/utils.js";
+export function readSavedEmbeddingProfiles(config) {
+    const models = isRecord(config.models) ? config.models : {};
+    return isRecord(models.embeddingProfiles) ? models.embeddingProfiles : {};
+}
+export function listSavedEmbeddingProfiles(config) {
+    return Object.freeze(Object.entries(readSavedEmbeddingProfiles(config)).flatMap(([id, profile]) => {
+        if (!isRecord(profile))
+            return [];
+        if (typeof profile.provider !== "string")
+            return [];
+        if (typeof profile.model !== "string")
+            return [];
+        return [Object.freeze({
+                id,
+                label: typeof profile.label === "string" ? profile.label : id,
+                providerId: profile.provider,
+                model: profile.model,
+            })];
+    }));
+}
+/** A saved choice is independent of the active memory binding and credentials. */
+export function buildSavedEmbeddingProfile(params) {
+    const models = isRecord(params.config.models) ? params.config.models : {};
+    const profiles = readSavedEmbeddingProfiles(params.config);
+    const profileId = `embedding-${randomUUID()}`;
+    return {
+        profileId,
+        config: {
+            ...params.config,
+            models: {
+                ...models,
+                embeddingProfiles: {
+                    ...profiles,
+                    [profileId]: { label: params.label, provider: params.providerId, model: params.model },
+                },
+            },
+        },
+    };
+}
+export function matchingEmbeddingProfileLabel(profile, providerId, model) {
+    if (!isRecord(profile))
+        return undefined;
+    if (profile.provider !== providerId)
+        return undefined;
+    if (profile.model !== model)
+        return undefined;
+    return typeof profile.label === "string" ? profile.label : undefined;
+}
+class SavedEmbeddingProfileRemovalError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+function hasConfiguredMemoryProfile(config, profileId) {
+    if (!isRecord(config.longTermMemory))
+        return false;
+    const selected = config.longTermMemory.embeddingProfileId;
+    return typeof selected === "string" && selected.trim() === profileId;
+}
+function requireRemovableSavedProfile(config, profileId) {
+    if (!Object.hasOwn(readSavedEmbeddingProfiles(config), profileId))
+        throw new SavedEmbeddingProfileRemovalError("The saved embedding profile no longer exists.", 404);
+    if (hasConfiguredMemoryProfile(config, profileId))
+        throw new SavedEmbeddingProfileRemovalError("Choose another memory profile before removing this one.", 409);
+}
+/** Remove a saved choice, never its provider or stored memory data. */
+export function buildRemovedEmbeddingProfile(config, profileId) {
+    requireRemovableSavedProfile(config, profileId);
+    const models = isRecord(config.models) ? config.models : {};
+    const profiles = { ...readSavedEmbeddingProfiles(config) };
+    delete profiles[profileId];
+    return { ...config, models: { ...models, embeddingProfiles: profiles } };
+}