@noodleseed/one 0.175.1 → 0.177.0

package/node_modules/@noodle-borg/assistant-gateway/dist/channel-coordinator.js

@@ -65,7 +65,15 @@ export class ChannelCoordinator {
             };
         });
     }
+    /** The binding that owns a provider phone-number asset, whatever its provider or state. */
+    async bindingForAsset(phoneNumberId) {
+        return this.store.transaction([CHANNEL_REGISTRY], (tx) => channelValue(tx, CHANNEL_REGISTRY, `asset:${channelDigest(phoneNumberId)}`));
+    }
     async configure(input, actor, key, revision) {
+        const meta = input.provider === 'meta';
+        // 360dialog authenticates callbacks per binding; Meta signs them with the app secret per WABA.
+        if (meta ? !input.wabaId || input.webhookSecret : !input.webhookSecret || input.wabaId)
+            throw new ChannelError('provider_configuration_invalid');
         const tenantKey = channelTenantKey(input.tenant);
         const priorId = await this.store.transaction([CHANNEL_REGISTRY], (tx) => channelValue(tx, CHANNEL_REGISTRY, tenantKey));
         const prior = priorId ? await this.internal(priorId) : undefined;
@@ -86,10 +94,11 @@ export class ChannelCoordinator {
             if (owner && owner !== id)
                 throw new ChannelError('asset_in_use');
             const now = this.now();
+            const { provider: _provider, ...configured } = input;
             const binding = {
-                ...input,
+                ...configured,
                 id,
-                provider: '360dialog',
+                provider: meta ? 'meta' : '360dialog',
                 revision: revision + 1,
                 generation: (existing?.generation ?? 0) + 1,
                 state: 'paused',

package/node_modules/@noodle-borg/assistant-gateway/dist/channel-types.d.ts

@@ -21,6 +21,8 @@ export type ChannelLimits = {
 export type ChannelLimitsInput = {
     [K in keyof ChannelLimits]?: number | undefined;
 };
+/** `360dialog` relays the Cloud API with a per-binding callback secret; `meta` is the Cloud API itself. */
+export type ChannelProvider = '360dialog' | 'meta';
 export type ChannelCapability = {
     readonly kind: 'tool' | 'knowledge';
     readonly name: string;
@@ -28,10 +30,14 @@ export type ChannelCapability = {
 export interface ChannelBinding {
     readonly id: string;
     readonly tenant: TenantRef;
-    readonly provider: '360dialog';
+    readonly provider: ChannelProvider;
     readonly phoneNumberId: string;
+    /** The WhatsApp Business Account that owns the number; present only for `meta`. */
+    readonly wabaId?: string | undefined;
+    /** Tenant secret name of the provider credential: 360dialog key or Meta business token. */
     readonly apiKeySecret: string;
-    readonly webhookSecret: string;
+    /** Tenant secret name of the per-binding callback secret; present only for `360dialog`. */
+    readonly webhookSecret?: string | undefined;
     readonly deploymentId: string;
     readonly capabilities: readonly ChannelCapability[];
     readonly supportEmail: string;
@@ -48,7 +54,9 @@ export interface ChannelBinding {
     readonly readyRevision?: number | undefined;
     readonly readyAt?: number | undefined;
 }
-export type ChannelConfigure = Pick<ChannelBinding, 'tenant' | 'phoneNumberId' | 'apiKeySecret' | 'webhookSecret' | 'deploymentId' | 'capabilities' | 'supportEmail'> & {
+export type ChannelConfigure = Pick<ChannelBinding, 'tenant' | 'phoneNumberId' | 'wabaId' | 'apiKeySecret' | 'webhookSecret' | 'deploymentId' | 'capabilities' | 'supportEmail'> & {
+    /** Defaults to `360dialog`. */
+    readonly provider?: ChannelProvider | undefined;
     readonly limits?: ChannelLimitsInput | undefined;
 };
 export interface ChannelAddress {
@@ -126,10 +134,11 @@ export declare function writeChannelEvent(tx: ChannelTransaction, scope: string,
 export declare function publicChannelBinding(binding: ChannelBinding): {
     id: string;
     tenant: TenantRef;
-    provider: "360dialog";
+    provider: ChannelProvider;
     phoneNumberId: string;
+    wabaId?: string | undefined;
     apiKeySecret: string;
-    webhookSecret: string;
+    webhookSecret?: string | undefined;
     deploymentId: string;
     capabilities: readonly ChannelCapability[];
     supportEmail: string;

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

@@ -48,14 +48,16 @@ export const CHANNELS_COMMAND = {
     arguments: [],
     flags: [],
     subcommands: [
-        group('whatsapp', 'Configure the 360dialog channel, test readiness, and control public messaging.', [
+        group('whatsapp', 'Configure a 360dialog or Meta Cloud API number, 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('provider', '360dialog (default) or meta for the Meta Cloud API.'),
                 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('waba-id', 'WhatsApp Business Account ID; required with --provider meta.'),
+                flag('api-key-secret', 'Managed secret name for the 360dialog key or the Meta business token.'),
+                flag('webhook-secret', 'Independent managed callback secret name; 360dialog only.'),
                 flag('capabilities', 'Comma-separated knowledge:name or tool:name selections.'),
                 flag('support-email', 'Contact shown when an answer cannot be completed.'),
                 ...limits,

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

@@ -0,0 +1,97 @@
+/** Staff conversation history operations (ADR 0241); imported by the solutions family. Data only. */
+import { INSTALLATION_ARGUMENT, OPTIONAL_FLAG, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+const paging = (maximum) => [
+    {
+        ...OPTIONAL_FLAG,
+        name: 'limit',
+        type: 'integer',
+        value: '<count>',
+        summary: 'Maximum conversations in this page.',
+        constraints: { minimum: 1, maximum },
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'cursor',
+        type: 'string',
+        value: '<cursor>',
+        summary: 'Opaque continuation from the prior page.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'channel',
+        type: 'string',
+        value: '<channel>',
+        summary: 'Only conversations from this channel.',
+        constraints: { choices: ['website', 'whatsapp'] },
+    },
+];
+const SELECTORS = ['conversation', 'customer', 'participant'];
+const SELECTOR_SUMMARIES = {
+    conversation: 'Conversation id to erase.',
+    customer: 'Verified customer reference whose conversations are erased.',
+    participant: 'WhatsApp participant reference whose conversations are erased.',
+};
+export const SOLUTION_CONVERSATIONS = {
+    name: 'conversations',
+    summary: 'Read, export and forget customer conversation history.',
+    arguments: [],
+    flags: [],
+    subcommands: [
+        {
+            name: 'list',
+            summary: 'List conversations with unexpired messages, newest first.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [...SOLUTION_COMMON_FLAGS, ...paging(100)],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'show',
+            summary: 'Show one conversation with its messages; the read is audited.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [
+                ...SOLUTION_COMMON_FLAGS,
+                {
+                    ...OPTIONAL_FLAG,
+                    required: true,
+                    name: 'conversation',
+                    type: 'string',
+                    value: '<id>',
+                    summary: 'Conversation id from conversations list.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'export',
+            summary: 'Export one page of conversations with messages (Owner or Administrator).',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [...SOLUTION_COMMON_FLAGS, ...paging(25)],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'forget',
+            summary: 'Erase one conversation, or every conversation of a customer or participant.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [
+                ...SOLUTION_COMMON_FLAGS,
+                ...SELECTORS.map((name) => ({
+                    ...OPTIONAL_FLAG,
+                    name,
+                    type: 'string',
+                    value: name === 'conversation' ? '<id>' : '<ref>',
+                    summary: SELECTOR_SUMMARIES[name],
+                    conflictsWith: SELECTORS.filter((other) => other !== name),
+                })),
+                {
+                    ...OPTIONAL_FLAG,
+                    name: 'confirm',
+                    type: 'boolean',
+                    required: true,
+                    summary: 'Confirm permanently erasing the selected conversation history.',
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+    ],
+};
+//# sourceMappingURL=catalog-data-solution-conversations.js.map

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

@@ -1,4 +1,5 @@
 /** Solution installation/operator catalog. Imports only dependency-free sibling data. */
+import { SOLUTION_CONVERSATIONS } from './catalog-data-solution-conversations.js';
 import { SOLUTION_DRAFTS } from './catalog-data-solution-drafts.js';
 import { AUTH_TOKEN, EXPECTED_REVISION, IDEMPOTENCY_KEY, INSTALLATION_ARGUMENT, JSON_FLAG, OPTIONAL_FLAG, PAGING_FLAGS, REQUIRED_ARGUMENT, SERVICE, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
 import { SOLUTION_PAGE } from './catalog-data-solution-page.js';
@@ -171,6 +172,7 @@ export const CATALOG_SOLUTIONS = {
                 },
             ],
         },
+        SOLUTION_CONVERSATIONS,
         {
             name: 'activity',
             summary: 'Inspect payload-free operation evidence and its retention policy.',

package/node_modules/@noodle-borg/knowledge-operations/dist/executor.d.ts

@@ -1,6 +1,6 @@
 /**
- * Runtime `search_<name>` execution (ADR 0202 amendment 2026-08-18): feature gate → bundled
- * BM25 for documents → bundled BM25 over the crawled site corpus → deterministic RRF fusion with
+ * Runtime `search_<name>` execution (ADR 0202 amendment 2026-08-18): bundled BM25 for documents
+ * → bundled BM25 over the crawled site corpus → deterministic RRF fusion with
  * the exact origin/path policy postfilter. Every query is in-process and free; the crawl-page
  * budget is enforced at crawl time (`crawl-lifecycle.ts`), not here. Before a component's first
  * completed crawl the site corpus is honestly empty, with the crawl state as the operator
@@ -8,7 +8,7 @@
  */
 import { type SearchHit } from '@noodle-borg/knowledge/portable';
 import type { KnowledgeDeployHooks } from './publication.js';
-import { type KnowledgeTenantRef } from './routes.js';
+import type { KnowledgeTenantRef } from './routes.js';
 /** The component facts the executor needs; a structural subset of the compiled component. */
 export interface KnowledgeSearchComponent {
     readonly name: string;
@@ -22,13 +22,11 @@ export interface KnowledgeSearchRequest {
     readonly limit?: number;
 }
 export interface KnowledgeSearchExecutor {
-    enabled(tenant: KnowledgeTenantRef): Promise<boolean>;
     /** Throws `KnowledgeError` or `SearchBudgetExhaustedError`; never returns partial truth. */
     search(tenant: KnowledgeTenantRef, component: KnowledgeSearchComponent, request: KnowledgeSearchRequest): Promise<readonly SearchHit[]>;
 }
 export interface KnowledgeSearchExecutorDeps {
     readonly hooks: KnowledgeDeployHooks;
-    readonly knowledgeEnabled: (tenant: KnowledgeTenantRef) => Promise<boolean>;
 }
 export declare function createKnowledgeSearchExecutor(deps: KnowledgeSearchExecutorDeps): KnowledgeSearchExecutor;
 //# sourceMappingURL=executor.d.ts.map

package/node_modules/@noodle-borg/knowledge-operations/dist/executor.js

@@ -1,6 +1,6 @@
 /**
- * Runtime `search_<name>` execution (ADR 0202 amendment 2026-08-18): feature gate → bundled
- * BM25 for documents → bundled BM25 over the crawled site corpus → deterministic RRF fusion with
+ * Runtime `search_<name>` execution (ADR 0202 amendment 2026-08-18): bundled BM25 for documents
+ * → bundled BM25 over the crawled site corpus → deterministic RRF fusion with
  * the exact origin/path policy postfilter. Every query is in-process and free; the crawl-page
  * budget is enforced at crawl time (`crawl-lifecycle.ts`), not here. Before a component's first
  * completed crawl the site corpus is honestly empty, with the crawl state as the operator
@@ -8,14 +8,9 @@
  */
 import { DEFAULT_RESULT_LIMIT, fuseHits, KnowledgeError, MAX_QUERY_CHARS, MAX_RESULT_LIMIT, MIN_QUERY_CHARS, MIN_RESULT_LIMIT, } from '@noodle-borg/knowledge/portable';
 import { searchSiteCorpus } from './crawl-lifecycle.js';
-import { knowledgeEnableCommand } from './routes.js';
 export function createKnowledgeSearchExecutor(deps) {
     return {
-        enabled: (tenant) => deps.knowledgeEnabled(tenant),
         async search(tenant, component, request) {
-            if (!(await deps.knowledgeEnabled(tenant))) {
-                throw new KnowledgeError('request', `knowledge is not enabled for this org/app/env; run: ${knowledgeEnableCommand(tenant)}`);
-            }
             if (request.query.length < MIN_QUERY_CHARS || request.query.length > MAX_QUERY_CHARS) {
                 throw new KnowledgeError('request', `query must be between ${MIN_QUERY_CHARS} and ${MAX_QUERY_CHARS} characters`);
             }

package/node_modules/@noodle-borg/knowledge-operations/dist/portable.d.ts

@@ -5,7 +5,7 @@ export { createKnowledgeSearchExecutor, type KnowledgeSearchComponent, type Know
 export { readBody, sendJson } from './http.js';
 export { type KnowledgeRouteRef, parseKnowledgePath } from './paths.js';
 export { createKnowledgeDeployHooks, type KnowledgeDeployFailure, type KnowledgeDeployHooks, KnowledgePublicationError, type KnowledgePublicationPlan, withKnowledgePublication, } from './publication.js';
-export { handleKnowledgeDocumentUpload, handleKnowledgePreflight, type KnowledgeRouteDeps, type KnowledgeTenantRef, knowledgeEnableCommand, knowledgeTenantKey, } from './routes.js';
+export { handleKnowledgeDocumentUpload, handleKnowledgePreflight, type KnowledgeRouteDeps, type KnowledgeTenantRef, knowledgeTenantKey, } from './routes.js';
 export { type BoundKnowledgeSearchPort, bindKnowledgeSearchPort, type KnowledgeSearchPortFactory, knowledgeSearchPortFactory, } from './search-port.js';
 export { budgetCeilingsResolver, buildKnowledgeRouteDeps, defaultKnowledgeStores, type KnowledgeServiceStores, wireKnowledge, } from './service-wiring.js';
 export { InMemoryKnowledgeStagingStore, type KnowledgeStagingStore, STAGING_TTL_MS, } from './staging-store.js';

package/node_modules/@noodle-borg/knowledge-operations/dist/portable.js

@@ -5,7 +5,7 @@ export { createKnowledgeSearchExecutor, } from './executor.js';
 export { readBody, sendJson } from './http.js';
 export { parseKnowledgePath } from './paths.js';
 export { createKnowledgeDeployHooks, KnowledgePublicationError, withKnowledgePublication, } from './publication.js';
-export { handleKnowledgeDocumentUpload, handleKnowledgePreflight, knowledgeEnableCommand, knowledgeTenantKey, } from './routes.js';
+export { handleKnowledgeDocumentUpload, handleKnowledgePreflight, knowledgeTenantKey, } from './routes.js';
 export { bindKnowledgeSearchPort, knowledgeSearchPortFactory, } from './search-port.js';
 export { budgetCeilingsResolver, buildKnowledgeRouteDeps, defaultKnowledgeStores, wireKnowledge, } from './service-wiring.js';
 export { InMemoryKnowledgeStagingStore, STAGING_TTL_MS, } from './staging-store.js';

package/node_modules/@noodle-borg/knowledge-operations/dist/publication.d.ts

@@ -51,7 +51,6 @@ export interface KnowledgeDeployHooks {
     sweep(): Promise<void>;
 }
 export declare function createKnowledgeDeployHooks(stores: KnowledgeServiceStores, options: {
-    readonly knowledgeEnabled: (tenant: KnowledgeTenantRef) => Promise<boolean>;
     /** Managed site datastore existence; when bound, a site() deploy fails before activation. */
     readonly siteProvisioned?: (tenant: KnowledgeTenantRef) => Promise<boolean>;
     /**

package/node_modules/@noodle-borg/knowledge-operations/dist/publication.js

@@ -5,7 +5,7 @@
  * the previous artifact + revision pair; retry is idempotent by content hash.
  */
 import { Bm25KnowledgeIndex, identityDocumentTextCodec, KnowledgeError, revisionContentHash, } from '@noodle-borg/knowledge/portable';
-import { knowledgeEnableCommand, knowledgeTenantKey } from './routes.js';
+import { knowledgeTenantKey } from './routes.js';
 /** Structured publication failure the registry maps onto its deploy error shape. */
 export class KnowledgePublicationError extends Error {
     errors;
@@ -84,15 +84,6 @@ export function createKnowledgeDeployHooks(stores, options) {
     const hooks = {
         async publish(tenant, deploymentId, components) {
             const withDocuments = components.filter((component) => component.documents.length > 0);
-            if (components.length > 0 && !(await options.knowledgeEnabled(tenant))) {
-                throw new KnowledgePublicationError([
-                    {
-                        code: 'knowledge_not_enabled',
-                        path: 'knowledge',
-                        message: `knowledge is not enabled for this org/app/env; run: ${knowledgeEnableCommand(tenant)}`,
-                    },
-                ]);
-            }
             const withSites = components.filter((component) => component.sites.length > 0);
             if (withSites.length > 0 && options.siteProvisioned !== undefined) {
                 if (!(await options.siteProvisioned(tenant))) {

package/node_modules/@noodle-borg/knowledge-operations/dist/routes.d.ts

@@ -8,8 +8,6 @@ export interface KnowledgeTenantRef {
 }
 export interface KnowledgeRouteDeps {
     readonly staging: KnowledgeStagingStore;
-    /** Managed-config feature gate (`NOODLE_KNOWLEDGE_ENABLED`), resolved org → app → env. */
-    readonly knowledgeEnabled: (tenant: KnowledgeTenantRef) => Promise<boolean>;
     readonly maxBodyBytes: number;
     /** Seals staged bytes at rest; the service injects its secret-box codec. */
     readonly codec?: DocumentTextCodec;
@@ -17,8 +15,6 @@ export interface KnowledgeRouteDeps {
     readonly status?: import('./status-routes.js').KnowledgeStatusDeps;
 }
 export declare function knowledgeTenantKey(tenant: KnowledgeTenantRef): string;
-/** The one command that turns the feature on for a tenant; every fail-closed error names it. */
-export declare function knowledgeEnableCommand(tenant: KnowledgeTenantRef): string;
 /**
  * `POST /v1/orgs/{o}/apps/{a}/envs/{e}/knowledge/preflight` — diff declared document hashes
  * against transient staging and published revisions; respond with exactly the hashes that

package/node_modules/@noodle-borg/knowledge-operations/dist/routes.js

@@ -1,7 +1,7 @@
 /**
  * Knowledge control-plane route handlers (ADR 0202 as amended). The service dispatch
  * authorizes the request and parses the tenant path, then delegates here; these handlers own
- * validation, the feature gate, staging, and wire shapes — never auth.
+ * validation, staging, and wire shapes — never auth.
  */
 import { createHash } from 'node:crypto';
 import { MAX_DOCUMENT_BYTES } from '@noodle-borg/knowledge/limits';
@@ -11,18 +11,6 @@ import { readBody, sendJson } from './http.js';
 export function knowledgeTenantKey(tenant) {
     return `${tenant.org}/${tenant.app}/${tenant.env}`;
 }
-/** The one command that turns the feature on for a tenant; every fail-closed error names it. */
-export function knowledgeEnableCommand(tenant) {
-    return (`noodle variables set NOODLE_KNOWLEDGE_ENABLED --value true --runtime cloud ` +
-        `--scope env --org ${tenant.org} --app ${tenant.app} --env ${tenant.env}`);
-}
-function sendGateClosed(res, tenant) {
-    sendJson(res, 403, {
-        code: 'knowledge_not_enabled',
-        error: 'knowledge is not enabled for this org/app/env',
-        fix: knowledgeEnableCommand(tenant),
-    });
-}
 const SHA256_HEX = /^[0-9a-f]{64}$/;
 /**
  * `POST /v1/orgs/{o}/apps/{a}/envs/{e}/knowledge/preflight` — diff declared document hashes
@@ -30,8 +18,6 @@ const SHA256_HEX = /^[0-9a-f]{64}$/;
  * still need bytes. Descriptors only; no contents cross this route.
  */
 export async function handleKnowledgePreflight(req, res, tenant, deps) {
-    if (!(await deps.knowledgeEnabled(tenant)))
-        return sendGateClosed(res, tenant);
     const body = await readBody(req, deps.maxBodyBytes);
     if (!body.ok)
         return sendJson(res, body.status, { error: body.error });
@@ -74,8 +60,6 @@ export async function handleKnowledgePreflight(req, res, tenant, deps) {
  * the service verifies declared length and hash before publication).
  */
 export async function handleKnowledgeDocumentUpload(req, res, tenant, sha256, deps) {
-    if (!(await deps.knowledgeEnabled(tenant)))
-        return sendGateClosed(res, tenant);
     if (!SHA256_HEX.test(sha256)) {
         return sendJson(res, 400, {
             code: 'invalid_knowledge_request',

package/node_modules/@noodle-borg/knowledge-operations/dist/search-port.d.ts

@@ -8,7 +8,6 @@ import { type SearchHit } from '@noodle-borg/knowledge/portable';
 import type { KnowledgeSearchComponent, KnowledgeSearchExecutor } from './executor.js';
 import type { KnowledgeTenantRef } from './routes.js';
 export interface BoundKnowledgeSearchPort {
-    enabled(): Promise<boolean>;
     search(componentName: string, request: {
         readonly query: string;
         readonly limit?: number;
@@ -17,7 +16,7 @@ export interface BoundKnowledgeSearchPort {
         readonly hits: readonly SearchHit[];
     } | {
         readonly ok: false;
-        readonly reason: 'budget_exhausted' | 'not_enabled' | 'provider_error';
+        readonly reason: 'budget_exhausted' | 'provider_error';
         readonly message: string;
     }>;
 }

package/node_modules/@noodle-borg/knowledge-operations/dist/search-port.js

@@ -10,7 +10,6 @@ export function knowledgeSearchPortFactory(executor) {
 }
 export function bindKnowledgeSearchPort(executor, tenant, components) {
     return {
-        enabled: () => executor.enabled(tenant),
         async search(componentName, request) {
             const component = components.find((candidate) => candidate.name === componentName);
             if (component === undefined) {
@@ -25,8 +24,7 @@ export function bindKnowledgeSearchPort(executor, tenant, components) {
                     return { ok: false, reason: 'budget_exhausted', message: error.message };
                 }
                 if (error instanceof KnowledgeError) {
-                    const reason = error.layer === 'request' ? 'not_enabled' : 'provider_error';
-                    return { ok: false, reason, message: error.message };
+                    return { ok: false, reason: 'provider_error', message: error.message };
                 }
                 return { ok: false, reason: 'provider_error', message: 'knowledge search failed' };
             }

package/node_modules/@noodle-borg/knowledge-operations/dist/service-wiring.d.ts

@@ -20,8 +20,8 @@ export interface KnowledgeServiceStores {
     readonly crawlState?: CrawlStateStore;
     /**
      * Composition seams for tests and BYO providers: fetcher selection defaults to the managed
-     * first-party crawler; the deploy gate defaults to always-provisioned (the managed crawler
-     * needs no provisioning — BYO configuration checks bind here).
+     * first-party crawler; the managed crawler needs no provisioning and BYO configuration checks
+     * bind here.
      */
     readonly fetcherFor?: (tenant: KnowledgeTenantRef, component: CrawlableComponent) => SiteFetcher;
     /** BYO index selection override; defaults to declaration-driven provider adapters. */
@@ -32,8 +32,8 @@ export interface KnowledgeServiceStores {
 export declare function defaultKnowledgeStores(): KnowledgeServiceStores;
 /** Budget ceilings from managed config with the ratified v0 defaults (2000 org / 1000 app). */
 export declare function budgetCeilingsResolver(resolveVariables: (tenant: KnowledgeTenantRef) => Promise<Record<string, string>>): (tenant: KnowledgeTenantRef) => Promise<SearchBudgetCeilings>;
-/** Assemble route deps over the service's managed-config resolver (`NOODLE_KNOWLEDGE_ENABLED`). */
-export declare function buildKnowledgeRouteDeps(stores: KnowledgeServiceStores, resolveVariables: (tenant: KnowledgeTenantRef) => Promise<Record<string, string>>, maxBodyBytes: number): KnowledgeRouteDeps;
+/** Assemble the always-available knowledge route dependencies. */
+export declare function buildKnowledgeRouteDeps(stores: KnowledgeServiceStores, maxBodyBytes: number): KnowledgeRouteDeps;
 /** Map a compiled index declaration plus resolved config values onto its provider adapter. */
 export declare function knowledgeIndexFromDeclaration(declaration: NonNullable<CompiledKnowledgeComponent['index']>, config: Readonly<Record<string, string>>, scope: KnowledgeScope): KnowledgeIndex;
 /**

package/node_modules/@noodle-borg/knowledge-operations/dist/service-wiring.js

@@ -32,11 +32,10 @@ export function budgetCeilingsResolver(resolveVariables) {
         };
     };
 }
-/** Assemble route deps over the service's managed-config resolver (`NOODLE_KNOWLEDGE_ENABLED`). */
-export function buildKnowledgeRouteDeps(stores, resolveVariables, maxBodyBytes) {
+/** Assemble the always-available knowledge route dependencies. */
+export function buildKnowledgeRouteDeps(stores, maxBodyBytes) {
     return {
         staging: stores.staging,
-        knowledgeEnabled: async (tenant) => (await resolveVariables(tenant)).NOODLE_KNOWLEDGE_ENABLED === 'true',
         maxBodyBytes,
         ...(stores.codec === undefined ? {} : { codec: stores.codec }),
     };
@@ -61,7 +60,7 @@ export function knowledgeIndexFromDeclaration(declaration, config, scope) {
  */
 export function wireKnowledge(registry, stores, resolveVariables, maxBodyBytes, resolveSecrets = async () => ({})) {
     const resolved = stores ?? defaultKnowledgeStores();
-    const deps = buildKnowledgeRouteDeps(resolved, resolveVariables, maxBodyBytes);
+    const deps = buildKnowledgeRouteDeps(resolved, maxBodyBytes);
     const ceilings = budgetCeilingsResolver(resolveVariables);
     // The managed first-party crawler needs no provisioning, so the deploy gate defaults open;
     // BYO provider configuration checks replace this seam when a component declares a provider.
@@ -117,7 +116,6 @@ export function wireKnowledge(registry, stores, resolveVariables, maxBodyBytes,
         return knowledgeIndexFromDeclaration(resolvedDeclaration, config, scope);
     };
     const hooks = createKnowledgeDeployHooks(resolved, {
-        knowledgeEnabled: deps.knowledgeEnabled,
         siteProvisioned,
         indexFor: resolved.indexFor ?? defaultIndexFor,
     });
@@ -146,12 +144,10 @@ export function wireKnowledge(registry, stores, resolveVariables, maxBodyBytes,
     };
     const bareExecutor = createKnowledgeSearchExecutor({
         hooks,
-        knowledgeEnabled: deps.knowledgeEnabled,
     });
     // Refresh-on-traffic: serving a sites component also checks whether its refresh is due and
     // kicks the crawl in the background — the visitor's answer never waits on it.
     const executor = {
-        enabled: bareExecutor.enabled,
         search: async (tenant, component, request) => {
             const hits = await bareExecutor.search(tenant, component, request);
             if (component.sites.length > 0) {
@@ -182,7 +178,6 @@ export function wireKnowledge(registry, stores, resolveVariables, maxBodyBytes,
     registry.setKnowledgeDeployHooks(crawlingHooks, knowledgeSearchPortFactory(executor));
     const status = {
         revisionStore: resolved.revisionStore,
-        knowledgeEnabled: deps.knowledgeEnabled,
         crawlState: (tenant, componentName) => crawlState.get(tenant, componentName),
         refresh: (tenant, component) => runComponentCrawl(crawlDeps, tenant, component),
         // Mirrors the fail-closed deploy gate above: without the managed project every site() is

package/node_modules/@noodle-borg/knowledge-operations/dist/status-routes.d.ts

@@ -7,10 +7,9 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { CompiledKnowledgeComponent, KnowledgeRevisionStore } from '@noodle-borg/knowledge/portable';
 import type { KnowledgeBudgetState, KnowledgeCrawlState } from '@noodle-borg/wire-contracts';
-import { type KnowledgeTenantRef } from './routes.js';
+import type { KnowledgeTenantRef } from './routes.js';
 export interface KnowledgeStatusDeps {
     readonly revisionStore: KnowledgeRevisionStore;
-    readonly knowledgeEnabled: (tenant: KnowledgeTenantRef) => Promise<boolean>;
     /** The active deployment's compiled knowledge components, or undefined when none is active. */
     readonly activeKnowledge: (tenant: KnowledgeTenantRef) => Promise<{
         readonly components: readonly CompiledKnowledgeComponent[];

package/node_modules/@noodle-borg/knowledge-operations/dist/status-routes.js

@@ -1,12 +1,4 @@
 import { sendJson } from './http.js';
-import { knowledgeEnableCommand } from './routes.js';
-function gateClosed(res, tenant) {
-    sendJson(res, 403, {
-        code: 'knowledge_not_enabled',
-        error: 'knowledge is not enabled for this org/app/env',
-        fix: knowledgeEnableCommand(tenant),
-    });
-}
 async function componentSummary(tenant, component, deploymentId, revisionStore) {
     const scope = { org: tenant.org, app: tenant.app, env: tenant.env };
     const active = component.documents.length > 0 ? await revisionStore.active(scope, component.name) : undefined;
@@ -22,8 +14,6 @@ async function componentSummary(tenant, component, deploymentId, revisionStore)
 }
 /** `GET /v1/orgs/{o}/apps/{a}/envs/{e}/knowledge` */
 export async function handleKnowledgeList(_req, res, tenant, deps) {
-    if (!(await deps.knowledgeEnabled(tenant)))
-        return gateClosed(res, tenant);
     const active = await deps.activeKnowledge(tenant);
     const components = [];
     for (const component of active?.components ?? []) {
@@ -38,8 +28,6 @@ export async function handleKnowledgeList(_req, res, tenant, deps) {
 }
 /** `GET /v1/orgs/{o}/apps/{a}/envs/{e}/knowledge/{name}/status` */
 export async function handleKnowledgeStatus(_req, res, tenant, componentName, deps) {
-    if (!(await deps.knowledgeEnabled(tenant)))
-        return gateClosed(res, tenant);
     const active = await deps.activeKnowledge(tenant);
     const component = active?.components.find((candidate) => candidate.name === componentName);
     if (active === undefined || component === undefined) {
@@ -70,8 +58,6 @@ export async function handleKnowledgeStatus(_req, res, tenant, componentName, de
  * The outcome (including failures) is the returned crawl state, never a thrown error.
  */
 export async function handleKnowledgeRefresh(_req, res, tenant, componentName, deps) {
-    if (!(await deps.knowledgeEnabled(tenant)))
-        return gateClosed(res, tenant);
     const active = await deps.activeKnowledge(tenant);
     const component = active?.components.find((candidate) => candidate.name === componentName);
     if (component === undefined || deps.refresh === undefined) {

package/node_modules/@noodle-borg/protocol/dist/knowledge-tool.js

@@ -2,20 +2,18 @@ import { coerceToolArguments } from './input-validation.js';
 export function findKnowledgeComponent(artifact, toolName) {
     return artifact.server.knowledge?.find((component) => component.generatedTool.name === toolName);
 }
-/** Listing predicate: the artifact declares knowledge AND the deployment's port is live. */
+/** Listing predicate: the artifact declares knowledge and the deployment has a search port. */
 export async function knowledgeToolsEnabled(artifact, deps) {
     if ((artifact.server.knowledge?.length ?? 0) === 0)
         return false;
-    if (deps.knowledgeSearch === undefined)
-        return false;
-    return deps.knowledgeSearch.enabled();
+    return deps.knowledgeSearch !== undefined;
 }
 export async function runKnowledgeSearchTool(component, deps, rawArguments) {
     const coerced = coerceToolArguments(component.generatedTool.inputSchema, rawArguments);
     if (coerced.issues.length > 0)
         return { kind: 'invalid', issues: coerced.issues };
     if (deps.knowledgeSearch === undefined) {
-        return { kind: 'error', reason: 'not_enabled', message: 'knowledge search is unavailable' };
+        return { kind: 'error', reason: 'provider_error', message: 'knowledge search is unavailable' };
     }
     const request = coerced.value;
     const outcome = await deps.knowledgeSearch.search(component.name, request);

package/node_modules/@noodle-borg/runtime/dist/execute.d.ts

@@ -61,10 +61,9 @@ export interface KnowledgeSearchHit {
 }
 /**
  * Deployment-bound knowledge retrieval port (structural; the service adapts its executor).
- * `enabled` gates listing as well as calls — a disabled surface lists no knowledge tools.
+ * Presence of the port makes declared knowledge tools available.
  */
 export interface KnowledgeSearchPort {
-    enabled(): Promise<boolean>;
     search(componentName: string, request: {
         readonly query: string;
         readonly limit?: number | undefined;
@@ -73,7 +72,7 @@ export interface KnowledgeSearchPort {
         readonly hits: readonly KnowledgeSearchHit[];
     } | {
         readonly ok: false;
-        readonly reason: 'budget_exhausted' | 'not_enabled' | 'provider_error';
+        readonly reason: 'budget_exhausted' | 'provider_error';
         readonly message: string;
     }>;
 }

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

@@ -1,3 +1,4 @@
+import { ConversationCapture } from './conversation-history/capture.js';
 /** Browser and messaging resolve model, execution and tenant policy from one composition. */
 export function assistantRouteDependencies(options, core) {
     return {
@@ -13,6 +14,14 @@ export function assistantRouteDependencies(options, core) {
             : {}),
         ...(options.captureRequestEvent ? { captureRequestEvent: options.captureRequestEvent } : {}),
         ...(options.clock ? { clock: options.clock } : {}),
+        ...(options.conversationHistory
+            ? {
+                conversations: new ConversationCapture(options.conversationHistory.store, options.conversationHistory.policy, {
+                    now: () => (options.clock?.() ?? new Date()).getTime(),
+                    ...(core.logger ? { logger: core.logger } : {}),
+                }),
+            }
+            : {}),
     };
 }
 //# sourceMappingURL=assistant-composition.js.map