@noodleseed/one 0.161.2 → 0.163.0

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

@@ -1,4 +1,4 @@
-import { AssistantInteractionCapacityError, assistantConfirmationReview, assistantConfirmationTransition, assistantInputTransition, assistantInteractionTool, assistantPreparedArgumentReview, assistantPreparedToolContinuation, assistantSafeOutput, assistantToolContinuation, assistantViewAvailableData, auditAssistantInteraction, recoverableAssistantView, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+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 { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { applyBrowserCors, authenticateSession, now, } from './assistant.js';
@@ -49,7 +49,7 @@ async function handleResolution(req, res, deps, legacyAcceptOnly) {
         return sendJson(res, 409, { error: 'interaction is invalid or expired' });
     }
     if (response.value.action !== 'accept') {
-        return resolveStop(res, deps, session, interaction, response.value.action, suggestions);
+        return resolveStop(req, res, deps, session, interaction, response.value.action, suggestions);
     }
     if (interaction.kind === 'confirmation' && response.value.content !== undefined) {
         return sendJson(res, 400, { error: 'confirmation content cannot replace reviewed arguments' });
@@ -76,13 +76,13 @@ async function handleResolution(req, res, deps, legacyAcceptOnly) {
         }
         acceptedContent = validated.value;
     }
-    return resolveAccept(res, deps, session, interaction, acceptedContent, suggestions);
+    return resolveAccept(req, res, deps, session, interaction, acceptedContent, suggestions);
 }
-async function resolveAccept(res, deps, session, interaction, content, suggestions) {
+async function resolveAccept(req, res, deps, session, interaction, content, suggestions) {
     if (interaction.status !== 'pending') {
         return replayOrConflict(res, deps, session, interaction, 'accept');
     }
-    const target = await sessionScopedTarget(deps.registry, session);
+    const target = await sessionScopedTarget(deps.registry, session, deps.resolveRuntimeTarget, req);
     if (!target) {
         await auditAssistantInteraction({
             audit: deps.audit,
@@ -126,38 +126,50 @@ async function resolveAccept(res, deps, session, interaction, content, suggestio
         action: 'accept',
         status: 'accepted',
     });
-    const executeDeps = {
-        ...withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
-        caller: session.caller,
-        context,
-    };
-    let result;
-    if (claimed.interaction.kind === 'confirmation') {
-        const prepared = assistantPreparedToolContinuation(claimed.interaction);
-        const tool = target.served.artifact.tools.find((candidate) => candidate.name === claimed.interaction.tool);
-        if (!prepared &&
-            tool?.fulfilment.kind === 'flow' &&
-            tool.fulfilment.steps.some((step) => step.kind === 'elicit')) {
-            result = {
-                status: 'failed',
-                error: {
-                    code: 'invalid_continuation',
-                    message: 'legacy confirmation did not capture elicited input',
-                },
-            };
+    const result = await boundedAssistantExecution(async (signal) => {
+        const executeDeps = {
+            ...withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
+            caller: session.caller,
+            context,
+            invocationId: claimed.interaction.id,
+            signal,
+        };
+        let result;
+        if (claimed.interaction.kind === 'confirmation') {
+            const prepared = assistantPreparedToolContinuation(claimed.interaction);
+            const tool = target.served.artifact.tools.find((candidate) => candidate.name === claimed.interaction.tool);
+            if (!prepared &&
+                tool?.fulfilment.kind === 'flow' &&
+                tool.fulfilment.steps.some((step) => step.kind === 'elicit')) {
+                result = {
+                    status: 'failed',
+                    error: {
+                        code: 'invalid_continuation',
+                        message: 'legacy confirmation did not capture elicited input',
+                    },
+                };
+            }
+            else {
+                result = prepared
+                    ? await executePreparedTool(target.served.artifact, prepared, executeDeps)
+                    : await executeToolInteractive(target.served.artifact, claimed.interaction.tool, claimed.interaction.arguments, executeDeps);
+            }
         }
         else {
-            result = prepared
-                ? await executePreparedTool(target.served.artifact, prepared, executeDeps)
-                : await executeToolInteractive(target.served.artifact, claimed.interaction.tool, claimed.interaction.arguments, executeDeps);
+            const continuation = assistantToolContinuation(claimed.interaction);
+            result = isToolPreparationContinuation(continuation)
+                ? await resumeToolPreparation(target.served.artifact, continuation, { action: 'accept', content }, executeDeps)
+                : await resumeTool(target.served.artifact, continuation, { action: 'accept', content }, executeDeps);
         }
-    }
-    else {
-        const continuation = assistantToolContinuation(claimed.interaction);
-        result = isToolPreparationContinuation(continuation)
-            ? await resumeToolPreparation(target.served.artifact, continuation, { action: 'accept', content }, executeDeps)
-            : await resumeTool(target.served.artifact, continuation, { action: 'accept', content }, executeDeps);
-    }
+        return result;
+    }, () => ({
+        status: 'failed',
+        error: {
+            code: 'connector_error',
+            reason: 'operation_outcome_unknown',
+            message: 'Execution stopped. Verify the original outcome before requesting another write.',
+        },
+    }));
     return finishExecution(res, deps, session, claimed.interaction, context, result, target, suggestions);
 }
 async function finishExecution(res, deps, session, interaction, context, result, target, suggestions) {
@@ -371,11 +383,11 @@ async function finishExecution(res, deps, session, interaction, context, result,
     await narrateResolvedInteraction(res, deps, target, session, toolName, 'accept', safeOutput, context, suggestions);
     return endInteractionSse(res);
 }
-async function resolveStop(res, deps, session, interaction, action, suggestions) {
+async function resolveStop(req, res, deps, session, interaction, action, suggestions) {
     if (interaction.status !== 'pending') {
         return replayOrConflict(res, deps, session, interaction, action);
     }
-    const target = await sessionScopedTarget(deps.registry, session);
+    const target = await sessionScopedTarget(deps.registry, session, deps.resolveRuntimeTarget, req);
     const context = target
         ? await resolveAssistantInteractionContext(interaction, session, target, deps)
         : undefined;

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

@@ -1,6 +1,7 @@
 import { authorizePublicConfiguration, effectiveAssistantBrowserConfiguration, publicEmbedTenant, publicSurfaceOf, } from '@noodle-borg/assistant-gateway/portable';
 import { sendJson } from '@noodle-borg/transport-http';
 import { applyBrowserCors } from './assistant-route-http.js';
+import { activeAssistantTarget } from './assistant-session-target.js';
 /** Browser-safe first paint for a public launcher; never mints a session or spends admission. */
 export async function handlePublicAssistantConfiguration(req, res, embedId, deps) {
     if (req.method !== 'GET')
@@ -13,7 +14,7 @@ export async function handlePublicAssistantConfiguration(req, res, embedId, deps
     const authorized = await authorizePublicConfiguration({ embedId, origin }, {
         embeds: deps.publicEmbeds,
         resolveActiveSurface: async (embed) => {
-            state.target = await deps.registry.getActiveByTenant(publicEmbedTenant(embed));
+            state.target = await activeAssistantTarget(deps, publicEmbedTenant(embed));
             return state.target
                 ? publicSurfaceOf(state.target.served.artifact.server.assistant)
                 : undefined;
@@ -29,7 +30,7 @@ export async function handlePublicAssistantConfiguration(req, res, embedId, deps
     if (target === undefined) {
         return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
     }
-    const resolved = await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(authorized.embed), deps.appearance, 'public');
+    const resolved = await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(authorized.embed), deps.appearance, 'public', target.businessNotice);
     applyBrowserCors(req, res, origin);
     res.setHeader('cache-control', 'private, no-cache');
     return sendJson(res, 200, {

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

@@ -5,6 +5,7 @@ import { assistantSessionUsageRequestEvent, captureAssistantUsage, captureRefuse
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { assistantSessionResponseSchema } from '@noodle-borg/wire-contracts';
 import { applyBrowserCors, assistantSessionEndpoints, now } from './assistant-route-http.js';
+import { activeAssistantTarget } from './assistant-session-target.js';
 /**
  * The transport half of anonymous session minting. Every decision — which refusal, in which order, and
  * whether the surface may serve at all — lives in `@noodle-borg/assistant-gateway`; this file parses a
@@ -28,11 +29,9 @@ export async function handlePublicAssistantSession(req, res, deps) {
     const { embedId, visitorId } = body.value;
     // The browser's Origin header is the claim under test. The body never asserts its own origin.
     const origin = typeof req.headers.origin === 'string' ? req.headers.origin : undefined;
-    // Admission tier 3. Hashed here so no raw address crosses into the decision, a counter key, or an
-    // audit payload; the socket address is Google's front end on Cloud Run, so the forwarded chain is the
-    // only place the visitor appears. Unparseable ingress yields no bucket and the surface tier alone
-    // applies — losing fairness, never solvency.
-    const addressBucket = clientAddressBucket(typeof req.headers['x-forwarded-for'] === 'string' ? req.headers['x-forwarded-for'] : undefined);
+    // Without deployment-verified ingress attribution only the immediate peer is authoritative.
+    // A shared proxy bucket can reduce fairness, but forged forwarding headers cannot rotate it.
+    const addressBucket = clientAddressBucket(req.socket.remoteAddress);
     let configuration;
     let sponsoredBudget;
     let usageSession;
@@ -40,7 +39,7 @@ export async function handlePublicAssistantSession(req, res, deps) {
         embeds,
         counters,
         resolveActiveSurface: async (embed) => {
-            const target = await deps.registry.getActiveByTenant(publicEmbedTenant(embed));
+            const target = await activeAssistantTarget(deps, publicEmbedTenant(embed));
             if (!target?.deploymentId)
                 return undefined;
             if (target.served.artifact.server.assistant?.model.kind === 'noodle-managed') {
@@ -55,11 +54,12 @@ export async function handlePublicAssistantSession(req, res, deps) {
         },
         resolveBudgetBounds: async () => sponsoredBudget,
         createSession: async (input) => {
-            const target = await deps.registry.getActiveByTenant(publicEmbedTenant(input.embed));
-            if (!target?.deploymentId)
-                throw new Error('assistant deployment vanished mid-mint');
+            const target = await activeAssistantTarget(deps, publicEmbedTenant(input.embed));
+            if (!target?.deploymentId ||
+                !publicSurfaceOf(target.served.artifact.server.assistant)?.origins.includes(input.origin))
+                throw new Error('assistant surface changed mid-mint');
             const current = now(deps);
-            configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(input.embed), deps.appearance, 'public')).effective;
+            configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(input.embed), deps.appearance, 'public', target.businessNotice)).effective;
             const created = await deps.store.createSession({
                 // A public surface has no client credential, so the embed id stands in as the minting
                 // authority. It is not a secret and nothing downstream may begin treating it as one.

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

@@ -1,6 +1,35 @@
-import { resolveAssistantSessionTarget, } from '@noodle-borg/assistant-gateway/portable';
+import { assistantConfigurationHasBusinessNotice, resolveAssistantSessionTarget, } from '@noodle-borg/assistant-gateway/portable';
+import { resolveTargetOrigins } from '../application-runtime-target.js';
 /** Adapt the registry to the gateway-owned, surface-projected session target decision. */
-export function sessionScopedTarget(registry, session) {
-    return resolveAssistantSessionTarget((deploymentId) => registry.get(deploymentId), session);
+export async function sessionScopedTarget(registry, session, resolve = resolveTargetOrigins, req) {
+    const target = await resolveAssistantSessionTarget(async (deploymentId) => {
+        const target = await registry.get(deploymentId);
+        return target && resolve(target);
+    }, session);
+    if (target === undefined)
+        return undefined;
+    if (target.businessNotice &&
+        !assistantConfigurationHasBusinessNotice(session.configuration, target.businessNotice))
+        return undefined;
+    const publicAdmission = trustedPublicAdmission({
+        scope: `${session.tenant.org}/${session.tenant.app}/${session.tenant.env}`,
+        sourceAddress: req?.socket?.remoteAddress,
+        subject: session.caller.subject,
+    });
+    return {
+        ...target,
+        served: {
+            ...target.served,
+            deps: {
+                ...target.served.deps,
+                ...(publicAdmission === undefined ? {} : { publicAdmission }),
+            },
+        },
+    };
 }
+export async function activeAssistantTarget(deps, tenant) {
+    const target = await deps.registry.getActiveByTenant(tenant);
+    return target && (deps.resolveRuntimeTarget ?? resolveTargetOrigins)(target);
+}
+import { trustedPublicAdmission } from '@noodle-borg/admission-limits/portable';
 //# sourceMappingURL=assistant-session-target.js.map

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

@@ -36,7 +36,7 @@ export async function handleAssistantSuggestions(req, res, deps) {
     }
     if (claim.disposition !== 'generate')
         return writeEmptySuggestions(res, session.origin);
-    const target = await sessionScopedTarget(deps.registry, session);
+    const target = await sessionScopedTarget(deps.registry, session, deps.resolveRuntimeTarget, req);
     if (!target) {
         await deps.store.failInitialSuggestions(session.id);
         return writeEmptySuggestions(res, session.origin);

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

@@ -18,7 +18,7 @@ export async function handleAssistantTranscript(req, res, deps) {
     if (!session)
         return;
     applyBrowserCors(req, res, session.origin);
-    const target = await sessionScopedTarget(deps.registry, session);
+    const target = await sessionScopedTarget(deps.registry, session, deps.resolveRuntimeTarget, req);
     const latestView = target && session.latestView
         ? assistantViewAvailableData(target.served.artifact, { ...session.latestView, replayed: true }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }))
         : undefined;

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

@@ -13,7 +13,7 @@ import { createAssistantTurnStats, runAgentTurn } from './assistant-agent.js';
 import { elevateAssistantSession } from './assistant-elevation.js';
 import { executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, resolveAssistantKnowledge, } from './assistant-knowledge.js';
 import { applyBrowserCors, assistantSessionEndpoints, authenticateSession, handleAssistantPreflight, now, } from './assistant-route-http.js';
-import { sessionScopedTarget } from './assistant-session-target.js';
+import { activeAssistantTarget, sessionScopedTarget } from './assistant-session-target.js';
 import { authorizeControlPlane } from './control-plane.js';
 export { applyBrowserCors, authenticateSession, handleAssistantPreflight, now };
 const SESSION_ABSOLUTE_MS = 2 * 60 * 60 * 1000;
@@ -62,7 +62,7 @@ export async function handleAssistantSession(req, res, deps) {
     // Clients are tenant-bound: sessions follow the tenant's ACTIVE deployment, and the origin
     // allowlist is read from the live artifact, so `noodle deploy` alone updates a live embed.
     // client.deploymentId/allowedOrigins remain as created-against audit data.
-    const target = await deps.registry.getActiveByTenant(client.tenant);
+    const target = await activeAssistantTarget(deps, client.tenant);
     const assistant = target?.served.artifact.server.assistant;
     if (!target?.deploymentId || !assistant)
         return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
@@ -98,7 +98,7 @@ export async function handleAssistantSession(req, res, deps) {
     const declaredClaims = assistant.sessionClaims ?? {};
     const claims = Object.fromEntries(Object.entries(isAssistantVerifiedClaims(parsed.claims) ? parsed.claims : {}).filter(([key]) => key in declaredClaims));
     const current = now(deps);
-    const configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, client.tenant, deps.appearance, surfaceBinding.kind === 'pre-surfaces' ? undefined : surfaceBinding.kind)).effective;
+    const configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, client.tenant, deps.appearance, surfaceBinding.kind === 'pre-surfaces' ? undefined : surfaceBinding.kind, target.businessNotice)).effective;
     const roles = canonicalizeAuthorizationClaimValues(parsed.user.roles, 'role');
     const scopes = canonicalizeAuthorizationClaimValues(parsed.user.scopes, 'scope');
     // Hoisted so an elevation and a fresh exchange bind the *same* principal. Two constructions would be
@@ -195,7 +195,10 @@ export async function handleAssistantTurn(req, res, deps) {
         return sendJson(res, body.status, { error: body.error });
     // Admission tier 3, hashed here for the same reason the mint hashes it: no raw address may reach the
     // decision, a counter key, or an audit payload.
-    const addressBucket = clientAddressBucket(typeof req.headers['x-forwarded-for'] === 'string' ? req.headers['x-forwarded-for'] : undefined);
+    const target = await sessionScopedTarget(deps.registry, session, deps.resolveRuntimeTarget, req);
+    if (!target)
+        return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
+    const addressBucket = clientAddressBucket(req.socket.remoteAddress);
     let turn;
     let message;
     let resumedTool;
@@ -256,8 +259,8 @@ export async function handleAssistantTurn(req, res, deps) {
         if (message.trim().length === 0) {
             return sendJson(res, 400, { error: '"message" must be a non-empty string' });
         }
-        // Admission before any metered work (ADR 0201 §8): ahead of the deployment read and well ahead
-        // of the model, so a refused turn costs the customer nothing.
+        // Resolve live authority first: a paused application or removed origin spends no turn allowance.
+        // Admission still precedes every model request and business operation.
         const refusal = await refusePublicTurn(deps, session, message, addressBucket);
         if (refusal)
             return refuseTurn(deps, res, session, refusal, usageStartedAt);
@@ -265,9 +268,6 @@ export async function handleAssistantTurn(req, res, deps) {
         if (session.pendingResume)
             await deps.store.consumePendingResume(session.id);
     }
-    const target = await sessionScopedTarget(deps.registry, session);
-    if (!target)
-        return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
     if (resumedTool !== undefined &&
         !target.served.artifact.tools.some((tool) => tool.name === resumedTool)) {
         // The elevation landed on a surface whose projection does not offer the intercepted tool: fail
@@ -378,7 +378,7 @@ export async function handleAssistantAppRequest(req, res, deps) {
         !isRecord(body.value.params)) {
         return sendJson(res, 400, { error: 'invalid MCP App request' });
     }
-    const target = await sessionScopedTarget(deps.registry, session);
+    const target = await sessionScopedTarget(deps.registry, session, deps.resolveRuntimeTarget, req);
     if (!target)
         return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
     const method = body.value.method;

package/node_modules/@noodle-borg/service/dist/routes/business-information-activity.js

@@ -0,0 +1,83 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ApplicationActivityListResponseSchema, ApplicationActivityPreviewResponseSchema, ApplicationActivitySettingsResponseSchema, ApplicationActivitySettingsSaveRequestSchema, } from '@noodle-borg/wire-contracts';
+import { ActivityPolicyError } from '../application-activity.js';
+import { businessGrantAllows } from '../business-information/model.js';
+import { requireIdentity, requireInstallationPermission, } from './business-information.js';
+import { parseBusinessPaging } from './business-information-request.js';
+export async function handleApplicationActivity(req, res, url, ref, deps) {
+    const settings = url.pathname.endsWith('/activity/settings');
+    const exporting = url.pathname.endsWith('/activity/export');
+    const preview = url.pathname.endsWith('/activity/preview');
+    if (req.method !== 'GET' && !(settings && req.method === 'PATCH')) {
+        res.setHeader('allow', settings ? 'GET, PATCH' : 'GET');
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const permission = req.method === 'PATCH'
+        ? 'installation:administer'
+        : exporting
+            ? 'records:export'
+            : 'records:read';
+    const authorized = await requireInstallationPermission(res, ref, identity, permission, deps);
+    if (!authorized)
+        return;
+    const reply = async (body) => {
+        if (await requireInstallationPermission(res, ref, identity, permission, deps))
+            sendJson(res, 200, body);
+    };
+    res.setHeader('cache-control', 'private, no-store');
+    try {
+        const allowedQuery = settings || preview ? [] : ['limit', 'cursor'];
+        for (const key of url.searchParams.keys())
+            if (!allowedQuery.includes(key) || url.searchParams.getAll(key).length !== 1)
+                throw new ActivityPolicyError('activity_invalid');
+        if (!deps.activity)
+            throw new ActivityPolicyError('activity_unavailable');
+        const canEdit = businessGrantAllows(authorized.grant, 'installation:administer');
+        if (settings && req.method === 'PATCH') {
+            const body = await readJsonBody(req, deps.maxBody);
+            if (!body.ok)
+                return sendJson(res, body.status, { error: body.error });
+            const parsed = ApplicationActivitySettingsSaveRequestSchema.safeParse(body.value);
+            if (!parsed.success)
+                throw new ActivityPolicyError('activity_invalid');
+            const data = await deps.activity.save(authorized.scope, parsed.data);
+            await deps.audit?.emit({
+                eventType: 'config.activity.retention_changed',
+                org: ref.org,
+                app: authorized.scope.app,
+                env: authorized.scope.env,
+                actorSubject: identity.subject,
+                details: { retentionDays: data.retentionDays },
+            });
+            return reply(ApplicationActivitySettingsResponseSchema.parse({ ok: true, data }));
+        }
+        if (preview)
+            return reply(ApplicationActivityPreviewResponseSchema.parse({
+                ok: true,
+                data: await deps.activity.preview(authorized.scope),
+            }));
+        if (settings)
+            return reply(ApplicationActivitySettingsResponseSchema.parse({
+                ok: true,
+                data: (await deps.activity.settings(authorized.scope, canEdit)).projection,
+            }));
+        const paging = parseBusinessPaging(url, 100);
+        if (!paging.ok)
+            return sendJson(res, 400, { error: paging.error });
+        const data = await deps.activity.page(authorized.scope, {
+            purpose: exporting ? 'export' : 'list',
+            limit: paging.value.limit ?? 50,
+            ...(paging.value.cursor === undefined ? {} : { cursor: paging.value.cursor }),
+        });
+        return reply(ApplicationActivityListResponseSchema.parse({ ok: true, data }));
+    }
+    catch (error) {
+        if (!(error instanceof ActivityPolicyError))
+            throw error;
+        sendJson(res, error.code === 'activity_unavailable' ? 503 : error.code === 'activity_conflict' ? 409 : 400, { code: error.code, error: error.message });
+    }
+}
+//# sourceMappingURL=business-information-activity.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-admission.js

@@ -0,0 +1,26 @@
+import { admitPublicRecord, clientAddressBucket, PUBLIC_ADMISSION_ASSERTION_HEADER, verifyPublicAdmissionAssertion, } from '@noodle-borg/admission-limits/portable';
+/** Atomically apply every unavoidable public-intake ceiling to one new logical record. */
+export async function consumePublicIntakeQuota(req, publicId, attempt, deps, binding) {
+    const timestamp = deps.now?.() ?? new Date();
+    // TLS proxy trust does not authenticate browser attribution. Until the Portal/service hop has its
+    // own verified assertion, use only the immediate peer and keep the installation ceiling as the
+    // unavoidable abuse bound. This deliberately collapses a Portal BFF to one fairness bucket instead
+    // of letting callers forge X-Forwarded-For into unlimited buckets.
+    const assertion = req.headers[PUBLIC_ADMISSION_ASSERTION_HEADER];
+    const attributed = typeof assertion === 'string' && binding && deps.publicAdmissionKeys
+        ? verifyPublicAdmissionAssertion(assertion, binding, deps.publicAdmissionKeys, timestamp)
+        : undefined;
+    if (assertion !== undefined && attributed === undefined)
+        return { allowed: false, reason: 'invalid_attribution' };
+    const peer = clientAddressBucket(req.socket.remoteAddress);
+    const buckets = attributed ?? (peer ? { network: peer } : {});
+    return admitPublicRecord({
+        counters: deps.publicCounters,
+        surfaceId: publicId,
+        attempt,
+        buckets,
+        now: timestamp,
+        ...(deps.publicAdmissionLimits ? { limits: deps.publicAdmissionLimits } : {}),
+    });
+}
+//# sourceMappingURL=business-information-admission.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-channels.js

@@ -0,0 +1,153 @@
+import { ADMISSION_DEFAULTS, clamp } from '@noodle-borg/admission-limits/portable';
+import { assistantEmbedOperatorView, publicSurfaceOf, surfaceEnvelope, } from '@noodle-borg/assistant-gateway/portable';
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ApplicationChannelsResponseSchema, ApplicationChannelsSaveRequestSchema, } from '@noodle-borg/wire-contracts';
+import { resolveTargetOrigins } from '../application-runtime-target.js';
+import { businessGrantAllows, } from '../business-information/portable.js';
+import { mutationFailure, requireIdentity, requireInstallationPermission, } from './business-information.js';
+import { tenantMcpUrl } from './endpoint-enrichment.js';
+/** Business grants project the existing MCP/assistant channel authority without developer permissions. */
+export async function handleBusinessChannels(req, res, ref, deps) {
+    if (req.method !== 'GET' && req.method !== 'PATCH') {
+        res.setHeader('Allow', 'GET, PATCH');
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const authorized = await requireInstallationPermission(res, ref, identity, req.method === 'PATCH' ? 'installation:administer' : 'records:read', deps);
+    if (!authorized)
+        return;
+    let installation = authorized.installation;
+    const setupReady = !deps.businessOnboarding || (await deps.businessOnboarding.ready(installation));
+    if (req.method === 'GET' && !setupReady)
+        return sendJson(res, 409, {
+            code: 'business_setup_required',
+            error: 'Complete the organization agreement and business notice before publishing agent channels.',
+        });
+    if (req.method === 'PATCH') {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = ApplicationChannelsSaveRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return sendJson(res, 400, { code: 'channels_invalid', error: 'invalid channel settings' });
+        if (parsed.data.active && !setupReady)
+            return sendJson(res, 409, {
+                code: 'business_setup_required',
+                error: 'Complete business setup before publishing agent channels.',
+            });
+        const result = await deps.store.setIntakeState({
+            scope: authorized.scope,
+            expectedRevision: parsed.data.expectedRevision,
+            active: parsed.data.active,
+            actorSubject: identity.subject,
+        });
+        if (!result.ok)
+            return mutationFailure(res, result);
+        installation = result.installation;
+    }
+    const projection = await projectBusinessChannels(installation, businessGrantAllows(authorized.grant, 'installation:administer'), deps.resolveEndpointBase(req), deps);
+    res.setHeader('cache-control', 'private, no-store');
+    sendJson(res, 200, ApplicationChannelsResponseSchema.parse({ ok: true, data: projection }));
+}
+export async function projectBusinessChannels(installation, canEdit, base, deps) {
+    const tenant = {
+        org: installation.scope.org,
+        app: installation.scope.app,
+        env: installation.scope.env,
+    };
+    const registered = await deps.registry.getActiveByTenant(tenant);
+    const target = registered && (await resolveTargetOrigins(registered));
+    const shared = { revision: installation.revision, active: installation.intakeActive, canEdit };
+    if (!target?.deploymentId)
+        return {
+            ...shared,
+            mcp: { status: 'unavailable' },
+            assistant: {
+                status: 'unavailable',
+                reason: 'The application has no active deployment.',
+                origins: [],
+                capabilities: [],
+            },
+        };
+    const endpointOptions = await deps.resolveEndpointUrlOptions?.(tenant.org);
+    const mcp = {
+        status: installation.intakeActive ? 'ready' : 'paused',
+        url: tenantMcpUrl(base, tenant, undefined, endpointOptions),
+        accessMode: target.accessMode,
+    };
+    const surface = publicSurfaceOf(target.served.artifact.server.assistant);
+    const emptyAssistant = {
+        status: 'unavailable',
+        origins: [...(surface?.origins ?? [])],
+        capabilities: surface?.capabilities.map((entry) => entry.name) ?? [],
+    };
+    const records = await deps.publicEmbeds?.list(tenant);
+    const record = records?.find((entry) => entry.revokedAt === undefined &&
+        entry.org === tenant.org &&
+        entry.app === tenant.app &&
+        entry.env === tenant.env);
+    const counters = deps.admissionCounters;
+    if (!surface || !record || !counters) {
+        return {
+            ...shared,
+            deploymentId: target.deploymentId,
+            mcp,
+            assistant: {
+                ...emptyAssistant,
+                reason: 'The public assistant is not configured for this deployment.',
+            },
+        };
+    }
+    const at = deps.now?.() ?? new Date();
+    const managed = target.served.artifact.server.assistant?.model?.kind === 'noodle-managed';
+    const binding = managed
+        ? await deps.managedModelResolver?.resolve({
+            tenant,
+            deploymentId: target.deploymentId,
+        })
+        : undefined;
+    const bounds = binding?.publicAdmission;
+    const modelUnavailable = managed && binding === undefined;
+    const view = await assistantEmbedOperatorView({
+        record,
+        surface,
+        envelope: surfaceEnvelope(clamp(deps.admissionEnvelope ?? ADMISSION_DEFAULTS), record, bounds),
+        peek: (key) => counters.peek(key, at),
+        ...(bounds?.spend ? { spend: bounds.spend } : {}),
+    });
+    const ready = surface.origins.length > 0 && surface.capabilities.length > 0 && !modelUnavailable;
+    return {
+        ...shared,
+        deploymentId: target.deploymentId,
+        mcp,
+        assistant: {
+            status: !ready
+                ? 'unavailable'
+                : !installation.intakeActive || view.turnsPerDay === 0 || view.mintsPerDay === 0
+                    ? 'paused'
+                    : 'ready',
+            ...(!ready
+                ? {
+                    reason: modelUnavailable
+                        ? 'Managed assistant availability is not configured for this application.'
+                        : 'The application needs an allowed website origin and declared assistant capabilities.',
+                }
+                : {}),
+            embedId: record.embedId,
+            serviceUrl: base.replace(/\/+$/, ''),
+            scriptUrl: `${base.replace(/\/+$/, '')}/v1/assistant/embed.js`,
+            origins: [...view.origins],
+            capabilities: [...view.capabilities],
+            usage: {
+                turnsPerDay: view.turnsPerDay,
+                turnsToday: view.turnsToday,
+                mintsPerDay: view.mintsPerDay,
+                mintsToday: view.mintsToday,
+                ...(view.managedSpend ? { managedSpend: view.managedSpend } : {}),
+            },
+        },
+    };
+}
+//# sourceMappingURL=business-information-channels.js.map