@noodleseed/one 0.162.0 → 0.163.0

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

@@ -6,14 +6,14 @@ import { DeploymentLockedError, deploymentLockedConflict, deploymentLockedPrefli
 import { defaultActiveRecord } from './deployment-versioning.js';
 import { updateRegistryAccess } from './registry-access.js';
 import { compileRegistryTarget } from './registry-compile.js';
-import { preflightRegistryDeploy, resolveDeployAttempt } from './registry-deploy-transaction.js';
+import { preflightRegistryDeploy, resolveDeployAttempt, withDeploymentConfiguration, } from './registry-deploy-transaction.js';
 import { deploymentOwnerSubject, missingCapabilityErrors, } from './registry-helpers.js';
 import { registryDeploymentPackage, renderDeploymentPackageSnapshot } from './registry-package.js';
 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 { emptySecretEnvelope, recordTenant, servedTargetFor, targetForPersistedRecord, tenantDeploymentKey, tenantKey, } from './registry-targets.js';
+import { deploymentSourceFor, emptySecretEnvelope, rebindNativeRecords, recordTenant, servedTargetFor, targetForPersistedRecord, 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';
@@ -23,12 +23,14 @@ export class ServerRegistry {
     #activeTenants = new Map();
     #productionEnvironments = new Map();
     #store;
+    #applicationLifecycleObserver;
     #configStore;
     #customerVerifierFactory;
     #policyGate;
     #transactionalModuleDeploymentActivation;
     #platformCatalog;
     #platformConnectors;
+    #nativeRecords;
     #stateHandleStoreFactory;
     #delegatedCredentialStore;
     #sealCustomerCredential;
@@ -57,6 +59,7 @@ export class ServerRegistry {
             options.transactionalModuleDeploymentActivation === true;
         this.#platformCatalog = withBuiltinStateCatalog(options.platformCatalog ?? []);
         this.#platformConnectors = options.platformConnectors ?? [];
+        this.#nativeRecords = options.nativeRecords;
         this.#stateHandleStoreFactory = options.stateHandleStoreFactory;
         this.#delegatedCredentialStore = options.delegatedCredentialStore;
         this.#sealCustomerCredential = options.sealCustomerCredential;
@@ -80,8 +83,22 @@ export class ServerRegistry {
         return this.#transactionalModuleDeploymentActivation;
     }
     setPlatformConnectors(input) {
-        this.#platformCatalog = withBuiltinStateCatalog(input.catalog);
-        this.#platformConnectors = input.connectors;
+        if (input.catalog !== undefined)
+            this.#platformCatalog = withBuiltinStateCatalog(input.catalog);
+        if (input.connectors !== undefined)
+            this.#platformConnectors = input.connectors;
+        this.#nativeRecords = input.nativeRecords;
+        if (input.catalog !== undefined || input.connectors !== undefined) {
+            this.#servers.clear();
+            return;
+        }
+        // Bind the new native-record port without resetting unrelated deployment-owned state or hooks.
+        for (const [id, target] of this.#servers) {
+            const record = this.#records.get(id);
+            if (!record)
+                continue;
+            this.#servers.set(id, rebindNativeRecords(target, record, input.nativeRecords));
+        }
     }
     setLocalAssetOptions(options) {
         this.#localAssetOptions = options;
@@ -91,103 +108,80 @@ export class ServerRegistry {
         return this.#localAssetsByPath.get(pathname);
     }
     async deploy(tenant, manifest, options = {}) {
-        const { connectors, actor, accessMode, hostedAssets, serverVersion, deploymentSource, idempotencyKey, } = options;
-        const { orgMembershipSources } = options;
-        const { automationId } = options;
-        const safeTenant = validateTenantRef(tenant);
-        const safeServerVersion = serverVersion !== undefined ? normalizeServerVersion(serverVersion) : undefined;
-        if (safeServerVersion !== undefined) {
-            const active = await activeRecordVersion(this.#stateView(), safeTenant, safeServerVersion);
-            if (active?.deploymentLock !== undefined)
-                return deploymentLockedConflict();
-        }
-        const preflight = await preflightRegistryDeploy({
-            options,
-            serviceCapabilities: this.#serviceCapabilities,
-            compile: () => this.#compileTarget(safeTenant, manifest, connectors, hostedAssets, false),
-        });
-        if (!preflight.ok)
-            return preflight;
-        const attempt = await resolveDeployAttempt({
-            serverName: preflight.serverName,
-            ...(idempotencyKey !== undefined ? { idempotencyKey } : {}),
-            ...(this.#store !== undefined ? { store: this.#store } : {}),
-            records: this.#records,
-            tenant: safeTenant,
-            manifest,
-            options,
-        });
-        if (attempt.replay !== undefined)
-            return attempt.replay;
-        const { deploymentId } = attempt;
-        let appPackageSnapshot = preflight.appPackageSnapshot;
-        if (preflight.appPackageArtifact !== undefined && appPackageSnapshot === undefined) {
-            const rendered = renderDeploymentPackageSnapshot(preflight.appPackageArtifact, this.#appPackageRenderer);
-            if (!rendered.ok)
-                return rendered;
-            appPackageSnapshot = rendered.snapshot;
-        }
-        const version = Date.now();
-        const built = preflight.bindDeployment(deploymentId);
-        const serverAuth = built.artifact.server.auth;
-        const ownerSubject = accessMode === 'owner-only' ? (options.ownerSubject ?? actor?.subject) : undefined;
-        const record = {
-            schemaVersion: 1,
-            deploymentId,
-            orgSlug: safeTenant.org,
-            appSlug: safeTenant.app,
-            environment: safeTenant.env,
-            ...(safeServerVersion !== undefined ? { serverVersion: safeServerVersion } : {}),
-            deploymentVersion: version,
-            active: automationId === undefined,
-            serverName: built.artifact.server.name,
-            createdAt: new Date().toISOString(),
-            ...(actor ? { createdBySubject: actor.subject, createdByEmail: actor.email } : {}),
-            ...(ownerSubject !== undefined ? { ownerSubject } : {}),
-            ...(deploymentSource !== undefined ? { deploymentSource } : {}),
-            ...(accessMode !== undefined ? { accessMode } : {}),
-            ...(orgMembershipSources !== undefined ? { orgMembershipSources } : {}),
-            ...(serverAuth !== undefined ? { serverAuth } : {}),
-            manifest,
-            ...(connectors !== undefined ? { connectors } : {}),
-            ...(hostedAssets !== undefined && hostedAssets.length > 0 ? { hostedAssets } : {}),
-            ...(appPackageSnapshot !== undefined ? { appPackageSnapshot } : {}),
-            secrets: emptySecretEnvelope(),
-        };
-        if (await this.#hasCustomerAuthAudienceConflict(record, serverAuth)) {
-            return customerAuthAudienceConflictFailure();
-        }
-        let active;
-        try {
-            active = await withKnowledgePublication(this.#knowledgeHooks, safeTenant, deploymentId, built.artifact.server.knowledge, () => persistDeployRecord(this.#stateView(), record, safeTenant, automationId === undefined));
-        }
-        catch (error) {
-            if (error instanceof KnowledgePublicationError) {
-                return { ok: false, errors: error.errors };
+        return withDeploymentConfiguration(this.#configStore, tenant.org, async () => {
+            const { connectors, actor, accessMode, hostedAssets, serverVersion, deploymentSource, idempotencyKey, } = options;
+            const { orgMembershipSources } = options;
+            const { automationId } = options;
+            const safeTenant = validateTenantRef(tenant);
+            const safeServerVersion = serverVersion !== undefined ? normalizeServerVersion(serverVersion) : undefined;
+            if (safeServerVersion !== undefined) {
+                const active = await activeRecordVersion(this.#stateView(), safeTenant, safeServerVersion);
+                if (active?.deploymentLock !== undefined)
+                    return deploymentLockedConflict();
+            }
+            const preflight = await preflightRegistryDeploy({
+                options,
+                serviceCapabilities: this.#serviceCapabilities,
+                compile: () => this.#compileTarget(safeTenant, manifest, connectors, hostedAssets, false),
+            });
+            if (!preflight.ok)
+                return preflight;
+            const attempt = await resolveDeployAttempt({
+                serverName: preflight.serverName,
+                ...(idempotencyKey !== undefined ? { idempotencyKey } : {}),
+                ...(this.#store !== undefined ? { store: this.#store } : {}),
+                records: this.#records,
+                tenant: safeTenant,
+                manifest,
+                options,
+            });
+            if (attempt.replay !== undefined)
+                return attempt.replay;
+            const { deploymentId } = attempt;
+            let appPackageSnapshot = preflight.appPackageSnapshot;
+            if (preflight.appPackageArtifact !== undefined && appPackageSnapshot === undefined) {
+                const rendered = renderDeploymentPackageSnapshot(preflight.appPackageArtifact, this.#appPackageRenderer);
+                if (!rendered.ok)
+                    return rendered;
+                appPackageSnapshot = rendered.snapshot;
             }
-            if (error instanceof CustomerAuthAudienceConflictError) {
+            const version = Date.now();
+            const built = preflight.bindDeployment(deploymentId);
+            const serverAuth = built.artifact.server.auth;
+            const ownerSubject = accessMode === 'owner-only' ? (options.ownerSubject ?? actor?.subject) : undefined;
+            const record = {
+                schemaVersion: 1,
+                deploymentId,
+                orgSlug: safeTenant.org,
+                appSlug: safeTenant.app,
+                environment: safeTenant.env,
+                ...(safeServerVersion !== undefined ? { serverVersion: safeServerVersion } : {}),
+                deploymentVersion: version,
+                active: automationId === undefined,
+                serverName: built.artifact.server.name,
+                createdAt: new Date().toISOString(),
+                ...(actor ? { createdBySubject: actor.subject, createdByEmail: actor.email } : {}),
+                ...(ownerSubject !== undefined ? { ownerSubject } : {}),
+                ...(deploymentSource !== undefined ? { deploymentSource } : {}),
+                ...(accessMode !== undefined ? { accessMode } : {}),
+                ...(orgMembershipSources !== undefined ? { orgMembershipSources } : {}),
+                ...(serverAuth !== undefined ? { serverAuth } : {}),
+                manifest,
+                ...(connectors !== undefined ? { connectors } : {}),
+                ...(hostedAssets !== undefined && hostedAssets.length > 0 ? { hostedAssets } : {}),
+                ...(appPackageSnapshot !== undefined ? { appPackageSnapshot } : {}),
+                secrets: emptySecretEnvelope(),
+            };
+            if (await this.#hasCustomerAuthAudienceConflict(record, serverAuth)) {
                 return customerAuthAudienceConflictFailure();
             }
-            if (error instanceof DeploymentLockedError)
-                return deploymentLockedConflict();
-            throw error;
-        }
-        if (automationId !== undefined) {
-            let activation;
+            let active;
             try {
-                activation = await this.#store?.activateDeployment(safeTenant, deploymentId, undefined, {
-                    automationId,
-                });
+                active = await withKnowledgePublication(this.#knowledgeHooks, safeTenant, deploymentId, built.artifact.server.knowledge, () => persistDeployRecord(this.#stateView(), record, safeTenant, automationId === undefined));
             }
             catch (error) {
-                if (error instanceof DeploymentActivationError && error.code === 'automation_superseded') {
-                    return {
-                        ok: false,
-                        superseded: true,
-                        deploymentId,
-                        deploymentVersion: version,
-                        ...(safeServerVersion !== undefined ? { serverVersion: safeServerVersion } : {}),
-                    };
+                if (error instanceof KnowledgePublicationError) {
+                    return { ok: false, errors: error.errors };
                 }
                 if (error instanceof CustomerAuthAudienceConflictError) {
                     return customerAuthAudienceConflictFailure();
@@ -196,40 +190,66 @@ export class ServerRegistry {
                     return deploymentLockedConflict();
                 throw error;
             }
-            if (activation === undefined) {
-                return {
-                    ok: false,
-                    errors: [
-                        {
-                            code: 'run_activation_failed',
-                            path: 'deploymentId',
-                            message: 'deployment could not be activated for this automation run',
-                        },
-                    ],
-                };
+            if (automationId !== undefined) {
+                let activation;
+                try {
+                    activation = await this.#store?.activateDeployment(safeTenant, deploymentId, undefined, {
+                        automationId,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof DeploymentActivationError &&
+                        error.code === 'automation_superseded') {
+                        return {
+                            ok: false,
+                            superseded: true,
+                            deploymentId,
+                            deploymentVersion: version,
+                            ...(safeServerVersion !== undefined ? { serverVersion: safeServerVersion } : {}),
+                        };
+                    }
+                    if (error instanceof CustomerAuthAudienceConflictError) {
+                        return customerAuthAudienceConflictFailure();
+                    }
+                    if (error instanceof DeploymentLockedError)
+                        return deploymentLockedConflict();
+                    throw error;
+                }
+                if (activation === undefined) {
+                    return {
+                        ok: false,
+                        errors: [
+                            {
+                                code: 'run_activation_failed',
+                                path: 'deploymentId',
+                                message: 'deployment could not be activated for this automation run',
+                            },
+                        ],
+                    };
+                }
+                active = activation.active;
+                this.#records.set(active.deploymentId, active);
+                const previous = activation.previousActive;
+                if (previous !== undefined && previous.deploymentId !== active.deploymentId) {
+                    this.#records.set(previous.deploymentId, { ...previous, active: false });
+                }
             }
-            active = activation.active;
-            this.#records.set(active.deploymentId, active);
-            const previous = activation.previousActive;
-            if (previous !== undefined && previous.deploymentId !== active.deploymentId) {
-                this.#records.set(previous.deploymentId, { ...previous, active: false });
+            if (await this.#hasCustomerAuthAudienceConflict(active, serverAuth)) {
+                return customerAuthAudienceConflictFailure();
             }
-        }
-        if (await this.#hasCustomerAuthAudienceConflict(active, serverAuth)) {
-            return customerAuthAudienceConflictFailure();
-        }
-        this.#servers.set(deploymentId, servedTargetFor(active, built, this.#customerVerifierFactory));
-        this.#activeTenants.set(tenantDeploymentKey(safeTenant, safeServerVersion), deploymentId);
-        this.#activeTenants.delete(tenantKey(safeTenant));
-        const activeOwnerSubject = deploymentOwnerSubject(active);
-        return {
-            ok: true,
-            deploymentId,
-            deploymentVersion: version,
-            ...(safeServerVersion !== undefined ? { serverVersion: safeServerVersion } : {}),
-            ...(accessMode !== undefined ? { accessMode } : {}),
-            ...(activeOwnerSubject !== undefined ? { ownerSubject: activeOwnerSubject } : {}),
-        };
+            this.#servers.set(deploymentId, servedTargetFor(active, built, this.#customerVerifierFactory));
+            this.#activeTenants.set(tenantDeploymentKey(safeTenant, safeServerVersion), deploymentId);
+            this.#activeTenants.delete(tenantKey(safeTenant));
+            const activeOwnerSubject = deploymentOwnerSubject(active);
+            return {
+                ok: true,
+                deploymentId,
+                deploymentVersion: version,
+                ...(safeServerVersion !== undefined ? { serverVersion: safeServerVersion } : {}),
+                ...(accessMode !== undefined ? { accessMode } : {}),
+                ...(activeOwnerSubject !== undefined ? { ownerSubject: activeOwnerSubject } : {}),
+            };
+        });
     }
     /** Read-only deploy validation used by the CLI before config writes, asset upload, or persistence. */
     async preflightDeploy(tenant, manifest, options = {}) {
@@ -264,6 +284,7 @@ export class ServerRegistry {
     }
     async #compileTarget(tenant, manifest, connectors, hostedAssets, renderAppPackage = false, deploymentId) {
         return compileRegistryTarget({
+            activeArtifact: async () => (await this.getActiveByTenant(tenant))?.served.artifact,
             configStore: this.#configStore,
             platformCatalog: this.#platformCatalog,
             localAssetOptions: this.#localAssetOptions,
@@ -277,6 +298,7 @@ export class ServerRegistry {
             googleWorkloadIdentity: this.#googleWorkloadIdentity,
             stateHandleStoreFactory: this.#stateHandleStoreFactory,
             platformConnectors: this.#platformConnectors,
+            nativeRecords: this.#nativeRecords,
             policyGate: this.#policyGate,
             appPackageRenderer: this.#appPackageRenderer,
             knowledgeSearch: this.#knowledgeSearch,
@@ -293,12 +315,10 @@ export class ServerRegistry {
         const cached = this.#servers.get(deploymentId);
         if (cached)
             return cached;
-        if (!this.#store)
-            return undefined;
         const inflight = this.#inflight.get(deploymentId);
         if (inflight)
             return inflight;
-        const promise = this.#loadAndCompile(this.#store, deploymentId).finally(() => {
+        const promise = this.#loadAndCompile(deploymentId).finally(() => {
             this.#inflight.delete(deploymentId);
         });
         this.#inflight.set(deploymentId, promise);
@@ -362,18 +382,29 @@ export class ServerRegistry {
     getAppArchivedAt(org, app) {
         return registryAppArchivedAt(this.#stateView(), org, app);
     }
-    archiveApp(org, app, at) {
-        return registryArchiveApp(this.#stateView(), org, app, at);
+    setApplicationLifecycleObserver(observer) {
+        this.#applicationLifecycleObserver = observer;
+    }
+    async archiveApp(org, app, at) {
+        const result = await registryArchiveApp(this.#stateView(), org, app, at);
+        if (result)
+            await this.#applicationLifecycleObserver?.(org, app, result.archivedAt);
+        return result;
     }
     restoreApp(org, app) {
         return registryRestoreApp(this.#stateView(), org, app, (record) => this.#compilePersistedRecord(record));
     }
     sweepArchived(before) {
-        return registrySweepArchived(this.#stateView(), before);
+        return registrySweepArchived(this.#stateView(), before, this.#applicationLifecycleObserver);
     }
     listApps(org, opts = {}) {
         return registryListApps(this.#stateView(), org, opts);
     }
+    async getAppGeneration(org, app) {
+        return this.#store
+            ? this.#store.getAppGeneration(org, app)
+            : (await this.getApp(org, app))?.createdAt;
+    }
     getApp(org, app) {
         return registryGetApp(this.#stateView(), org, app);
     }
@@ -386,6 +417,10 @@ export class ServerRegistry {
     setProductionEnvironment(org, app, env) {
         return registrySetProductionEnvironment(this.#stateView(), org, app, env);
     }
+    /** Immutable executable bytes for a same-tenant installation; never includes configuration or credentials. */
+    getDeploymentSource(tenant, deploymentId) {
+        return deploymentSourceFor(this.#stateView(), tenant, deploymentId);
+    }
     getDeployment(org, deploymentId) {
         return registryGetDeployment(this.#stateView(), org, deploymentId);
     }
@@ -428,6 +463,8 @@ export class ServerRegistry {
     async rollback(ref, deploymentId) {
         const safe = validateTenantRef(ref);
         return rollbackWithMappedErrors({
+            configStore: this.#configStore,
+            org: safe.org,
             run: () => rollbackDeployment(this.#stateView(), safe, deploymentId, (record) => this.#compilePersistedRecord(record), this.#serviceCapabilities, this.#customerVerifierFactory, (record, auth) => this.#hasCustomerAuthAudienceConflict(record, auth)),
             pairKnowledge: async () => this.#knowledgeHooks?.rollback(deploymentId),
             isAudienceConflict: (error) => error instanceof CustomerAuthAudienceConflictError,
@@ -447,7 +484,6 @@ export class ServerRegistry {
         return this.#knowledgeSearch;
     }
     async #targetForPersistedRecord(record) {
-        const store = this.#store;
         return targetForPersistedRecord(record, {
             records: this.#records,
             servers: this.#servers,
@@ -455,11 +491,15 @@ export class ServerRegistry {
                 ? { customerVerifierFactory: this.#customerVerifierFactory }
                 : {}),
             hasCustomerAuthConflict: (candidate, auth) => this.#hasCustomerAuthAudienceConflict(candidate, auth),
-            ...(store ? { load: () => this.#loadAndCompile(store, record) } : {}),
+            load: () => this.#loadAndCompile(record),
         });
     }
-    async #loadAndCompile(store, source) {
-        const record = typeof source === 'string' ? await store.get(source) : source;
+    async #loadAndCompile(source) {
+        const record = typeof source === 'string'
+            ? this.#store
+                ? await this.#store.get(source)
+                : this.#records.get(source)
+            : source;
         if (!record)
             return undefined;
         const deploymentId = record.deploymentId;

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

@@ -2,6 +2,7 @@ import { assistantAppearanceOverrideSchema, assistantBrowserConfiguration, resol
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { sendForbidden } from '../http-util.js';
 import { now } from './assistant-route-http.js';
+import { activeAssistantTarget } from './assistant-session-target.js';
 import { authorizeControlPlane } from './control-plane.js';
 export async function handleAssistantAppearance(req, res, tenant, deps) {
     const store = deps.appearance;
@@ -52,7 +53,7 @@ export async function handleAssistantAppearance(req, res, tenant, deps) {
             currentRevision: updated.currentRevision,
         });
     }
-    const target = await deps.registry.getActiveByTenant(tenant);
+    const target = await activeAssistantTarget({ registry: deps.registry }, tenant);
     await deps.audit.emit({
         eventType: updated.record.override === undefined
             ? 'assistant.appearance.reset'
@@ -73,7 +74,7 @@ export async function handleAssistantAppearance(req, res, tenant, deps) {
     return respond(res, tenant, deps, updated.record, target);
 }
 async function respond(res, tenant, deps, knownRecord, knownTarget) {
-    const target = knownTarget ?? (await deps.registry.getActiveByTenant(tenant));
+    const target = knownTarget ?? (await activeAssistantTarget({ registry: deps.registry }, tenant));
     const developer = target && assistantBrowserConfiguration(target.served.artifact.server);
     const record = knownRecord ?? (await deps.appearance?.get(tenant));
     const resolution = resolveAssistantAppearanceConfiguration(developer, record?.override);

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

@@ -1,6 +1,7 @@
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { sendForbidden } from '../http-util.js';
 import { now } from './assistant-route-http.js';
+import { activeAssistantTarget } from './assistant-session-target.js';
 import { authorizeControlPlane } from './control-plane.js';
 export async function handleAssistantClients(req, res, tenant, id, action, deps) {
     const identity = await authorizeControlPlane(req, res, deps.gate, { requireIdentity: false });
@@ -29,7 +30,7 @@ export async function handleAssistantClients(req, res, tenant, id, action, deps)
         if (typeof name !== 'string' || name.trim().length < 1 || name.length > 80) {
             return sendJson(res, 400, { error: '"name" must be a non-empty string' });
         }
-        const target = await deps.registry.getActiveByTenant(tenant);
+        const target = await activeAssistantTarget({ registry: deps.registry }, tenant);
         const assistant = target?.served.artifact.server.assistant;
         if (!target?.deploymentId || !assistant)
             return sendJson(res, 409, { error: 'deployment has no embedded assistant' });

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

@@ -7,6 +7,7 @@ import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { sendForbidden } from '../http-util.js';
 import { resolveAssistantModelBinding } from './assistant-model-binding.js';
 import { now } from './assistant-route-http.js';
+import { activeAssistantTarget } from './assistant-session-target.js';
 import { authorizeControlPlane } from './control-plane.js';
 /**
  * The doctor half of the assistant boundary, kept out of `assistant.ts` for the same reason the
@@ -43,7 +44,7 @@ export async function handleAssistantDoctor(req, res, tenant, deps) {
             (typeof userId !== 'string' || userId.length < 1 || userId.length > 240))) {
         return sendJson(res, 400, { error: 'clientId, clientSecret, and origin are required' });
     }
-    const target = await deps.registry.getActiveByTenant(tenant);
+    const target = await activeAssistantTarget({ registry: deps.registry }, tenant);
     const assistant = target?.served.artifact.server.assistant;
     const deploymentOk = Boolean(target?.deploymentId && assistant);
     const client = await deps.store.authenticateClient(clientId, clientSecret);

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

@@ -3,6 +3,7 @@ import { assistantEmbedOperatorView, parsePublicEmbedBudget, publicSurfaceOf, su
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { sendForbidden } from '../http-util.js';
 import { now } from './assistant-route-http.js';
+import { activeAssistantTarget } from './assistant-session-target.js';
 import { authorizeControlPlane } from './control-plane.js';
 /**
  * The operator's view of a tenant's public surfaces, and the one control over them.
@@ -45,6 +46,9 @@ export async function handleAssistantEmbeds(req, res, tenant, embedId, deps) {
         const budget = parsePublicEmbedBudget(body.value);
         if (!budget.ok)
             return sendJson(res, 400, { error: budget.error });
+        const owned = (await embeds.list(tenant)).some((record) => record.embedId === embedId && record.revokedAt === undefined);
+        if (!owned)
+            return sendJson(res, 404, { error: 'embed not found' });
         const updated = await embeds.setBudget(embedId, budget.value, now(deps));
         // 404 here rather than the mint route's 403: this caller has already proven org membership, so
         // telling them an id of theirs does not exist is information they are entitled to.
@@ -59,13 +63,14 @@ export async function handleAssistantEmbeds(req, res, tenant, embedId, deps) {
     return sendJson(res, 405, { error: 'method not allowed' });
 }
 async function view(record, tenant, defaults, deps, counters) {
-    const target = await deps.registry.getActiveByTenant(tenant);
+    const target = await activeAssistantTarget({ registry: deps.registry }, tenant);
     const at = now(deps);
     // The same bounds admission resolves, not the bare defaults: a sponsored surface enforces the
     // hosted envelope, and reporting the unsponsored one told an operator a number nothing honours.
     const deploymentId = target?.deploymentId ?? '';
-    const bounds = (await deps.managedModelResolver?.resolve({ tenant, deploymentId }))
-        ?.publicAdmission;
+    const bounds = target?.served.artifact.server.assistant?.model?.kind === 'noodle-managed'
+        ? (await deps.managedModelResolver?.resolve({ tenant, deploymentId }))?.publicAdmission
+        : undefined;
     return assistantEmbedOperatorView({
         record,
         surface: publicSurfaceOf(target?.served.artifact.server.assistant),

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

@@ -62,7 +62,7 @@ export async function replayOrConflict(res, deps, session, interaction, action)
         const tool = assistantInteractionTool(current) ?? 'unknown_tool';
         const result = current.publicOutcome.result ?? current.publicOutcome;
         writeToolCompleted(res, current.id, tool, result, true);
-        const deployment = await sessionScopedTarget(deps.registry, session);
+        const deployment = await sessionScopedTarget(deps.registry, session, deps.resolveRuntimeTarget);
         const view = deployment
             ? assistantViewAvailableData(deployment.served.artifact, {
                 id: current.id,