@noodleseed/one 0.173.0 → 0.175.0

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

@@ -1,11 +1,17 @@
-import { beginChannelProviderBlock, CHANNEL_RETENTION_MS, ChannelCoordinator, ChannelError, channelDigest, channelProviderBlocks, finishChannelProviderBlock, messagingSurfaceOf, projectArtifactForSurface, resolveInvocationContextSnapshot, withAssistantTurnExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { beginChannelProviderBlock, CHANNEL_RETENTION_MS, ChannelCoordinator, ChannelError, channelDigest, channelProviderBlocks, collectionSpecFor, finishChannelProviderBlock, messagingSurfaceOf, projectArtifactForSurface, resolveInvocationContextSnapshot, WHATSAPP_CONFIRMATION_EXPIRY_MS, withAssistantTurnExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { guardedFetch } from '@noodle-borg/connector-http';
+import { executePreparedTool, prepareToolForConfirmation } from '@noodle-borg/runtime';
 import { runAgentTurn } from '../routes/assistant-agent.js';
 import { resolveAssistantKnowledge } from '../routes/assistant-knowledge.js';
 import { resolveAssistantModelBinding } from '../routes/assistant-model-binding.js';
 import { activeAssistantTarget } from '../routes/assistant-session-target.js';
 import { resolveConfigScope } from '../store.js';
 import { Dialog360, verifyWhatsAppWebhookSecret, WHATSAPP_CALLBACK_HEADER } from './360dialog.js';
+import { capabilityReport } from './capability-report.js';
+import { collectionCustody, messagingAdmissionDigest, redactPrivate, runCollectionTurn, } from './collection-turn.js';
 import { verifiedInferenceBound, withChannelInferenceGuard } from './inference-guard.js';
+import { messagingProjectionIneligibility } from './messaging-eligibility.js';
+import { reviewButtonBinding } from './reply-buttons.js';
 export class WhatsAppRuntime {
     options;
     deps;
@@ -41,14 +47,9 @@ export class WhatsAppRuntime {
         if (binding.capabilities.some((cap) => !surface.capabilities.some((authored) => authored.kind === cap.kind && authored.name === cap.name)))
             throw new ChannelError('capability_not_authored');
         const artifact = projectArtifactForSurface(target.served.artifact, binding.capabilities);
-        if (artifact.tools.some((tool) => tool.annotations?.readOnlyHint !== true || tool._meta?.ui))
-            throw new ChannelError('messaging_action_unsupported');
-        // This first slice has no separately budgeted connector-backed inference. Pure reads and
-        // the existing corpus search remain available; external lookups require their owning slice.
-        const external = (fulfilment) => fulfilment.kind === 'operation' || fulfilment.steps.some((step) => step.kind === 'operation');
-        if (artifact.tools.some((tool) => external(tool.fulfilment)) ||
-            (artifact.server.context?.ambient && external(artifact.server.context.ambient.fulfilment)))
-            throw new ChannelError('external_lookup_not_enabled');
+        const ineligible = messagingProjectionIneligibility(artifact);
+        if (ineligible !== undefined)
+            throw new ChannelError(ineligible);
         return { ...target, served: { ...target.served, artifact } };
     }
     async doctor(id, req) {
@@ -75,8 +76,9 @@ export class WhatsAppRuntime {
             if (!this.options.worker.ready())
                 throw new ChannelError('worker_unavailable');
         });
+        let target;
         await check('deployment', async () => {
-            await this.target(binding);
+            target = await this.target(binding);
         });
         await check('model_cost', async () => {
             const model = await resolveAssistantModelBinding(await this.target(binding), binding.tenant, binding.deploymentId, this.deps, 'whatsapp');
@@ -109,7 +111,20 @@ export class WhatsAppRuntime {
         const ready = checks.every((check) => check.status === 'ready');
         if (ready)
             await this.channels.markReady(id, binding.revision);
-        return { ready, revision: binding.revision, checks, webhookUrl: this.webhookUrl(req, binding) };
+        // The compatibility report rides beside readiness and never changes it (ADR 0240 decision 7).
+        const capabilities = await capabilityReport({
+            artifact: target?.served.artifact,
+            tenant: binding.tenant,
+            durable: this.options.store.durable,
+            installations: this.options.installations,
+        });
+        return {
+            ready,
+            revision: binding.revision,
+            checks,
+            capabilities,
+            webhookUrl: this.webhookUrl(req, binding),
+        };
     }
     async webhook(id, req) {
         const binding = await this.channels.internal(id);
@@ -247,7 +262,11 @@ export class WhatsAppRuntime {
                 const { adapter } = await this.provider(send.binding);
                 await this.channels.assertSend(id, send.event.id, send.event.lease);
                 this.options.worker.signal.throwIfAborted();
-                await this.channels.sent(id, send.event.id, send.event.lease, await adapter.send({ to: send.participant.address, text: send.event.reply }));
+                await this.channels.sent(id, send.event.id, send.event.lease, await adapter.send({
+                    to: send.participant.address,
+                    text: send.event.reply,
+                    ...(send.event.buttons === undefined ? {} : { buttons: send.event.buttons }),
+                }));
             }
         }
         catch {
@@ -277,9 +296,11 @@ export class WhatsAppRuntime {
         timer.unref?.();
         try {
             const target = await this.target(binding);
+            const artifact = target.served.artifact;
             const model = await resolveAssistantModelBinding(target, binding.tenant, binding.deploymentId, this.deps, 'whatsapp');
             if (!model)
                 throw new ChannelError('model_not_configured');
+            const guarded = withChannelInferenceGuard(model, this.channels, binding.id, event.id, beforeStep);
             const session = {
                 kind: 'messaging',
                 channel: 'whatsapp',
@@ -292,34 +313,107 @@ export class WhatsAppRuntime {
                 history: participant.history.map(({ role, content }) => ({ role, content })),
                 modelToolUses: participant.modelToolUses ?? [],
             };
+            const executeDeps = withAssistantTurnExecutionAuthority({ ...target.served.deps, signal }, artifact, session);
             const context = await resolveInvocationContextSnapshot({
-                artifact: target.served.artifact,
-                executeDeps: withAssistantTurnExecutionAuthority({ ...target.served.deps, signal }, target.served.artifact, session),
+                artifact,
+                executeDeps,
                 caller: session.caller,
                 instant: new Date(this.channels.now()),
             });
-            let text = '', failure;
-            await runAgentTurn(target, session, event.text, context, this.deps, (result) => {
-                if (result.event === 'content' && typeof result.data.delta === 'string')
-                    text += result.data.delta;
-                if (result.event === 'error')
-                    failure = String(result.data.code ?? 'answer_failed');
-            }, undefined, undefined, undefined, false, {
-                binding: withChannelInferenceGuard(model, this.channels, binding.id, event.id, beforeStep),
-                beforeStep,
-                claimTool: (name) => this.channels.claimTool(binding.id, participant.id, name),
-                signal,
-            });
-            if (failure || !text.trim())
-                throw new ChannelError(failure ?? 'answer_unavailable');
-            const disclosure = participant.history.length === 0
-                ? `I’m ${target.served.artifact.server.branding?.name ?? target.served.artifact.server.title}’s AI assistant.\n\n`
-                : '';
-            const answer = disclosure + text.trim();
+            const now = this.channels.now();
+            const inbound = event.text ?? '';
+            // A tapped button is input only for the pending review: it never reaches the model as text,
+            // and history keeps the label the participant saw.
+            const button = event.button;
+            const heard = event.text ?? button?.title ?? '';
+            const custody = collectionCustody(this.options.store, binding.id, participant.id);
+            let ledger = await custody.load();
+            let spec = ledger === undefined
+                ? undefined
+                : collectionSpecFor(artifact, ledger.interactionId, WHATSAPP_CONFIRMATION_EXPIRY_MS);
+            if (ledger !== undefined && spec === undefined) {
+                // The deployment no longer declares this interaction: the stale ledger is dropped.
+                await custody.remove();
+                ledger = undefined;
+            }
+            let outcome = button === undefined ? { kind: 'none' } : { kind: 'ignored', code: 'button_unbound' };
+            if (ledger !== undefined && spec !== undefined) {
+                const toolDeps = { ...executeDeps, caller: session.caller, context };
+                outcome = await runCollectionTurn(ledger, inbound, {
+                    spec,
+                    artifact,
+                    now,
+                    supportEmail: binding.supportEmail,
+                    buttons: reviewButtonBinding(binding.indexKey, binding.id, participant.id),
+                    model: {
+                        binding: guarded,
+                        fetcher: this.deps.modelFetch ?? ((url, init) => guardedFetch(new URL(url), init)),
+                        signal,
+                    },
+                    prepare: (action, input) => prepareToolForConfirmation(artifact, action, input, toolDeps),
+                    execute: async (proposalId, continuation) => {
+                        await beforeStep();
+                        return executePreparedTool(artifact, continuation, {
+                            ...toolDeps,
+                            invocationId: proposalId,
+                            publicAdmission: {
+                                messaging: messagingAdmissionDigest(binding.id, participant.id),
+                                provenance: { kind: 'messaging', channel: 'whatsapp' },
+                            },
+                        });
+                    },
+                    persist: custody.persist,
+                    remove: custody.remove,
+                }, button?.id);
+                ledger = outcome.kind === 'reply' || outcome.kind === 'model' ? outcome.ledger : undefined;
+            }
+            if (outcome.kind === 'ignored') {
+                // An unknown, stale or foreign token: no reply, no model call, one content-free code.
+                await this.channels.fail(binding.id, event.id, event.lease, outcome.code, 'cancelled');
+                return;
+            }
+            let answer;
+            if (outcome.kind === 'reply')
+                answer = outcome.reply;
+            else {
+                let text = '', failure;
+                await runAgentTurn(target, session, outcome.kind === 'model' ? outcome.utterance : inbound, context, this.deps, (result) => {
+                    if (result.event === 'content' && typeof result.data.delta === 'string')
+                        text += result.data.delta;
+                    if (result.event === 'error')
+                        failure = String(result.data.code ?? 'answer_failed');
+                }, undefined, undefined, undefined, false, {
+                    binding: guarded,
+                    beforeStep,
+                    claimTool: (name) => this.channels.claimTool(binding.id, participant.id, name),
+                    signal,
+                    collection: {
+                        open: ledger,
+                        now,
+                        retentionMs: historyRetention,
+                        confirmationExpiryMs: WHATSAPP_CONFIRMATION_EXPIRY_MS,
+                        save: async (opened) => {
+                            await custody.persist(opened);
+                            ledger = opened;
+                            spec = collectionSpecFor(artifact, opened.interactionId, WHATSAPP_CONFIRMATION_EXPIRY_MS);
+                        },
+                    },
+                    ...(outcome.kind === 'model' ? { systemNote: outcome.note } : {}),
+                });
+                if (failure || !text.trim())
+                    throw new ChannelError(failure ?? 'answer_unavailable');
+                const disclosure = participant.history.length === 0
+                    ? `I’m ${artifact.server.branding?.name ?? artifact.server.title}’s AI assistant.\n\n`
+                    : '';
+                answer = disclosure + text.trim();
+            }
             const bounded = answer.length <= 3500
                 ? answer
                 : `${answer.slice(0, 3350).replace(/[\uD800-\uDBFF]$/u, '')}\n\nAsk me to expand on any part.`;
-            await this.channels.complete(binding.id, event.id, event.lease, bounded, historyRetention);
+            // Marked-private values never persist: history and the event row keep redacted text, and the
+            // full review outlives only its own delivery.
+            const scrub = (text) => ledger !== undefined && spec !== undefined ? redactPrivate(spec, ledger, text) : text;
+            await this.channels.complete(binding.id, event.id, event.lease, bounded, historyRetention, undefined, { user: scrub(heard), assistant: scrub(bounded) }, outcome.kind === 'reply' ? outcome.buttons : undefined);
         }
         catch (error) {
             const code = error instanceof ChannelError ? error.code : 'answer_failed';

package/node_modules/@noodle-borg/service/dist/native-record-connector.js

@@ -98,7 +98,7 @@ class NativeRecordConnector {
                 idempotencyKey: key,
                 payload,
                 ...(publicInput ? { publicInput: true } : {}),
-                origin: { kind: 'mcp', reference: 'native-tool' },
+                origin: trustedOrigin(call),
                 actorSubject,
             };
             const completed = await store.probeRequest(request);
@@ -113,8 +113,10 @@ class NativeRecordConnector {
             if (publicInput) {
                 if (!installation.intakeActive || this.dependencies.publicIntakeEnabled === false)
                     return fail(call, 503, 'Public record intake is paused.');
-                if (call.publicAdmission === undefined || !call.publicAdmission.network)
-                    return fail(call, 503, 'Trusted network admission context is required for public record writes.');
+                if (call.publicAdmission === undefined ||
+                    (!call.publicAdmission.network && !call.publicAdmission.messaging))
+                    return fail(call, 503, 'Trusted network or messaging admission context is required for public record writes.');
+                const { provenance: _provenance, ...buckets } = call.publicAdmission;
                 const quota = await admitPublicRecord({
                     counters: this.dependencies.counters,
                     surfaceId: installation.publicId,
@@ -122,7 +124,7 @@ class NativeRecordConnector {
                         key: `solution-intake:logical:${installation.publicId}:${idempotencyDigest(key)}`,
                         fingerprint: requestFingerprint(request),
                     },
-                    buckets: call.publicAdmission,
+                    buckets,
                     now: this.dependencies.now?.() ?? new Date(),
                 });
                 if (!quota.allowed)
@@ -196,6 +198,19 @@ class NativeRecordConnector {
             : { ok: true, record: recordToWire(result.record) };
     }
 }
+/**
+ * Record provenance comes only from the trusted call context (ADR 0240): a messaging channel names
+ * itself through `publicAdmission.provenance` and must arrive with its participant bucket; anything
+ * a caller claims inside tool input has no effect.
+ */
+function trustedOrigin(call) {
+    const provenance = call.publicAdmission?.provenance;
+    if (provenance === undefined)
+        return { kind: 'mcp', reference: 'native-tool' };
+    if (!call.publicAdmission?.messaging)
+        return fail(call, 503, 'Messaging provenance requires a trusted participant admission bucket.');
+    return { kind: 'messaging', reference: provenance.channel };
+}
 function receipt(record) {
     return { ok: true, recordId: record.id, revision: record.revision };
 }

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

@@ -1,6 +1,6 @@
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
-import { APPLICATION_DRAFT_LIMITS, ApplicationDraftCreateRequestSchema, ApplicationDraftDiffRequestSchema, ApplicationDraftDiffResponseSchema, ApplicationDraftEditRequestSchema, ApplicationDraftHistoryResponseSchema, ApplicationDraftListResponseSchema, ApplicationDraftResponseSchema, ApplicationDraftRevisionRequestSchema, ApplicationDraftUndoRequestSchema, } from '@noodle-borg/wire-contracts';
-import { ApplicationDraftError } from '../application-drafts/contracts.js';
+import { APPLICATION_DRAFT_LIMITS, ApplicationDraftCreateRequestSchema, ApplicationDraftDiffRequestSchema, ApplicationDraftDiffResponseSchema, ApplicationDraftEditRequestSchema, ApplicationDraftHistoryResponseSchema, ApplicationDraftListResponseSchema, ApplicationDraftResponseSchema, ApplicationDraftRevisionRequestSchema, ApplicationDraftUndoRequestSchema, ApplicationDraftValidationResponseSchema, } from '@noodle-borg/wire-contracts';
+import { ApplicationDraftError, DraftValidationUnavailableError, } from '../application-drafts/contracts.js';
 import { applicationDraftMethods, parseApplicationDraftPath } from '../application-drafts/paths.js';
 import { admitBusinessTarget, authorizeBusinessApi } from '../business-api-admission.js';
 import { requestIdempotencyKey } from './business-information-request.js';
@@ -11,6 +11,14 @@ export async function handleApplicationDraftRoute(req, res, url, deps) {
         await handle(req, res, url, deps);
     }
     catch (error) {
+        if (error instanceof DraftValidationUnavailableError) {
+            if (error.code === 'busy')
+                res.setHeader('retry-after', '2');
+            return sendJson(res, error.code === 'busy' ? 429 : 503, {
+                code: error.code === 'busy' ? 'validation_busy' : 'validation_unavailable',
+                error: 'Draft validation is temporarily unavailable. Nothing was published.',
+            });
+        }
         if (error instanceof ApplicationDraftError) {
             const status = error.code === 'forbidden'
                 ? 403
@@ -94,6 +102,40 @@ async function handle(req, res, url, deps) {
     const body = await readJsonBody(req, Math.min(deps.maxBody, APPLICATION_DRAFT_LIMITS.totalBytes * 6 + 32_768));
     if (!body.ok)
         return sendJson(res, body.status, { error: body.error });
+    if (id && action === 'validate' && req.method === 'POST') {
+        const parsed = ApplicationDraftRevisionRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res);
+        if (!deps.compiler)
+            return sendJson(res, 503, {
+                code: 'validation_unavailable',
+                error: 'Draft validation is not configured. Nothing was published.',
+            });
+        const input = { scope, id, actorSubject, expectedRevision: parsed.data.expectedRevision };
+        const draft = await deps.drafts.forValidation(input);
+        const result = await deps.compiler.compile(draft.source);
+        // Do not hold a database lock during customer compilation. Recheck under the authority lock afterwards.
+        const current = await deps.drafts.forValidation(input);
+        if (current.sourceDigest !== draft.sourceDigest ||
+            (result.ok && result.sourceDigest !== draft.sourceDigest))
+            throw new ApplicationDraftError('revision_conflict', current.revision);
+        const validation = {
+            draftId: id,
+            revision: draft.revision,
+            sourceDigest: draft.sourceDigest,
+            check: 'source-and-manifest',
+            published: false,
+            ...(result.ok
+                ? {
+                    status: 'valid',
+                    compilerDigest: result.compilerDigest,
+                    artifactDigest: result.artifactDigest,
+                    issues: [],
+                }
+                : { status: 'invalid', issues: result.issues }),
+        };
+        return sendJson(res, 200, ApplicationDraftValidationResponseSchema.parse({ ok: true, data: { validation } }));
+    }
     if (id !== undefined && req.method === 'DELETE') {
         const parsed = ApplicationDraftRevisionRequestSchema.safeParse(body.value);
         if (!parsed.success)

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

@@ -94,6 +94,9 @@ export async function runAgentTurn(target, session, message, context, deps, emit
             ...(pageContext === undefined ? {} : { pageContext }),
             ...(modelContext === undefined ? {} : { modelContext }),
         }),
+        ...(transport?.systemNote === undefined
+            ? []
+            : [{ role: 'system', content: transport.systemNote }]),
         ...session.history,
         { role: 'user', content: message },
     ];
@@ -272,6 +275,7 @@ export async function runAgentTurn(target, session, message, context, deps, emit
                     context,
                     session,
                     claimTool: transport?.claimTool ?? (async () => false),
+                    ...(transport?.collection === undefined ? {} : { collection: transport.collection }),
                 })
                 : await dispatchAssistantTool({
                     artifact: target.served.artifact,

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

@@ -0,0 +1,23 @@
+import { applySecurityHeaders, enforceHttps } from '@noodle-borg/transport-http';
+import { parseApplicationDraftPath } from '../application-drafts/paths.js';
+import { parseBusinessWorkspacePath } from '../business-workspaces/paths.js';
+import { handleApplicationDraftRoute, } from './application-drafts.js';
+import { handleBusinessWorkspaceRoute } from './business-workspaces.js';
+/** Explicit versioned authority, independent of the managed-record switch. */
+export function dispatchBusinessAuthoringRoutes(req, res, url, authoring, deps) {
+    if (!authoring)
+        return false;
+    const workspace = url.pathname === '/v1/me/business-workspaces' || parseBusinessWorkspacePath(url.pathname);
+    if (!workspace && !parseApplicationDraftPath(url.pathname))
+        return false;
+    applySecurityHeaders(res, deps.tls);
+    if (!enforceHttps(req, res, deps.tls)) {
+        const merged = { ...deps, ...authoring };
+        if (workspace)
+            void handleBusinessWorkspaceRoute(req, res, url, merged);
+        else
+            void handleApplicationDraftRoute(req, res, url, merged);
+    }
+    return true;
+}
+//# sourceMappingURL=business-authoring-dispatch.js.map

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

@@ -0,0 +1,39 @@
+import { sendJson } from '@noodle-borg/transport-http';
+import { admitBusinessTarget, authorizeBusinessApi } from '../business-api-admission.js';
+import { businessGrantAllows, } from '../business-information/portable.js';
+import { sendForbidden } from '../http-util.js';
+export async function requireIdentity(req, res, deps) {
+    return authorizeBusinessApi(req, res, deps);
+}
+export async function requireInstallationGrant(res, ref, identity, deps, permission) {
+    if (ref.installationId === undefined)
+        return undefined;
+    const installation = await deps.store.getInstallationById(ref.org, ref.installationId);
+    if (installation === undefined) {
+        sendJson(res, 404, { error: 'installation not found' });
+        return undefined;
+    }
+    const grant = await resolveBusinessStaffGrant(deps, installation.scope, identity.subject);
+    if (grant?.revokedAt !== undefined || grant === undefined) {
+        sendForbidden(res, 'business grant required');
+        return undefined;
+    }
+    if (permission && !businessGrantAllows(grant, permission)) {
+        sendForbidden(res, `business permission required: ${permission}`);
+        return undefined;
+    }
+    if (!(await admitBusinessTarget(res, installation.scope)))
+        return undefined;
+    return { installation, scope: installation.scope, grant };
+}
+export async function resolveBusinessStaffGrant(deps, scope, subject) {
+    return deps.store.staff.resolve(scope, subject);
+}
+export async function requireInstallationPermission(res, ref, identity, permission, deps) {
+    return requireInstallationGrant(res, ref, identity, deps, permission);
+}
+/** Local store effects only: respond after the authority transaction commits. */
+export async function runBusinessStaffOperation(deps, scope, actor, permission, operation) {
+    return deps.store.staff.run(scope, actor, permission, operation);
+}
+//# sourceMappingURL=business-information-access.js.map

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

@@ -57,7 +57,7 @@ export async function handleApplicationActivity(req, res, url, ref, deps) {
             body,
             reviewer: identity.subject,
             canEdit: businessGrantAllows(authorized.grant, 'installation:administer'),
-        });
+        }, (operation) => deps.store.staff.run(authorized.scope, identity.subject, permission, operation));
         if ('audit' in result)
             await deps.audit?.emit({
                 ...result.audit,

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

@@ -37,12 +37,12 @@ export async function handleBusinessChannels(req, res, ref, deps) {
                 code: 'business_setup_required',
                 error: 'Complete business setup before publishing agent channels.',
             });
-        const result = await deps.store.setIntakeState({
+        const result = await deps.store.staff.run(authorized.scope, identity.subject, 'installation:administer', () => 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;

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

@@ -26,10 +26,16 @@ export async function handleApplicationConnections(req, res, ref, deps) {
     try {
         const targets = await deps.resolveConnectionTargets(authorized.installation);
         const connections = deps.connections;
-        const projection = async () => ({
-            connections: await Promise.all(targets.map((target) => connections.inspect(target))),
-            canEdit: businessGrantAllows(authorized.grant, 'installation:administer'),
-        });
+        const projection = async () => {
+            const views = await Promise.all(targets.map((target) => connections.inspect(target, (operation) => deps.store.staff.run(authorized.scope, identity.subject, 'records:read', operation, () => new ConnectionError('connection_denied')))));
+            const current = await deps.store.staff.resolve(authorized.scope, identity.subject);
+            if (!businessGrantAllows(current, 'records:read') || current?.role === 'viewer')
+                throw new ConnectionError('connection_denied');
+            return {
+                connections: views,
+                canEdit: businessGrantAllows(current, 'installation:administer'),
+            };
+        };
         if (!mutation)
             return sendJson(res, 200, ApplicationConnectionsResponseSchema.parse({ ok: true, data: await projection() }));
         const target = targets.find((item) => item.key.connectionId === ref.connectionId);

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

@@ -1,14 +1,13 @@
 import { OrganizationAgreementError } from '@noodle-borg/control-plane/portable';
 import { sendJson } from '@noodle-borg/transport-http';
-import { parseApplicationDraftPath } from '../application-drafts/paths.js';
 import { BusinessNoticeError } from '../business-information/business-notice.js';
 import { parseBusinessPagePath } from '../business-information/business-page-paths.js';
 import { InstallationCapacityError } from '../business-information/installation-capacity.js';
 import { NativeStorageLimitError } from '../business-information/native-storage-budget.js';
 import { SourceCredentialError } from '../business-information/source-credential-fence.js';
 import { SourceCapacityError } from '../business-information/source-custody-budget.js';
+import { BusinessWorkspaceError } from '../business-workspaces/contracts.js';
 import { respondRouteError } from '../http-util.js';
-import { handleApplicationDraftRoute } from './application-drafts.js';
 import { handleBusinessGrants, handleManagedRecords, handleSolutionCatalog, handleSolutionInstallations, } from './business-information.js';
 import { handleApplicationActivity, } from './business-information-activity.js';
 import { handleBusinessChannels, } from './business-information-channels.js';
@@ -22,6 +21,7 @@ import { handleBusinessInformationReaderFloor } from './business-information-rea
 import { handleBusinessSettings } from './business-information-settings.js';
 import { handleCollectionSource } from './business-information-source.js';
 import { handleBusinessInvitationAccept, handleBusinessInvitations, handleEligibleBusinessAssignees, handleMySolutionInstallations, } from './business-information-staff.js';
+import { handleNativeRecordLifecycle } from './business-native-lifecycle.js';
 export function dispatchBusinessInformationRoutes(req, res, url, deps) {
     const pageRef = parseBusinessPagePath(url.pathname);
     const publicPage = /^\/v1\/business-pages\/(sol_[a-f0-9]{32})$/.exec(url.pathname);
@@ -37,10 +37,6 @@ export function dispatchBusinessInformationRoutes(req, res, url, deps) {
             ? handleBusinessPage(req, res, pageRef, pageDeps)
             : handlePublicBusinessPage(req, res, publicPage[1], pageDeps));
     }
-    if (deps.authoring && parseApplicationDraftPath(url.pathname)) {
-        const draftDeps = { ...deps, ...deps.authoring, maxBody: deps.maxDraftBody ?? deps.maxBody };
-        return run(req, res, deps, () => handleApplicationDraftRoute(req, res, url, draftDeps));
-    }
     const agreement = /^\/v1\/orgs\/([a-z0-9][a-z0-9-]{0,62})\/agreement$/.exec(url.pathname);
     if (agreement?.[1])
         return run(req, res, deps, () => handleOrganizationAgreement(req, res, agreement[1], deps));
@@ -78,6 +74,8 @@ export function dispatchBusinessInformationRoutes(req, res, url, deps) {
     const installationRef = parseSolutionInstallationPath(url.pathname);
     if (installationRef === undefined)
         return false;
+    if (installationRef.action === 'record-lifecycle')
+        return run(req, res, deps, () => handleNativeRecordLifecycle(req, res, installationRef, deps));
     if (installationRef.action === 'notice')
         return run(req, res, deps, () => handleBusinessNotice(req, res, installationRef, deps));
     if ((installationRef.action === 'activity' || installationRef.action === 'coordination') &&
@@ -131,6 +129,13 @@ function run(req, res, deps, handle) {
     return true;
 }
 function respondBusinessError(deps, res, event, error) {
+    if (error instanceof BusinessWorkspaceError) {
+        sendJson(res, error.code === 'forbidden' ? 403 : 409, {
+            error: 'Business access changed. Refresh before continuing.',
+            code: error.code,
+        });
+        return;
+    }
     if (error instanceof OrganizationAgreementError || error instanceof BusinessNoticeError) {
         const forbidden = error.code === 'agreement_owner_required' || error.code === 'business_notice_forbidden';
         sendJson(res, forbidden ? 403 : 409, { error: error.message, code: error.code });

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

@@ -11,12 +11,14 @@ export function stableInstallationId(org, app, env) {
 /** Read current activation authority; intake is an independent operator setting. */
 export async function installationProjection(installation, role, identity, deps) {
     const state = (await deps.readInstallationActivation?.(installation)) ?? 'unavailable';
+    const access = await deps.workspaces?.resolveAccess(installation.scope.org, identity.subject);
     const canRetry = state === 'pending' &&
         deps.activateInstallation !== undefined &&
         role === 'administrator' &&
         (await canManageMembers(deps.controlPlane, installation.scope.org, identity));
     return {
-        ...installationToWire(installation, role),
+        ...installationToWire(installation, access?.role ?? role),
+        ...(access ? { authorityVersion: 1 } : {}),
         activation: state === 'pending' ? { state, canRetry } : { state, canRetry: false },
     };
 }

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

@@ -1,16 +1,20 @@
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
 import { BusinessNoticeResponseSchema, BusinessNoticeSaveRequestSchema, OrganizationAgreementAcceptRequestSchema, OrganizationAgreementResponseSchema, } from '@noodle-borg/wire-contracts';
 import { admitBusinessTarget } from '../business-api-admission.js';
+import { businessGrantAllows } from '../business-information/model.js';
 import { sendForbidden } from '../http-util.js';
 import { invalid, methodNotAllowed, requireIdentity, requireInstallationGrant, requireInstallationPermission, } from './business-information.js';
 import { canManageMembers } from './org-admin.js';
 export async function handleOrganizationAgreement(req, res, org, deps) {
     if (req.method !== 'GET' && req.method !== 'POST')
         return methodNotAllowed(res);
+    res.setHeader('cache-control', 'private, no-store');
     const identity = await requireIdentity(req, res, deps);
     if (identity === false)
         return;
-    if (!(await canManageMembers(deps.controlPlane, org, identity)))
+    const selected = await deps.workspaces?.authorize(org, identity.subject, 'settings:manage');
+    if (selected === 'denied' ||
+        (selected !== 'allowed' && !(await canManageMembers(deps.controlPlane, org, identity))))
         return sendForbidden(res, 'organization owner required');
     if (!(await admitBusinessTarget(res, { org })))
         return;
@@ -62,7 +66,7 @@ export async function handleBusinessNotice(req, res, ref, deps) {
         data: {
             revision: record?.revision ?? 0,
             notice: record?.notice ?? null,
-            canEdit: authorized.grant.role === 'administrator',
+            canEdit: businessGrantAllows(authorized.grant, 'installation:administer'),
         },
     }));
 }

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

@@ -59,7 +59,7 @@ export async function handleBusinessPage(req, res, ref, deps) {
     if (!authorized)
         return;
     try {
-        let record = await deps.store.pages.get(authorized.scope);
+        let record = await deps.store.staff.run(authorized.scope, identity.subject, 'installation:administer', () => deps.store.pages.get(authorized.scope), () => new BusinessPageError('business_page_forbidden'));
         if (req.method !== 'GET') {
             const body = await readJsonBody(req, Math.min(deps.maxBody, 256 * 1024));
             if (!body.ok)

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

@@ -27,7 +27,7 @@ export function parseSolutionInstallationPath(pathname) {
                 ...(connectionAction === undefined ? {} : { connectionAction }),
             };
     }
-    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|channels|operations\/coordination(?:\/resolve)?|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
+    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(activate|settings|notice|record-lifecycle|channels|operations\/coordination(?:\/resolve)?|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
     if (application !== null) {
         const org = decoded(application, 1);
         const installationId = decoded(application, 2);

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

@@ -1,5 +1,6 @@
 import { sendJson } from '@noodle-borg/transport-http';
 import { PayloadValidationError, } from '../business-information/portable.js';
+import { runBusinessStaffOperation } from './business-information-access.js';
 export async function createNativeRecord(res, deps, input) {
     try {
         const request = {
@@ -11,13 +12,17 @@ export async function createNativeRecord(res, deps, input) {
             actorSubject: input.actorSubject,
         };
         if (input.admit) {
-            const receipt = await deps.store.probeRequest(request);
+            const receipt = input.origin.kind === 'portal'
+                ? await runBusinessStaffOperation(deps, request.scope, input.actorSubject, 'records:create', () => deps.store.probeRequest(request))
+                : await deps.store.probeRequest(request);
             if (receipt.disposition !== 'missing')
                 return receipt;
             if (!(await input.admit()))
                 return undefined;
         }
-        return await deps.store.createRequest(request);
+        return input.origin.kind === 'portal'
+            ? await runBusinessStaffOperation(deps, request.scope, input.actorSubject, 'records:create', () => deps.store.createRequest(request))
+            : await deps.store.createRequest(request);
     }
     catch (error) {
         if (!(error instanceof PayloadValidationError))