@noodleseed/one 0.163.0 → 0.165.0

package/node_modules/@noodle-borg/runtime/dist/operation-execution.js

@@ -3,8 +3,10 @@ import { sanitizeConnectorFailureDetails } from './connector/failure-details.js'
 import { isConnectorInvocationError } from './connector/types.js';
 import { preflightOperationCustomerRoutes, resolveCustomerActionRouteBindings, resolveCustomerConnectorRoute, } from './customer-routing.js';
 import { ExpressionEvalError } from './eval/evaluate.js';
+import { nestedOperationHost } from './nested-operation-host.js';
+import { admitCoordinatedAction, beginOperationCoordination, coordinatedParentId, } from './operation-coordination-execution.js';
 import { acquireOperationCredential } from './operation-credential.js';
-import { withOperationEvidence } from './operation-evidence.js';
+import { safeOperationEvidence, withOperationEvidence } from './operation-evidence.js';
 import { checkSignature, evalExprMap, validateAgainstSchema } from './operation-validation.js';
 import { samePreparedAction } from './prepared-action-match.js';
 import { splitResultMeta } from './result-meta.js';
@@ -116,6 +118,8 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
     const initialCancellation = executionCancellation(deps.signal, beforeDispatch);
     if (initialCancellation)
         return { ok: false, error: initialCancellation };
+    if (sig.type === 'action' && !admitCoordinatedAction(host))
+        return fail('policy_denied', 'This coordinated invocation cannot dispatch another external action.');
     const callKey = operationKey(ref);
     if (hostCallStack(host).includes(callKey)) {
         return fail('circular_call_dependency', `circular connector operation call detected at ${callKey}`, outputPath);
@@ -155,6 +159,9 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
         const acquired = await acquireOperationCredential(ref, deps, customerRoute);
         if (!acquired.ok)
             return { ok: false, error: acquired.error };
+        const afterCredential = executionCancellation(deps.signal, beforeDispatch);
+        if (afterCredential)
+            return { ok: false, error: afterCredential };
         const { credential } = acquired;
         let connectorArgs;
         try {
@@ -169,6 +176,8 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
         const admitted = admittedExecutionSignal(deps.signal);
         disposeSignal = admitted.dispose;
         const execution = operationIdentity(host, deps, toolName, ref, argsPath);
+        const parentId = coordinatedParentId(host);
+        const coordinationConnection = connector.coordination?.(ref.operation)?.connectionId;
         const executionBoundMs = connector.executionBoundMs?.(ref.operation);
         const deadline = executionBoundMs === undefined ? undefined : AbortSignal.timeout(executionBoundMs);
         const signal = deadline === undefined
@@ -178,6 +187,8 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
                 : AbortSignal.any([deadline, admitted.signal]);
         return await withOperationEvidence(sig.type === 'action' ? deps.operationEvidence : undefined, {
             id: execution.id,
+            ...(parentId === undefined ? {} : { parentId }),
+            ...(coordinationConnection === undefined ? {} : { connectionId: coordinationConnection }),
             tool: toolName,
             operation: ref,
             arguments: connectorArgs,
@@ -187,108 +198,158 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
                 : { executionRevision: deps.executionBinding.revision }),
             ...(executionBoundMs === undefined ? {} : { executionBoundMs }),
         }, async (reportOutcome) => {
-            let output;
-            try {
-                if (signal?.aborted)
-                    return fail('execution_cancelled', 'Execution deadline elapsed before connector dispatch.');
-                output = await connector.invoke({
-                    operation: ref.operation,
-                    execution,
-                    reportOutcome,
-                    ...(deps.publicAdmission === undefined
-                        ? {}
-                        : { publicAdmission: deps.publicAdmission }),
-                    args: connectorArgs,
-                    env,
-                    ...(signal === undefined ? {} : { signal }),
-                    credential,
-                    acquireTransportCredential: async () => {
-                        const { credentialBinding: _accountBinding, ...transportRef } = ref;
-                        const transport = await acquireOperationCredential(transportRef, deps, customerRoute);
-                        if (!transport.ok)
-                            throw new Error('Independent transport credential unavailable');
-                        return transport.credential;
-                    },
-                    ...(ref.credentialBinding === undefined
-                        ? {}
-                        : { credentialPresentation: ref.credentialBinding.presentation }),
-                    ...(deps.caller !== undefined ? { caller: deps.caller } : {}),
-                    ...(customerRoute === undefined ? {} : { route: customerRoute }),
-                    host,
-                    ...(deps.trace === undefined ? {} : { trace: deps.trace }),
-                });
-            }
-            catch (error) {
-                const hostCall = hostCallErrorSnapshot(error);
-                if (hostCall !== undefined) {
-                    return fail(hostCall.code, hostCall.message, hostCall.path);
-                }
-                if (isConnectorInvocationError(error)) {
-                    const failureDetails = sanitizeConnectorFailureDetails(error, {
-                        includeResponseExcerpt: customerRoute === undefined,
+            const declaration = connector.coordination?.(ref.operation);
+            let coordinated;
+            let outcome;
+            if (declaration) {
+                try {
+                    coordinated = await beginOperationCoordination({
+                        declaration,
+                        executionId: execution.id,
+                        executionBoundMs,
+                        args: connectorArgs,
+                        env,
+                        deps,
+                        host,
                     });
-                    deps.trace?.record({
-                        kind: 'connector',
-                        connectorId: ref.connectorId,
-                        connectorVersion: ref.connectorVersion,
+                }
+                catch {
+                    reportOutcome({ outcome: 'rejected' });
+                    return fail('execution_admission_error', 'External operation coordination unavailable; no action dispatched.');
+                }
+            }
+            try {
+                let output;
+                try {
+                    if (signal?.aborted)
+                        return fail('execution_cancelled', 'Execution deadline elapsed before connector dispatch.');
+                    output = await connector.invoke({
                         operation: ref.operation,
-                        ...failureDetails,
+                        execution,
+                        reportOutcome: (value) => {
+                            outcome = safeOperationEvidence(value);
+                            reportOutcome(outcome);
+                        },
+                        ...(coordinated === undefined
+                            ? {}
+                            : {
+                                coordination: {
+                                    acquired: coordinated.lease.acquired,
+                                    ...(coordinated.lease.previous
+                                        ? { previous: coordinated.lease.previous }
+                                        : {}),
+                                },
+                                resolveCoordination: () => {
+                                    if (signal?.aborted)
+                                        return Promise.reject(new Error('Coordination recovery expired'));
+                                    return coordinated.lease.resolvePrevious();
+                                },
+                            }),
+                        ...(deps.publicAdmission === undefined
+                            ? {}
+                            : { publicAdmission: deps.publicAdmission }),
+                        args: connectorArgs,
+                        env,
+                        ...(signal === undefined ? {} : { signal }),
+                        credential,
+                        acquireTransportCredential: async () => {
+                            const { credentialBinding: _accountBinding, ...transportRef } = ref;
+                            const transport = await acquireOperationCredential(transportRef, deps, customerRoute);
+                            if (!transport.ok)
+                                throw new Error('Independent transport credential unavailable');
+                            return transport.credential;
+                        },
+                        ...(ref.credentialBinding === undefined
+                            ? {}
+                            : { credentialPresentation: ref.credentialBinding.presentation }),
+                        ...(deps.caller !== undefined ? { caller: deps.caller } : {}),
+                        ...(customerRoute === undefined ? {} : { route: customerRoute }),
+                        host: nestedOperationHost(ref, host, signal),
+                        ...(deps.trace === undefined ? {} : { trace: deps.trace }),
                     });
-                    // Attribution keeps the sanitized classification (never the excerpt) so analytics can name
-                    // the failing connector/operation/stage while the wire result stays generic (#1309).
-                    const status = statusClass(failureDetails.status);
-                    const reason = failureDetails.status === 401 || failureDetails.status === 403
-                        ? 'upstream_authentication_lost'
-                        : failureDetails.category;
+                }
+                catch (error) {
+                    const hostCall = hostCallErrorSnapshot(error);
+                    if (hostCall !== undefined) {
+                        return fail(hostCall.code, hostCall.message, hostCall.path);
+                    }
+                    if (isConnectorInvocationError(error)) {
+                        const failureDetails = sanitizeConnectorFailureDetails(error, {
+                            includeResponseExcerpt: customerRoute === undefined,
+                        });
+                        deps.trace?.record({
+                            kind: 'connector',
+                            connectorId: ref.connectorId,
+                            connectorVersion: ref.connectorVersion,
+                            operation: ref.operation,
+                            ...failureDetails,
+                        });
+                        // Attribution keeps the sanitized classification (never the excerpt) so analytics can name
+                        // the failing connector/operation/stage while the wire result stays generic (#1309).
+                        const status = statusClass(failureDetails.status);
+                        const reason = failureDetails.status === 401 || failureDetails.status === 403
+                            ? 'upstream_authentication_lost'
+                            : failureDetails.category;
+                        return fail('connector_error', `connector failed for operation "${ref.operation}"`, {
+                            ...(reason === undefined ? {} : { reason }),
+                            connector: {
+                                connectorId: ref.connectorId,
+                                connectorVersion: ref.connectorVersion,
+                                operation: ref.operation,
+                                ...(failureDetails.category === undefined
+                                    ? {}
+                                    : { category: failureDetails.category }),
+                                ...(status === undefined ? {} : { statusClass: status }),
+                                ...(failureDetails.attempts === undefined
+                                    ? {}
+                                    : { attempts: failureDetails.attempts }),
+                                ...(failureDetails.retryable === undefined
+                                    ? {}
+                                    : { retryable: failureDetails.retryable }),
+                            },
+                        });
+                    }
+                    // Normalize connector failures; never surface backend internals or credentials.
                     return fail('connector_error', `connector failed for operation "${ref.operation}"`, {
-                        ...(reason === undefined ? {} : { reason }),
                         connector: {
                             connectorId: ref.connectorId,
                             connectorVersion: ref.connectorVersion,
                             operation: ref.operation,
-                            ...(failureDetails.category === undefined
-                                ? {}
-                                : { category: failureDetails.category }),
-                            ...(status === undefined ? {} : { statusClass: status }),
-                            ...(failureDetails.attempts === undefined
-                                ? {}
-                                : { attempts: failureDetails.attempts }),
-                            ...(failureDetails.retryable === undefined
-                                ? {}
-                                : { retryable: failureDetails.retryable }),
                         },
                     });
                 }
-                // Normalize connector failures; never surface backend internals or credentials.
-                return fail('connector_error', `connector failed for operation "${ref.operation}"`, {
-                    connector: {
-                        connectorId: ref.connectorId,
-                        connectorVersion: ref.connectorVersion,
-                        operation: ref.operation,
-                    },
-                });
-            }
-            if (customerRoute !== undefined) {
-                const cloned = cloneRoutedOutput(output, customerRoute.baseUrl);
-                if (!cloned.ok) {
-                    return fail('connector_error', `connector failed for operation "${ref.operation}"`);
+                if (customerRoute !== undefined) {
+                    const cloned = cloneRoutedOutput(output, customerRoute.baseUrl);
+                    if (!cloned.ok) {
+                        return fail('connector_error', `connector failed for operation "${ref.operation}"`);
+                    }
+                    output = cloned.value;
                 }
-                output = cloned.value;
-            }
-            let redacted;
-            try {
-                redacted = await policy.after(context, output);
+                let redacted;
+                try {
+                    redacted = await policy.after(context, output);
+                }
+                catch {
+                    return fail('policy_error', 'policy after hook failed');
+                }
+                // Projection metadata is a reserved runtime envelope, not part of the connector's visible output
+                // contract. Validate the visible value deeply while preserving policy-processed metadata for the
+                // flow/result projection channel.
+                const outputError = validateAgainstSchema(splitResultMeta(redacted).visible, sig.output, outputPath, 'output_invalid', 'output field');
+                if (outputError)
+                    return { ok: false, error: outputError };
+                return { ok: true, output: redacted };
             }
-            catch {
-                return fail('policy_error', 'policy after hook failed');
+            finally {
+                try {
+                    await coordinated?.lease.finish(coordinated.didAdmitAction()
+                        ? (outcome ?? { outcome: 'unknown' })
+                        : { outcome: 'rejected' });
+                }
+                finally {
+                    coordinated?.dispose();
+                }
             }
-            // Projection metadata is a reserved runtime envelope, not part of the connector's visible output
-            // contract. Validate the visible value deeply while preserving policy-processed metadata for the
-            // flow/result projection channel.
-            const outputError = validateAgainstSchema(splitResultMeta(redacted).visible, sig.output, outputPath, 'output_invalid', 'output field');
-            if (outputError)
-                return { ok: false, error: outputError };
-            return { ok: true, output: redacted };
         });
     }
     finally {
@@ -301,7 +362,7 @@ export function createHost(toolName, deps, policy, env, callStack, beforeDispatc
     const host = {
         [CALL_STACK]: callStack,
         [INVOCATION]: { id: deps.invocationId ?? randomUUID(), occurrences: new Map() },
-        async callOperation(ref, args, path) {
+        async callOperation(ref, args, path, parentSignal) {
             const connector = deps.connectors.resolve(ref);
             if (!connector)
                 throw new HostCallError('connector_unavailable', 'connector unavailable');
@@ -313,11 +374,29 @@ export function createHost(toolName, deps, policy, env, callStack, beforeDispatc
             const argError = validateAgainstSchema(args, sig.input, `${path}.args`, 'arg_invalid', 'argument');
             if (argError)
                 throw new HostCallError(argError.code, argError.message, argError.path);
-            const result = await invokeOperation(ref, args, sig, toolName, deps, policy, this, env, `${path}.args`, `${path}.output`, beforeDispatch);
-            if (!result.ok) {
-                throw new HostCallError(result.error.code, result.error.message, result.error.path);
+            const cancellation = executionCancellation(deps.signal, beforeDispatch);
+            if (cancellation)
+                throw new HostCallError(cancellation.code, cancellation.message);
+            // A disconnected admitted request must not mask a later hard parent deadline in AbortSignal.any.
+            const inherited = parentSignal === undefined ? undefined : admittedExecutionSignal(deps.signal);
+            try {
+                const nestedDeps = parentSignal === undefined
+                    ? deps
+                    : {
+                        ...deps,
+                        signal: inherited?.signal === undefined
+                            ? parentSignal
+                            : AbortSignal.any([inherited.signal, parentSignal]),
+                    };
+                const result = await invokeOperation(ref, args, sig, toolName, nestedDeps, policy, this, env, `${path}.args`, `${path}.output`, beforeDispatch);
+                if (!result.ok) {
+                    throw new HostCallError(result.error.code, result.error.message, result.error.path);
+                }
+                return result.output;
+            }
+            finally {
+                inherited?.dispose();
             }
-            return result.output;
         },
     };
     return host;

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

@@ -1,15 +1,21 @@
 import { createHmac } from 'node:crypto';
 import { canonicalJson, sha256Canonical } from '@noodle-borg/compiler';
+import { ApplicationActivityListResponseSchema, ApplicationActivityPreviewResponseSchema, ApplicationActivitySettingsResponseSchema, ApplicationActivitySettingsSaveRequestSchema, OperationCoordinationListRequestSchema, OperationCoordinationListResponseSchema, OperationCoordinationResolveRequestSchema, OperationCoordinationResolveResponseSchema, } from '@noodle-borg/wire-contracts';
 import { resolveApplicationRuntimeTarget } from './application-runtime-target.js';
+import { createOperationCoordinationPort, } from './operation-coordination.js';
 import { createOperationEvidencePort, } from './operation-evidence.js';
+const POLICY_MESSAGES = {
+    activity_conflict: 'History settings or plan changed. Reload before continuing.',
+    activity_invalid: 'Activity paging or retention is invalid for the current policy.',
+    activity_unavailable: 'Verified activity history policy is unavailable.',
+    coordination_invalid: 'Invalid coordination request.',
+    coordination_conflict: 'The operation is active, changed, or unavailable. Inspect the current state before reviewing it again.',
+    coordination_unavailable: 'Verified coordination state is unavailable.',
+};
 export class ActivityPolicyError extends Error {
     code;
     constructor(code) {
-        super(code === 'activity_conflict'
-            ? 'History settings or plan changed. Reload before continuing.'
-            : code === 'activity_invalid'
-                ? 'Activity paging or retention is invalid for the current policy.'
-                : 'Verified activity history policy is unavailable.');
+        super(POLICY_MESSAGES[code]);
         this.code = code;
     }
 }
@@ -19,6 +25,124 @@ export class ApplicationActivity {
     constructor(options) {
         this.options = options;
     }
+    /** Shared strict operator projection. Callers authorize the live installation grant before and after it. */
+    async project(scope, action, input) {
+        const coordinating = action.startsWith('coordination');
+        const invalid = () => new ActivityPolicyError(coordinating ? 'coordination_invalid' : 'activity_invalid');
+        const allowed = action === 'coordination-list'
+            ? ['limit', 'beforeResource']
+            : action === 'list' || action === 'export'
+                ? ['limit', 'cursor']
+                : [];
+        const parameters = new Map();
+        for (const [key, value] of input.parameters) {
+            if (!allowed.includes(key) || parameters.has(key))
+                throw invalid();
+            parameters.set(key, value);
+        }
+        const mutation = (response, eventType, details) => ({
+            response,
+            audit: { eventType, details },
+        });
+        if (action === 'coordination-resolve') {
+            const parsed = OperationCoordinationResolveRequestSchema.safeParse(input.body);
+            if (!parsed.success)
+                throw invalid();
+            const store = this.options.coordination;
+            if (!store)
+                throw new ActivityPolicyError('coordination_unavailable');
+            let resolved;
+            try {
+                resolved = await store.resolve(scope, parsed.data.resource, parsed.data.token, {
+                    reviewer: input.reviewer,
+                    reason: parsed.data.reason,
+                });
+            }
+            catch {
+                throw new ActivityPolicyError('coordination_unavailable');
+            }
+            if (!resolved)
+                throw new ActivityPolicyError('coordination_conflict');
+            return mutation(OperationCoordinationResolveResponseSchema.parse({ ok: true, data: { resolved: true } }), 'config.operation.coordination_resolved', { resource: parsed.data.resource });
+        }
+        if (action === 'coordination-list') {
+            const parsed = OperationCoordinationListRequestSchema.safeParse({
+                ...(parameters.has('limit') ? { limit: Number(parameters.get('limit')) } : {}),
+                ...(parameters.has('beforeResource')
+                    ? { beforeResource: parameters.get('beforeResource') }
+                    : {}),
+            });
+            if (!parsed.success)
+                throw invalid();
+            const store = this.options.coordination;
+            if (!store)
+                throw new ActivityPolicyError('coordination_unavailable');
+            try {
+                const limit = parsed.data.limit ?? 100;
+                const records = await store.list(scope, limit, parsed.data.beforeResource);
+                if (records.some((record) => canonicalJson(record.scope) !== canonicalJson(scope)))
+                    throw new Error('Coordination scope mismatch');
+                return {
+                    response: OperationCoordinationListResponseSchema.parse({
+                        ok: true,
+                        data: {
+                            records: records.map(({ resource, token, reference, operationDigest, startedAt, deadline, state }) => ({
+                                resource,
+                                token,
+                                reference,
+                                operationDigest,
+                                startedAt: new Date(startedAt).toISOString(),
+                                deadline: new Date(deadline).toISOString(),
+                                state,
+                            })),
+                            ...(records.length === limit ? { nextBeforeResource: records.at(-1)?.resource } : {}),
+                        },
+                    }),
+                };
+            }
+            catch {
+                throw new ActivityPolicyError('coordination_unavailable');
+            }
+        }
+        if (action === 'save-settings') {
+            const parsed = ApplicationActivitySettingsSaveRequestSchema.safeParse(input.body);
+            if (!parsed.success)
+                throw invalid();
+            const data = await this.save(scope, parsed.data);
+            return mutation(ApplicationActivitySettingsResponseSchema.parse({ ok: true, data }), 'config.activity.retention_changed', { retentionDays: data.retentionDays });
+        }
+        if (action === 'preview')
+            return {
+                response: ApplicationActivityPreviewResponseSchema.parse({
+                    ok: true,
+                    data: await this.preview(scope),
+                }),
+            };
+        if (action === 'settings')
+            return {
+                response: ApplicationActivitySettingsResponseSchema.parse({
+                    ok: true,
+                    data: (await this.settings(scope, input.canEdit)).projection,
+                }),
+            };
+        const limit = parameters.has('limit') ? Number(parameters.get('limit')) : 50;
+        const cursor = parameters.get('cursor');
+        if (!Number.isInteger(limit) ||
+            limit < 1 ||
+            limit > 100 ||
+            (cursor !== undefined && (!cursor || cursor.length > 2048)))
+            throw invalid();
+        return {
+            response: ApplicationActivityListResponseSchema.parse({
+                ok: true,
+                data: await this.page(scope, {
+                    purpose: action,
+                    limit,
+                    ...(cursor === undefined ? {} : { cursor }),
+                }),
+            }),
+        };
+    }
     async settings(scope, canEdit) {
         const allowance = await this.options.allowance(scope.org);
         if (!allowance ||
@@ -174,6 +298,19 @@ export class ApplicationActivity {
         const scope = installation.scope;
         const revision = target.served.deps.executionBinding?.revision;
         const epochRevision = sha256Canonical({ revision, epoch: this.options.epoch });
+        const authorize = async () => {
+            const active = await deps.registry.getActiveByTenant({
+                org: scope.org,
+                app: scope.app,
+                env: scope.env,
+            });
+            if (!active || active.deploymentId !== target.deploymentId)
+                return false;
+            const current = await resolveApplicationRuntimeTarget(active, deps.installations, deps.connections?.readGenerations);
+            return (!!current &&
+                revision !== undefined &&
+                current.served.deps.executionBinding?.revision === revision);
+        };
         const evidence = createOperationEvidencePort({
             ...this.options,
             scope,
@@ -181,20 +318,16 @@ export class ApplicationActivity {
             historyDays: async () => (await this.settings(scope, false)).projection.retentionDays,
             executionBoundMs: (intent) => intent.executionBoundMs,
             connectionGeneration: (id) => target.served.deps.executionBinding?.connections[id] ?? revision,
-            authorize: async () => {
-                const active = await deps.registry.getActiveByTenant({
-                    org: scope.org,
-                    app: scope.app,
-                    env: scope.env,
-                });
-                if (!active || active.deploymentId !== target.deploymentId)
-                    return false;
-                const current = await resolveApplicationRuntimeTarget(active, deps.installations, deps.connections?.readGenerations);
-                return (!!current &&
-                    revision !== undefined &&
-                    current.served.deps.executionBinding?.revision === revision);
-            },
+            authorize,
         });
+        const coordination = this.options.coordination &&
+            createOperationCoordinationPort({
+                ...this.options,
+                store: this.options.coordination,
+                scope,
+                authorize,
+                connectionGeneration: (id) => target.served.deps.executionBinding?.connections[id],
+            });
         return {
             ...target,
             served: {
@@ -202,6 +335,7 @@ export class ApplicationActivity {
                 deps: {
                     ...target.served.deps,
                     operationEvidence: evidence,
+                    ...(coordination ? { operationCoordination: coordination } : {}),
                     executionBinding: {
                         revision: epochRevision,
                         connections: target.served.deps.executionBinding?.connections ?? {},

package/node_modules/@noodle-borg/service/dist/application-runtime-target.js

@@ -2,7 +2,7 @@ import { sha256Canonical } from '@noodle-borg/compiler';
 import { resolveManagedOrigins } from '@noodle-borg/runtime';
 import { projectApplicationBusinessNotice, } from './application-business-notice.js';
 import { BusinessOnboarding } from './business-onboarding.js';
-import { activateSolutionInstallation, } from './solution-installation-activation.js';
+import { activateSolutionInstallation, readSolutionInstallationActivation, } from './solution-installation-activation.js';
 /** Resolve operator-owned origins from one current configuration snapshot, never a deployment cache. */
 export async function resolveTargetOrigins(target) {
     const env = target.served.deps.env;
@@ -86,6 +86,7 @@ export function applicationServingResolver(input) {
                     installation.applicationGeneration === 'pending')) {
                 const activated = await input.activate({
                     installation,
+                    purpose: 'runtime-refresh',
                     actor: { subject: 'noodle:managed-solution-release', email: '', superAdmin: false },
                 });
                 if (!activated.ok)
@@ -128,6 +129,13 @@ export function createApplicationServingRuntime(registry, providerOptions, contr
         controlPlane,
         audit,
     });
+    const readInstallationActivation = (installation) => readSolutionInstallationActivation(installation, {
+        registry,
+        businessInformationStore,
+        options: providerOptions,
+        controlPlane,
+        audit,
+    });
     const resolveRuntimeTarget = applicationServingResolver({
         registry,
         installations: businessInformationStore,
@@ -136,6 +144,11 @@ export function createApplicationServingRuntime(registry, providerOptions, contr
         activate: activateInstallation,
         ...(businessOnboarding ? { businessOnboarding } : {}),
     });
-    return { activateInstallation, resolveRuntimeTarget, businessOnboarding };
+    return {
+        activateInstallation,
+        readInstallationActivation,
+        resolveRuntimeTarget,
+        businessOnboarding,
+    };
 }
 //# sourceMappingURL=application-runtime-target.js.map

package/node_modules/@noodle-borg/service/dist/business-information/definition-resolver.js

@@ -1,5 +1,6 @@
 import { sha256Canonical } from '@noodle-borg/app-package';
 import { projectManagedCollectionControls } from '@noodle-borg/compiler';
+import { builtInDefinition } from './profiles.js';
 /**
  * Validate and freeze an active deployment as an immutable private solution definition.
  * Authorization and active-deployment lookup happen before this pure boundary.
@@ -91,4 +92,22 @@ function summaryFields(schema) {
 function singularize(title) {
     return title.endsWith('s') && title.length > 1 ? title.slice(0, -1) : title;
 }
+export async function resolveInstallDefinition(selector, installingOrg, resolvePrivateDefinition) {
+    if (selector.kind === 'managed') {
+        return builtInDefinition(selector.profileId);
+    }
+    if (selector.publisherOrg !== installingOrg ||
+        selector.publisherOrg === undefined ||
+        selector.app === undefined ||
+        selector.environment === undefined ||
+        selector.deploymentId === undefined) {
+        return undefined;
+    }
+    return resolvePrivateDefinition?.({
+        publisherOrg: selector.publisherOrg,
+        app: selector.app,
+        environment: selector.environment,
+        deploymentId: selector.deploymentId,
+    });
+}
 //# sourceMappingURL=definition-resolver.js.map

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

@@ -65,7 +65,7 @@ export class InMemoryBusinessInformationStore {
         return this.#lifecycle.setBusinessNotice(input);
     }
     async createInstallation(input) {
-        const normalized = normalizeInstallationInput(input);
+        const normalized = normalizeInstallationInput(input, this.#managedDefinition);
         const key = scopeKey(normalized.scope);
         return this.#locks.run(`installations:${normalized.scope.org}`, async () => {
             const existingKey = this.#installationIds.get(installationIdKey(normalized.scope.org, normalized.scope.installationId));

package/node_modules/@noodle-borg/service/dist/business-information/managed-solution-blueprints.js

@@ -27,6 +27,13 @@ export function managedSolutionBlueprint(key, release) {
     if (key === 'b2b_saas')
         return undefined;
     const blueprint = BLUEPRINTS[key];
+    if ((key === 'travel' || key === 'restaurant') && release === blueprint.release + 1)
+        return {
+            ...blueprint,
+            release,
+            followUpContact: true,
+            description: `${blueprint.description} Ask for the guest's reply email before submission so staff can follow up. Explain that the business receives this address; never invent it or claim it is verified.`,
+        };
     return blueprint.release === release ? blueprint : undefined;
 }
 export function managedSolutionVariables() {