fix(test): address CodeRabbit review on failure triage

- Move --dry-run payload to sampleFailureTriageResult in samples.ts
- Use .option for --project so requireProjectId emits exit 5
- Build cluster labels from the chosen representative test
- Append short hash suffix to clusterId to avoid slug collisions

Author: SahilRakhaiya05

src/commands/test.ts

@@ -17,7 +17,7 @@ import {
   writeBundle,
   type WriteBundleResult,
 } from '../lib/bundle.js';
-import { findSample } from '../lib/dry-run/samples.js';
+import { findSample, sampleFailureTriageResult } from '../lib/dry-run/samples.js';
 import {
   ApiError,
   CLIError,
@@ -4065,78 +4065,7 @@ export async function runFailureTriage(
   const stderrFn = deps.stderr ?? ((line: string) => process.stderr.write(`${line}\n`));
 
   if (opts.dryRun) {
-    const dryRunResult: FailureTriageResult = {
-      projectId: opts.projectId,
-      clusters: [
-        {
-          clusterId: 'cluster_kind_network_timeout',
-          label: 'Environment issue (network_timeout)',
-          groupKey: 'kind:network_timeout',
-          groupReason: 'failure_kind',
-          failureKind: 'network_timeout',
-          representativeTestId: 'test_dryrun_a',
-          memberTestIds: ['test_dryrun_a', 'test_dryrun_b'],
-          members: [
-            {
-              testId: 'test_dryrun_a',
-              testName: 'Dry-run checkout flow',
-              testType: 'frontend',
-              updatedAt: '2026-06-26T12:00:00.000Z',
-              status: 'failed',
-              failureKind: 'network_timeout',
-              snapshotId: 'snap_dryrun_a',
-              rootCauseHypothesis: null,
-              recommendedFixTarget: null,
-            },
-            {
-              testId: 'test_dryrun_b',
-              testName: 'Dry-run profile update',
-              testType: 'frontend',
-              updatedAt: '2026-06-26T12:01:00.000Z',
-              status: 'failed',
-              failureKind: 'network_timeout',
-              snapshotId: 'snap_dryrun_b',
-              rootCauseHypothesis: null,
-              recommendedFixTarget: null,
-            },
-          ],
-          canonicalRootCause: null,
-          confidence: 0.88,
-          fixPriority: 1,
-        },
-        {
-          clusterId: 'cluster_ref_src_components_checkoutform_tsx_412',
-          label: 'Shared fix target: src/components/CheckoutForm.tsx:412',
-          groupKey: 'ref:src/components/CheckoutForm.tsx:412',
-          groupReason: 'fix_target',
-          failureKind: 'assertion',
-          representativeTestId: 'test_dryrun_c',
-          memberTestIds: ['test_dryrun_c'],
-          members: [
-            {
-              testId: 'test_dryrun_c',
-              testName: 'Dry-run submit checkout',
-              testType: 'frontend',
-              updatedAt: '2026-06-26T12:02:00.000Z',
-              status: 'failed',
-              failureKind: 'assertion',
-              snapshotId: 'snap_dryrun_c',
-              rootCauseHypothesis:
-                'Submit button is disabled because the credit-card field is empty.',
-              recommendedFixTarget: {
-                kind: 'code',
-                reference: 'src/components/CheckoutForm.tsx:412',
-                rationale: 'Disabled state originates from `isFormValid()`.',
-              },
-            },
-          ],
-          canonicalRootCause: 'Submit button is disabled because the credit-card field is empty.',
-          confidence: 0.7,
-          fixPriority: 3,
-        },
-      ],
-      summary: { totalFailed: 3, clusterCount: 2, skipped: 0 },
-    };
+    const dryRunResult = sampleFailureTriageResult(opts.projectId);
     out.print(dryRunResult, data => renderFailureTriageText(data as FailureTriageResult));
     return dryRunResult;
   }
@@ -8922,7 +8851,7 @@ function createTestFailureCommand(deps: TestDeps): Command {
     .description(
       'Group all failed tests in a project into root-cause clusters (lightweight summary fan-out — no bundle downloads)',
     )
-    .requiredOption('--project <id>', 'project id (returned by `testsprite project list`)')
+    .option('--project <id>', 'project id (returned by `testsprite project list`)')
     .option('--type <type>', 'filter by test type (frontend|backend)')
     .option(
       '--filter <substr>',
@@ -8950,13 +8879,13 @@ function createTestFailureCommand(deps: TestDeps): Command {
     )
     .action(
       async (
-        cmdOpts: { project: string; type?: string; filter?: string; maxConcurrency?: string },
+        cmdOpts: { project?: string; type?: string; filter?: string; maxConcurrency?: string },
         command: Command,
       ) => {
         await runFailureTriage(
           {
             ...resolveCommonOptions(command),
-            projectId: cmdOpts.project,
+            projectId: cmdOpts.project ?? '',
             type: parseEnumFlag(cmdOpts.type, 'type', TEST_TYPES),
             nameFilter: cmdOpts.filter,
             maxConcurrency:

src/lib/dry-run/samples.test.ts

@@ -1,5 +1,25 @@
 import { describe, expect, it } from 'vitest';
-import { DRY_RUN_SAMPLE_ENTRIES, findSample } from './samples.js';
+import { DRY_RUN_SAMPLE_ENTRIES, findSample, sampleFailureTriageResult } from './samples.js';
+
+describe('sampleFailureTriageResult', () => {
+  it('returns a FailureTriageResult envelope wired for --dry-run', () => {
+    const result = sampleFailureTriageResult('proj_dry');
+    expect(result.projectId).toBe('proj_dry');
+    expect(result.summary).toEqual({ totalFailed: 3, clusterCount: 2, skipped: 0 });
+    expect(result.clusters).toHaveLength(2);
+    expect(result.clusters[0]).toMatchObject({
+      groupReason: 'failure_kind',
+      representativeTestId: expect.any(String),
+      memberTestIds: expect.any(Array),
+      confidence: expect.any(Number),
+      fixPriority: expect.any(Number),
+    });
+    expect(result.clusters[1]).toMatchObject({
+      groupReason: 'fix_target',
+      label: expect.stringContaining('Shared fix target:'),
+    });
+  });
+});
 
 describe('findSample', () => {
   it('resolves /me', () => {

src/lib/dry-run/samples.ts

@@ -27,6 +27,7 @@ import type {
   CliTestStep,
 } from '../../commands/test.js';
 import type { MeResponse } from '../../commands/auth.js';
+import type { FailureTriageResult } from '../failure-triage.js';
 import type { Page } from '../pagination.js';
 import type {
   TriggerRunResponse,
@@ -309,6 +310,86 @@ const failureSummary: CliFailureSummary = {
   recommendedFixTarget: failureContext.failure.recommendedFixTarget,
 };
 
+/**
+ * Canned response for `test failure triage --dry-run`. Client-side
+ * orchestration command — not a single backend endpoint — so the full
+ * clustered envelope lives here alongside the per-route samples above.
+ */
+export function sampleFailureTriageResult(projectId: string): FailureTriageResult {
+  return {
+    projectId,
+    clusters: [
+      {
+        clusterId: 'cluster_kind_network_timeout',
+        label: 'Environment issue (network_timeout)',
+        groupKey: 'kind:network_timeout',
+        groupReason: 'failure_kind',
+        failureKind: 'network_timeout',
+        representativeTestId: 'test_dryrun_a',
+        memberTestIds: ['test_dryrun_a', 'test_dryrun_b'],
+        members: [
+          {
+            testId: 'test_dryrun_a',
+            testName: 'Dry-run checkout flow',
+            testType: 'frontend',
+            updatedAt: '2026-06-26T12:00:00.000Z',
+            status: 'failed',
+            failureKind: 'network_timeout',
+            snapshotId: 'snap_dryrun_a',
+            rootCauseHypothesis: null,
+            recommendedFixTarget: null,
+          },
+          {
+            testId: 'test_dryrun_b',
+            testName: 'Dry-run profile update',
+            testType: 'frontend',
+            updatedAt: '2026-06-26T12:01:00.000Z',
+            status: 'failed',
+            failureKind: 'network_timeout',
+            snapshotId: 'snap_dryrun_b',
+            rootCauseHypothesis: null,
+            recommendedFixTarget: null,
+          },
+        ],
+        canonicalRootCause: null,
+        confidence: 0.88,
+        fixPriority: 1,
+      },
+      {
+        clusterId: 'cluster_ref_src_components_checkoutform_tsx_412',
+        label: 'Shared fix target: src/components/CheckoutForm.tsx:412',
+        groupKey: 'ref:src/components/CheckoutForm.tsx:412',
+        groupReason: 'fix_target',
+        failureKind: 'assertion',
+        representativeTestId: 'test_dryrun_c',
+        memberTestIds: ['test_dryrun_c'],
+        members: [
+          {
+            testId: 'test_dryrun_c',
+            testName: 'Dry-run submit checkout',
+            testType: 'frontend',
+            updatedAt: '2026-06-26T12:02:00.000Z',
+            status: 'failed',
+            failureKind: 'assertion',
+            snapshotId: 'snap_dryrun_c',
+            rootCauseHypothesis:
+              'Submit button is disabled because the credit-card field is empty.',
+            recommendedFixTarget: {
+              kind: 'code',
+              reference: 'src/components/CheckoutForm.tsx:412',
+              rationale: 'Disabled state originates from `isFormValid()`.',
+            },
+          },
+        ],
+        canonicalRootCause: 'Submit button is disabled because the credit-card field is empty.',
+        confidence: 0.7,
+        fixPriority: 3,
+      },
+    ],
+    summary: { totalFailed: 3, clusterCount: 2, skipped: 0 },
+  };
+}
+
 /**
  * Dry-run sample lookup keyed by OpenAPI operationId. Order matters in
  * {@link findSample}: more specific patterns must precede their generic

src/lib/failure-triage.test.ts

@@ -209,4 +209,76 @@ describe('buildFailureClusters', () => {
     expect(result.clusters).toEqual([]);
     expect(result.summary.totalFailed).toBe(0);
   });
+
+  it('labels hypothesis clusters from the representative test, not map-insertion order', () => {
+    const sharedHyp = 'Shared login validation failure across checkout flows.';
+    const result = buildFailureClusters('proj_hyp', [
+      makeInput({
+        testId: 't_first',
+        updatedAt: '2026-06-20T00:00:00.000Z',
+        summary: {
+          status: 'failed',
+          failureKind: 'assertion',
+          snapshotId: 'snap_first',
+          rootCauseHypothesis: sharedHyp,
+          recommendedFixTarget: null,
+        },
+      }),
+      makeInput({
+        testId: 't_recent',
+        updatedAt: '2026-06-26T00:00:00.000Z',
+        summary: {
+          status: 'failed',
+          failureKind: 'assertion',
+          snapshotId: 'snap_recent',
+          rootCauseHypothesis: sharedHyp,
+          recommendedFixTarget: null,
+        },
+      }),
+    ]);
+
+    const cluster = result.clusters[0]!;
+    expect(cluster.representativeTestId).toBe('t_recent');
+    expect(cluster.label).toBe(sharedHyp);
+    expect(cluster.canonicalRootCause).toBe(sharedHyp);
+  });
+
+  it('assigns distinct clusterIds when slug prefixes would otherwise collide', () => {
+    const longRef = `${'a'.repeat(50)}`;
+    const result = buildFailureClusters('proj_collide', [
+      makeInput({
+        testId: 't_one',
+        summary: {
+          status: 'failed',
+          failureKind: 'assertion',
+          snapshotId: 'snap_one',
+          rootCauseHypothesis: null,
+          recommendedFixTarget: {
+            kind: 'code',
+            reference: `${longRef}_one`,
+            rationale: 'First target',
+          },
+        },
+      }),
+      makeInput({
+        testId: 't_two',
+        summary: {
+          status: 'failed',
+          failureKind: 'assertion',
+          snapshotId: 'snap_two',
+          rootCauseHypothesis: null,
+          recommendedFixTarget: {
+            kind: 'code',
+            reference: `${longRef}_two`,
+            rationale: 'Second target',
+          },
+        },
+      }),
+    ]);
+
+    expect(result.clusters).toHaveLength(2);
+    expect(result.clusters[0]!.clusterId).not.toBe(result.clusters[1]!.clusterId);
+    expect(result.clusters[0]!.clusterId).toMatch(/_[0-9a-f]{8}$/);
+    expect(result.clusters[1]!.clusterId).toMatch(/_[0-9a-f]{8}$/);
+  });
 });

src/lib/failure-triage.ts

@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto';
+
 /**
  * Client-side failure triage — groups per-test failure summaries into
  * root-cause clusters using deterministic heuristics over existing
@@ -190,11 +192,10 @@ export function computeFixPriority(
 
 function buildClusterLabel(
   groupReason: FailureTriageGroupReason,
-  members: FailureTriageMember[],
+  representative: FailureTriageMember,
   failureKind: string | null,
 ): string {
-  const rep = members.find(m => m.recommendedFixTarget?.reference) ?? members[0]!;
-  const ref = rep.recommendedFixTarget?.reference;
+  const ref = representative.recommendedFixTarget?.reference;
 
   if (groupReason === 'fix_target' && ref) {
     return `Shared fix target: ${ref}`;
@@ -203,21 +204,22 @@ function buildClusterLabel(
     return `Environment issue (${failureKind})`;
   }
   if (groupReason === 'hypothesis') {
-    const hyp = rep.rootCauseHypothesis;
+    const hyp = representative.rootCauseHypothesis;
     if (hyp) {
       return hyp.length > 80 ? `${hyp.slice(0, 77)}…` : hyp;
     }
   }
-  return `Independent failure: ${rep.testName}`;
+  return `Independent failure: ${representative.testName}`;
 }
 
 function slugifyClusterId(groupKey: string): string {
   const slug = groupKey
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '_')
-    .replace(/^_|_$/g, '')
-    .slice(0, 48);
-  return slug.length > 0 ? slug : 'unknown';
+    .replace(/^_|_$/g, '');
+  const hash = createHash('sha256').update(groupKey).digest('hex').slice(0, 8);
+  const prefix = slug.length > 0 ? slug.slice(0, 48) : 'unknown';
+  return `${prefix}_${hash}`;
 }
 
 function toMember(input: FailureTriageInput): FailureTriageMember {
@@ -267,7 +269,7 @@ export function buildFailureClusters(
 
     clusters.push({
       clusterId: `cluster_${slugifyClusterId(groupKey)}`,
-      label: buildClusterLabel(reason, members, failureKind),
+      label: buildClusterLabel(reason, rep, failureKind),
       groupKey,
       groupReason: reason,
       failureKind,