@noodleseed/one 0.139.3 → 0.140.0

package/node_modules/@noodle-borg/protocol/dist/handlers/resources.js

@@ -3,7 +3,7 @@ import { executeResource } from '@noodle-borg/runtime';
 import { parseUriTemplate } from '@noodle-borg/uri-template';
 import { RESOURCE_NOT_FOUND } from '../error-codes.js';
 import { mapResourceContents, mapResourcesList, mapResourceTemplatesList } from '../mapping.js';
-import { estimateTokens, notify } from '../observation.js';
+import { estimateTokens, executionErrorObservation, notify } from '../observation.js';
 export function registerResources(server, artifact, deps, context) {
     server.setRequestHandler(ListResourcesRequestSchema, () => mapResourcesList(artifact));
     server.setRequestHandler(ListResourceTemplatesRequestSchema, () => mapResourceTemplatesList(artifact));
@@ -19,7 +19,7 @@ export function registerResources(server, artifact, deps, context) {
                     method: 'resources/read',
                     resourceName: resource.name,
                     outcome: 'mcp_error',
-                    errorKind: result.error.code,
+                    ...executionErrorObservation(result.error),
                 });
                 throw new McpError(ErrorCode.InternalError, result.error.message);
             }

package/node_modules/@noodle-borg/protocol/dist/handlers/tools.js

@@ -5,7 +5,7 @@ import { extractIntentCapture, intentCaptureEligible } from '../intent-capture.j
 import { extractElicitationResponses, toolUsesPortableInteractionArgument, } from '../interaction-envelope.js';
 import { findKnowledgeComponent, knowledgeToolsEnabled, runKnowledgeSearchTool, } from '../knowledge-tool.js';
 import { mapExecutionError, mapToolOutput, mapToolsList, redactWidgetLinkedOutput, } from '../mapping.js';
-import { estimateTokens, notify, } from '../observation.js';
+import { estimateTokens, executionErrorObservation, notify, } from '../observation.js';
 import { evaluateToolAuthorization, TOOL_AUTHORIZATION_DENIED } from '../tool-authorization.js';
 import { runMcpToolInteraction } from '../tool-interaction.js';
 import { interactionUnavailableToolResult, stoppedToolResult } from '../tool-results.js';
@@ -148,10 +148,10 @@ export function registerTools(server, artifact, deps, context) {
         // The same split is the analytics two-tier taxonomy: tool_error vs mcp_error (ADR 0121).
         const outcome = mapExecutionError(result.error);
         if ('result' in outcome) {
-            observe('tool_error', { errorKind: result.error.code });
+            observe('tool_error', executionErrorObservation(result.error));
             return outcome.result;
         }
-        observe('mcp_error', { errorKind: result.error.code });
+        observe('mcp_error', executionErrorObservation(result.error));
         throw new McpError(outcome.error.code, outcome.error.message);
     });
 }

package/node_modules/@noodle-borg/protocol/dist/observation.d.ts

@@ -16,7 +16,23 @@ export interface ProtocolObservation {
     readonly intent?: IntentCaptureValue;
     /** Rough token-equivalent of the response payload (chars/4), the context-bloat gauge. */
     readonly outputTokensEst?: number;
+    /** Safe connector failure attribution projected from the execution error (#1309); scalars only. */
+    readonly connector?: ConnectorFailureAttribution;
 }
+/**
+ * The analytics `errorKind` for an execution error: the stable code, refined with the allowlisted
+ * `reason` when one exists (`connector_error.timeout`). Analytics-only — wire mapping is unchanged.
+ */
+export declare function executionErrorKind(error: {
+    readonly code: string;
+    readonly reason?: string;
+}): string;
+/** The observation slice carried by an execution error, ready to spread into an observe call. */
+export declare function executionErrorObservation(error: {
+    readonly code: string;
+    readonly reason?: string;
+    readonly connector?: ConnectorFailureAttribution;
+}): Pick<ProtocolObservation, 'errorKind' | 'connector'>;
 interface ObservationContext {
     readonly observe?: (observation: ProtocolObservation) => void;
 }
@@ -26,5 +42,6 @@ export declare function notify(context: ObservationContext, observation: Protoco
  * the response path serializes it once — wire framing/duplication is deliberately excluded. */
 export declare function estimateTokens(value: unknown): number;
 import type { IntentCaptureValue } from '@noodle-borg/module';
+import type { ConnectorFailureAttribution } from '@noodle-borg/runtime';
 export {};
 //# sourceMappingURL=observation.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/observation.js

@@ -1,3 +1,17 @@
+/**
+ * The analytics `errorKind` for an execution error: the stable code, refined with the allowlisted
+ * `reason` when one exists (`connector_error.timeout`). Analytics-only — wire mapping is unchanged.
+ */
+export function executionErrorKind(error) {
+    return error.reason === undefined ? error.code : `${error.code}.${error.reason}`;
+}
+/** The observation slice carried by an execution error, ready to spread into an observe call. */
+export function executionErrorObservation(error) {
+    return {
+        errorKind: executionErrorKind(error),
+        ...(error.connector === undefined ? {} : { connector: error.connector }),
+    };
+}
 /** Report an observation; an observer bug must never break the request it watched. */
 export function notify(context, observation) {
     try {

package/node_modules/@noodle-borg/protocol/dist/v2/server.js

@@ -8,7 +8,7 @@ import { extractIntentCapture, intentCaptureEligible } from '../intent-capture.j
 import { extractElicitationResponses, toolUsesPortableInteractionArgument, } from '../interaction-envelope.js';
 import { findKnowledgeComponent, knowledgeToolsEnabled, runKnowledgeSearchTool, } from '../knowledge-tool.js';
 import { mapExecutionError, mapPromptMessages, mapPromptsList, mapResourceContents, mapResourcesList, mapResourceTemplatesList, mapToolOutput, mapToolsList, redactWidgetLinkedOutput, } from '../mapping.js';
-import { estimateTokens, notify, } from '../observation.js';
+import { estimateTokens, executionErrorObservation, notify, } from '../observation.js';
 import { buildProtocolRequestDeps } from '../request-deps.js';
 import { assertRequestStateBinding, RequestStateError, } from '../request-state.js';
 import { evaluateToolAuthorization } from '../tool-authorization.js';
@@ -310,10 +310,10 @@ function registerV2Tools(server, artifact, deps, context, era) {
         }
         const outcome = mapExecutionError(result.error);
         if ('result' in outcome) {
-            observe('tool_error', { errorKind: result.error.code });
+            observe('tool_error', executionErrorObservation(result.error));
             return outcome.result;
         }
-        observe('mcp_error', { errorKind: result.error.code });
+        observe('mcp_error', executionErrorObservation(result.error));
         throw new ProtocolError(outcome.error.code, outcome.error.message);
     });
 }
@@ -349,7 +349,7 @@ function registerV2Resources(server, artifact, deps, context, era, skill) {
                     method: 'resources/read',
                     resourceName: resource.name,
                     outcome: 'mcp_error',
-                    errorKind: result.error.code,
+                    ...executionErrorObservation(result.error),
                 });
                 throw new ProtocolError(-32603, result.error.message);
             }
@@ -390,7 +390,7 @@ function registerV2Prompts(server, artifact, deps, context) {
         }
         const result = await executePrompt(artifact, name, args ?? {}, deps);
         if (!result.ok) {
-            observe('mcp_error', { errorKind: result.error.code });
+            observe('mcp_error', executionErrorObservation(result.error));
             throw new ProtocolError(-32603, result.error.message);
         }
         const mapped = mapPromptMessages(result.output, prompt.description);

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

@@ -16,7 +16,7 @@ export type { InvocationContext, InvocationContextPreferenceSource, InvocationLo
 export { type ManagedOriginResolutionResult, resolveManagedOrigins, } from './managed-origins.js';
 export { AllowAllPolicy } from './policy/allow-all.js';
 export type { PolicyContext, PolicyDecision, PolicyGate } from './policy/types.js';
-export { type ConfirmationActionReview, type ConfirmationPreparationResult, type ConfirmationReview, 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 { 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 { assertNoSecretValue, assertSchemaValue, COMPLETE_STATE_OPERATION, createStateConnector, InMemoryStateHandleStore, 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, } from './state-handles.js';
 export type { ToolDispatchContext, ToolDispatchDecision, ToolDispatchHook, } from './tool-dispatch.js';

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

@@ -29,6 +29,6 @@ export declare function prepareOperationAction(ref: ResolvedOperationRef | {
 }, argsAst: ExprMap, scope: EvalScope, deps: ExecuteDeps, argsPath: string, additionalOperationCount?: number): PreparedOperationActionResult;
 /** @internal Shared with the suspension-aware flow executor. */
 export declare function createHost(toolName: string, deps: ExecuteDeps, policy: PolicyGate, env: Record<string, string>, callStack: string[], beforeDispatch?: ToolDispatchHook): ConnectorCallHost;
-export declare function fail(code: ExecutionError['code'], message: string, pathOrDetails?: string | Pick<ExecutionError, 'reason' | 'fix' | 'next'>): ExecutionResult;
+export declare function fail(code: ExecutionError['code'], message: string, pathOrDetails?: string | Pick<ExecutionError, 'reason' | 'fix' | 'next' | 'connector'>): ExecutionResult;
 export {};
 //# sourceMappingURL=operation-execution.d.ts.map

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

@@ -189,14 +189,32 @@ async function invokeOperation(ref, args, sig, toolName, deps, policy, host, env
                     operation: ref.operation,
                     ...failureDetails,
                 });
-                if (failureDetails.category === 'response_too_large') {
-                    return fail('connector_error', `connector failed for operation "${ref.operation}"`, {
-                        reason: 'response_too_large',
-                    });
-                }
+                // Attribution keeps the sanitized classification (never the excerpt) so analytics can name
+                // the failing connector/operation/stage while the wire result stays generic (#1309).
+                const status = statusClass(failureDetails.status);
+                return fail('connector_error', `connector failed for operation "${ref.operation}"`, {
+                    ...(failureDetails.category === undefined ? {} : { reason: failureDetails.category }),
+                    connector: {
+                        connectorId: ref.connectorId,
+                        connectorVersion: ref.connectorVersion,
+                        operation: ref.operation,
+                        ...(failureDetails.category === undefined ? {} : { category: failureDetails.category }),
+                        ...(status === undefined ? {} : { statusClass: status }),
+                        ...(failureDetails.attempts === undefined ? {} : { attempts: failureDetails.attempts }),
+                        ...(failureDetails.retryable === undefined
+                            ? {}
+                            : { retryable: failureDetails.retryable }),
+                    },
+                });
             }
             // Normalize connector failures; never surface backend internals or credentials.
-            return fail('connector_error', `connector failed for operation "${ref.operation}"`);
+            return fail('connector_error', `connector failed for operation "${ref.operation}"`, {
+                connector: {
+                    connectorId: ref.connectorId,
+                    connectorVersion: ref.connectorVersion,
+                    operation: ref.operation,
+                },
+            });
         }
         if (customerRoute !== undefined) {
             const cloned = cloneRoutedOutput(output, customerRoute.baseUrl);
@@ -278,6 +296,16 @@ function hostCallErrorSnapshot(value) {
         ? hostCallErrors.get(value)
         : undefined;
 }
+/** Upstream status class for retained attribution; the exact status stays out of analytics. */
+function statusClass(status) {
+    if (status === undefined)
+        return undefined;
+    if (status >= 500 && status <= 599)
+        return '5xx';
+    if (status >= 400 && status <= 499)
+        return '4xx';
+    return undefined;
+}
 export function fail(code, message, pathOrDetails) {
     if (typeof pathOrDetails === 'string') {
         return { ok: false, error: { code, message, path: pathOrDetails } };

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

@@ -1,7 +1,23 @@
 import type { CredentialProfile } from '@noodle-borg/compiler';
+import type { ConnectorFailureCategory } from './connector/types.js';
 import type { CustomerRouteBinding } from './customer-routing.js';
 /** Why a tool call could not be fulfilled. Protocol and embedded adapters map this internal contract. */
 export type ExecutionErrorCode = 'shape_only_artifact' | 'unknown_tool' | 'unknown_resource' | 'unknown_prompt' | 'unsupported_fulfilment' | 'connector_unavailable' | 'connector_route_unavailable' | 'credential_unavailable' | 'signature_drift' | 'policy_denied' | 'policy_error' | 'dispatch_denied' | 'usage_limit_exceeded' | 'duplicate_execution_suppressed' | 'execution_admission_error' | 'execution_cancelled' | 'arg_invalid' | 'invalid_continuation' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'expression_error' | 'circular_call_dependency' | 'connector_error' | 'output_invalid';
+/**
+ * Safe connector failure attribution for operator analytics (issue #1309): platform identifiers and
+ * bounded classification only — never an upstream message, response body, credential, or exact URL.
+ * Adapters must keep this off every model-facing wire channel.
+ */
+export interface ConnectorFailureAttribution {
+    readonly connectorId: string;
+    readonly connectorVersion: string;
+    readonly operation: string;
+    readonly category?: ConnectorFailureCategory;
+    /** Upstream HTTP status class; the exact status is deliberately not retained. */
+    readonly statusClass?: '4xx' | '5xx';
+    readonly attempts?: number;
+    readonly retryable?: boolean;
+}
 /** A typed execution failure. `path` locates the offending field/expression when applicable and
  * never carries a sensitive value. */
 export interface ExecutionError {
@@ -10,6 +26,8 @@ export interface ExecutionError {
     readonly path?: string;
     /** Stable, allowlisted machine-readable detail. Never an upstream error message. */
     readonly reason?: string;
+    /** Present on connector failures; analytics-only, never serialized to a client. */
+    readonly connector?: ConnectorFailureAttribution;
     /** Safe monthly-allowance reset instant, present only for commercial usage denial. */
     readonly resetAt?: string;
     /** Safe remediation text intended for a developer or agent. */

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

@@ -1,4 +1,5 @@
 import { cspFaultsInManifest } from '@noodle-borg/compiler';
+import { ensurePersonalWorkspace } from '@noodle-borg/control-plane/portable';
 import { DEVELOPER_CLI_PATH } from '@noodle-borg/developer-mcp';
 import { normalizeServerVersion } from '@noodle-borg/module';
 import { noopLogger } from '@noodle-borg/transport-http';
@@ -6,7 +7,6 @@ import { deployRequestSchema, formatWireError, } from '@noodle-borg/wire-contrac
 import { authorizeDeveloperGrant, } from '../auth/developer-grant-guard.js';
 import { baseFromRequest, readDeployBody, sendForbidden, sendJson, sendUnauthorized, } from '../http-util.js';
 import { endpointUrlOptionsForOrg } from '../mcp-public-routing.js';
-import { ensurePersonalWorkspace } from '../personal-workspace.js';
 import { manifestUsesUserRoot } from '../registry-access.js';
 import { isIdentityAccessMode } from './access-mode.js';
 import { validateDeployIdempotency } from './deploy-idempotency.js';

package/node_modules/@noodle-borg/service/dist/service-resource-cleanup.js

@@ -1,9 +1,5 @@
 /** Close every boot-owned resource, preserving all failures without skipping later cleanup. */
 export async function closeServiceResources(input) {
-    if (input.retentionTimer !== undefined)
-        clearInterval(input.retentionTimer);
-    if (input.intentRetentionTimer !== undefined)
-        clearInterval(input.intentRetentionTimer);
     if (input.welcomeEmailTimer !== undefined)
         clearInterval(input.welcomeEmailTimer);
     if (input.feedbackOperationsTimer !== undefined)
@@ -14,8 +10,7 @@ export async function closeServiceResources(input) {
     if (moduleHost !== undefined) {
         await captureCleanupError(errors, () => moduleHost.dispose());
     }
-    await captureCleanupError(errors, () => input.requestEventBuffer.close());
-    await captureCleanupError(errors, () => input.intentEventBuffer.close());
+    await captureCleanupError(errors, () => input.telemetry.dispose());
     const postgresPool = input.postgresPool;
     if (postgresPool !== undefined) {
         await captureCleanupError(errors, () => postgresPool.close());

package/node_modules/@noodle-borg/service/package.json

@@ -39,7 +39,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.84.0",
+    "@noodle-borg/agent-kit": "0.84.1",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

package/node_modules/@noodle-borg/transport-http/dist/client-identity.js

@@ -0,0 +1,124 @@
+import { CLIENT_FAMILY_OTHER, CLIENT_FAMILY_UNKNOWN } from '@noodle-borg/module';
+/**
+ * Safe client attribution for request analytics (issue #1309): bounded projections of MCP
+ * `clientInfo` and of the transport user agent, plus the best-effort session→clientInfo memo that
+ * lets legacy-era requests after `initialize` keep their client identity. Nothing here ever retains
+ * a raw user-agent string, and every retained value is length-bounded and control-character free.
+ */
+const MAX_CLIENT_NAME = 128;
+const MAX_CLIENT_VERSION = 64;
+const MAX_FAMILY = 32;
+/**
+ * Known HTTP client user agents, matched case-insensitively against the user-agent prefix tokens.
+ * A closed table keeps the retained cardinality bounded: anything else becomes `other`, an absent
+ * user agent becomes `unknown`. Order matters — first match wins.
+ */
+const KNOWN_UA_FAMILIES = [
+    [/claude/i, 'claude'],
+    [/anthropic/i, 'anthropic-sdk'],
+    [/openai/i, 'openai'],
+    [/mcp-inspector|inspector/i, 'mcp-inspector'],
+    [/undici/i, 'undici'],
+    [/node-fetch/i, 'node-fetch'],
+    [/\bnode\b|nodejs/i, 'node'],
+    [/\bbun\b/i, 'bun'],
+    [/\bdeno\b/i, 'deno'],
+    [/python-httpx|\bhttpx\b/i, 'python-httpx'],
+    [/python-requests/i, 'python-requests'],
+    [/python-urllib|python/i, 'python'],
+    [/axios/i, 'axios'],
+    [/\bgot\b/i, 'got'],
+    [/curl/i, 'curl'],
+    [/wget/i, 'wget'],
+    [/postman/i, 'postman'],
+    [/insomnia/i, 'insomnia'],
+    [/go-http-client/i, 'go-http-client'],
+    [/okhttp/i, 'okhttp'],
+    [/java/i, 'java'],
+    [/mozilla|chrome|safari|firefox|edg/i, 'browser'],
+];
+/** Bound a wire-supplied client identity scalar: printable, trimmed, and length-capped. */
+export function boundedClientScalar(value, max) {
+    if (value === undefined)
+        return undefined;
+    let cleaned = '';
+    for (const char of value) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code >= 0x20 && code !== 0x7f)
+            cleaned += char; // strip C0 controls and DEL
+    }
+    cleaned = cleaned.trim();
+    if (cleaned.length === 0)
+        return undefined;
+    return cleaned.length > max ? cleaned.slice(0, max) : cleaned;
+}
+export function boundedClientName(value) {
+    return boundedClientScalar(value, MAX_CLIENT_NAME);
+}
+export function boundedClientVersion(value) {
+    return boundedClientScalar(value, MAX_CLIENT_VERSION);
+}
+/**
+ * The bounded client family for one request. `clientInfo.name` wins (its sanitized token — the name
+ * itself is already retained, so the family adds no cardinality); otherwise the user agent maps
+ * through the closed table above; `other` for an unmatched agent, `unknown` for none at all.
+ */
+export function clientFamily(clientName, userAgent) {
+    if (clientName !== undefined) {
+        const token = clientName
+            .toLowerCase()
+            .replace(/[^a-z0-9._-]+/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .slice(0, MAX_FAMILY);
+        if (token.length > 0)
+            return token;
+    }
+    if (userAgent === undefined || userAgent.trim().length === 0)
+        return CLIENT_FAMILY_UNKNOWN;
+    for (const [pattern, family] of KNOWN_UA_FAMILIES) {
+        if (pattern.test(userAgent))
+            return family;
+    }
+    return CLIENT_FAMILY_OTHER;
+}
+/**
+ * Bounded, best-effort LRU memo from an analytics session id to the `initialize` client identity,
+ * keyed per tenant so one tenant's session ids can never resolve another's client names. Purely an
+ * attribution aid: entries are non-authoritative, evicted oldest-first, and never required.
+ */
+export class SessionClientMemo {
+    #entries = new Map();
+    #cap;
+    constructor(cap = 2048) {
+        this.#cap = cap;
+    }
+    remember(key, identity) {
+        if (identity.clientName === undefined && identity.clientVersion === undefined)
+            return;
+        if (this.#entries.has(key))
+            this.#entries.delete(key);
+        this.#entries.set(key, identity);
+        if (this.#entries.size > this.#cap) {
+            const oldest = this.#entries.keys().next().value;
+            if (oldest !== undefined)
+                this.#entries.delete(oldest);
+        }
+    }
+    recall(key) {
+        const found = this.#entries.get(key);
+        if (found !== undefined) {
+            // Refresh recency so active sessions survive eviction pressure.
+            this.#entries.delete(key);
+            this.#entries.set(key, found);
+        }
+        return found;
+    }
+    get size() {
+        return this.#entries.size;
+    }
+}
+/** Tenant-scoped memo key; the org always participates so keys cannot collide across tenants. */
+export function sessionClientKey(org, app, env, sessionId) {
+    return `${org}/${app ?? ''}/${env ?? ''}#${sessionId}`;
+}
+//# sourceMappingURL=client-identity.js.map

package/node_modules/@noodle-borg/transport-http/dist/identity-authorization.js

@@ -11,12 +11,12 @@ export async function authorizeIdentityMode(req, res, auth) {
     const token = bearerToken(req);
     if (token === null || auth.verifyOwnerToken === undefined) {
         sendUnauthorized(res, challenge);
-        return { allow: false };
+        return { allow: false, reason: token === null ? 'missing_token' : 'verifier_unavailable' };
     }
     const verification = await auth.verifyOwnerToken(token, canonicalResourceUrl(req, auth));
     if (verification === null) {
         sendUnauthorized(res, challenge);
-        return { allow: false };
+        return { allow: false, reason: 'token_rejected' };
     }
     const { caller: identity } = verification;
     if (identity.identityKind === 'service') {
@@ -36,18 +36,18 @@ export async function authorizeIdentityMode(req, res, auth) {
     if (auth.accessMode === 'customers') {
         if (identity.identityKind !== 'customer') {
             sendUnauthorized(res, challenge);
-            return { allow: false };
+            return { allow: false, reason: 'identity_not_customer' };
         }
         return { allow: true, caller: identity, ...privateCustomerContext };
     }
     if (auth.accessMode === 'owner-only') {
         if (auth.ownerSubject === undefined) {
             sendUnauthorized(res, challenge);
-            return { allow: false };
+            return { allow: false, reason: 'owner_unconfigured' };
         }
         if (identity.subject !== auth.ownerSubject) {
             sendForbidden(res);
-            return { allow: false };
+            return { allow: false, reason: 'owner_mismatch' };
         }
         return { allow: true, caller: identity, ...privateCustomerContext };
     }
@@ -65,7 +65,7 @@ export async function authorizeIdentityMode(req, res, auth) {
             });
         if (membership?.allowed !== true) {
             sendForbidden(res);
-            return { allow: false };
+            return { allow: false, reason: 'org_membership_denied' };
         }
     }
     return { allow: true, caller: identity, ...privateCustomerContext };
@@ -90,12 +90,12 @@ export async function authorizeMixedMode(req, res, auth) {
     const challenge = protectedResourceMetadataUrl(req, auth);
     if (auth.verifyOwnerToken === undefined) {
         sendUnauthorized(res, challenge);
-        return { allow: false };
+        return { allow: false, reason: 'verifier_unavailable' };
     }
     const verification = await auth.verifyOwnerToken(token, canonicalResourceUrl(req, auth));
     if (verification === null) {
         sendUnauthorized(res, challenge);
-        return { allow: false };
+        return { allow: false, reason: 'token_rejected' };
     }
     return {
         allow: true,

package/node_modules/@noodle-borg/transport-http/dist/request-capture.js

@@ -1,3 +1,13 @@
+import { boundedClientName, boundedClientVersion, clientFamily, SessionClientMemo, sessionClientKey, } from './client-identity.js';
+/**
+ * Best-effort per-process memo from a legacy analytics session id to its `initialize` clientInfo, so
+ * legacy tool calls keep client attribution when the client supplies `Mcp-Session-Id` (#1309).
+ */
+let sessionClientMemo = new SessionClientMemo();
+/** Test seam: drop all memoized session client identities. */
+export function resetSessionClientMemo() {
+    sessionClientMemo = new SessionClientMemo();
+}
 /** JSON-RPC methods that are protocol discovery/chatter, excluded from usage metrics (ADR 0121). */
 const DISCOVERY_METHODS = new Set([
     'server/discover',
@@ -33,6 +43,25 @@ export function emitRequestEvent(input) {
     const failed = res.statusCode >= 400;
     const toolName = observed?.toolName ?? (method === 'tools/call' ? rpcTargetName(first, method) : undefined);
     const errorKind = observed?.errorKind ?? (failed ? `http_${res.statusCode}` : undefined);
+    // Client identity: the request's own clientInfo wins; a legacy request that supplies a session id
+    // falls back to the identity memoized from that session's `initialize` (#1309). Values are bounded.
+    let clientName = boundedClientName(modern?.clientName ?? init?.clientName);
+    let clientVersion = boundedClientVersion(modern?.clientVersion ?? init?.clientVersion);
+    if (sessionId !== undefined) {
+        const key = sessionClientKey(org, tenant?.app ?? auth.app, tenant?.env ?? auth.environment, sessionId);
+        if (method === 'initialize' && clientName !== undefined) {
+            sessionClientMemo.remember(key, {
+                clientName,
+                ...(clientVersion === undefined ? {} : { clientVersion }),
+            });
+        }
+        else if (clientName === undefined) {
+            const recalled = sessionClientMemo.recall(key);
+            clientName = recalled?.clientName;
+            clientVersion ??= recalled?.clientVersion;
+        }
+    }
+    const family = clientFamily(clientName, header(req, 'user-agent'));
     const event = {
         org,
         ...(tenant !== undefined ? { app: tenant.app, env: tenant.env } : {}),
@@ -43,16 +72,9 @@ export function emitRequestEvent(input) {
         requestId,
         ...(sessionId !== undefined ? { sessionId } : {}),
         sessionSource: sessionId !== undefined ? 'mcp' : 'none',
-        ...(modern?.clientName !== undefined
-            ? { clientName: modern.clientName }
-            : init?.clientName !== undefined
-                ? { clientName: init.clientName }
-                : {}),
-        ...(modern?.clientVersion !== undefined
-            ? { clientVersion: modern.clientVersion }
-            : init?.clientVersion !== undefined
-                ? { clientVersion: init.clientVersion }
-                : {}),
+        ...(clientName !== undefined ? { clientName } : {}),
+        ...(clientVersion !== undefined ? { clientVersion } : {}),
+        clientFamily: family,
         ...(auth.accessMode !== undefined ? { accessMode: auth.accessMode } : {}),
         subjectKind: subject !== undefined ? 'authenticated' : 'anonymous',
         method,
@@ -63,9 +85,12 @@ export function emitRequestEvent(input) {
         outcome: observed?.outcome ?? (failed ? 'mcp_error' : 'ok'),
         ...(errorKind !== undefined ? { errorKind } : {}),
         durationMs: Date.now() - startedAt,
+        ...(input.timing?.queueMs !== undefined ? { queueMs: input.timing.queueMs } : {}),
+        ...(input.timing?.execMs !== undefined ? { execMs: input.timing.execMs } : {}),
         ...(observed?.outputTokensEst !== undefined
             ? { outputTokensEst: observed.outputTokensEst }
             : {}),
+        ...connectorDetails(observed),
     };
     try {
         capture(event);
@@ -74,6 +99,68 @@ export function emitRequestEvent(input) {
         // Analytics is strictly best-effort; a capture bug must never surface to the caller.
     }
 }
+/** Project the observation's safe connector attribution into the scalar-only `details` bag. */
+function connectorDetails(observed) {
+    const connector = observed?.connector;
+    if (connector === undefined)
+        return {};
+    return {
+        details: {
+            connectorId: connector.connectorId,
+            connectorVersion: connector.connectorVersion,
+            connectorOperation: connector.operation,
+            ...(connector.category !== undefined ? { connectorCategory: connector.category } : {}),
+            ...(connector.statusClass !== undefined
+                ? { connectorStatusClass: connector.statusClass }
+                : {}),
+            ...(connector.attempts !== undefined ? { connectorAttempts: connector.attempts } : {}),
+            ...(connector.retryable !== undefined ? { connectorRetryable: connector.retryable } : {}),
+        },
+    };
+}
+/**
+ * Reason a front-door denial (identity auth, admission, tool authorization) was sent before any
+ * protocol handler ran. Bounded reason tokens compose the analytics `errorKind` (#1309).
+ */
+export function emitDeniedRequestEvent(input) {
+    const { req, auth, tenant, target, parsed, startedAt, requestId, errorKind } = input;
+    const capture = auth.captureRequestEvent;
+    if (capture === undefined)
+        return;
+    const org = tenant?.org ?? auth.org;
+    if (org === undefined)
+        return;
+    const first = Array.isArray(parsed) ? parsed[0] : parsed;
+    const method = first === undefined ? 'unknown' : rpcMethod(first);
+    const toolName = method === 'tools/call' ? rpcTargetName(first, method) : undefined;
+    const modern = modernRequestInfo(first);
+    const sdkProtocolVersion = modern?.protocolVersion ?? header(req, 'mcp-protocol-version');
+    const event = {
+        org,
+        ...(tenant !== undefined ? { app: tenant.app, env: tenant.env } : {}),
+        ...(auth.deploymentId !== undefined ? { deploymentId: auth.deploymentId } : {}),
+        serverVersion: target.artifact.server.version,
+        ...(sdkProtocolVersion !== undefined ? { sdkProtocolVersion } : {}),
+        ...(first !== undefined ? { protocolEra: modern === undefined ? 'legacy' : 'modern' } : {}),
+        requestId,
+        sessionSource: 'none',
+        clientFamily: clientFamily(undefined, header(req, 'user-agent')),
+        ...(auth.accessMode !== undefined ? { accessMode: auth.accessMode } : {}),
+        subjectKind: 'anonymous',
+        method,
+        kind: 'usage',
+        ...(toolName !== undefined ? { toolName } : {}),
+        outcome: 'mcp_error',
+        errorKind,
+        durationMs: Date.now() - startedAt,
+    };
+    try {
+        capture(event);
+    }
+    catch {
+        // Analytics is strictly best-effort.
+    }
+}
 /** Emit validated intent observations into their separate operator stream. */
 export function emitIntentEvents(input) {
     const { req, target, auth, tenant, parsed, observations, requestId } = input;