@noodleseed/one 0.137.0 → 0.139.0

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

@@ -0,0 +1,52 @@
+import type { FetchLike, Tool } from '@modelcontextprotocol/client';
+import type { CredentialProfile, OperationSignature } from '@noodle-borg/compiler';
+import type { DnsLookup } from '../ssrf.js';
+/** How a broker-minted credential is presented to an upstream MCP server. */
+export type McpAuthScheme = CredentialProfile | {
+    readonly kind: 'cookie';
+};
+/** One curated Noodle operation mapped to one frozen upstream MCP tool. */
+export interface McpOperation {
+    readonly upstreamTool: string;
+    readonly signature: OperationSignature;
+    /** Frozen upstream output schema; omitted when the imported tool had no output schema. */
+    readonly upstreamOutputSchema?: OperationSignature['output'];
+    readonly auth?: McpAuthScheme;
+    /** Inclusive decoded-result limit. Defaults to the connector-wide limit. */
+    readonly maxResponseBytes?: number;
+    readonly fake?: McpOperationFake;
+}
+export type McpOperationFake = {
+    readonly structuredContent: Readonly<Record<string, unknown>>;
+} | {
+    readonly text: string;
+};
+/** Runtime configuration for one remote Streamable HTTP MCP server. */
+export interface McpConnectorConfig {
+    readonly id: string;
+    readonly version: string;
+    /** Literal endpoint or one exact `${env.NAME}` managed-variable reference. */
+    readonly endpoint: string;
+    /** Exact egress origins. Required when `endpoint` is managed. */
+    readonly allowedOrigins?: readonly string[];
+    readonly operations: Readonly<Record<string, McpOperation>>;
+    readonly auth?: McpAuthScheme;
+    /** Total connection + call timeout. Default 10 seconds. */
+    readonly timeoutMs?: number;
+    /** Inclusive decoded MCP response limit. Default 1 MiB, maximum 6 MiB. */
+    readonly maxResponseBytes?: number;
+    /** Protocol-era policy. `auto` safely negotiates modern or legacy and is the default. */
+    readonly protocol?: 'auto' | 'legacy' | 'modern';
+    /** Compiler-owned deterministic mode; bypasses transport and credentials. */
+    readonly fakeMode?: boolean;
+}
+/**
+ * Hermetic-test seams. Production compilation never accepts or emits these values; outbound traffic uses
+ * the guarded transport and system DNS resolver.
+ */
+export interface McpConnectorDependencies {
+    readonly fetch?: FetchLike;
+    readonly lookup?: DnsLookup;
+}
+export declare function toolDefinition(operation: McpOperation): Tool;
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/types.js

@@ -0,0 +1,10 @@
+export function toolDefinition(operation) {
+    return {
+        name: operation.upstreamTool,
+        inputSchema: operation.signature.input,
+        ...(operation.upstreamOutputSchema === undefined
+            ? {}
+            : { outputSchema: operation.upstreamOutputSchema }),
+    };
+}
+//# sourceMappingURL=types.js.map

package/node_modules/@noodle-borg/connector-http/package.json

@@ -22,12 +22,15 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "@modelcontextprotocol/client": "2.0.0",
     "@noodle-borg/compiler": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
     "ipaddr.js": "^2.4.0",
     "undici": "^8.7.0"
   },
   "devDependencies": {
-    "@types/node": "^24.13.1"
+    "@modelcontextprotocol/server": "2.0.0",
+    "@types/node": "^24.13.1",
+    "zod": "^4.4.3"
   }
 }

package/node_modules/@noodle-borg/control-plane/dist/portable.d.ts

@@ -4,5 +4,7 @@ export { InMemoryControlPlaneStore } from './in-memory-control-plane-store.js';
 export { bindInMemoryOrganizationStore, type InMemoryOrganizationOperations, InMemoryOrganizationStore, } from './in-memory-organization-store.js';
 export { InMemoryMcpSubdomainClaimStore, McpSubdomainCooldownError, McpSubdomainIdempotencyConflictError, McpSubdomainOwnerRequiredError, type McpSubdomainRouteRef, McpSubdomainUnavailableError, mcpSubdomainEndpointOptions, type ResolvedMcpTenantRef, resolveMcpSubdomainTenant, } from './mcp-subdomain-claims.js';
 export { domainFromEmail, domainKey, memberKey, normalizeSignupAllowlistValue, personalOrgSlug, personalOrgSlugSuffix, signupKey, } from './organization-helpers.js';
+export { type RollbackControlPlane, type RollbackOperationDependencies, type RollbackOperationInput, type RollbackOperationResult, type RollbackRegistry, rollbackDeploymentOperation, } from './rollback-deployment.js';
+export type { RollbackResult } from './rollback-result.js';
 export { DOMAIN_PATTERN, isSystemOwnedOrgSlug, OPENAI_APPS_CHALLENGE_MAX_LENGTH, SLUG_PATTERN, validateDomain, validateMcpSubdomain, validateOpenAIAppsChallenge, validateOrgMembershipDomain, validateOrgRole, validateSignupAllowlistKind, validateSlug, validateUserOwnedOrgSlug, } from './validation.js';
 //# sourceMappingURL=portable.d.ts.map

package/node_modules/@noodle-borg/control-plane/dist/portable.js

@@ -3,5 +3,6 @@ export { InMemoryControlPlaneStore } from './in-memory-control-plane-store.js';
 export { bindInMemoryOrganizationStore, InMemoryOrganizationStore, } from './in-memory-organization-store.js';
 export { InMemoryMcpSubdomainClaimStore, McpSubdomainCooldownError, McpSubdomainIdempotencyConflictError, McpSubdomainOwnerRequiredError, McpSubdomainUnavailableError, mcpSubdomainEndpointOptions, resolveMcpSubdomainTenant, } from './mcp-subdomain-claims.js';
 export { domainFromEmail, domainKey, memberKey, normalizeSignupAllowlistValue, personalOrgSlug, personalOrgSlugSuffix, signupKey, } from './organization-helpers.js';
+export { rollbackDeploymentOperation, } from './rollback-deployment.js';
 export { DOMAIN_PATTERN, isSystemOwnedOrgSlug, OPENAI_APPS_CHALLENGE_MAX_LENGTH, SLUG_PATTERN, validateDomain, validateMcpSubdomain, validateOpenAIAppsChallenge, validateOrgMembershipDomain, validateOrgRole, validateSignupAllowlistKind, validateSlug, validateUserOwnedOrgSlug, } from './validation.js';
 //# sourceMappingURL=portable.js.map

package/node_modules/@noodle-borg/control-plane/dist/rollback-deployment.d.ts

@@ -0,0 +1,61 @@
+import { type AuditSink, type DeploymentOperationTarget, type EndpointUrlOptions } from '@noodle-borg/module';
+import type { RollbackResult } from './rollback-result.js';
+export interface RollbackRegistry {
+    getAppArchivedAt(org: string, app: string): Promise<string | undefined>;
+    rollback(target: DeploymentOperationTarget, deploymentId: string): Promise<RollbackResult>;
+}
+export interface RollbackControlPlane {
+    getOrgMember(input: {
+        readonly org: string;
+        readonly subject: string;
+    }): Promise<{
+        readonly role: string;
+    } | undefined>;
+}
+export interface RollbackOperationDependencies {
+    readonly registry: RollbackRegistry;
+    readonly controlPlane: RollbackControlPlane;
+    readonly audit: AuditSink;
+}
+export interface RollbackOperationInput {
+    readonly actor: {
+        readonly subject: string;
+        readonly email?: string;
+        readonly superAdmin: boolean;
+    };
+    readonly target: DeploymentOperationTarget;
+    readonly deploymentId: string;
+    readonly reason?: string;
+    readonly publicBaseUrl: string;
+    readonly endpointOptions?: EndpointUrlOptions;
+}
+export type RollbackOperationResult = {
+    readonly ok: true;
+    readonly view: {
+        readonly target: DeploymentOperationTarget;
+        readonly rollback: {
+            readonly deploymentId: string;
+            readonly serverVersion?: string;
+            readonly previousDeploymentId?: string;
+            readonly alreadyActive: boolean;
+            readonly endpointUrl: string;
+            readonly accessMode: string;
+            readonly ownerSubject?: string;
+            readonly previousAccessMode?: string;
+            readonly serverName: string;
+            readonly createdAt: string;
+        };
+    };
+} | {
+    readonly ok: false;
+    readonly status: 403 | 404 | 409 | 503;
+    readonly code: 'forbidden' | 'app_archived' | 'deployment_not_found' | 'deployment_incompatible' | 'deployment_locked' | 'production_app_limit_exceeded' | 'billing_enforcement_unavailable';
+    readonly message: string;
+};
+/**
+ * Activate a previous deployment through the service's canonical governance boundary.
+ * HTTP routes, agent tools, and MCP App widgets must all call this operation rather than
+ * duplicating owner checks, commercial admission, endpoint construction, or audit behavior.
+ */
+export declare function rollbackDeploymentOperation(dependencies: RollbackOperationDependencies, input: RollbackOperationInput): Promise<RollbackOperationResult>;
+//# sourceMappingURL=rollback-deployment.d.ts.map

package/node_modules/@noodle-borg/{service/dist/operations → control-plane/dist}/rollback-deployment.js

@@ -1,5 +1,4 @@
-import { DeploymentActivationError } from '@noodle-borg/module';
-import { tenantMcpUrl } from '../registry-helpers.js';
+import { DeploymentActivationError, tenantMcpUrl, } from '@noodle-borg/module';
 /**
  * Activate a previous deployment through the service's canonical governance boundary.
  * HTTP routes, agent tools, and MCP App widgets must all call this operation rather than
@@ -81,6 +80,7 @@ export async function rollbackDeploymentOperation(dependencies, input) {
                 : {}),
             alreadyActive: result.alreadyActive,
             accessMode: result.accessMode,
+            ...(result.ownerSubject !== undefined ? { ownerSubject: result.ownerSubject } : {}),
             ...(result.previousAccessMode !== undefined
                 ? { previousAccessMode: result.previousAccessMode }
                 : {}),
@@ -101,6 +101,7 @@ export async function rollbackDeploymentOperation(dependencies, input) {
                 alreadyActive: result.alreadyActive,
                 endpointUrl,
                 accessMode: result.accessMode,
+                ...(result.ownerSubject !== undefined ? { ownerSubject: result.ownerSubject } : {}),
                 ...(result.previousAccessMode !== undefined
                     ? { previousAccessMode: result.previousAccessMode }
                     : {}),

package/node_modules/@noodle-borg/control-plane/dist/rollback-result.d.ts

@@ -0,0 +1,19 @@
+import type { AccessMode } from '@noodle-borg/module';
+export type RollbackResult = {
+    readonly ok: true;
+    readonly deploymentId: string;
+    readonly serverVersion?: string;
+    readonly previousDeploymentId?: string;
+    readonly alreadyActive: boolean;
+    readonly accessMode: AccessMode;
+    readonly ownerSubject?: string;
+    readonly previousAccessMode?: AccessMode;
+    readonly serverName: string;
+    readonly createdAt: string;
+} | {
+    readonly ok: false;
+    readonly status: 404 | 409;
+    readonly code?: 'deployment_locked';
+    readonly error: string;
+};
+//# sourceMappingURL=rollback-result.d.ts.map

package/node_modules/@noodle-borg/control-plane/package.json

@@ -25,7 +25,9 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@noodle-borg/module": "0.0.0"
+  },
   "devDependencies": {
     "@types/node": "^24.13.1",
     "@types/pg": "^8.20.0"

package/node_modules/@noodle-borg/developer-mcp/dist/contracts.js

@@ -23,6 +23,7 @@ export const tenantSlugSchema = z
 export const appSlugSchema = tenantSlugSchema;
 export const environmentNameSchema = tenantSlugSchema;
 export const boundedIdSchema = z.string().min(1).max(200);
+const ownerSubjectSchema = z.string().min(1).max(512);
 export const developerMcpContextSchema = z.strictObject({
     subject: z.string().min(1).max(255),
     clientId: z.string().min(1).max(255),
@@ -122,6 +123,7 @@ export const deploymentSummarySchema = z.strictObject({
     serverName: z.string().min(1).max(200),
     createdAt: isoTimestampSchema,
     accessMode: z.string().min(1).max(64).optional(),
+    ownerSubject: ownerSubjectSchema.optional(),
     endpointUrl: z.url().optional(),
 });
 export const appSummaryViewSchema = z.strictObject({
@@ -163,6 +165,7 @@ export const deploymentInspectionViewSchema = z.strictObject({
         createdAt: isoTimestampSchema,
         createdByEmail: z.email().optional(),
         accessMode: z.string().min(1).max(64),
+        ownerSubject: ownerSubjectSchema.optional(),
     }),
     health: z.strictObject({
         state: z.string().min(1).max(100),
@@ -203,6 +206,7 @@ export const rollbackViewSchema = z.strictObject({
         alreadyActive: z.boolean(),
         endpointUrl: z.url(),
         accessMode: z.string().min(1).max(64),
+        ownerSubject: ownerSubjectSchema.optional(),
         previousAccessMode: z.string().min(1).max(64).optional(),
         serverName: z.string().min(1).max(200),
         createdAt: isoTimestampSchema,

package/node_modules/@noodle-borg/developer-mcp/dist/widgets/app-overview.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ActionStatus, BoundValue, EmptyState, Panel, WidgetHeader } from './shared.js';
 export function AppOverviewWidget() {
-    return (_jsxs("main", { children: [_jsx(WidgetHeader, { eyebrow: "Noodle Cloud", title: "App overview", description: "Deployment state for the organization and environments selected at connection time.", statusPath: "data.active" }), _jsx(Panel, { title: "Selected app", description: "This view is limited to the active developer grant.", children: _jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "App", path: "data.app" }), _jsx(BoundValue, { label: "Environment", path: "data.selectedEnvironment" }), _jsx(BoundValue, { label: "Active", path: "data.active" }), _jsx(BoundValue, { label: "Last activity", path: "data.lastActivityAt" })] }) }), _jsx(Panel, { title: "Granted environments", children: _jsxs("div", { className: "tag-list", "data-collection": "data.environments", "data-collection-item": "environment", children: [_jsx("template", { "data-collection-template": "", children: _jsx("span", { className: "tag", "data-bind": "environment", children: "Loading" }) }), _jsx(EmptyState, { children: "No environment is available in this result." })] }) }), _jsxs(Panel, { title: "Active deployment", children: [_jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "Deployment", path: "data.latest.deploymentId" }), _jsx(BoundValue, { label: "Created", path: "data.latest.createdAt" }), _jsx(BoundValue, { label: "Access", path: "data.latest.accessMode" }), _jsx(BoundValue, { label: "Endpoint", path: "data.latest.endpointUrl" })] }), _jsx("p", { className: "notice", "data-bind-if": "data.active", children: "An active deployment is serving this environment." })] }), _jsx(ActionStatus, {})] }));
+    return (_jsxs("main", { children: [_jsx(WidgetHeader, { eyebrow: "Noodle Cloud", title: "App overview", description: "Deployment state for the organization and environments selected at connection time.", statusPath: "data.active" }), _jsx(Panel, { title: "Selected app", description: "This view is limited to the active developer grant.", children: _jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "App", path: "data.app" }), _jsx(BoundValue, { label: "Environment", path: "data.selectedEnvironment" }), _jsx(BoundValue, { label: "Active", path: "data.active" }), _jsx(BoundValue, { label: "Last activity", path: "data.lastActivityAt" })] }) }), _jsx(Panel, { title: "Granted environments", children: _jsxs("div", { className: "tag-list", "data-collection": "data.environments", "data-collection-item": "environment", children: [_jsx("template", { "data-collection-template": "", children: _jsx("span", { className: "tag", "data-bind": "environment", children: "Loading" }) }), _jsx(EmptyState, { children: "No environment is available in this result." })] }) }), _jsxs(Panel, { title: "Active deployment", children: [_jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "Deployment", path: "data.latest.deploymentId" }), _jsx(BoundValue, { label: "Created", path: "data.latest.createdAt" }), _jsx(BoundValue, { label: "Access", path: "data.latest.accessMode" }), _jsx(BoundValue, { label: "Owner", path: "data.latest.ownerSubject" }), _jsx(BoundValue, { label: "Endpoint", path: "data.latest.endpointUrl" })] }), _jsx("p", { className: "notice", "data-bind-if": "data.active", children: "An active deployment is serving this environment." })] }), _jsx(ActionStatus, {})] }));
 }
 //# sourceMappingURL=app-overview.js.map

package/node_modules/@noodle-borg/developer-mcp/dist/widgets/deployment-detail.js

@@ -2,6 +2,6 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ActionStatus, BoundValue, EmptyState, Panel, WidgetHeader } from './shared.js';
 const ROLLBACK_ARGUMENTS = '{"app":"{{data.target.app}}","env":"{{data.target.env}}","deploymentId":"{{data.rollbackCandidate.deploymentId}}"}';
 export function DeploymentDetailWidget() {
-    return (_jsxs("main", { children: [_jsx(WidgetHeader, { eyebrow: "Noodle Cloud", title: "Deployment detail", description: "Runtime health, surface compatibility, and governed rollback state.", statusPath: "data.health.state" }), _jsx(Panel, { title: "Deployment identity", children: _jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "App", path: "data.target.app" }), _jsx(BoundValue, { label: "Environment", path: "data.target.env" }), _jsx(BoundValue, { label: "Deployment", path: "data.deployment.deploymentId" }), _jsx(BoundValue, { label: "Created", path: "data.deployment.createdAt" }), _jsx(BoundValue, { label: "Access", path: "data.deployment.accessMode" }), _jsx(BoundValue, { label: "Endpoint", path: "data.deployment.endpointUrl" })] }) }), _jsxs(Panel, { title: "Runtime health", children: [_jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "State", path: "data.health.state" }), _jsx(BoundValue, { label: "MCP Apps", path: "data.surface.compatibility.mcpApps" }), _jsx(BoundValue, { label: "ChatGPT", path: "data.surface.compatibility.chatgpt" }), _jsx(BoundValue, { label: "Claude", path: "data.surface.compatibility.claude" })] }), _jsxs("div", { className: "collection", "data-collection": "data.health.missingSecrets", "data-collection-item": "missing", children: [_jsx("template", { "data-collection-template": "", children: _jsx("p", { className: "collection-card", "data-bind": "missing", children: "Loading" }) }), _jsx(EmptyState, { children: "No missing managed configuration was reported." })] })] }), _jsxs(Panel, { title: "Rollback", description: "Noodle Cloud rechecks ownership, selected environment, compatibility, and admission before activation.", children: [_jsxs("div", { className: "action-row", children: [_jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "Candidate", path: "data.rollbackCandidate.deploymentId" }), _jsx(BoundValue, { label: "Created", path: "data.rollbackCandidate.createdAt" })] }), _jsx("button", { type: "button", className: "primary-action danger-action", "data-action": "call", "data-action-tool": "rollback_deployment", "data-action-args": ROLLBACK_ARGUMENTS, "data-bind-if": "data.rollbackCandidate.deploymentId", hidden: true, children: "Roll back to candidate" })] }), _jsx("p", { className: "notice", children: "If no candidate is shown, use the headless deployment workflow to inspect an explicit deployment ID." })] }), _jsx(Panel, { title: "Rollback outcome", children: _jsxs("dl", { className: "facts", "data-bind-if": "data.rollback.deploymentId", children: [_jsx(BoundValue, { label: "Activated deployment", path: "data.rollback.deploymentId" }), _jsx(BoundValue, { label: "Previously active", path: "data.rollback.previousDeploymentId" }), _jsx(BoundValue, { label: "Already active", path: "data.rollback.alreadyActive" }), _jsx(BoundValue, { label: "Endpoint", path: "data.rollback.endpointUrl" })] }) }), _jsx(ActionStatus, {})] }));
+    return (_jsxs("main", { children: [_jsx(WidgetHeader, { eyebrow: "Noodle Cloud", title: "Deployment detail", description: "Runtime health, surface compatibility, and governed rollback state.", statusPath: "data.health.state" }), _jsx(Panel, { title: "Deployment identity", children: _jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "App", path: "data.target.app" }), _jsx(BoundValue, { label: "Environment", path: "data.target.env" }), _jsx(BoundValue, { label: "Deployment", path: "data.deployment.deploymentId" }), _jsx(BoundValue, { label: "Created", path: "data.deployment.createdAt" }), _jsx(BoundValue, { label: "Access", path: "data.deployment.accessMode" }), _jsx(BoundValue, { label: "Owner", path: "data.deployment.ownerSubject" }), _jsx(BoundValue, { label: "Endpoint", path: "data.deployment.endpointUrl" })] }) }), _jsxs(Panel, { title: "Runtime health", children: [_jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "State", path: "data.health.state" }), _jsx(BoundValue, { label: "MCP Apps", path: "data.surface.compatibility.mcpApps" }), _jsx(BoundValue, { label: "ChatGPT", path: "data.surface.compatibility.chatgpt" }), _jsx(BoundValue, { label: "Claude", path: "data.surface.compatibility.claude" })] }), _jsxs("div", { className: "collection", "data-collection": "data.health.missingSecrets", "data-collection-item": "missing", children: [_jsx("template", { "data-collection-template": "", children: _jsx("p", { className: "collection-card", "data-bind": "missing", children: "Loading" }) }), _jsx(EmptyState, { children: "No missing managed configuration was reported." })] })] }), _jsxs(Panel, { title: "Rollback", description: "Noodle Cloud rechecks ownership, selected environment, compatibility, and admission before activation.", children: [_jsxs("div", { className: "action-row", children: [_jsxs("dl", { className: "facts", children: [_jsx(BoundValue, { label: "Candidate", path: "data.rollbackCandidate.deploymentId" }), _jsx(BoundValue, { label: "Created", path: "data.rollbackCandidate.createdAt" })] }), _jsx("button", { type: "button", className: "primary-action danger-action", "data-action": "call", "data-action-tool": "rollback_deployment", "data-action-args": ROLLBACK_ARGUMENTS, "data-bind-if": "data.rollbackCandidate.deploymentId", hidden: true, children: "Roll back to candidate" })] }), _jsx("p", { className: "notice", children: "If no candidate is shown, use the headless deployment workflow to inspect an explicit deployment ID." })] }), _jsx(Panel, { title: "Rollback outcome", children: _jsxs("dl", { className: "facts", "data-bind-if": "data.rollback.deploymentId", children: [_jsx(BoundValue, { label: "Activated deployment", path: "data.rollback.deploymentId" }), _jsx(BoundValue, { label: "Previously active", path: "data.rollback.previousDeploymentId" }), _jsx(BoundValue, { label: "Already active", path: "data.rollback.alreadyActive" }), _jsx(BoundValue, { label: "Endpoint", path: "data.rollback.endpointUrl" }), _jsx(BoundValue, { label: "Owner", path: "data.rollback.ownerSubject" })] }) }), _jsx(ActionStatus, {})] }));
 }
 //# sourceMappingURL=deployment-detail.js.map

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

@@ -399,6 +399,7 @@ export interface RequestEventFilter {
     readonly org: string;
     readonly app?: string;
     readonly env?: string;
+    readonly method?: string;
     readonly outcome?: RequestOutcome;
     readonly toolName?: string;
     readonly clientName?: string;

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

@@ -16,7 +16,6 @@ export type DeploymentAutomationInput = {
     readonly previousAccessMode?: AccessMode;
     readonly declaredAccessMode?: string;
     readonly previousOwnerSubject?: string;
-    readonly previousOwnerEmail?: string;
 };
 export type DeploymentAutomationAuthorization = {
     readonly kind: 'not-automation';
@@ -29,6 +28,7 @@ export type DeploymentAutomationAuthorization = {
     readonly kind: 'authorized';
     readonly automationId: string;
     readonly actor: ControlPlaneIdentity;
+    readonly ownerSubject?: string;
     readonly accessMode?: AccessMode;
     readonly accessModeSource?: 'previous' | 'declared';
 };

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

@@ -0,0 +1,11 @@
+export interface DeploymentOperationTarget {
+    readonly org: string;
+    readonly app: string;
+    readonly env: string;
+}
+export interface EndpointUrlOptions {
+    readonly publicBaseDomain?: string;
+    readonly mcpSubdomain?: string;
+}
+export declare function tenantMcpUrl(base: string, tenant: DeploymentOperationTarget, serverVersion?: string, options?: EndpointUrlOptions): string;
+//# sourceMappingURL=endpoint-url.d.ts.map

package/node_modules/@noodle-borg/module/dist/endpoint-url.js

@@ -0,0 +1,20 @@
+import { formatPublicMcpUrl, serverVersionPathSegment } from './contract.js';
+export function tenantMcpUrl(base, tenant, serverVersion, options = {}) {
+    if (options.publicBaseDomain !== undefined) {
+        if (options.mcpSubdomain === undefined) {
+            throw new Error('MCP subdomain is required to format a public endpoint URL');
+        }
+        return formatPublicMcpUrl(options.publicBaseDomain, {
+            mcpSubdomain: options.mcpSubdomain,
+            app: tenant.app,
+            env: tenant.env,
+            ...(serverVersion !== undefined ? { serverVersion } : {}),
+        });
+    }
+    const versionPath = serverVersion !== undefined ? `/${serverVersionPathSegment(serverVersion)}` : '';
+    const origin = new URL(base).origin;
+    return tenant.env === 'prod'
+        ? `${origin}/o/${tenant.org}/${tenant.app}${versionPath}/mcp`
+        : `${origin}/o/${tenant.org}/${tenant.app}/${tenant.env}${versionPath}/mcp`;
+}
+//# sourceMappingURL=endpoint-url.js.map

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

@@ -2,6 +2,7 @@ export * from './asset-store.js';
 export * from './contract.js';
 export * from './deployment-activation.js';
 export * from './deployment-automation.js';
+export * from './endpoint-url.js';
 export * from './intent.js';
 export * from './organization-provisioning.js';
 export * from './platform-human-identity.js';

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

@@ -2,6 +2,7 @@ export * from './asset-store.js';
 export * from './contract.js';
 export * from './deployment-activation.js';
 export * from './deployment-automation.js';
+export * from './endpoint-url.js';
 export * from './intent.js';
 export * from './organization-provisioning.js';
 export * from './platform-human-identity.js';

package/node_modules/@noodle-borg/observability/dist/assistant-usage.js

@@ -0,0 +1,217 @@
+import { randomUUID } from 'node:crypto';
+export const ASSISTANT_USAGE_METHOD = 'assistant';
+const EMPTY_TURN_COUNTERS = {
+    modelRequests: 0,
+    toolCalls: 0,
+    interactionCount: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+};
+export function assistantSessionUsageRequestEvent(session, durationMs) {
+    return assistantUsageRequestEvent({
+        ...session.tenant,
+        deploymentId: session.deploymentId,
+        eventKind: 'session',
+        sessionId: session.id,
+        surface: assistantSurface(session),
+        ...(session.modelSource === undefined ? {} : { modelSource: session.modelSource }),
+        durationMs,
+    });
+}
+export function assistantTurnUsageRequestEvent(session, input) {
+    return assistantUsageRequestEvent({
+        ...session.tenant,
+        deploymentId: session.deploymentId,
+        eventKind: 'turn',
+        sessionId: session.id,
+        surface: assistantSurface(session),
+        ...(session.modelSource === undefined ? {} : { modelSource: session.modelSource }),
+        outcome: input.outcome,
+        turnNumber: input.turnNumber,
+        durationMs: input.durationMs,
+        ...(input.counters ?? EMPTY_TURN_COUNTERS),
+        ...(input.errorKind === undefined ? {} : { errorKind: input.errorKind }),
+    });
+}
+export function assistantRefusedTurnUsageRequestEvent(session, errorKind, durationMs) {
+    return assistantTurnUsageRequestEvent(session, {
+        outcome: 'refused',
+        turnNumber: session.turnCount,
+        durationMs,
+        errorKind,
+    });
+}
+function assistantSurface(session) {
+    return session.publicEmbedId === undefined ? 'authenticated' : 'public';
+}
+export function assistantTurnNumber(session) {
+    if (session.publicEmbedId !== undefined)
+        return session.turnCount + 1;
+    return session.history.filter((message) => message.role === 'user').length + 1;
+}
+export function captureAssistantUsage(capture, event) {
+    try {
+        capture?.(event);
+    }
+    catch {
+        // Telemetry is best effort and never changes the assistant response path.
+    }
+}
+/**
+ * Project one assistant lifecycle event onto the shared tenant request stream. The allowlist is
+ * deliberately scalar-only: conversation text, model messages, tool arguments/results, headers,
+ * credentials, and page context have no field to enter through.
+ */
+export function assistantUsageRequestEvent(input) {
+    const details = {
+        eventKind: input.eventKind,
+        surface: input.surface,
+        ...(input.modelSource === undefined ? {} : { modelSource: input.modelSource }),
+        ...(input.eventKind === 'turn'
+            ? {
+                assistantOutcome: input.outcome,
+                turnNumber: input.turnNumber,
+                modelRequests: input.modelRequests,
+                toolCalls: input.toolCalls,
+                interactionCount: input.interactionCount,
+                promptTokens: input.promptTokens,
+                completionTokens: input.completionTokens,
+                totalTokens: input.totalTokens,
+                ...(input.reasoningTokens === undefined
+                    ? {}
+                    : { reasoningTokens: input.reasoningTokens }),
+            }
+            : {}),
+    };
+    return {
+        org: input.org,
+        app: input.app,
+        env: input.env,
+        deploymentId: input.deploymentId,
+        requestId: randomUUID(),
+        sessionId: input.sessionId,
+        sessionSource: 'synthetic',
+        subjectKind: input.surface === 'public' ? 'anonymous' : 'authenticated',
+        accessMode: input.surface === 'public' ? 'public' : 'authenticated',
+        method: ASSISTANT_USAGE_METHOD,
+        kind: 'usage',
+        outcome: input.eventKind === 'session' || input.outcome === 'delivered'
+            ? 'ok'
+            : input.outcome === 'refused'
+                ? 'tool_error'
+                : 'mcp_error',
+        ...(input.eventKind === 'turn' && input.errorKind !== undefined
+            ? { errorKind: input.errorKind }
+            : {}),
+        durationMs: finiteNonNegative(input.durationMs),
+        details,
+    };
+}
+export function aggregateAssistantUsage(events) {
+    let minted = 0;
+    let publicSessions = 0;
+    let authenticatedSessions = 0;
+    let delivered = 0;
+    let failed = 0;
+    let refused = 0;
+    let modelRequests = 0;
+    let toolTurns = 0;
+    let interactionTurns = 0;
+    let prompt = 0;
+    let completion = 0;
+    let reasoning = 0;
+    let total = 0;
+    let noodleManaged = 0;
+    let operator = 0;
+    const latencies = [];
+    const sessionDepth = new Map();
+    for (const event of events) {
+        if (event.method !== ASSISTANT_USAGE_METHOD)
+            continue;
+        const details = event.details;
+        const eventKind = scalarString(details?.eventKind);
+        const surface = scalarString(details?.surface);
+        if (eventKind === 'session') {
+            minted += 1;
+            if (surface === 'public')
+                publicSessions += 1;
+            if (surface === 'authenticated')
+                authenticatedSessions += 1;
+            continue;
+        }
+        if (eventKind !== 'turn')
+            continue;
+        const outcome = scalarString(details?.assistantOutcome);
+        if (outcome === 'delivered')
+            delivered += 1;
+        else if (outcome === 'refused')
+            refused += 1;
+        else if (outcome === 'failed')
+            failed += 1;
+        else
+            continue;
+        latencies.push(finiteNonNegative(event.durationMs));
+        modelRequests += scalarCount(details?.modelRequests);
+        if (scalarCount(details?.toolCalls) > 0)
+            toolTurns += 1;
+        if (scalarCount(details?.interactionCount) > 0)
+            interactionTurns += 1;
+        prompt += scalarCount(details?.promptTokens);
+        completion += scalarCount(details?.completionTokens);
+        reasoning += scalarCount(details?.reasoningTokens);
+        total += scalarCount(details?.totalTokens);
+        const source = scalarString(details?.modelSource);
+        if (source === 'noodle-managed')
+            noodleManaged += 1;
+        if (source === 'operator')
+            operator += 1;
+        const turnNumber = scalarCount(details?.turnNumber);
+        if (event.sessionId !== undefined && turnNumber > 0) {
+            sessionDepth.set(event.sessionId, Math.max(sessionDepth.get(event.sessionId) ?? 0, turnNumber));
+        }
+    }
+    const depths = [...sessionDepth.values()].sort((a, b) => a - b);
+    const sortedLatencies = latencies.sort((a, b) => a - b);
+    return {
+        sessions: { minted, public: publicSessions, authenticated: authenticatedSessions },
+        turns: {
+            attempted: delivered + failed + refused,
+            delivered,
+            failed,
+            refused,
+        },
+        depth: {
+            p50: percentile(depths, 50),
+            p90: percentile(depths, 90),
+            max: depths.at(-1) ?? 0,
+            atLeast10: depths.filter((value) => value >= 10).length,
+            atLeast20: depths.filter((value) => value >= 20).length,
+            atLeast30: depths.filter((value) => value >= 30).length,
+            atLeast40: depths.filter((value) => value >= 40).length,
+        },
+        engagement: { modelRequests, toolTurns, interactionTurns },
+        latency: {
+            p50Ms: percentile(sortedLatencies, 50),
+            p95Ms: percentile(sortedLatencies, 95),
+        },
+        tokens: { prompt, completion, reasoning, total },
+        byModelSource: { noodleManaged, operator },
+    };
+}
+function scalarString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function scalarCount(value) {
+    return typeof value === 'number' ? Math.floor(finiteNonNegative(value)) : 0;
+}
+function finiteNonNegative(value) {
+    return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function percentile(sorted, percentileValue) {
+    if (sorted.length === 0)
+        return 0;
+    const rank = Math.ceil((percentileValue / 100) * sorted.length);
+    return sorted[Math.min(Math.max(rank, 1), sorted.length) - 1] ?? 0;
+}
+//# sourceMappingURL=assistant-usage.js.map

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

@@ -1,5 +1,7 @@
+export * from './assistant-usage.js';
 export * from './intent-capture.js';
 export * from './request-event-buffer.js';
+export * from './request-event-metrics.js';
 export * from './request-events.js';
 export * from './request-events-postgres.js';
 export * from './runtime.js';

package/node_modules/@noodle-borg/{service → observability}/dist/request-event-metrics.js

@@ -10,8 +10,11 @@ function hourBucket(iso) {
     return `${iso.slice(0, 13)}:00:00.000Z`;
 }
 export function aggregateRequestEvents(events) {
-    const usage = events.filter((e) => e.kind === 'usage');
-    const discovery = events.length - usage.length;
+    // Assistant lifecycle records share the durable tenant stream but have their own aggregate. Keep
+    // the long-standing MCP metrics contract stable rather than counting one user turn as an MCP call.
+    const mcpEvents = events.filter((event) => event.method !== 'assistant');
+    const usage = mcpEvents.filter((event) => event.kind === 'usage');
+    const discovery = mcpEvents.length - usage.length;
     const durations = usage.map((e) => e.durationMs).sort((a, b) => a - b);
     let ok = 0;
     let toolErrors = 0;

package/node_modules/@noodle-borg/observability/dist/request-events-postgres.js

@@ -51,6 +51,10 @@ export async function ensureRequestEventSchema(pool) {
     await pool.query(`
     CREATE INDEX IF NOT EXISTS request_events_tenant_time_idx
       ON request_events (org_slug, app_slug, environment, seq DESC)
+  `);
+    await pool.query(`
+    CREATE INDEX IF NOT EXISTS request_events_tenant_method_time_idx
+      ON request_events (org_slug, app_slug, environment, method, seq DESC)
   `);
     await pool.query(`
     CREATE INDEX IF NOT EXISTS request_events_session_idx
@@ -128,6 +132,8 @@ export class PostgresRequestEventStore {
             add('app_slug', filter.app);
         if (filter.env !== undefined)
             add('environment', filter.env);
+        if (filter.method !== undefined)
+            add('method', filter.method);
         if (filter.outcome !== undefined)
             add('outcome', filter.outcome);
         if (filter.toolName !== undefined)

package/node_modules/@noodle-borg/observability/dist/request-events.js

@@ -41,6 +41,8 @@ function matches(event, filter) {
         return false;
     if (filter.env !== undefined && event.env !== filter.env)
         return false;
+    if (filter.method !== undefined && event.method !== filter.method)
+        return false;
     if (filter.outcome !== undefined && event.outcome !== filter.outcome)
         return false;
     if (filter.toolName !== undefined && event.toolName !== filter.toolName)

package/node_modules/@noodle-borg/openapi-import/dist/index.js

@@ -1,5 +1,6 @@
 import YAML from 'yaml';
 import { importResponseSchema, toOutputJsonSchema, } from './response-schema.js';
+export * from './mcp/index.js';
 export { importResponseSchema, MAX_RESPONSE_SCHEMA_DEPTH, MAX_RESPONSE_SCHEMA_NODES, toOutputJsonSchema, } from './response-schema.js';
 const METHODS = new Set(['get', 'post', 'put', 'patch', 'delete']);
 export function parseOpenApiToIr(source, options) {