@noodleseed/one 0.169.0 → 0.170.0

package/node_modules/@noodle-borg/managed-capabilities/dist/operator-route.js

@@ -0,0 +1,160 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { CapabilityBudget } from './budget.js';
+import { webCapabilityBaseSchema } from './contracts.js';
+import { CapabilityError } from './errors.js';
+import { capabilityInspectionSchema, capabilityListResponseSchema, capabilityPolicyUpdateSchema, capabilityScopeSchema, capabilityTestRequestSchema, capabilityTestResponseSchema, } from './operator-contracts.js';
+import { CapabilityPolicyConflict } from './policy-store.js';
+const path = /^\/v1\/orgs\/([^/]+)\/apps\/([^/]+)\/envs\/([^/]+)\/capabilities(?:\/([^/]+)(?:\/(policy|test))?)?$/;
+/** Operator diagnostic commands share policy/admission; they never expose source bodies. */
+export function capabilityOperatorRoute(service) {
+    return {
+        id: 'managed-capabilities',
+        match: (_method, url) => path.test(url.pathname),
+        handle: async (req, res, ctx) => {
+            try {
+                const match = path.exec(new URL(req.url ?? '/', 'http://service.invalid').pathname);
+                if (!match)
+                    return send(res, 404, { error: 'not_found' });
+                const scope = capabilityScopeSchema.parse({
+                    org: match[1],
+                    app: match[2],
+                    env: match[3],
+                    name: match[4] ?? 'list',
+                });
+                const { name, ...tenant } = scope;
+                const action = match[5];
+                const reading = req.method === 'GET' && action === undefined;
+                if (!reading &&
+                    !(req.method === 'PUT' && action === 'policy') &&
+                    !(req.method === 'POST' && action === 'test')) {
+                    return send(res, 405, { error: 'method_not_allowed' });
+                }
+                const auth = await ctx.tenantControl?.authorize(req, {
+                    org: scope.org,
+                    permission: reading ? 'org:member' : 'org:manage',
+                });
+                if (auth?.ok !== true || auth.identity === undefined)
+                    return send(res, auth?.ok === false ? auth.status : 401, {
+                        error: 'capability_forbidden',
+                    });
+                const target = await ctx.capabilityDeployments?.get(req, tenant);
+                if (target === undefined)
+                    return send(res, 404, { error: 'deployment_not_found' });
+                // The service has already compiled and authorized these declarations. Diagnostics need only intent.
+                const declarations = target.declarations.map((raw) => webCapabilityBaseSchema.strip().parse(raw));
+                if (match[4] === undefined) {
+                    return send(res, 200, capabilityListResponseSchema.parse({
+                        deploymentId: target.deploymentId,
+                        capabilities: await Promise.all(declarations.map((d) => service.inspect(tenant, d))),
+                    }));
+                }
+                const declaration = declarations.find((d) => d.name === name);
+                if (declaration === undefined)
+                    return send(res, 404, { error: 'capability_not_found' });
+                if (reading)
+                    return send(res, 200, capabilityInspectionSchema.parse(await service.inspect(tenant, declaration)));
+                const body = await jsonBody(req);
+                if (action === 'policy') {
+                    const update = capabilityPolicyUpdateSchema.parse(body);
+                    const record = await service.configure(tenant, declaration, {
+                        ...update,
+                        actor: auth.identity.subject,
+                    });
+                    await ctx.audit?.emit({
+                        eventType: 'capability.policy.updated',
+                        ...tenant,
+                        actorSubject: auth.identity.subject,
+                        deploymentId: target.deploymentId,
+                        details: { name, revision: record.revision, enabled: record.policy.enabled },
+                    });
+                    return send(res, 200, capabilityInspectionSchema.parse(await service.inspect(tenant, declaration)));
+                }
+                const test = capabilityTestRequestSchema.parse(body);
+                const cancelled = new AbortController();
+                const abort = () => cancelled.abort();
+                req.once('aborted', abort);
+                res.once('close', abort);
+                try {
+                    const result = await service.execute(declaration, test.request, {
+                        tenant,
+                        deploymentId: target.deploymentId,
+                        executionId: randomUUID(),
+                        subject: auth.identity.subject,
+                        anonymous: false,
+                        authorized: true,
+                        budget: new CapabilityBudget(),
+                        signal: cancelled.signal,
+                    }, test.mode === 'fixture'
+                        ? {
+                            read: async ({ url }) => ({
+                                url,
+                                title: 'Diagnostic fixture',
+                                text: 'Synthetic diagnostic evidence. No website was fetched.',
+                                links: [],
+                                retrievedAt: new Date().toISOString(),
+                            }),
+                        }
+                        : undefined);
+                    return send(res, 200, capabilityTestResponseSchema.parse({
+                        mode: test.mode,
+                        status: result.status,
+                        pages: result.items.length,
+                        sources: result.sources.map(({ ref, url, retrievedAt }) => ({
+                            ref,
+                            url,
+                            retrievedAt,
+                        })),
+                        warnings: result.warnings,
+                    }));
+                }
+                finally {
+                    req.off('aborted', abort);
+                    res.off('close', abort);
+                }
+            }
+            catch (error) {
+                const status = error instanceof CapabilityPolicyConflict
+                    ? 409
+                    : error instanceof z.ZodError
+                        ? 400
+                        : error instanceof CapabilityError
+                            ? 422
+                            : 503;
+                send(res, status, {
+                    error: error instanceof CapabilityPolicyConflict
+                        ? 'capability_policy_conflict'
+                        : error instanceof z.ZodError
+                            ? 'invalid_request'
+                            : error instanceof CapabilityError
+                                ? error.code
+                                : 'capability_unavailable',
+                });
+            }
+        },
+    };
+}
+async function jsonBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const raw of req) {
+        const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+        size += chunk.length;
+        if (size > 16_384)
+            throw new CapabilityError('capability_source_rejected');
+        chunks.push(chunk);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new CapabilityError('capability_source_rejected');
+    }
+}
+function send(res, status, value) {
+    if (res.destroyed || res.writableEnded)
+        return;
+    res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+    res.end(JSON.stringify(value));
+}
+//# sourceMappingURL=operator-route.js.map

package/node_modules/@noodle-borg/managed-capabilities/dist/policy-store.d.ts

@@ -0,0 +1,34 @@
+import { type CapabilityPolicyRecord, type CapabilityPolicyUpdate, type CapabilityScope } from './operator-contracts.js';
+export * from './operator-contracts.js';
+export interface CapabilityPolicyStore {
+    readonly durable: boolean;
+    get(scope: CapabilityScope): Promise<CapabilityPolicyRecord | undefined>;
+    replace(scope: CapabilityScope, update: CapabilityPolicyUpdate): Promise<CapabilityPolicyRecord>;
+}
+export declare class CapabilityPolicyConflict extends Error {
+    constructor();
+}
+export declare function capabilityScopeKey(scope: CapabilityScope): string;
+export declare function checkedPolicyUpdate(update: CapabilityPolicyUpdate): {
+    actor: string;
+    fingerprint: string;
+    expectedRevision: number;
+    mutationId: string;
+    policy: {
+        enabled: boolean;
+        dailyCalls: number;
+        maxUrls?: number | undefined;
+        maxCalls?: number | undefined;
+        timeoutMs?: number | undefined;
+        maxTextBytes?: number | undefined;
+        domains?: string[] | undefined;
+    };
+};
+/** Development/test only. Hosted composition rejects a non-durable policy or counter store. */
+export declare class InMemoryCapabilityPolicyStore implements CapabilityPolicyStore {
+    #private;
+    readonly durable = false;
+    get(scope: CapabilityScope): Promise<CapabilityPolicyRecord | undefined>;
+    replace(scope: CapabilityScope, input: CapabilityPolicyUpdate): Promise<CapabilityPolicyRecord>;
+}
+//# sourceMappingURL=policy-store.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/policy-store.js

@@ -0,0 +1,61 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { capabilityPolicyUpdateSchema, capabilityScopeSchema, } from './operator-contracts.js';
+export * from './operator-contracts.js';
+export class CapabilityPolicyConflict extends Error {
+    constructor() {
+        super('capability_policy_conflict');
+    }
+}
+export function capabilityScopeKey(scope) {
+    const parsed = capabilityScopeSchema.parse(scope);
+    return JSON.stringify([
+        parsed.org,
+        parsed.app,
+        parsed.env,
+        `capability.web-extract.${parsed.name}.provider`,
+    ]);
+}
+export function checkedPolicyUpdate(update) {
+    const { actor, ...body } = update;
+    const parsed = capabilityPolicyUpdateSchema.parse(body);
+    z.string().min(1).max(512).parse(actor);
+    const fingerprint = createHash('sha256')
+        .update(JSON.stringify({ ...parsed, actor }))
+        .digest('hex');
+    return { ...parsed, actor, fingerprint };
+}
+/** Development/test only. Hosted composition rejects a non-durable policy or counter store. */
+export class InMemoryCapabilityPolicyStore {
+    durable = false;
+    #records = new Map();
+    async get(scope) {
+        const entry = this.#records.get(capabilityScopeKey(scope));
+        return entry === undefined ? undefined : structuredClone(entry.record);
+    }
+    async replace(scope, input) {
+        const key = capabilityScopeKey(scope);
+        const update = checkedPolicyUpdate(input);
+        const prior = this.#records.get(key);
+        if (prior?.mutationId === update.mutationId) {
+            if (prior.fingerprint !== update.fingerprint)
+                throw new CapabilityPolicyConflict();
+            return structuredClone(prior.record);
+        }
+        if ((prior?.record.revision ?? 0) !== update.expectedRevision)
+            throw new CapabilityPolicyConflict();
+        const record = {
+            revision: update.expectedRevision + 1,
+            policy: update.policy,
+            actor: update.actor,
+            updatedAt: new Date().toISOString(),
+        };
+        this.#records.set(key, {
+            record,
+            mutationId: update.mutationId,
+            fingerprint: update.fingerprint,
+        });
+        return structuredClone(record);
+    }
+}
+//# sourceMappingURL=policy-store.js.map

package/node_modules/@noodle-borg/managed-capabilities/dist/portable.d.ts

@@ -0,0 +1,10 @@
+export { CapabilityBudget, type CapabilityBudgetSnapshot } from './budget.js';
+export * from './contracts.js';
+export { CAPABILITY_ERROR_CODES, CapabilityError, type CapabilityErrorCode } from './errors.js';
+export { effectiveWebPolicy, executeWebExtract, type PublicPageReaderPort, type WebExtractDeps, } from './executor.js';
+export { WEB_EXTRACT_LIMITS } from './limits.js';
+export { capabilityOperatorRoute } from './operator-route.js';
+export * from './policy-store.js';
+export { type CapabilityInvocation, CapabilityService, type CapabilityServiceOptions, } from './service.js';
+export { publicPageUrl } from './urls.js';
+//# sourceMappingURL=portable.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/portable.js

@@ -0,0 +1,10 @@
+export { CapabilityBudget } from './budget.js';
+export * from './contracts.js';
+export { CAPABILITY_ERROR_CODES, CapabilityError } from './errors.js';
+export { effectiveWebPolicy, executeWebExtract, } from './executor.js';
+export { WEB_EXTRACT_LIMITS } from './limits.js';
+export { capabilityOperatorRoute } from './operator-route.js';
+export * from './policy-store.js';
+export { CapabilityService, } from './service.js';
+export { publicPageUrl } from './urls.js';
+//# sourceMappingURL=portable.js.map

package/node_modules/@noodle-borg/managed-capabilities/dist/service.d.ts

@@ -0,0 +1,83 @@
+import type { AtomicDailyCounterStore } from '@noodle-borg/admission-limits/portable';
+import type { CapabilityBudget } from './budget.js';
+import type { WebCapability, WebExtractResult } from './contracts.js';
+import { type PublicPageReaderPort } from './executor.js';
+import { type CapabilityPolicyStore, type CapabilityPolicyUpdate, type CapabilityScope } from './policy-store.js';
+type Tenant = Pick<CapabilityScope, 'org' | 'app' | 'env'>;
+export interface CapabilityServiceOptions {
+    readonly profile: 'development' | 'hosted';
+    readonly policies: CapabilityPolicyStore;
+    readonly counters: AtomicDailyCounterStore;
+    readonly reader: PublicPageReaderPort;
+    /** Exact hosted cohort targets. Empty or absent disables all hosted extraction. */
+    readonly enabledScopes?: readonly Tenant[];
+    readonly audit?: (fields: Readonly<Record<string, string | number | boolean>> & Tenant) => void | Promise<void>;
+}
+export interface CapabilityInvocation {
+    readonly tenant: Tenant;
+    readonly deploymentId: string;
+    readonly executionId: string;
+    readonly subject?: string;
+    readonly anonymous: boolean;
+    readonly network?: string;
+    readonly authorized: boolean;
+    readonly budget: CapabilityBudget;
+    readonly signal?: AbortSignal;
+}
+/** Policy/admission authority shared by normal tools and operator diagnostics. Never resolves a model. */
+export declare class CapabilityService {
+    readonly options: CapabilityServiceOptions;
+    constructor(options: CapabilityServiceOptions);
+    enabled(tenant: Tenant): boolean;
+    inspect(tenant: Tenant, declaration: WebCapability): Promise<{
+        actor?: string;
+        updatedAt?: string;
+        name: string;
+        class: "web.extract.v1";
+        title: string;
+        serviceKey: string;
+        available: boolean;
+        profile: string;
+        revision: number;
+        developerPolicy: {
+            maxUrls?: number | undefined;
+            maxCalls?: number | undefined;
+            timeoutMs?: number | undefined;
+            maxTextBytes?: number | undefined;
+            domains?: string[] | undefined;
+        };
+        operatorPolicy: {
+            enabled: boolean;
+            dailyCalls: number;
+            maxUrls?: number | undefined;
+            maxCalls?: number | undefined;
+            timeoutMs?: number | undefined;
+            maxTextBytes?: number | undefined;
+            domains?: string[] | undefined;
+        };
+        effectivePolicy: {
+            maxUrls?: number | undefined;
+            maxCalls?: number | undefined;
+            timeoutMs?: number | undefined;
+            maxTextBytes?: number | undefined;
+            domains?: string[] | undefined;
+        };
+    }>;
+    configure(tenant: Tenant, declaration: WebCapability, update: CapabilityPolicyUpdate): Promise<{
+        revision: number;
+        policy: {
+            enabled: boolean;
+            dailyCalls: number;
+            maxUrls?: number | undefined;
+            maxCalls?: number | undefined;
+            timeoutMs?: number | undefined;
+            maxTextBytes?: number | undefined;
+            domains?: string[] | undefined;
+        };
+        actor: string;
+        updatedAt: string;
+    }>;
+    execute(declaration: WebCapability, input: unknown, context: CapabilityInvocation, reader?: PublicPageReaderPort): Promise<WebExtractResult>;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/service.js

@@ -0,0 +1,139 @@
+import { createHash } from 'node:crypto';
+import { CapabilityError } from './errors.js';
+import { effectiveWebPolicy, executeWebExtract } from './executor.js';
+import { WEB_EXTRACT_LIMITS } from './limits.js';
+import { capabilityScopeKey, } from './policy-store.js';
+/** Policy/admission authority shared by normal tools and operator diagnostics. Never resolves a model. */
+export class CapabilityService {
+    options;
+    constructor(options) {
+        this.options = options;
+        if (options.profile === 'hosted' && (!options.policies.durable || !options.counters.durable)) {
+            throw new Error('capability_durable_authority_required');
+        }
+    }
+    enabled(tenant) {
+        return (this.options.profile === 'development' ||
+            (this.options.enabledScopes ?? []).some((scope) => scope.org === tenant.org && scope.app === tenant.app && scope.env === tenant.env));
+    }
+    async inspect(tenant, declaration) {
+        const record = await this.options.policies.get({ ...tenant, name: declaration.name });
+        const operator = record === undefined ? {} : policyBounds(record.policy);
+        return {
+            name: declaration.name,
+            class: declaration.class,
+            title: declaration.title,
+            serviceKey: `capability.web-extract.${declaration.name}.provider`,
+            available: this.enabled(tenant) && record?.policy.enabled === true,
+            profile: this.options.profile === 'hosted' ? 'managed-learning-cohort' : 'local-first-party',
+            revision: record?.revision ?? 0,
+            developerPolicy: declaration.policy ?? {},
+            operatorPolicy: record?.policy ?? { enabled: false, dailyCalls: 100 },
+            effectivePolicy: effectiveWebPolicy(declaration.policy, operator),
+            ...(record === undefined ? {} : { actor: record.actor, updatedAt: record.updatedAt }),
+        };
+    }
+    async configure(tenant, declaration, update) {
+        const effective = effectiveWebPolicy(declaration.policy, policyBounds(update.policy));
+        for (const key of ['maxUrls', 'maxCalls', 'timeoutMs', 'maxTextBytes']) {
+            if (update.policy[key] !== undefined && update.policy[key] !== effective[key])
+                throw new CapabilityError('capability_policy_denied');
+        }
+        if (update.policy.domains?.some((host) => !effective.domains?.includes(host)))
+            throw new CapabilityError('capability_policy_denied');
+        return this.options.policies.replace({ ...tenant, name: declaration.name }, update);
+    }
+    async execute(declaration, input, context, reader = this.options.reader) {
+        const scope = { ...context.tenant, name: declaration.name };
+        if (!this.enabled(context.tenant))
+            throw new CapabilityError('capability_unavailable');
+        let record;
+        try {
+            record = await this.options.policies.get(scope);
+        }
+        catch {
+            throw new CapabilityError('capability_unavailable');
+        }
+        if (record?.policy.enabled !== true)
+            throw new CapabilityError('capability_unavailable');
+        if (context.anonymous && !context.network)
+            throw new CapabilityError('capability_policy_denied');
+        if (!context.anonymous && !context.subject)
+            throw new CapabilityError('capability_policy_denied');
+        const scopeId = opaque(capabilityScopeKey(scope));
+        const amount = WEB_EXTRACT_LIMITS.maxHttpAttempts;
+        const attribution = context.anonymous
+            ? `network:${context.network}`
+            : `subject:${context.subject}`;
+        const started = Date.now();
+        try {
+            const result = await executeWebExtract(declaration, input, {
+                reader,
+                enabled: true,
+                authorized: context.authorized,
+                budget: context.budget,
+                operatorPolicy: policyBounds(record.policy),
+                ...(context.signal === undefined ? {} : { signal: context.signal }),
+                admit: async () => {
+                    const requests = [
+                        { key: 'capability:web-extract:fleet', amount, limit: 1000 * amount },
+                        { key: `capability:${scopeId}`, amount, limit: record.policy.dailyCalls * amount },
+                        {
+                            key: `capability:caller:${opaque(`${scopeId}:${attribution}`)}`,
+                            amount,
+                            limit: 10 * amount,
+                        },
+                        ...(context.network === undefined
+                            ? []
+                            : [
+                                {
+                                    key: `capability:network:${opaque(context.network)}`,
+                                    amount,
+                                    limit: 30 * amount,
+                                },
+                            ]),
+                    ];
+                    const attempt = {
+                        key: `capability:attempt:${opaque(`${scopeId}:${context.deploymentId}:${context.executionId}`)}`,
+                        fingerprint: opaque(JSON.stringify(input)),
+                    };
+                    const outcome = await this.options.counters.consumeAllOnce(requests, attempt, new Date());
+                    // A replay is not a cache hit: there is no retained source body, so it cannot authorize more I/O.
+                    return outcome.kind === 'consumed';
+                },
+            });
+            await this.options.audit?.({
+                ...context.tenant,
+                class: declaration.class,
+                scope: scopeId,
+                policyRevision: record.revision,
+                status: result.status,
+                pages: result.items.length,
+                elapsedMs: Date.now() - started,
+            });
+            return result;
+        }
+        catch (error) {
+            const safe = error instanceof CapabilityError ? error : new CapabilityError('capability_unavailable');
+            await Promise.resolve()
+                .then(() => this.options.audit?.({
+                ...context.tenant,
+                class: declaration.class,
+                scope: scopeId,
+                policyRevision: record.revision,
+                status: safe.code,
+                elapsedMs: Date.now() - started,
+            }))
+                .catch(() => { });
+            throw safe;
+        }
+    }
+}
+function opaque(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function policyBounds(policy) {
+    const { enabled: _enabled, dailyCalls: _daily, ...bounds } = policy;
+    return bounds;
+}
+//# sourceMappingURL=service.js.map

package/node_modules/@noodle-borg/managed-capabilities/dist/urls.d.ts

@@ -0,0 +1,3 @@
+/** Syntactic policy only. The adapter must additionally pin socket DNS to public unicast addresses. */
+export declare function publicPageUrl(value: string, domains?: readonly string[]): URL;
+//# sourceMappingURL=urls.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/urls.js

@@ -0,0 +1,30 @@
+import { isIP } from 'node:net';
+import { CapabilityError } from './errors.js';
+import { WEB_EXTRACT_LIMITS } from './limits.js';
+/** Syntactic policy only. The adapter must additionally pin socket DNS to public unicast addresses. */
+export function publicPageUrl(value, domains) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new CapabilityError('capability_source_rejected');
+    }
+    const host = url.hostname;
+    if (value.length > WEB_EXTRACT_LIMITS.maxUrlCharacters ||
+        url.protocol !== 'https:' ||
+        url.username !== '' ||
+        url.password !== '' ||
+        url.port !== '' ||
+        url.search !== '' ||
+        isIP(host.replace(/^\[|\]$/g, '')) !== 0 ||
+        !host.includes('.') ||
+        host.endsWith('.') ||
+        /(?:^|\.)(?:localhost|local|internal|test|invalid)$/.test(host) ||
+        (domains !== undefined && !domains.includes(host))) {
+        throw new CapabilityError('capability_source_rejected');
+    }
+    url.hash = '';
+    return url;
+}
+//# sourceMappingURL=urls.js.map

package/node_modules/@noodle-borg/managed-capabilities/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@noodle-borg/managed-capabilities",
+  "version": "0.0.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "main": "./dist/portable.js",
+  "types": "./dist/portable.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/portable.d.ts",
+      "import": "./dist/portable.js"
+    },
+    "./portable": {
+      "types": "./dist/portable.d.ts",
+      "import": "./dist/portable.js"
+    },
+    "./contracts": {
+      "types": "./dist/operator-contracts.d.ts",
+      "import": "./dist/operator-contracts.js"
+    },
+    "./testing": {
+      "types": "./dist/conformance.d.ts",
+      "import": "./dist/conformance.js"
+    },
+    "./postgres": {
+      "types": "./dist/postgres.d.ts",
+      "import": "./dist/postgres.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@noodle-borg/module": "0.0.0",
+    "@noodle-borg/admission-limits": "0.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.1",
+    "@types/pg": "^8.20.0"
+  }
+}

package/node_modules/@noodle-borg/module/dist/contract.d.ts

@@ -25,6 +25,17 @@ export interface ModuleRouteContext {
     readonly tenantControl?: TenantControlAuthorizer;
     /** Narrow deployment/App Package projection for hosted package operations. */
     readonly deploymentPackages?: DeploymentPackageView;
+    /** Read-only exact active capability declarations, available after same-request tenant authorization. */
+    readonly capabilityDeployments?: {
+        get(req: IncomingMessage, scope: {
+            readonly org: string;
+            readonly app: string;
+            readonly env: string;
+        }): Promise<{
+            readonly deploymentId: string;
+            readonly declarations: readonly unknown[];
+        } | undefined>;
+    };
     /** Minimal live deployment/package identity used only after an opaque delivery lookup. */
     readonly distributionDelivery?: DistributionDeliveryView;
     /** Host audit sink for route-emitted audit events; absent means the host has no audit trail. */

package/node_modules/@noodle-borg/runtime/dist/confirmation.js

@@ -1,3 +1,4 @@
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { resolveVariableEnvironment, validateVariableContinuation } from './business-variables.js';
 import { analyzeEligibleActions, countTrailingEligibleOperations, isActionOperation, validateConfirmationFlow, } from './confirmation-analysis.js';
 import { artifactIdentity, confirmationRequired, sameArtifact, } from './confirmation-continuation.js';
@@ -10,12 +11,32 @@ import { createHost, evalExprMap, prepareOperationAction, resolveEnv, runOperati
 import { AllowAllPolicy } from './policy/allow-all.js';
 import { attachResultMeta, splitResultMeta } from './result-meta.js';
 import { admitToolDispatch, latchToolDispatchAdmission } from './tool-dispatch.js';
+function carryBudget(result, budget) {
+    if (result.status === 'input_required')
+        return {
+            ...result,
+            continuation: { ...result.continuation, capabilityBudget: budget.snapshot() },
+        };
+    if (result.status === 'confirmation_required')
+        return {
+            ...result,
+            continuation: { ...result.continuation, capabilityBudget: budget.snapshot() },
+        };
+    return result;
+}
 /**
  * Evaluate the pure prefix of a confirmable tool. Connector operations are an absolute suspension
  * boundary: this function either requests input, returns a prepared confirmation, or fails before
  * invoking one.
  */
 export async function prepareToolForConfirmation(artifact, toolName, input, deps) {
+    const capabilityBudget = deps.capabilityBudget ?? new CapabilityBudget();
+    return carryBudget(await prepareToolForConfirmationInternal(artifact, toolName, input, {
+        ...deps,
+        capabilityBudget,
+    }), capabilityBudget);
+}
+async function prepareToolForConfirmationInternal(artifact, toolName, input, deps) {
     if (artifact.resolution !== 'resolved') {
         return failPreparation('shape_only_artifact', 'runtime refuses to serve a shape-only artifact');
     }
@@ -52,6 +73,13 @@ export async function prepareToolForConfirmation(artifact, toolName, input, deps
 }
 /** Resume the pure preparation prefix with one accepted, declined, or cancelled input response. */
 export async function resumeToolPreparation(artifact, continuation, response, deps) {
+    const capabilityBudget = new CapabilityBudget(continuation.capabilityBudget);
+    return carryBudget(await resumeToolPreparationInternal(artifact, continuation, response, {
+        ...deps,
+        capabilityBudget,
+    }), capabilityBudget);
+}
+async function resumeToolPreparationInternal(artifact, continuation, response, deps) {
     if (artifact.resolution !== 'resolved') {
         return failPreparation('shape_only_artifact', 'runtime refuses to serve a shape-only artifact');
     }
@@ -94,6 +122,7 @@ export async function resumeToolPreparation(artifact, continuation, response, de
  * after performing a side effect.
  */
 export async function executePreparedTool(artifact, continuation, deps) {
+    deps = { ...deps, capabilityBudget: new CapabilityBudget(continuation.capabilityBudget) };
     if (artifact.resolution !== 'resolved') {
         return failInteractive('shape_only_artifact', 'runtime refuses to serve a shape-only artifact');
     }