viewer: preset member dropdown, eligible/not-eligible outcomes, clearer steps

Form: a scenario dropdown (eligible / not eligible) with read-only member fields instead of free-text input. Backend: thread an 'eligible' flag through $kickoff -> workflow -> eligibility so the synthesized CoverageEligibilityResponse is either in-force (copay) or not in force. Viewer: a colored verdict banner on the result, kickoff restored as step 01 with browser/Aidbox location chips, the link+QR shown as their own block above 'Behind the scenes', manifest panel shows the full poll history, and plainer step copy.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: spicyfalafel

aidbox-integrations/smart-health-link/src/handlers/shl.ts

@@ -48,6 +48,8 @@ export class ShlHandler {
       payerName,
       memberId: memberId ?? 'unknown',
       passcode: params.passcode,
+      // Optional demo control: pass eligible=false to synthesize a not-eligible result.
+      eligible: params.eligible !== 'false',
     });
 
     return json({

aidbox-integrations/smart-health-link/src/server.ts

@@ -71,6 +71,7 @@ const server = Bun.serve({
         payerName?: string;
         memberId?: string;
         passcode?: string;
+        eligible?: boolean;
       };
       try {
         body = (await req.json()) as typeof body;
@@ -89,6 +90,7 @@ const server = Bun.serve({
           payerName: body.payerName,
           memberId: body.memberId ?? 'unknown',
           passcode: body.passcode,
+          eligible: body.eligible,
         });
         return Response.json({
           shlinkId: result.shlinkId,

aidbox-integrations/smart-health-link/src/services/eligibility-workflow.ts

@@ -33,6 +33,7 @@ export class EligibilityWorkflow {
     payerName: string;
     memberId: string;
     passcode?: string;
+    eligible?: boolean;
   }): Promise<{ shlinkId: string; shlink: string; payload: SHLPayload }> {
     const minted = await this.shl.mintLink({
       label: `Eligibility result for ${input.memberName}`,
@@ -47,7 +48,7 @@ export class EligibilityWorkflow {
 
   private async runJob(
     shlinkId: string,
-    input: { memberName: string; payerName: string; memberId: string }
+    input: { memberName: string; payerName: string; memberId: string; eligible?: boolean }
   ): Promise<void> {
     try {
       await new Promise((resolve) =>

aidbox-integrations/smart-health-link/src/services/eligibility.ts

@@ -18,10 +18,47 @@ export class EligibilityService {
     memberName: string;
     payerName: string;
     memberId: string;
+    eligible?: boolean;
   }): Promise<{ id: string; resource: Record<string, unknown> }> {
-    // No registered patient or stored Coverage yet — the prospective member is
+    const isEligible = input.eligible !== false;
+    // No registered patient or stored Coverage yet: the prospective member is
     // pre-registration. We carry the coverage and the originating request as
     // contained resources so the response validates while staying self-contained.
+    const insurance = isEligible
+      ? [
+          {
+            coverage: { reference: '#coverage' },
+            inforce: true,
+            item: [
+              {
+                category: {
+                  coding: [
+                    {
+                      system: 'http://terminology.hl7.org/CodeSystem/ex-benefitcategory',
+                      code: '30',
+                      display: 'Health Benefit Plan Coverage',
+                    },
+                  ],
+                },
+                benefit: [
+                  {
+                    type: {
+                      coding: [
+                        {
+                          system: 'http://terminology.hl7.org/CodeSystem/benefit-type',
+                          code: 'copay',
+                          display: 'Copayment per service',
+                        },
+                      ],
+                    },
+                    allowedMoney: { value: 0, currency: 'USD' },
+                  },
+                ],
+              },
+            ],
+          },
+        ]
+      : [{ coverage: { reference: '#coverage' }, inforce: false }];
     const resource: Record<string, unknown> = {
       resourceType: 'CoverageEligibilityResponse',
       status: 'active',
@@ -50,42 +87,11 @@ export class EligibilityService {
       created: new Date().toISOString(),
       request: { reference: '#request' },
       outcome: 'complete',
-      disposition: `Member ${input.memberName} is eligible for services under ${input.payerName}.`,
+      disposition: isEligible
+        ? `Member ${input.memberName} is eligible for services under ${input.payerName}.`
+        : `Member ${input.memberName} is not eligible for services under ${input.payerName}.`,
       insurer: { display: input.payerName },
-      insurance: [
-        {
-          coverage: { reference: '#coverage' },
-          inforce: true,
-          item: [
-            {
-              category: {
-                coding: [
-                  {
-                    system: 'http://terminology.hl7.org/CodeSystem/ex-benefitcategory',
-                    code: '30',
-                    display: 'Health Benefit Plan Coverage',
-                  },
-                ],
-              },
-              benefit: [
-                {
-                  type: {
-                    coding: [
-                      {
-                        system:
-                          'http://terminology.hl7.org/CodeSystem/benefit-type',
-                        code: 'copay',
-                        display: 'Copayment per service',
-                      },
-                    ],
-                  },
-                  allowedMoney: { value: 0, currency: 'USD' },
-                },
-              ],
-            },
-          ],
-        },
-      ],
+      insurance,
     };
 
     const created = await this.fhir.create<{ id: string }>(