@noodleseed/one 0.170.0 → 0.171.0

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-channels.js

@@ -0,0 +1,121 @@
+const flag = (name, summary, type = 'string') => ({
+    name,
+    summary,
+    type,
+    ...(type === 'boolean' ? {} : { value: '<value>' }),
+    required: false,
+    repeatable: false,
+    sensitive: name === 'auth-token',
+    aliases: [],
+    conflictsWith: [],
+});
+const scope = [
+    flag('org', 'Organization.'),
+    flag('app', 'Application.'),
+    flag('env', 'Environment.'),
+    flag('service', 'Service URL.'),
+    flag('auth-token', 'Control-plane token.'),
+    flag('json', 'Machine-readable output.', 'boolean'),
+];
+const mutation = [flag('idempotency-key', 'Stable key for retrying this logical change.')];
+const revision = flag('expected-revision', 'Current revision from status; zero when creating.', 'number');
+const blockScope = flag('scope', 'local (default) or explicit provider block.');
+const participant = flag('participant-id', 'Protected participant identifier from events list.');
+const limits = [
+    'per-minute',
+    'per-hour',
+    'per-day',
+    'channel-per-day',
+    'new-participants-per-day',
+    'concurrent',
+    'pending-per-participant',
+    'pending',
+    'text-characters',
+    'daily-micro-usd',
+].map((name) => flag(name, `Lower the ${name} ceiling; zero disables this allowance.`, 'number'));
+const leaf = (name, summary, flags = []) => ({
+    name,
+    summary,
+    flags: [...scope, ...flags],
+    arguments: [],
+    jsonOutput: { mode: 'single' },
+});
+const group = (name, summary, subcommands) => ({ name, summary, subcommands, flags: [], arguments: [] });
+export const CHANNELS_COMMAND = {
+    name: 'channels',
+    section: 'operate',
+    summary: 'Connect and operate the same application on messaging channels.',
+    arguments: [],
+    flags: [],
+    subcommands: [
+        group('whatsapp', 'Configure the 360dialog channel, test readiness, and control public messaging.', [
+            leaf('status', 'Show configuration and current revision.'),
+            leaf('configure', 'Save a paused binding using managed secret references.', [
+                revision,
+                ...mutation,
+                flag('phone-number-id', '360dialog/Meta phone-number asset ID.'),
+                flag('api-key-secret', 'Managed secret name for the 360dialog key.'),
+                flag('webhook-secret', 'Independent managed callback secret name.'),
+                flag('capabilities', 'Comma-separated knowledge:name or tool:name selections.'),
+                flag('support-email', 'Contact shown when an answer cannot be completed.'),
+                ...limits,
+            ]),
+            leaf('doctor', 'Check deployment, storage, worker, model cost bound, and provider setup.', mutation),
+            leaf('enable', 'Enable after a successful current readiness check.', [
+                revision,
+                ...mutation,
+            ]),
+            leaf('pause', 'Stop new work and unsent replies.', [revision, ...mutation]),
+            leaf('disconnect', 'Fence this binding and retain governed receipts.', [
+                revision,
+                ...mutation,
+            ]),
+            group('webhook', 'Inspect or configure the owned provider callback.', [
+                leaf('inspect', 'Check URL and authentication without disclosing headers.'),
+                leaf('configure', 'Register the service-owned callback.', [revision, ...mutation]),
+            ]),
+            group('limits', 'Inspect or lower the approved limits.', [
+                leaf('get', 'Show limits.'),
+                leaf('set', 'Lower selected limits.', [revision, ...mutation, ...limits]),
+            ]),
+            leaf('usage', 'Show UTC-day settled and reserved inference spend.'),
+            group('blocks', 'Inspect local blocks.', [
+                leaf('list', 'List local and provider block evidence.', [
+                    flag('after', 'Cursor from the previous page.'),
+                ]),
+            ]),
+            leaf('block', 'Block locally; optionally request a provider block.', [
+                participant,
+                blockScope,
+                flag('phone-stdin', 'Read a phone number securely from standard input.', 'boolean'),
+                flag('until', 'Expiry as an ISO timestamp.'),
+                flag('indefinite', 'Explicitly retain this block until removed.', 'boolean'),
+                ...mutation,
+            ]),
+            leaf('unblock', 'Remove an explicitly selected block without resetting usage.', [
+                participant,
+                blockScope,
+                flag('phone-stdin', 'Supply the number if retained participant context has expired.', 'boolean'),
+                ...mutation,
+            ]),
+            group('cooldown', 'Inspect or clear an automatic cooldown.', [
+                leaf('inspect', 'Show a participant cooldown.', [participant]),
+                leaf('clear', 'Clear cooldown without resetting quotas.', [participant, ...mutation]),
+            ]),
+            group('events', 'Inspect content-free transport receipts.', [
+                leaf('list', 'List a page of events.', [
+                    flag('after', 'Cursor returned by the previous page.'),
+                ]),
+                leaf('inspect', 'Inspect one event.', [flag('event-id', 'Event identifier.')]),
+                leaf('reconcile', 'Read current receipt evidence without resending.', [
+                    flag('event-id', 'Event identifier.'),
+                    ...mutation,
+                ]),
+            ]),
+            group('conversation', 'Erase conversation content.', [
+                leaf('forget', 'Erase participant context and message content while preserving safeguards.', [participant, ...mutation]),
+            ]),
+        ]),
+    ],
+};
+//# sourceMappingURL=catalog-data-channels.js.map

package/node_modules/@noodle-borg/cli-catalog/dist/index.js

@@ -4,6 +4,7 @@ export * from './catalog-data-auth-discovery.js';
 export * from './catalog-data-billing.js';
 export * from './catalog-data-bootstrap-authoring.js';
 export * from './catalog-data-bootstrap-pre-auth.js';
+export * from './catalog-data-channels.js';
 export * from './catalog-data-config.js';
 export * from './catalog-data-core.js';
 export * from './catalog-data-distributions.js';

package/node_modules/@noodle-borg/compiler/dist/artifact/config.js

@@ -20,7 +20,7 @@ function collectVariablesFromManagedOrigins(manifest, out) {
     const assistant = manifest.server.assistant;
     const values = [
         ...(assistant?.allowedOrigins ?? []),
-        ...(assistant?.surfaces?.flatMap((surface) => surface.origins) ?? []),
+        ...(assistant?.surfaces?.flatMap((surface) => surface.kind === 'messaging' ? [] : surface.origins) ?? []),
         ...(manifest.handoff?.allowedDomains ?? []),
     ];
     for (const value of values) {

package/node_modules/@noodle-borg/compiler/dist/errors.d.ts

@@ -1,7 +1,7 @@
 import type { AppPackageArtifactV1 } from '@noodle-borg/app-package';
 import type { RuntimeArtifact } from './artifact/types.js';
 import type { PackagedAsset } from './assets.js';
-export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'ambiguous_nested_connector_binding' | 'invalid_connector_call_graph' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
+export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'ambiguous_nested_connector_binding' | 'invalid_connector_call_graph' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_messaging_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
 export interface CompileError {
     readonly code: CompileErrorCode;
     /** Dotted path to the offending location (e.g. `tools.1.name`); empty string for the document root. */

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.d.ts

@@ -358,10 +358,25 @@ export declare const manifestV1Schema: z.ZodObject<{
                 kind: z.ZodLiteral<"noodle-managed">;
             }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
-            surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            surfaces: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"messaging">;
+                channel: z.ZodLiteral<"whatsapp">;
+                mode: z.ZodLiteral<"public">;
+                capabilities: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        tool: "tool";
+                        resource: "resource";
+                        prompt: "prompt";
+                        knowledge: "knowledge";
+                    }>;
+                    name: z.ZodString;
+                }, z.core.$strict>>;
+                instructions: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"website">>;
                 mode: z.ZodEnum<{
-                    authenticated: "authenticated";
                     public: "public";
+                    authenticated: "authenticated";
                     mixed: "mixed";
                 }>;
                 origins: z.ZodArray<z.ZodString>;
@@ -386,7 +401,7 @@ export declare const manifestV1Schema: z.ZodObject<{
                     windowSeconds: z.ZodOptional<z.ZodNumber>;
                     maxRestores: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
-            }, z.core.$strict>>>;
+            }, z.core.$strict>]>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>>;
@@ -847,10 +862,25 @@ export declare const manifestV2Schema: z.ZodObject<{
                 kind: z.ZodLiteral<"noodle-managed">;
             }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
-            surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            surfaces: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"messaging">;
+                channel: z.ZodLiteral<"whatsapp">;
+                mode: z.ZodLiteral<"public">;
+                capabilities: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        tool: "tool";
+                        resource: "resource";
+                        prompt: "prompt";
+                        knowledge: "knowledge";
+                    }>;
+                    name: z.ZodString;
+                }, z.core.$strict>>;
+                instructions: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"website">>;
                 mode: z.ZodEnum<{
-                    authenticated: "authenticated";
                     public: "public";
+                    authenticated: "authenticated";
                     mixed: "mixed";
                 }>;
                 origins: z.ZodArray<z.ZodString>;
@@ -875,7 +905,7 @@ export declare const manifestV2Schema: z.ZodObject<{
                     windowSeconds: z.ZodOptional<z.ZodNumber>;
                     maxRestores: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
-            }, z.core.$strict>>>;
+            }, z.core.$strict>]>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>>;
@@ -1602,10 +1632,25 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"noodle-managed">;
             }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
-            surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            surfaces: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"messaging">;
+                channel: z.ZodLiteral<"whatsapp">;
+                mode: z.ZodLiteral<"public">;
+                capabilities: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        tool: "tool";
+                        resource: "resource";
+                        prompt: "prompt";
+                        knowledge: "knowledge";
+                    }>;
+                    name: z.ZodString;
+                }, z.core.$strict>>;
+                instructions: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"website">>;
                 mode: z.ZodEnum<{
-                    authenticated: "authenticated";
                     public: "public";
+                    authenticated: "authenticated";
                     mixed: "mixed";
                 }>;
                 origins: z.ZodArray<z.ZodString>;
@@ -1630,7 +1675,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     windowSeconds: z.ZodOptional<z.ZodNumber>;
                     maxRestores: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
-            }, z.core.$strict>>>;
+            }, z.core.$strict>]>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>>;
@@ -2090,10 +2135,25 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"noodle-managed">;
             }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
-            surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            surfaces: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"messaging">;
+                channel: z.ZodLiteral<"whatsapp">;
+                mode: z.ZodLiteral<"public">;
+                capabilities: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        tool: "tool";
+                        resource: "resource";
+                        prompt: "prompt";
+                        knowledge: "knowledge";
+                    }>;
+                    name: z.ZodString;
+                }, z.core.$strict>>;
+                instructions: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"website">>;
                 mode: z.ZodEnum<{
-                    authenticated: "authenticated";
                     public: "public";
+                    authenticated: "authenticated";
                     mixed: "mixed";
                 }>;
                 origins: z.ZodArray<z.ZodString>;
@@ -2118,7 +2178,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     windowSeconds: z.ZodOptional<z.ZodNumber>;
                     maxRestores: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
-            }, z.core.$strict>>>;
+            }, z.core.$strict>]>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>>;

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -277,38 +277,50 @@ const embeddedAssistantSchema = z
             .strict(),
         z.object({ kind: z.literal('noodle-managed') }).strict(),
     ]),
-    allowedOrigins: z.array(assistantOriginOrVariableSchema).min(1),
+    allowedOrigins: z.array(assistantOriginOrVariableSchema),
     // The front doors this assistant serves (ADR 0201, amended 2026-08-12). Absent means the pre-0201
     // authenticated shape, so released artifacts keep their meaning; `allowedOrigins` stays the union
     // and `sessionClaims` stays mirrored, so the service reads both unchanged. `capabilities` is the
     // exact reachable surface: optional when authenticated, required when public or mixed.
     surfaces: z
-        .array(z
-        .object({
-        mode: z.enum(['authenticated', 'public', 'mixed']),
-        origins: z.array(assistantOriginOrVariableSchema).min(1),
-        instructions: z.string().trim().min(1).max(MAX_SERVER_INSTRUCTIONS).optional(),
-        capabilities: z.array(assistantCapabilitySchema).optional(),
-        sessionClaims: sessionClaimsSchema.optional(),
-        // Overrides the assistant's own opt-in for sessions minted on this surface, in either
-        // direction (ADR 0220, amended). Declared explicitly rather than inherited from
-        // `assistantUiSchema.shape` — this is not renderer presentation, and a surface that
-        // acquired it by a spread would be an accident rather than a decision.
-        webmcp: optionalStrictObject({ enabled: z.boolean().optional() }),
-        // Anonymous cross-page display continuity (ADR 0223, clauses 11-16), declared per public
-        // or mixed surface. These bounds mirror the structural ceilings the gateway clamps to at
-        // runtime; the ADR is the single source, and this package cannot import the gateway
-        // because the dependency runs the other way. Refusing rather than clamping is deliberate:
-        // the gateway narrows an operator's value silently by design, but a developer who asks
-        // for more than the ceiling has made a mistake, and silence would hide it until someone
-        // measured the live behaviour.
-        continuity: optionalStrictObject({
-            enabled: z.boolean().optional(),
-            windowSeconds: z.number().int().min(0).max(600).optional(),
-            maxRestores: z.number().int().min(0).max(10).optional(),
-        }),
-    })
-        .strict())
+        .array(z.union([
+        z
+            .object({
+            kind: z.literal('messaging'),
+            channel: z.literal('whatsapp'),
+            mode: z.literal('public'),
+            capabilities: z.array(assistantCapabilitySchema),
+            instructions: z.string().trim().min(1).max(MAX_SERVER_INSTRUCTIONS).optional(),
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal('website').optional(),
+            mode: z.enum(['authenticated', 'public', 'mixed']),
+            origins: z.array(assistantOriginOrVariableSchema).min(1),
+            instructions: z.string().trim().min(1).max(MAX_SERVER_INSTRUCTIONS).optional(),
+            capabilities: z.array(assistantCapabilitySchema).optional(),
+            sessionClaims: sessionClaimsSchema.optional(),
+            // Overrides the assistant's own opt-in for sessions minted on this surface, in either
+            // direction (ADR 0220, amended). Declared explicitly rather than inherited from
+            // `assistantUiSchema.shape` — this is not renderer presentation, and a surface that
+            // acquired it by a spread would be an accident rather than a decision.
+            webmcp: optionalStrictObject({ enabled: z.boolean().optional() }),
+            // Anonymous cross-page display continuity (ADR 0223, clauses 11-16), declared per public
+            // or mixed surface. These bounds mirror the structural ceilings the gateway clamps to at
+            // runtime; the ADR is the single source, and this package cannot import the gateway
+            // because the dependency runs the other way. Refusing rather than clamping is deliberate:
+            // the gateway narrows an operator's value silently by design, but a developer who asks
+            // for more than the ceiling has made a mistake, and silence would hide it until someone
+            // measured the live behaviour.
+            continuity: optionalStrictObject({
+                enabled: z.boolean().optional(),
+                windowSeconds: z.number().int().min(0).max(600).optional(),
+                maxRestores: z.number().int().min(0).max(10).optional(),
+            }),
+        })
+            .strict(),
+    ]))
         .min(1)
         .optional(),
     // Mirrored from the authenticated surface; the session exchange reads it here (ADR 0141,
@@ -323,7 +335,19 @@ const embeddedAssistantSchema = z
 })
     .strict()
     .superRefine((assistant, ctx) => {
+    const messaging = assistant.surfaces?.filter((surface) => surface.kind === 'messaging') ?? [];
+    if (messaging.length > 1)
+        ctx.addIssue({ code: 'custom', path: ['surfaces'], message: 'duplicate whatsapp surface' });
+    if (assistant.allowedOrigins.length === 0 && messaging.length === 0) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['allowedOrigins'],
+            message: 'a website assistant requires allowedOrigins',
+        });
+    }
     assistant.surfaces?.forEach((surface, index) => {
+        if (surface.kind === 'messaging')
+            return;
         // The authenticated direction already reattaches through ADR 0223 clause 7, authorized by a
         // backend-verified subject rather than by possession of a handle. A `continuity` block here
         // would be a developer believing they configured something nothing reads, so refuse it rather

package/node_modules/@noodle-borg/compiler/dist/manifest/website-projection.d.ts

@@ -18,6 +18,7 @@ import type { CompileError } from '../errors.js';
  * ADR 0055's third class — a declared anonymous fallback — stays reserved, not produced.
  */
 interface AssistantSurfaceInput {
+    readonly kind?: 'website' | 'messaging' | undefined;
     readonly mode: 'authenticated' | 'public' | 'mixed';
     readonly capabilities?: readonly {
         readonly kind: string;

package/node_modules/@noodle-borg/compiler/dist/manifest/website-projection.js

@@ -26,12 +26,31 @@ export function validateWebsiteProjection(assistant, surfaces) {
                 });
                 return;
             }
+            if (surface.kind === 'messaging' && !['tool', 'knowledge'].includes(capability.kind)) {
+                errors.push({
+                    code: 'assistant_messaging_unsupported',
+                    path: `server.assistant.surfaces[${surfaceIndex}].capabilities[${index}]`,
+                    message: 'Messaging currently supports pure read tools and knowledge only',
+                });
+                return;
+            }
             if (surface.mode === 'authenticated' || capability.kind !== 'tool')
                 return;
             const tool = toolsByName.get(capability.name);
             if (tool === undefined)
                 return;
             const path = `tools.${tool.name}`;
+            if (surface.kind === 'messaging' &&
+                (tool.annotations?.readOnlyHint !== true ||
+                    tool._meta?.ui !== undefined ||
+                    tool.fulfilment.kind === 'operation' ||
+                    tool.fulfilment.steps.some((step) => step.kind === 'operation'))) {
+                errors.push({
+                    code: 'assistant_messaging_unsupported',
+                    path,
+                    message: `"${tool.name}" requires a write, connector, or UI renderer not enabled for this messaging slice`,
+                });
+            }
             if (surface.mode === 'public' && anonymousBehavior(tool) === 'requires-identity') {
                 errors.push({
                     code: 'assistant_public_user_reference',

package/node_modules/@noodle-borg/module-audit/dist/index.js

@@ -0,0 +1,37 @@
+import { MODULE_API_VERSION } from '@noodle-borg/module';
+import { PostgresAuditStore } from './postgres-audit.js';
+import { createAuditEventsRoute } from './route.js';
+export { ensureAuditSchema, insertAuditEvent, PostgresAuditStore } from './postgres-audit.js';
+export { createAuditEventsRoute } from './route.js';
+export function createModule() {
+    return {
+        name: '@noodle-borg/module-audit',
+        version: '0.0.0',
+        apiVersion: MODULE_API_VERSION,
+        init: async (ctx) => {
+            const pool = ctx.stores?.postgresPool?.();
+            if (!isPgPool(pool)) {
+                throw new Error('@noodle-borg/module-audit requires a Postgres pool');
+            }
+            const store = new PostgresAuditStore(pool);
+            await store.ensureSchema();
+            return {
+                auditStore: store,
+                routes: [createAuditEventsRoute(store)],
+                readiness: async () => {
+                    try {
+                        await pool.query('SELECT 1');
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+            };
+        },
+    };
+}
+function isPgPool(value) {
+    return typeof value === 'object' && value !== null && typeof value.query === 'function';
+}
+//# sourceMappingURL=index.js.map

package/node_modules/@noodle-borg/module-audit/dist/postgres-audit.js

@@ -0,0 +1,126 @@
+import { randomUUID } from 'node:crypto';
+import { AUDIT_SCHEMA_VERSION, redactDetails, } from '@noodle-borg/module';
+/**
+ * Create the append-only `audit_events` table if absent (idempotent; run once at startup). Unlike
+ * `deploy_records`/`config_values`, this table has **no foreign key to `environments`** — audit evidence
+ * must survive tenant/app/env deletion, so it carries plain `org_slug`/`app_slug`/`environment` text and is
+ * never cascade-deleted. `seq` (bigserial) gives a stable newest-first order and a future cursor for the
+ * audit query API; `details` is `jsonb` holding the already-redacted scalar bag.
+ */
+export async function ensureAuditSchema(pool) {
+    await pool.query(`
+    CREATE TABLE IF NOT EXISTS audit_events (
+      seq            bigserial PRIMARY KEY,
+      id             uuid NOT NULL,
+      event_type     text NOT NULL,
+      org_slug       text NOT NULL,
+      app_slug       text,
+      environment    text,
+      deployment_id  text,
+      actor_subject  text,
+      actor_email    text,
+      decision       text,
+      status         text,
+      reason_code    text,
+      schema_version int NOT NULL,
+      details        jsonb,
+      created_at     timestamptz NOT NULL
+    )
+  `);
+    await pool.query(`
+    CREATE INDEX IF NOT EXISTS audit_events_tenant_time_idx
+      ON audit_events (org_slug, app_slug, environment, seq DESC)
+  `);
+}
+/**
+ * Insert one canonical, redacted audit row through either a pool or an already-open transaction client.
+ * This helper deliberately does not manage a transaction: callers using a `PoolClient` keep the audit
+ * evidence in the same commit boundary as the state change it records.
+ */
+export async function insertAuditEvent(queryable, input, options = {}) {
+    const details = redactDetails(input.details);
+    await queryable.query(`INSERT INTO audit_events
+      (id, event_type, org_slug, app_slug, environment, deployment_id, actor_subject, actor_email,
+       decision, status, reason_code, schema_version, details, created_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)`, [
+        (options.id ?? randomUUID)(),
+        input.eventType,
+        input.org,
+        input.app ?? null,
+        input.env ?? null,
+        input.deploymentId ?? null,
+        input.actorSubject ?? null,
+        input.actorEmail ?? null,
+        input.decision ?? null,
+        input.status !== undefined ? String(input.status) : null,
+        input.reasonCode ?? null,
+        AUDIT_SCHEMA_VERSION,
+        details !== undefined ? JSON.stringify(details) : null,
+        (options.now ?? (() => new Date()))(),
+    ]);
+}
+/**
+ * Relational system of record for {@link AuditEvent}s (parallels {@link InMemoryAuditStore}). The `pg.Pool`
+ * is injected; this class is pure SQL and unit-testable against any local Postgres.
+ */
+export class PostgresAuditStore {
+    #pool;
+    #now;
+    #id;
+    constructor(pool, options = {}) {
+        this.#pool = pool;
+        this.#now = options.now ?? (() => new Date());
+        this.#id = options.id ?? randomUUID;
+    }
+    ensureSchema() {
+        return ensureAuditSchema(this.#pool);
+    }
+    async emit(input) {
+        await insertAuditEvent(this.#pool, input, { now: this.#now, id: this.#id });
+    }
+    async list(filter) {
+        const org = validateSlug('org', filter.org);
+        const clauses = ['org_slug = $1'];
+        const values = [org];
+        if (filter.app !== undefined) {
+            values.push(filter.app);
+            clauses.push(`app_slug = $${values.length}`);
+        }
+        if (filter.env !== undefined) {
+            values.push(filter.env);
+            clauses.push(`environment = $${values.length}`);
+        }
+        if (filter.eventType !== undefined) {
+            values.push(filter.eventType);
+            clauses.push(`event_type = $${values.length}`);
+        }
+        const limit = filter.limit !== undefined ? ` LIMIT ${Number(filter.limit)}` : '';
+        const { rows } = await this.#pool.query(`SELECT * FROM audit_events WHERE ${clauses.join(' AND ')} ORDER BY seq DESC${limit}`, values);
+        return rows.map(rowToEvent);
+    }
+}
+function rowToEvent(row) {
+    return {
+        id: row.id,
+        schemaVersion: row.schema_version,
+        eventType: row.event_type,
+        org: row.org_slug,
+        createdAt: row.created_at.toISOString(),
+        ...(row.app_slug !== null ? { app: row.app_slug } : {}),
+        ...(row.environment !== null ? { env: row.environment } : {}),
+        ...(row.deployment_id !== null ? { deploymentId: row.deployment_id } : {}),
+        ...(row.actor_subject !== null ? { actorSubject: row.actor_subject } : {}),
+        ...(row.actor_email !== null ? { actorEmail: row.actor_email } : {}),
+        ...(row.decision !== null ? { decision: row.decision } : {}),
+        ...(row.status !== null ? { status: row.status } : {}),
+        ...(row.reason_code !== null ? { reasonCode: row.reason_code } : {}),
+        ...(row.details !== null ? { details: row.details } : {}),
+    };
+}
+function validateSlug(label, value) {
+    if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(value)) {
+        throw new Error(`${label} must be a lowercase slug`);
+    }
+    return value;
+}
+//# sourceMappingURL=postgres-audit.js.map