@noodleseed/one 0.137.0 → 0.138.0

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/service/dist/assistant-bindings.js

@@ -3,7 +3,7 @@ import { missingSecretErrors, missingVariableErrors } from './registry-helpers.j
 import { serverAuthSecretBindings } from './server-auth-bindings.js';
 const VARIABLE = /\$\{env\.([A-Za-z0-9_]+)\}/g;
 export function assistantSecretBindings(assistant) {
-    return assistant
+    return assistant?.model.kind === 'openai-compatible'
         ? [
             {
                 connectorId: 'server.assistant',
@@ -17,6 +17,8 @@ export function assistantSecretBindings(assistant) {
 export function assistantVariableBindings(assistant) {
     if (!assistant)
         return [];
+    if (assistant.model.kind !== 'openai-compatible')
+        return [];
     const names = new Set();
     for (const value of [assistant.model.baseUrl, assistant.model.model]) {
         for (const match of value.matchAll(VARIABLE)) {

package/node_modules/@noodle-borg/service/dist/developer-mcp/control-plane-adapter.js

@@ -1,7 +1,6 @@
-import { mcpSubdomainEndpointOptions } from '@noodle-borg/control-plane/portable';
+import { mcpSubdomainEndpointOptions, rollbackDeploymentOperation, } from '@noodle-borg/control-plane/portable';
 import { DeveloperControlPlaneError, } from '@noodle-borg/developer-mcp';
-import { rollbackDeploymentOperation } from '../operations/rollback-deployment.js';
-import { aggregateRequestEvents } from '../request-event-metrics.js';
+import { aggregateRequestEvents } from '@noodle-borg/observability';
 import { inspectCompiledServiceDeployment, inspectServiceDeployment } from './inspection.js';
 const METRICS_SCAN_LIMIT = 50_000;
 const WINDOWS_MS = {
@@ -261,6 +260,7 @@ function mapDeployment(deployment) {
         serverName: deployment.serverName,
         createdAt: deployment.createdAt,
         accessMode: deployment.accessMode,
+        ...(deployment.ownerSubject !== undefined ? { ownerSubject: deployment.ownerSubject } : {}),
         ...(deployment.endpointUrl !== undefined ? { endpointUrl: deployment.endpointUrl } : {}),
     };
 }

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

@@ -1,4 +1,4 @@
-import { tenantMcpUrl } from '../registry-helpers.js';
+import { tenantMcpUrl } from '@noodle-borg/module';
 export async function inspectServiceDeployment(registry, tenant, baseUrl, endpointOptions = {}) {
     const status = await registry.getStatus(tenant, baseUrl, undefined, endpointOptions);
     if (status === undefined)
@@ -109,6 +109,7 @@ export function inspectCompiledServiceDeployment(deployment, artifact, baseUrl,
                 ? {}
                 : { createdByEmail: deployment.createdByEmail }),
             accessMode: deployment.accessMode,
+            ...(deployment.ownerSubject !== undefined ? { ownerSubject: deployment.ownerSubject } : {}),
         },
         health: { state: 'ready', missingSecrets: [] },
         surface,