test(fdm): cover workflow and ruleset projections (#1751)

Co-authored-by: codex <codex@example.com>

Author: kubohiroya

docs/fdm-seven-layer-contract-audit.md

@@ -62,7 +62,7 @@ The initial implementation keeps node data version `1` and preserves existing se
 - Payloads that specify both old and new aliases with conflicting values are rejected.
 - Axis maps still contain the four visible dashboard slots, but each slot can choose either legacy or canonical axis names.
 - `fdmSweep` is the primary FDM sweep mutation. `fdmVerify` remains a compatibility mutation while upstream keeps exposing it.
-- Dedicated run/job lifecycle, workflow projection, ruleset governance, and lifecycle-aware space mutation stay gated until the matching ide-gsm schema capabilities are available.
+- Dedicated run/job lifecycle and lifecycle-aware space mutation stay gated until the matching ide-gsm schema capabilities are available. L4 workflow and L5 ruleset projections are represented as optional server-provided dashboard projections; unavailable, stale, and unsupported states are displayed without client-side inference.
 
 ## Dashboard adapter implementation
 
@@ -89,8 +89,8 @@ Phase B1 now keeps each layer represented by an executable fixture or an explici
 | L1 parameter set | `parameterSet` / `profile` saved-node normalization | covered |
 | L2 range snapshot | `resultRef` to `snapshot.resultRef` projection | covered |
 | L3 run/job | runtime-event bridge payload and forbidden credential-key rejection | covered |
-| L4 workflow | workflow projection acceptance and unknown enum rejection | covered |
-| L5 ruleset | ruleset governance projection acceptance | covered |
+| L4 workflow | workflow projection acceptance, full known enum coverage, unknown enum rejection, and representative UI states | covered |
+| L5 ruleset | ruleset governance projection acceptance, fingerprint/digest display, missing issue-number visibility, and unavailable/stale UI states | covered |
 | L6 space | space catalog metadata with explicit unavailable or unscoped capability provenance | covered, pending #1735/#1736 action/view expansion |
 
 Later issues should extend these fixtures instead of creating divergent local terminology. #1732 adds read-only intake for baseline/fork/lineage capability summaries without per-space inference, #1735 owns lifecycle dry-run/safety wiring, and #1736 owns fork/cross-space read-only dashboard views.

packages/fdm-api/src/__tests__/fdmDashboardValidators.test.ts

@@ -1,6 +1,10 @@
 import {
   assertFdmDashboardResponse,
   type FdmDashboardResponse,
+  type FdmWorkflowNextAction,
+  type FdmWorkflowOperationOutcome,
+  type FdmWorkflowOperationStatus,
+  type FdmWorkflowStatus,
   filterFdmCells,
   normalizeFdmDashboardResponse,
   projectFdmCellAxisKey,
@@ -277,6 +281,98 @@ describe('fdm dashboard validators', () => {
     ).not.toThrow();
   });
 
+  it('accepts every upstream workflow projection enum value explicitly', () => {
+    const workflowStatuses: readonly FdmWorkflowStatus[] = [
+      'CREATED',
+      'PREFLIGHT_FAILED',
+      'RUNNING',
+      'DIAGNOSING',
+      'WAITING_FOR_AGENT',
+      'RECHECKING_REPAIR',
+      'WAITING_FOR_HUMAN',
+      'COMPLETED',
+      'COMPLETED_WITH_WAIVER',
+      'ABORTED',
+      'CANCELLED',
+      'VERIFYING_REPAIR',
+      'COMPLETE',
+    ];
+    const operationStatuses: readonly FdmWorkflowOperationStatus[] = [
+      'PENDING',
+      'READY',
+      'RUNNING',
+      'TERMINAL',
+      'UNKNOWN_AFTER_INTERRUPTION',
+    ];
+    const operationOutcomes: readonly FdmWorkflowOperationOutcome[] = [
+      'SUCCEEDED',
+      'DRIFTED',
+      'MISSING_ARTIFACT',
+      'UNSUPPORTED_CAPABILITY',
+      'EXECUTION_FAILED',
+      'CANCELLED',
+      'SKIPPED',
+    ];
+    const nextActions: readonly FdmWorkflowNextAction[] = [
+      'await-dependency',
+      'complete-workflow',
+      'execute-operation',
+      'request-agent-work',
+      'rerun-producer',
+      'run-diagnosis',
+      'retry-operation',
+    ];
+
+    for (const status of workflowStatuses) {
+      expect(() =>
+        assertFdmDashboardResponse({
+          ...response,
+          workflow: {
+            availability: 'available',
+            status,
+          },
+        })
+      ).not.toThrow();
+    }
+
+    for (const status of operationStatuses) {
+      expect(() =>
+        assertFdmDashboardResponse({
+          ...response,
+          workflow: {
+            availability: 'available',
+            operations: [{ id: `operation-${status}`, status }],
+          },
+        })
+      ).not.toThrow();
+    }
+
+    for (const outcome of operationOutcomes) {
+      expect(() =>
+        assertFdmDashboardResponse({
+          ...response,
+          workflow: {
+            availability: 'available',
+            operations: [{ id: `operation-${outcome}`, status: 'TERMINAL', outcome }],
+          },
+        })
+      ).not.toThrow();
+    }
+
+    for (const nextAction of nextActions) {
+      expect(() =>
+        assertFdmDashboardResponse({
+          ...response,
+          workflow: {
+            availability: 'available',
+            nextAction,
+            operations: [{ id: `operation-${nextAction}`, status: 'READY', nextAction }],
+          },
+        })
+      ).not.toThrow();
+    }
+  });
+
   it('rejects unknown workflow projection enum values', () => {
     expect(() =>
       assertFdmDashboardResponse({

plugins/fdm-plugin/src/ui/dashboard/FdmDashboardPresentation.tsx

@@ -252,6 +252,12 @@ function ProjectionStatusBar({
             {ruleset.version ? (
               <Chip size="small" label={ruleset.version} variant="outlined" />
             ) : null}
+            {ruleset.fingerprint ? (
+              <Chip size="small" label={ruleset.fingerprint} variant="outlined" />
+            ) : null}
+            {ruleset.digest ? (
+              <Chip size="small" label={ruleset.digest} variant="outlined" />
+            ) : null}
           </Stack>
           {ruleset.message ? (
             <Typography variant="caption" color="text.secondary">

plugins/fdm-plugin/src/ui/dashboard/__tests__/FdmDashboardView.test.tsx

@@ -273,6 +273,8 @@ describe('FdmDashboardView', () => {
         ruleset: {
           availability: 'stale',
           rulesetId: 'ruleset-a',
+          fingerprint: 'fingerprint-a',
+          digest: 'sha256:ruleset-a',
           acceptedKnownIssues: [{ reason: 'Missing server issue number' }],
           message: 'Ruleset requires server-side revalidation',
         },
@@ -289,6 +291,65 @@ describe('FdmDashboardView', () => {
     ).toBeInTheDocument();
     expect(screen.getByText('Ruleset')).toBeInTheDocument();
     expect(screen.getByText('ruleset-a')).toBeInTheDocument();
+    expect(screen.getByText('fingerprint-a')).toBeInTheDocument();
+    expect(screen.getByText('sha256:ruleset-a')).toBeInTheDocument();
+    expect(screen.getByText(/accepted known issue: unavailable/)).toBeInTheDocument();
+  });
+
+  it.each([
+    ['WAITING_FOR_AGENT', 'request-agent-work', 'Agent work is required'],
+    ['RECHECKING_REPAIR', 'retry-operation', 'Repair recheck is running'],
+    ['COMPLETED_WITH_WAIVER', 'complete-workflow', 'Workflow completed with a server waiver'],
+  ] as const)(
+    'renders the server-provided workflow state %s',
+    async (status, nextAction, message) => {
+      const port: FdmDashboardPort = {
+        loadDashboard: vi.fn().mockResolvedValue({
+          ...response,
+          workflow: {
+            availability: 'available',
+            workflowId: `workflow-${status}`,
+            status,
+            nextAction,
+            message,
+          },
+        }),
+        performAction: vi.fn(),
+      };
+
+      render(<FdmDashboardView node={response.node} port={port} />);
+
+      expect(await screen.findByText(status)).toBeInTheDocument();
+      expect(screen.getByText(nextAction)).toBeInTheDocument();
+      expect(screen.getByText(message)).toBeInTheDocument();
+    }
+  );
+
+  it('renders unavailable and unsupported projection states as server contract messages', async () => {
+    const port: FdmDashboardPort = {
+      loadDashboard: vi.fn().mockResolvedValue({
+        ...response,
+        workflow: {
+          availability: 'unsupported',
+          message: 'Workflow projection is not exposed by this server',
+        },
+        ruleset: {
+          availability: 'unavailable',
+          message: 'Ruleset governance metadata is unavailable',
+          acceptedKnownIssues: [{ reason: 'Server did not provide an issue number' }],
+        },
+      }),
+      performAction: vi.fn(),
+    };
+
+    render(<FdmDashboardView node={response.node} port={port} />);
+
+    expect(await screen.findByText('unsupported')).toBeInTheDocument();
+    expect(
+      screen.getByText('Workflow projection is not exposed by this server')
+    ).toBeInTheDocument();
+    expect(screen.getByText('unavailable')).toBeInTheDocument();
+    expect(screen.getByText('Ruleset governance metadata is unavailable')).toBeInTheDocument();
     expect(screen.getByText(/accepted known issue: unavailable/)).toBeInTheDocument();
   });