feat: record command attrs on telemetry failure via fallbackAttrs

Add optional fallbackAttrs parameter to client.withCommandRun so
command-specific attributes are recorded even when the callback throws.

- client.ts: accept fallbackAttrs, use on failure instead of {}
- client.ts: run resilientParse on all non-empty attrs (not just success)
- cli-command-run.ts: withCommandRunTelemetry passes attrs as fallbackAttrs
- cli-command-run.ts: runCliCommand accepts optional knownAttrs param
- command.tsx: extract knownAttrs upfront, pass to runCliCommand
- client.test.ts: add unit tests for fallbackAttrs behavior
- create-edge-cases.test.ts: assert attrs present on failure entry

Author: Hweinstock

integ-tests/create-edge-cases.test.ts

@@ -38,6 +38,8 @@ describe.skipIf(!prereqs.npm || !prereqs.git)('integration: create edge cases',
       telemetry.assertMetricEmitted({
         command: 'create',
         exit_reason: 'failure',
+        language: 'python',
+        has_agent: 'true',
       });
     });
 

src/cli/commands/create/command.tsx

@@ -114,6 +114,18 @@ async function handleCreateCLI(options: CreateOptions): Promise<void> {
     process.exit(0);
   }
 
+  const knownAttrs = {
+    language: standardize(Language, options.language),
+    framework: standardize(Framework, options.framework),
+    model_provider: standardize(ModelProviderEnum, options.modelProvider),
+    memory: standardize(Memory, options.memory ?? 'none'),
+    protocol: standardize(Protocol, options.protocol ?? 'http'),
+    build: standardize(Build, options.build ?? 'codezip'),
+    agent_type: standardize(AgentType, options.type ?? 'create'),
+    network_mode: standardize(NetworkModeEnum, options.networkMode ?? 'public'),
+    has_agent: options.agent !== false,
+  };
+
   await runCliCommand('create', !!options.json, async () => {
     const validation = validateCreateOptions(options, cwd);
     if (!validation.valid) {
@@ -188,18 +200,8 @@ async function handleCreateCLI(options: CreateOptions): Promise<void> {
       }
     }
 
-    return {
-      language: standardize(Language, options.language),
-      framework: standardize(Framework, options.framework),
-      model_provider: standardize(ModelProviderEnum, options.modelProvider),
-      memory: standardize(Memory, options.memory ?? 'none'),
-      protocol: standardize(Protocol, options.protocol ?? 'http'),
-      build: standardize(Build, options.build ?? 'codezip'),
-      agent_type: standardize(AgentType, options.type ?? 'create'),
-      network_mode: standardize(NetworkModeEnum, options.networkMode ?? 'public'),
-      has_agent: options.agent !== false,
-    };
-  });
+    return knownAttrs;
+  }, knownAttrs);
 }
 
 export const registerCreate = (program: Command) => {

src/cli/telemetry/README.md

@@ -62,11 +62,12 @@ async function withCommandRunTelemetry<C extends Command, R extends OperationRes
 
 **Behavior:**
 
-- On success (`{ success: true }`): records success telemetry with `attrs`, returns the result.
-- On failure (`{ success: false, error }`): records failure telemetry, returns the result to the caller.
-- On throw: records failure telemetry, returns `{ success: false, error }` so callers don't leak unhandled rejections.
+- On success: records `attrs` with `exit_reason: 'success'`, returns the result.
+- On failure/throw: records `attrs` with `exit_reason: 'failure'`, returns `{ success: false, error }`.
 - If telemetry is unavailable: runs `fn()` untracked.
 
+Since `attrs` are passed upfront, they are always recorded — even on failure.
+
 **Example with attributes:**
 
 ```ts
@@ -95,6 +96,17 @@ await runCliCommand('add.widget', !!options.json, async () => {
 });
 ```
 
+To record attrs on failure, pass `knownAttrs` as the fourth argument:
+
+```ts
+const knownAttrs = { widget_type: standardize(WidgetType, options.type), count: options.items.length };
+await runCliCommand('add.widget', !!options.json, async () => {
+  const result = await widgetPrimitive.add(options);
+  if (!result.success) throw new Error(result.error);
+  return knownAttrs;
+}, knownAttrs);
+```
+
 ## Key Points
 
 - Telemetry never crashes the CLI — `standardize()` falls back gracefully, `resilientParse` defaults invalid fields to

src/cli/telemetry/__tests__/client.test.ts

@@ -173,5 +173,54 @@ describe('TelemetryClient', () => {
         exit_reason: 'cancel',
       });
     });
+
+    it('records fallbackAttrs on failure when provided', async () => {
+      const sink = new InMemorySink();
+      const client = new TelemetryClient(sink);
+
+      await expect(
+        client.withCommandRun(
+          'create',
+          async () => {
+            throw new Error('validation failed');
+          },
+          {
+            language: 'python',
+            framework: 'strands',
+            model_provider: 'bedrock',
+            memory: 'none',
+            protocol: 'http',
+            build: 'codezip',
+            agent_type: 'create',
+            network_mode: 'public',
+            has_agent: true,
+          }
+        )
+      ).rejects.toThrow('validation failed');
+
+      expect(sink.metrics).toHaveLength(1);
+      expect(sink.metrics[0]!.attrs).toMatchObject({
+        exit_reason: 'failure',
+        error_name: 'UnknownError',
+        language: 'python',
+        framework: 'strands',
+        model_provider: 'bedrock',
+        has_agent: 'true',
+      });
+    });
+
+    it('records empty attrs on failure when fallbackAttrs not provided', async () => {
+      const sink = new InMemorySink();
+      const client = new TelemetryClient(sink);
+
+      await expect(
+        client.withCommandRun('deploy', async () => {
+          throw new Error('boom');
+        })
+      ).rejects.toThrow('boom');
+
+      expect(sink.metrics).toHaveLength(1);
+      expect(sink.metrics[0]!.attrs.language).toBeUndefined();
+    });
   });
 });

src/cli/telemetry/cli-command-run.ts

@@ -35,7 +35,7 @@ export async function withCommandRunTelemetry<C extends Command, R extends Opera
       result = await fn();
       if (!result.success) throw new Error(result.error);
       return attrs;
-    });
+    }, attrs);
   } catch (e) {
     // withCommandRun re-throws after recording failure telemetry.
     // If result was set, fn() returned a failure result — return it directly.
@@ -52,19 +52,21 @@ export async function withCommandRunTelemetry<C extends Command, R extends Opera
  * Record telemetry, print errors, and exit the process.
  * Use in CLI command handlers where the command is the final action.
  * The callback returns attrs on success and throws on failure.
+ * Pass knownAttrs to record command-specific attributes even on failure.
  */
 export async function runCliCommand<C extends Command>(
   command: C,
   json: boolean,
-  fn: () => Promise<CommandAttrs<C>>
+  fn: () => Promise<CommandAttrs<C>>,
+  knownAttrs?: Partial<CommandAttrs<C>>
 ): Promise<never> {
   try {
     const client = await getTelemetryClient();
     if (!client) {
       await fn();
       process.exit(0);
     }
-    await client.withCommandRun(command, fn);
+    await client.withCommandRun(command, fn, knownAttrs);
     process.exit(0);
   } catch (error) {
     if (json) {

src/cli/telemetry/client.ts

@@ -26,7 +26,8 @@ export class TelemetryClient {
    */
   async withCommandRun<C extends Command>(
     command: C,
-    fn: () => CommandAttrs<C> | typeof CANCELLED | Promise<CommandAttrs<C> | typeof CANCELLED>
+    fn: () => CommandAttrs<C> | typeof CANCELLED | Promise<CommandAttrs<C> | typeof CANCELLED>,
+    fallbackAttrs?: Partial<CommandAttrs<C>>
   ): Promise<void> {
     const start = performance.now();
     try {
@@ -43,7 +44,7 @@ export class TelemetryClient {
         error_name: classifyError(err),
         is_user_error: isUserError(err),
       };
-      this.recordCommandRun(command, failureResult, {}, Math.round(performance.now() - start));
+      this.recordCommandRun(command, failureResult, fallbackAttrs ?? {}, Math.round(performance.now() - start));
       throw err;
     } finally {
       try {
@@ -75,11 +76,9 @@ export class TelemetryClient {
 
       // Validate command attrs resiliently: invalid fields default to 'unknown'
       // instead of dropping the entire metric.
-      // On failure/cancel the callback attrs are empty so validation is skipped.
-      const validatedAttrs =
-        result.exit_reason !== 'failure' && result.exit_reason !== 'cancel'
-          ? resilientParse(COMMAND_SCHEMAS[command], attrs as Record<string, unknown>)
-          : attrs;
+      const validatedAttrs = Object.keys(attrs as Record<string, unknown>).length > 0
+        ? resilientParse(COMMAND_SCHEMAS[command], attrs as Record<string, unknown>)
+        : attrs;
 
       const otelAttrs: Record<string, string | number> = {
         command_group: deriveCommandGroup(command),