@noodleseed/one 0.168.0 → 0.170.0

package/node_modules/@noodle-borg/service/dist/local-options.d.ts

@@ -6,6 +6,7 @@ import type { LocalDevtoolsDelegatedExchangeRuntime } from './local-devtools-del
 import type { ServerRegistry } from './registry.js';
 import type { ConfigStore, TenantBridgeAuthConfig } from './store.js';
 type LocalRuntimeOptions = {
+    readonly capabilities?: import('@noodle-borg/managed-capabilities').CapabilityService;
     readonly assistantStore?: import('@noodle-borg/assistant-gateway/portable').AssistantStore;
     readonly assistantAppearance?: import('@noodle-borg/assistant-gateway/portable').AssistantAppearanceSettingsStore;
     readonly publicEmbeds?: import('@noodle-borg/assistant-gateway/portable').PublicEmbedStore;

package/node_modules/@noodle-borg/service/dist/local-web-capabilities.js

@@ -0,0 +1,13 @@
+import { InMemoryDailyCounterStore } from '@noodle-borg/admission-limits/portable';
+import { PublicPageReader } from '@noodle-borg/knowledge-crawl';
+import { CapabilityService, InMemoryCapabilityPolicyStore, } from '@noodle-borg/managed-capabilities';
+/** Loopback-only composition. Keep PostgreSQL imports out of the published CLI graph. */
+export function localWebCapabilities() {
+    return new CapabilityService({
+        profile: 'development',
+        policies: new InMemoryCapabilityPolicyStore(),
+        counters: new InMemoryDailyCounterStore(),
+        reader: new PublicPageReader(),
+    });
+}
+//# sourceMappingURL=local-web-capabilities.js.map

package/node_modules/@noodle-borg/service/dist/mcp-protocol-runtime.js

@@ -0,0 +1,21 @@
+import { RequestStateManager, requestStateSecretBox, } from '@noodle-borg/protocol';
+/**
+ * Build the fleet-shared request-state manager. Static-key deployments use an HKDF domain-separated key;
+ * KMS deployments reuse the configured envelope-encryption custodian because its raw KEK cannot be
+ * exported for HKDF.
+ */
+export function createHostedMcpRequestStateManager(input) {
+    if (input.secretMasterKey !== undefined) {
+        return new RequestStateManager(requestStateSecretBox(Buffer.from(input.secretMasterKey, 'base64')));
+    }
+    return input.secretBox === undefined ? undefined : new RequestStateManager(input.secretBox);
+}
+/** Resolve the temporary origin-wide rollout gate from operator configuration. */
+export function resolveMcpProtocolMode(value) {
+    if (value === undefined || value === 'dual')
+        return 'dual';
+    if (value === 'legacy-only')
+        return value;
+    throw new Error('NOODLE_MCP_PROTOCOL_MODE must be dual or legacy-only');
+}
+//# sourceMappingURL=mcp-protocol-runtime.js.map

package/node_modules/@noodle-borg/service/dist/modules/route-dispatch.js

@@ -14,6 +14,19 @@ export function createModuleRouteContext(hostRequest, deps) {
         logger: deps.logger ?? noopModuleLogger,
         controlPlane: deps.gate,
         audit: deps.audit,
+        capabilityDeployments: {
+            get: async (request, scope) => {
+                if (request !== hostRequest || !authorizedOrgs.has(scope.org))
+                    return undefined;
+                const target = await deps.registry.getActiveByTenant(scope);
+                if (target?.deploymentId === undefined)
+                    return undefined;
+                return {
+                    deploymentId: target.deploymentId,
+                    declarations: target.served.artifact.server.capabilities ?? [],
+                };
+            },
+        },
         platformIdentityRecovery: {
             reconcile: (plan) => deps.registry.reconcilePlatformAccountReset(plan),
             customerAuthRestoreProjections: async (deploymentIds) => (await deps.registry.customerAuthRestoreProjections(deploymentIds)).map((projection) => ({

package/node_modules/@noodle-borg/service/dist/registry-compile.js

@@ -9,10 +9,12 @@ import { ManagedConfigBroker } from './credential-broker.js';
 import { deploymentCredentialBrokerOptions } from './credential-broker-options.js';
 import { deploymentRecordVersionError } from './deployment-record-version.js';
 import { normalizePersistedManifestForCompile } from './manifest-normalize.js';
+import { registryRecordStillExists } from './registry-deletion.js';
 import { missingCapabilityErrors, missingSecretErrors, missingVariableErrors, } from './registry-helpers.js';
 import { servedTargetFor } from './registry-targets.js';
 import { createDeploymentStateConnector, } from './state-connector-factory.js';
 import { resolveConfigScope, } from './store.js';
+import { deploymentWebConnector } from './web-capabilities.js';
 /** Reject unsupported persisted semantics before constructing executable runtime dependencies. */
 export async function compilePersistedRegistryRecord(record, compileTarget) {
     const versionError = deploymentRecordVersionError(record);
@@ -196,11 +198,13 @@ export async function compileRegistryTarget(context, input) {
             artifact,
             ...(boundDeploymentId === undefined ? {} : { deploymentId: boundDeploymentId }),
         });
+        const webConnector = deploymentWebConnector(artifact, tenant, boundDeploymentId, context.capabilities);
         return {
             artifact,
             deps: {
                 connectors: new InMemoryConnectorRegistry([
                     ...context.platformConnectors,
+                    ...(webConnector === undefined ? [] : [webConnector]),
                     ...(nativeRecords === undefined ? [] : [nativeRecords]),
                     ...(stateConnector !== undefined ? [stateConnector] : []),
                     ...httpConnectors,
@@ -252,6 +256,11 @@ export async function loadPersistedRegistryTarget(source, context) {
     if (record.active &&
         (await context.hasCustomerAuthConflict(record, built.served.artifact.server.auth)))
         return undefined;
+    const exists = state.store === undefined
+        ? state.records.has(deploymentId)
+        : await registryRecordStillExists(state, deploymentId);
+    if (!exists)
+        return undefined;
     const target = servedTargetFor(record, built.served, context.customerVerifierFactory);
     state.servers.set(deploymentId, target);
     state.records.set(deploymentId, record);

package/node_modules/@noodle-borg/service/dist/registry-deletion.js

@@ -0,0 +1,75 @@
+import { planDeploymentDeletion } from './deployment-deletion.js';
+import { targetForPersistedRecord } from './registry-targets.js';
+import { validateTenantRef } from './store/validate.js';
+export function evictDeletedDeployments(state, ids) {
+    for (const id of ids) {
+        state.records.delete(id);
+        state.servers.delete(id);
+    }
+    for (const [key, id] of state.activeTenants)
+        if (ids.has(id))
+            state.activeTenants.delete(key);
+}
+export async function deleteRegistryDeployments(state, ref, selection) {
+    const safe = validateTenantRef(ref);
+    const result = state.store === undefined
+        ? planDeploymentDeletion([...state.records.values()], safe, selection)
+        : await state.store.deleteDeployments(safe, selection);
+    if (result.ok)
+        evictDeletedDeployments(state, new Set(result.deleted.map((record) => record.deploymentId)));
+    return result;
+}
+/** Async compilation must rejoin authority before publishing a result into the disposable cache. */
+export async function registryRecordStillExists(state, deploymentId) {
+    const current = state.store === undefined
+        ? state.records.get(deploymentId)
+        : await state.store.get(deploymentId);
+    if (current !== undefined && current.archivedAt === undefined)
+        return true;
+    evictDeletedDeployments(state, new Set([deploymentId]));
+    return false;
+}
+/** Refresh warmed cache entries from authority and coalesce compilation on a cache miss. */
+export async function readRegistryTarget(state, deploymentId, inflight, targetForRecord, load) {
+    if (state.records.get(deploymentId)?.archivedAt !== undefined)
+        return undefined;
+    if (state.servers.has(deploymentId)) {
+        const record = state.store
+            ? await state.store.get(deploymentId)
+            : state.records.get(deploymentId);
+        if (record === undefined)
+            evictDeletedDeployments(state, new Set([deploymentId]));
+        return record === undefined || record.archivedAt !== undefined
+            ? undefined
+            : targetForRecord(record);
+    }
+    const pending = inflight.get(deploymentId);
+    if (pending)
+        return pending;
+    const promise = load(deploymentId).finally(() => {
+        inflight.delete(deploymentId);
+    });
+    inflight.set(deploymentId, promise);
+    return promise;
+}
+/** No-store records are authority, so stale reconciliation must never repopulate absent records. */
+export async function reconcileRegistryTarget(state, record, context) {
+    let loaded = false;
+    const target = await targetForPersistedRecord(record, {
+        ...context,
+        load: () => {
+            loaded = true;
+            return context.load();
+        },
+        records: state.records,
+        servers: state.servers,
+        recordStillPresent: () => state.store !== undefined || state.records.has(record.deploymentId),
+    });
+    // A cold load already checks store authority just before publication; warm reconciliation must too.
+    // No async presence snapshot in no-store mode: deletion and publication share one synchronous turn.
+    const exists = state.store === undefined
+        ? state.records.has(record.deploymentId)
+        : loaded || (await registryRecordStillExists(state, record.deploymentId));
+    return exists ? target : undefined;
+}
+//# sourceMappingURL=registry-deletion.js.map

package/node_modules/@noodle-borg/service/dist/registry-state.js

@@ -166,8 +166,10 @@ export async function setRegistryDeploymentLock(state, ref, serverVersion, expec
             state.records.set(result.record.deploymentId, result.record);
         return result;
     }
-    const active = await activeRecordVersion(state, safe, safeVersion);
-    if (active === undefined)
+    const observed = await activeRecordVersion(state, safe, safeVersion);
+    // The lookup yields; a concurrent deletion or pointer move must win before any cache write.
+    const active = observed === undefined ? undefined : state.records.get(observed.deploymentId);
+    if (active === undefined || !active.active || active.archivedAt !== undefined)
         return { ok: false, reason: 'no_active_deployment' };
     if (active.deploymentId !== expectedDeploymentId)
         return { ok: false, reason: 'conflict' };

package/node_modules/@noodle-borg/service/dist/registry-targets.js

@@ -110,6 +110,8 @@ function bindAppPackageSnapshot(served, value) {
 }
 /** Reconcile one persisted record with its cached served target without trusting stale auth projections. */
 export async function targetForPersistedRecord(record, state) {
+    if (state.recordStillPresent?.() === false)
+        return undefined;
     const cached = state.servers.get(record.deploymentId);
     const cachedSchemaVersion = cached === undefined ? undefined : targetPolicyVersions.get(cached);
     state.records.set(record.deploymentId, record);
@@ -127,6 +129,8 @@ export async function targetForPersistedRecord(record, state) {
         (await state.hasCustomerAuthConflict(record, cached.served.artifact.server.auth))) {
         return undefined;
     }
+    if (state.recordStillPresent?.() === false)
+        return undefined;
     if (cachedSchemaVersion === record.schemaVersion && servedTargetMatchesRecord(cached, record))
         return cached;
     const reconciled = servedTargetFor(record, cached.served, state.customerVerifierFactory);

package/node_modules/@noodle-borg/service/dist/registry-types.d.ts

@@ -96,6 +96,7 @@ export interface AccessUpdateOptions {
     readonly serverVersion?: string | undefined;
 }
 export interface ServerRegistryOptions {
+    readonly capabilities?: import('@noodle-borg/managed-capabilities').CapabilityService;
     readonly nativeRecords?: NativeRecordConnectorFactory;
     /** Pure renderer injection used for deployment-bound package construction and failure testing. */
     readonly renderAppPackage?: AppPackageRenderer;

package/node_modules/@noodle-borg/service/dist/registry.d.ts

@@ -9,6 +9,7 @@ import type { ServedTarget } from '@noodle-borg/transport-http';
 import type { NativeRecordConnectorFactory } from './native-record-connector.js';
 import { type ActiveDeployProvenance } from './registry-helpers.js';
 import type { AccessUpdateOptions, AccessUpdateResult, DeployOptions, DeployPreflightResult, RecoverResult, RunDeployResult, ServerRegistryOptions } from './registry-types.js';
+import type { DeploymentDeleteResult, DeploymentDeleteSelection } from './store.js';
 import { type AppArchiveResult, type AppRestoreResult, type AppSummary, type ArtifactStore, type ConfigStore, type CustomerAuthRestoreProjection, type DeploymentListFilter, type DeploymentLock, type DeploymentLockUpdateResult, type DeploymentStatus, type DeploymentSummary, type DeployRecord, type EnvSummary, type ProductionEnvironmentChange, type TenantRef } from './store.js';
 export type { RollbackResult } from '@noodle-borg/control-plane/portable';
 export type { DeploymentPackage } from './registry-package.js';
@@ -29,6 +30,7 @@ export declare class ServerRegistry {
     /** Read-only deploy validation used by the CLI before config writes, asset upload, or persistence. */
     preflightDeploy(tenant: TenantRef, manifest: string, options?: DeployOptions): Promise<DeployPreflightResult>;
     recover(): Promise<RecoverResult>;
+    deleteDeployments(ref: TenantRef, selection: DeploymentDeleteSelection): Promise<DeploymentDeleteResult>;
     get(deploymentId: string): Promise<ServedTarget | undefined>;
     /** Resolve a deployment-id data-plane route only while that exact record is actively serving. */
     getServing(deploymentId: string): Promise<ServedTarget | undefined>;

package/node_modules/@noodle-borg/service/dist/registry.js

@@ -6,6 +6,7 @@ import { DeploymentPolicyChangedError, UnsupportedDeploymentRecordVersionError,
 import { defaultActiveRecord } from './deployment-versioning.js';
 import { updateRegistryAccess } from './registry-access.js';
 import { compilePersistedRegistryRecord, compileRegistryTarget, loadPersistedRegistryTarget, } from './registry-compile.js';
+import { deleteRegistryDeployments, readRegistryTarget, reconcileRegistryTarget, } from './registry-deletion.js';
 import { createRegistryDeployRecord, deployedRecordResult, deploymentWriteVersionError, preflightRegistryDeploy, replacementDeploymentPolicy, resolveDeployAttempt, withDeploymentConfiguration, } from './registry-deploy-transaction.js';
 import { deploymentOwnerSubject } from './registry-helpers.js';
 import { registryDeploymentPackage, renderDeploymentPackageSnapshot } from './registry-package.js';
@@ -13,7 +14,7 @@ import { recoverRegistryRecords } from './registry-recover.js';
 import { rollbackDeployment, rollbackWithMappedErrors } from './registry-rollback.js';
 import { activeRecord, activeRecordVersion, persistDeployRecord, reconcilePlatformAccountResetRegistryCache, registryAppArchivedAt, registryArchiveApp, registryCustomerAuthRestoreProjections, registryGetApp, registryGetDeployment, registryGetEnvironment, registryListApps, registryListEnvironments, registryRestoreApp, registrySetProductionEnvironment, registrySweepArchived, setRegistryDeploymentLock, } from './registry-state.js';
 import { deploymentStatusFor } from './registry-status.js';
-import { deploymentSourceFor, rebindNativeRecords, servedTargetFor, targetForPersistedRecord, tenantDeploymentKey, tenantKey, } from './registry-targets.js';
+import { deploymentSourceFor, rebindNativeRecords, servedTargetFor, tenantDeploymentKey, tenantKey, } from './registry-targets.js';
 import { withBuiltinStateCatalog } from './state-catalog.js';
 import { deploymentSummary, matchesDeploymentFilter, validateDeploymentListFilter, } from './store/records.js';
 import { InMemoryConfigStore, validateTenantRef, } from './store.js';
@@ -31,6 +32,7 @@ export class ServerRegistry {
     #platformCatalog;
     #platformConnectors;
     #nativeRecords;
+    #capabilities;
     #stateHandleStoreFactory;
     #delegatedCredentialStore;
     #sealCustomerCredential;
@@ -60,6 +62,7 @@ export class ServerRegistry {
         this.#platformCatalog = withBuiltinStateCatalog(options.platformCatalog ?? []);
         this.#platformConnectors = options.platformConnectors ?? [];
         this.#nativeRecords = options.nativeRecords;
+        this.#capabilities = options.capabilities;
         this.#stateHandleStoreFactory = options.stateHandleStoreFactory;
         this.#delegatedCredentialStore = options.delegatedCredentialStore;
         this.#sealCustomerCredential = options.sealCustomerCredential;
@@ -310,6 +313,7 @@ export class ServerRegistry {
             stateHandleStoreFactory: this.#stateHandleStoreFactory,
             platformConnectors: this.#platformConnectors,
             nativeRecords: this.#nativeRecords,
+            capabilities: this.#capabilities,
             policyGate: this.#policyGate,
             appPackageRenderer: this.#appPackageRenderer,
             knowledgeSearch: this.#knowledgeSearch,
@@ -318,26 +322,11 @@ export class ServerRegistry {
     #compilePersistedRecord(record) {
         return compilePersistedRegistryRecord(record, this.#compileTarget.bind(this));
     }
+    deleteDeployments(ref, selection) {
+        return deleteRegistryDeployments(this.#stateView(), ref, selection);
+    }
     async get(deploymentId) {
-        if (this.#records.get(deploymentId)?.archivedAt !== undefined)
-            return undefined;
-        const cached = this.#servers.get(deploymentId);
-        if (cached) {
-            const record = this.#store
-                ? await this.#store.get(deploymentId)
-                : this.#records.get(deploymentId);
-            return record === undefined || record.archivedAt !== undefined
-                ? undefined
-                : this.#targetForPersistedRecord(record);
-        }
-        const inflight = this.#inflight.get(deploymentId);
-        if (inflight)
-            return inflight;
-        const promise = this.#loadAndCompile(deploymentId).finally(() => {
-            this.#inflight.delete(deploymentId);
-        });
-        this.#inflight.set(deploymentId, promise);
-        return promise;
+        return readRegistryTarget(this.#stateView(), deploymentId, this.#inflight, (record) => this.#targetForPersistedRecord(record), (id) => this.#loadAndCompile(id));
     }
     /** Resolve a deployment-id data-plane route only while that exact record is actively serving. */
     async getServing(deploymentId) {
@@ -499,9 +488,7 @@ export class ServerRegistry {
         return this.#knowledgeSearch;
     }
     async #targetForPersistedRecord(record) {
-        return targetForPersistedRecord(record, {
-            records: this.#records,
-            servers: this.#servers,
+        return reconcileRegistryTarget(this.#stateView(), record, {
             ...(this.#customerVerifierFactory
                 ? { customerVerifierFactory: this.#customerVerifierFactory }
                 : {}),

package/node_modules/@noodle-borg/service/dist/routes/assistant-agent.js

@@ -3,6 +3,7 @@ import { assistantCoreModelMessages, assistantTurnModelContextMessages, requestA
 import { assistantGuideModelContext, assistantModelToolOncePerSession, assistantModelToolRequiredWhenVisible, assistantOmittedToolResult, assistantViewAvailableData, dispatchAssistantTool, projectAssistantGuide, publicSurfaceOf, recoverableAssistantView, remainingTurnTokens, selectAssistantModelTools, toolTouchesDelegatedAuth, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
 import { guardedFetch } from '@noodle-borg/connector-http';
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { evaluateToolAuthorization } from '@noodle-borg/protocol';
 import { interceptForElevation, offersSignIn } from './assistant-elevation.js';
 import { assistantKnowledgeModelTools, executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, KNOWLEDGE_CITATION_GUIDANCE, resolveAssistantKnowledge, } from './assistant-knowledge.js';
@@ -98,6 +99,7 @@ export async function runAgentTurn(target, session, message, context, deps, emit
     // Across every step of this turn, not per step: eight tool calls is eight, however the model splits
     // them, or a model that loops one call per step would spend the budget a step at a time.
     let toolCallsThisTurn = 0;
+    const capabilityBudget = new CapabilityBudget();
     let omittedToolRecoveries = 0;
     let remainingTokens = binding.requestPolicy?.maxTokensPerTurn;
     const turnSignal = binding.requestPolicy?.maxTurnMs === undefined
@@ -247,7 +249,7 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                 artifact: target.served.artifact,
                 tool,
                 arguments: args,
-                executeDeps: withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
+                executeDeps: withAssistantSessionExecutionAuthority({ ...target.served.deps, capabilityBudget }, target.served.artifact, session),
                 caller: session.caller,
                 context,
                 session,
@@ -273,7 +275,8 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                 arguments: args,
             }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }));
             if (view) {
-                await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
+                if (!dispatch.ephemeral)
+                    await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
                 emit({ event: 'view_available', data: { ...view } });
             }
             messages.push({

package/node_modules/@noodle-borg/service/dist/routes/assistant-interactions.js

@@ -1,5 +1,5 @@
 import { AssistantInteractionCapacityError, assistantConfirmationReview, assistantConfirmationTransition, assistantInputTransition, assistantInteractionTool, assistantPreparedArgumentReview, assistantPreparedToolContinuation, assistantSafeOutput, assistantToolContinuation, assistantViewAvailableData, auditAssistantInteraction, boundedAssistantExecution, recoverableAssistantView, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
-import { executePreparedTool, executeToolInteractive, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
+import { executePreparedTool, executeToolInteractive, hasEphemeralEvidence, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { applyBrowserCors, authenticateSession, now, } from './assistant.js';
 import { replayOrConflict, writeUnknownOutcome } from './assistant-interaction-replay.js';
@@ -347,7 +347,9 @@ async function finishExecution(res, deps, session, interaction, context, result,
     }
     const completedTool = target.served.artifact.tools.find((tool) => tool.name === toolName);
     const safeOutput = assistantSafeOutput(completedTool?.outputSchema, result.output);
-    const completed = await completeAssistantInteractionExecution(deps, session, interaction, 'succeeded', 'tool_completed', toolName, { result: safeOutput });
+    const ephemeral = hasEphemeralEvidence(result.output);
+    const retainedOutput = ephemeral ? { evidenceRetained: false } : safeOutput;
+    const completed = await completeAssistantInteractionExecution(deps, session, interaction, 'succeeded', 'tool_completed', toolName, { result: retainedOutput });
     if (!completed)
         return writeUnknownOutcome(res, deps, session, interaction, 'accept');
     await auditAssistantInteraction({
@@ -364,7 +366,7 @@ async function finishExecution(res, deps, session, interaction, context, result,
         // Model-facing scaffolding: the panel saw the tool_completed card, never this row's tool JSON.
         {
             role: 'assistant',
-            content: `Completed ${toolName}: ${JSON.stringify(safeOutput)}`,
+            content: `Completed ${toolName}: ${JSON.stringify(retainedOutput)}`,
             kind: 'narration',
         },
     ]);
@@ -377,7 +379,8 @@ async function finishExecution(res, deps, session, interaction, context, result,
         result: safeOutput,
     }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }));
     if (view) {
-        await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
+        if (!ephemeral)
+            await deps.store.replaceLatestView(session.id, recoverableAssistantView(view));
         writeViewAvailable(res, view);
     }
     await narrateResolvedInteraction(res, deps, target, session, toolName, 'accept', safeOutput, context, suggestions);

package/node_modules/@noodle-borg/service/dist/routes/deploy-dispatch.js

@@ -2,9 +2,23 @@ import { applySecurityHeaders, enforceHttps, } from '@noodle-borg/transport-http
 import { respondRouteError } from '../http-util.js';
 import { handleDeploy } from './control-plane.js';
 import { handleDeployPreflight } from './deploy-preflight.js';
+import { handleDeploymentDelete, parseVersionDeletePath } from './deployment-delete.js';
 import { handleDeploymentLockUpdate } from './deployment-lock.js';
-import { parseTenantDeploymentLockPath, parseTenantDeployPath, parseTenantDeployPreflightPath, } from './paths.js';
+import { parseDeploymentItemPath, parseTenantDeploymentLockPath, parseTenantDeployPath, parseTenantDeployPreflightPath, } from './paths.js';
 export function dispatchDeployRoutes(req, res, url, deps) {
+    if (req.method === 'DELETE') {
+        const item = parseDeploymentItemPath(url.pathname);
+        const deletion = item
+            ? { kind: 'deployment', ...item }
+            : parseVersionDeletePath(url.pathname);
+        if (deletion) {
+            applySecurityHeaders(res, deps.tls);
+            if (enforceHttps(req, res, deps.tls))
+                return true;
+            handleDeploymentDelete(req, res, deletion, { ...deps, maxBody: deps.maxBody.control }).catch((error) => respondRouteError(deps.logger, res, 'deployment-delete.error', error));
+            return true;
+        }
+    }
     const deploymentLock = parseTenantDeploymentLockPath(url.pathname);
     if (req.method === 'PATCH' && deploymentLock !== undefined) {
         applySecurityHeaders(res, deps.tls);

package/node_modules/@noodle-borg/service/dist/routes/deployment-delete.js

@@ -0,0 +1,53 @@
+import { deleteDeploymentOperation, } from '@noodle-borg/control-plane/portable';
+import { normalizeServerVersion } from '@noodle-borg/module';
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { deploymentDeleteResponseSchema, deploymentVersionDeleteRequestSchema, } from '@noodle-borg/wire-contracts';
+import { validateTenantRef } from '../store.js';
+import { authorizeControlPlane } from './control-plane.js';
+/** An exact numeric version, or the legacy unversioned scope; never semantic-version equivalence. */
+export function parseVersionDeletePath(pathname) {
+    const match = /^\/v1\/orgs\/([^/]+)\/apps\/([^/]+)\/envs\/([^/]+)\/versions\/([^/]+)$/.exec(pathname);
+    if (!match)
+        return undefined;
+    try {
+        const target = validateTenantRef({
+            org: decodeURIComponent(match[1]),
+            app: decodeURIComponent(match[2]),
+            env: decodeURIComponent(match[3]),
+        });
+        const version = decodeURIComponent(match[4]);
+        return {
+            kind: 'version',
+            org: target.org,
+            target,
+            ...(version === 'legacy' ? {} : { serverVersion: normalizeServerVersion(version) }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function handleDeploymentDelete(req, res, route, deps) {
+    const identity = await authorizeControlPlane(req, res, deps.gate, { requireIdentity: true });
+    if (identity === false)
+        return;
+    let expectedDeploymentIds;
+    if (route.kind === 'version') {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = deploymentVersionDeleteRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return sendJson(res, 400, { error: 'Invalid version deletion confirmation.' });
+        expectedDeploymentIds = parsed.data.expectedDeploymentIds;
+    }
+    const result = await deleteDeploymentOperation(deps, {
+        actor: identity,
+        scope: route,
+        ...(expectedDeploymentIds === undefined ? {} : { expectedDeploymentIds }),
+    });
+    return result.ok
+        ? sendJson(res, 200, deploymentDeleteResponseSchema.parse(result.view))
+        : sendJson(res, result.status, { code: result.code, error: result.error });
+}
+//# sourceMappingURL=deployment-delete.js.map

package/node_modules/@noodle-borg/service/dist/serve-local.js

@@ -3,6 +3,7 @@ import { InMemoryControlPlaneStore } from '@noodle-borg/control-plane/portable';
 import { InMemoryAssetStore } from './assets.js';
 import { createCustomerVerifierFactory, createHostedCustomerVerifierFactory, createLocalDevtoolsCustomerVerifierFactory, } from './customer-verifier.js';
 import { createLocalDevtoolsDelegatedCredentialSource } from './local-devtools-delegated-credentials.js';
+import { localWebCapabilities } from './local-web-capabilities.js';
 import { ServerRegistry } from './registry.js';
 import { isLoopbackHost } from './serve-resource-auth.js';
 import { createServiceHandler } from './service.js';
@@ -48,7 +49,9 @@ export async function serveLocalService(options = {}) {
     const delegatedCredentials = directCustomerAuth
         ? createLocalDevtoolsDelegatedCredentialSource()
         : undefined;
+    const capabilities = options.runtime?.capabilities ?? localWebCapabilities();
     const registry = new ServerRegistry(undefined, undefined, configStore, {
+        capabilities,
         customerVerifierFactory,
         ...(delegatedCredentials === undefined
             ? {}
@@ -62,6 +65,17 @@ export async function serveLocalService(options = {}) {
             : { localDevtoolsDelegatedExchange: options.localDevtoolsDelegatedExchange }),
     });
     const handler = createServiceHandler(registry, {
+        capabilities,
+        deployGate: {
+            authorize: () => ({
+                ok: true,
+                identity: {
+                    subject: 'local-operator',
+                    email: 'local-operator@localhost',
+                    superAdmin: true,
+                },
+            }),
+        },
         controlPlaneStore,
         configStore,
         assetStore: new InMemoryAssetStore(),

package/node_modules/@noodle-borg/service/dist/serve-resource-auth.js

@@ -1,10 +1,20 @@
 import { resolveMcpSubdomainTenant } from '@noodle-borg/control-plane/portable';
 import { normalizePublicBaseDomain, parseCanonicalPublicMcpUrl, parseLegacyTenantMcpPath, } from '@noodle-borg/module';
 import { resolveTenantBridgeAuthVariables } from './managed-config-expressions.js';
+import { createHostedMcpRequestStateManager } from './mcp-protocol-runtime.js';
 import { resolveConfigScope, } from './store.js';
 export function isLoopbackHost(host) {
     return host === '127.0.0.1' || host === '::1' || host === 'localhost';
 }
+export function resolveMcpRequestState(options, secretBox) {
+    return (options.mcpRequestState ??
+        createHostedMcpRequestStateManager({
+            ...(options.wrappingMasterKey === undefined && options.secretMasterKey !== undefined
+                ? { secretMasterKey: options.secretMasterKey }
+                : {}),
+            ...(secretBox === undefined ? {} : { secretBox }),
+        }));
+}
 export function assertLocalDevtoolsServiceBoundary(host, options) {
     if (options.localDevtoolsDirectFirebaseAuth === true && !isLoopbackHost(host)) {
         throw new Error('local Devtools Firebase verification requires a loopback service bind');

package/node_modules/@noodle-borg/service/dist/service.js

@@ -2,6 +2,7 @@ import { InMemoryDailyCounterStore } from '@noodle-borg/admission-limits/portabl
 import { InMemoryAssistantAppearanceSettingsStore, InMemoryAssistantStore, } from '@noodle-borg/assistant-gateway/portable';
 import { allowAllGate, InMemoryControlPlaneStore } from '@noodle-borg/control-plane/portable';
 import { dispatchKnowledgeRequest } from '@noodle-borg/knowledge-operations/portable';
+import { capabilityOperatorRoute } from '@noodle-borg/managed-capabilities';
 import { OPENAI_APPS_CHALLENGE_PATH } from '@noodle-borg/module';
 import { applySecurityHeaders, createMcpRouter, enforceHttps, noopLogger, sendJson, } from '@noodle-borg/transport-http';
 import { AnonymousConsumerLimiter, createAdmissionGate } from './admission.js';
@@ -163,7 +164,12 @@ export function createServiceHandler(registry, options = {}) {
     });
     archiveSweeper.maybeSweep();
     const moduleRouteDeps = {
-        routes: moduleHost.routes,
+        routes: [
+            ...moduleHost.routes,
+            ...(options.capabilities === undefined
+                ? []
+                : [capabilityOperatorRoute(options.capabilities)]),
+        ],
         logger,
         gate,
         controlPlane,

package/node_modules/@noodle-borg/service/dist/store/in-memory.d.ts

@@ -1,7 +1,8 @@
-import type { ActiveAccessUpdateInput, AppArchiveResult, AppRestorePrecondition, AppRestoreResult, AppSummary, ArtifactStore, DeploymentActivationPrecondition, DeploymentActivationResult, DeploymentListFilter, DeploymentLock, DeploymentLockUpdateResult, DeploymentPolicyPrecondition, DeploymentSummary, DeployRecord, EnvSummary, ProductionEnvironmentChange, TenantAuthConfig, TenantRef } from '../store.js';
+import type { ActiveAccessUpdateInput, AppArchiveResult, AppRestorePrecondition, AppRestoreResult, AppSummary, ArtifactStore, DeploymentActivationPrecondition, DeploymentActivationResult, DeploymentDeleteResult, DeploymentDeleteSelection, DeploymentListFilter, DeploymentLock, DeploymentLockUpdateResult, DeploymentPolicyPrecondition, DeploymentSummary, DeployRecord, EnvSummary, ProductionEnvironmentChange, TenantAuthConfig, TenantRef } from '../store.js';
 /** In-memory store: keeps records in a Map. Used by tests and as an explicit, non-persistent option. */
 export declare class InMemoryArtifactStore implements ArtifactStore {
     #private;
+    deleteDeployments(ref: TenantRef, selection: DeploymentDeleteSelection): Promise<DeploymentDeleteResult>;
     append(record: DeployRecord, precondition?: DeploymentPolicyPrecondition): Promise<void>;
     loadAll(): Promise<readonly DeployRecord[]>;
     get(deploymentId: string): Promise<DeployRecord | undefined>;

package/node_modules/@noodle-borg/service/dist/store/in-memory.js

@@ -2,6 +2,7 @@ import { normalizeServerVersion } from '@noodle-borg/module';
 import { assertSameAppPackageSnapshot, sanitizeDeployRecordAppPackageSnapshot, } from '../app-package-snapshot.js';
 import { assertCustomerAuthRestorePrecondition, assertUniqueActiveCustomerAuthAudienceBindings, findActiveCustomerAuthAudienceConflict, requiresCustomerAuthProjection, } from '../customer-auth-audience-binding.js';
 import { matchesDeploymentActivation } from '../deployment-activation-precondition.js';
+import { planDeploymentDeletion } from '../deployment-deletion.js';
 import { assertDeploymentActivationUnlocked, assertDeploymentAppendUnlocked, } from '../deployment-lock.js';
 import { assertDeploymentAppendPolicy, assertDeploymentAppendVersion, } from '../deployment-record-version.js';
 import { defaultActiveRecord, sameDeploymentScope, sameTenantRecord, } from '../deployment-versioning.js';
@@ -11,6 +12,13 @@ import { validateSlug, validateTenantRef } from './validate.js';
 export class InMemoryArtifactStore {
     #records = new Map();
     #productionEnvironments = new Map();
+    deleteDeployments(ref, selection) {
+        const result = planDeploymentDeletion([...this.#records.values()], ref, selection);
+        if (result.ok)
+            for (const record of result.deleted)
+                this.#records.delete(record.deploymentId);
+        return Promise.resolve(result);
+    }
     async append(record, precondition) {
         assertDeploymentAppendVersion([...this.#records.values()], record);
         assertDeploymentAppendPolicy([...this.#records.values()], record, precondition);