@noodleseed/one 0.169.0 → 0.171.0

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

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

@@ -0,0 +1,66 @@
+export function createAuditEventsRoute(store) {
+    return {
+        id: 'audit.events',
+        match: (method, url) => method === 'GET' && url.pathname === '/v1/audit/events',
+        handle: async (req, res, ctx) => {
+            if (ctx.controlPlane === undefined) {
+                return sendJson(res, 401, { error: 'control-plane authentication required' });
+            }
+            const auth = await ctx.controlPlane.authorize(req);
+            if (!auth.ok) {
+                return sendJson(res, auth.status, { error: auth.message });
+            }
+            if (auth.identity === undefined) {
+                return sendJson(res, 401, { error: 'identity required' });
+            }
+            if (!auth.identity.superAdmin) {
+                return sendJson(res, 403, { error: 'forbidden' });
+            }
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            const org = url.searchParams.get('org');
+            if (org === null || org.length === 0) {
+                return sendJson(res, 400, { error: 'org query parameter is required' });
+            }
+            try {
+                const filter = auditFilterFromQuery(url, org);
+                const events = await store.list(filter);
+                return sendJson(res, 200, { ok: true, events });
+            }
+            catch (error) {
+                return sendJson(res, 400, { error: error.message });
+            }
+        },
+    };
+}
+function auditFilterFromQuery(url, org) {
+    const app = optionalQuery(url, 'app');
+    const env = optionalQuery(url, 'env');
+    const eventType = optionalQuery(url, 'eventType');
+    const limit = parseLimit(optionalQuery(url, 'limit'));
+    return {
+        org,
+        ...(app !== undefined ? { app } : {}),
+        ...(env !== undefined ? { env } : {}),
+        ...(eventType !== undefined ? { eventType } : {}),
+        ...(limit !== undefined ? { limit } : {}),
+    };
+}
+function optionalQuery(url, key) {
+    const value = url.searchParams.get(key);
+    return value !== null && value.length > 0 ? value : undefined;
+}
+function parseLimit(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 500) {
+        throw new Error('limit must be an integer from 1 to 500');
+    }
+    return parsed;
+}
+function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify(body));
+}
+//# sourceMappingURL=route.js.map

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');
     }

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

@@ -1,4 +1,5 @@
 import type { CredentialProfile, OperationSignature, ResolvedOperationRef } from '@noodle-borg/compiler';
+import type { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import type { DownstreamCredential } from '../broker/types.js';
 import type { CustomerConnectorRoute } from '../customer-routing.js';
 import type { OperationCoordinationDeclaration, OperationCoordinationSnapshot } from '../operation-coordination.js';
@@ -81,6 +82,7 @@ export interface ConnectorCallHost {
 }
 /** A single connector-operation invocation, fully resolved and credentialed by the runtime. */
 export interface ConnectorCall {
+    readonly capabilityBudget?: CapabilityBudget;
     readonly operation: string;
     /** Runtime-generated, deployment/step-bound identity. Not a business input or recovery authority. */
     readonly execution?: Readonly<{

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

@@ -1,4 +1,5 @@
 import type { ArtifactFulfilment, RuntimeArtifact } from '@noodle-borg/compiler';
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import type { CredentialBroker } from './broker/types.js';
 import type { CallerIdentity, ConnectorRegistry, ExecutionTraceSink } from './connector/types.js';
 import type { FrozenCustomerRoutes } from './customer-routing.js';
@@ -18,6 +19,8 @@ export { evalExprMap, validateAgainstSchema, validateAgainstSchemaWithDefaults,
  * [ADR 0005](../../../docs/decisions/0005-runtime-execution-boundary.md)).
  */
 export interface ExecuteDeps {
+    /** Trusted shared assistant-turn / MCP-invocation budget; never part of the expression scope. */
+    readonly capabilityBudget?: CapabilityBudget;
     readonly connectors: ConnectorRegistry;
     readonly broker: CredentialBroker;
     readonly policy?: PolicyGate;

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

@@ -1,3 +1,4 @@
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { resolveVariableEnvironment } from './business-variables.js';
 import { preflightFulfilmentSignatures } from './connector-snapshot.js';
 import { preflightFulfilmentCustomerRoutes } from './customer-routing.js';
@@ -29,7 +30,11 @@ export async function executeTool(artifact, toolName, input, deps) {
     const variables = resolveVariableEnvironment(artifact.server.variables ?? [], await resolveEnv(deps), toolName);
     if (!variables.ok)
         return variables;
-    return runFulfilment(tool.fulfilment, input, toolName, { ...deps, env: variables.env }, deps.beforeDispatch);
+    return runFulfilment(tool.fulfilment, input, toolName, {
+        ...deps,
+        env: variables.env,
+        capabilityBudget: deps.capabilityBudget ?? new CapabilityBudget(),
+    }, deps.beforeDispatch);
 }
 /**
  * Execute a resource read against a resolved artifact. `input` is the resource's variable scope — the

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

@@ -20,8 +20,9 @@ export type { OperationEvidence, OperationEvidenceIntent, OperationEvidencePort,
 export { AllowAllPolicy } from './policy/allow-all.js';
 export type { PolicyContext, PolicyDecision, PolicyGate } from './policy/types.js';
 export { type ConfirmationActionReview, type ConfirmationPreparationResult, type ConfirmationReview, type ConnectorFailureAttribution, type ElicitationRequest, type ElicitationResponse, type ExecutionError, type ExecutionErrorCode, type ExecutionResult, type InteractiveExecutionResult, isConfirmationRequired, isInputRequired, isInputRequiredForConfirmation, type PreparedOperationAction, type PreparedToolContinuation, type ToolContinuation, type ToolPreparationContinuation, } from './result.js';
-export { splitResultMeta } from './result-meta.js';
+export { hasEphemeralEvidence, splitResultMeta } from './result-meta.js';
 export { type CallerStateAdoptionInput, type CallerStateAdoptionResult, claimableStateHandleNames, } from './state-handle-ownership.js';
 export { assertExpectedStateRevision, assertNoSecretValue, assertSchemaValue, assertStateHandleNotCompleted, COMPLETE_STATE_OPERATION, createMutableStateHandleRecord, createStateConnector, InMemoryStateHandleStore, type MutableStateHandleRecord, PATCH_STATE_OPERATION, READ_STATE_OPERATION, STATE_CONNECTOR_ID, STATE_CONNECTOR_VERSION, STATE_OPERATION_SIGNATURES, StateConnector, type StateHandleRecord, type StateHandleStore, type StateInput, type StateMutationInput, type StatePatchInput, stateHandleRecordForMutation, toPublicStateHandleRecord, } from './state-handles.js';
 export type { ToolDispatchContext, ToolDispatchDecision, ToolDispatchHook, } from './tool-dispatch.js';
+export { WebCapabilityConnector, type WebCapabilityExecutionPort } from './web-capabilities.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -15,7 +15,8 @@ export { executeToolInteractive, resumeTool } from './interactive.js';
 export { resolveManagedOrigins, } from './managed-origins.js';
 export { AllowAllPolicy } from './policy/allow-all.js';
 export { isConfirmationRequired, isInputRequired, isInputRequiredForConfirmation, } from './result.js';
-export { splitResultMeta } from './result-meta.js';
+export { hasEphemeralEvidence, splitResultMeta } from './result-meta.js';
 export { claimableStateHandleNames, } from './state-handle-ownership.js';
 export { assertExpectedStateRevision, assertNoSecretValue, assertSchemaValue, assertStateHandleNotCompleted, COMPLETE_STATE_OPERATION, createMutableStateHandleRecord, createStateConnector, InMemoryStateHandleStore, PATCH_STATE_OPERATION, READ_STATE_OPERATION, STATE_CONNECTOR_ID, STATE_CONNECTOR_VERSION, STATE_OPERATION_SIGNATURES, StateConnector, stateHandleRecordForMutation, toPublicStateHandleRecord, } from './state-handles.js';
+export { WebCapabilityConnector } from './web-capabilities.js';
 //# sourceMappingURL=index.js.map

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

@@ -1,3 +1,4 @@
+import { CapabilityBudget } from '@noodle-borg/managed-capabilities';
 import { resolveVariableEnvironment, validateVariableContinuation } from './business-variables.js';
 import { preflightFulfilmentCustomerRoutes } from './customer-routing.js';
 import { validateElicitationContent } from './elicitation-response.js';
@@ -17,7 +18,11 @@ export async function executeToolInteractive(artifact, toolName, input, deps) {
     const variables = resolveVariableEnvironment(artifact.server.variables ?? [], await resolveEnv(deps), toolName);
     if (!variables.ok)
         return { status: 'failed', error: variables.error };
-    deps = { ...deps, env: variables.env };
+    deps = {
+        ...deps,
+        env: variables.env,
+        capabilityBudget: deps.capabilityBudget ?? new CapabilityBudget(),
+    };
     if (tool.fulfilment.kind !== 'flow' || !tool.fulfilment.steps.some((s) => s.kind === 'elicit')) {
         return toInteractive(await runFulfilment(tool.fulfilment, input, toolName, deps, deps.beforeDispatch));
     }
@@ -32,6 +37,7 @@ export async function executeToolInteractive(artifact, toolName, input, deps) {
 }
 /** Resume one server-held continuation with the user's reviewed response. */
 export async function resumeTool(artifact, continuation, response, deps) {
+    deps = { ...deps, capabilityBudget: new CapabilityBudget(continuation.capabilityBudget) };
     if (!sameArtifact(artifact, continuation) || continuation.version !== 1) {
         return interactiveFail('invalid_continuation', 'tool continuation does not match the artifact');
     }
@@ -84,6 +90,9 @@ async function runInteractiveFlow(artifact, toolName, flow, input, startIndex, s
                     status: 'input_required',
                     request,
                     continuation: {
+                        ...(deps.capabilityBudget === undefined
+                            ? {}
+                            : { capabilityBudget: deps.capabilityBudget.snapshot() }),
                         version: 1,
                         artifact: artifactIdentity(artifact),
                         toolName,

package/node_modules/@noodle-borg/runtime/dist/managed-origins.js

@@ -14,10 +14,12 @@ export function resolveManagedOrigins(artifact, variables, options = {}) {
             ...(assistant.surfaces === undefined
                 ? {}
                 : {
-                    surfaces: assistant.surfaces.map((surface, index) => ({
-                        ...surface,
-                        origins: resolveList(surface.origins, `server.assistant.surfaces.${index}.origins`, true),
-                    })),
+                    surfaces: assistant.surfaces.map((surface, index) => surface.kind === 'messaging'
+                        ? surface
+                        : {
+                            ...surface,
+                            origins: resolveList(surface.origins, `server.assistant.surfaces.${index}.origins`, true),
+                        }),
                 }),
         };
     const handoff = artifact.server.handoff;
@@ -29,6 +31,8 @@ export function resolveManagedOrigins(artifact, variables, options = {}) {
         };
     const owners = new Map();
     resolvedAssistant?.surfaces?.forEach((surface, index) => {
+        if (surface.kind === 'messaging')
+            return;
         for (const origin of surface.origins) {
             const prior = owners.get(origin);
             if (prior !== undefined && prior !== index)

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

@@ -224,6 +224,9 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
                     if (signal?.aborted)
                         return fail('execution_cancelled', 'Execution deadline elapsed before connector dispatch.');
                     output = await connector.invoke({
+                        ...(deps.capabilityBudget === undefined
+                            ? {}
+                            : { capabilityBudget: deps.capabilityBudget }),
                         operation: ref.operation,
                         execution,
                         reportOutcome: (value) => {