fix(kernel-utils): fix false negative in collectSheafGuard for rest-arg sections

`getGuardAt` was returning `undefined` for positions beyond a section's
fixed argument range, even when a `restArgGuard` was present. This caused
rest-arg sections to be absent from optional-position unions, producing
a false negative: e.g. `M.call().rest(M.string())` would not cover
position 0 in the union, so a call `['hello']` would fail the collected
guard even though the section accepts it.

Fix: fall through to `payload.restArgGuard` after exhausting the optional
array, so rest-arg sections contribute to every optional position in the
union.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: grypez

packages/kernel-utils/src/sheaf/guard.test.ts

@@ -9,6 +9,7 @@ import type { MethodGuard, Pattern } from '@endo/patterns';
 import { describe, it, expect } from 'vitest';
 
 import { collectSheafGuard } from './guard.ts';
+import { guardCoversPoint } from './stalk.ts';
 import type { Section } from './types.ts';
 
 const makeSection = (
@@ -159,6 +160,30 @@ describe('collectSheafGuard', () => {
     expect(matches(42, restArgGuard)).toBe(true);
   });
 
+  it('rest-arg section covers optional positions (no false negative)', () => {
+    // Section A requires 1 number; Section B requires 0 args but accepts any
+    // number of strings via rest. A call ['hello'] is covered by B — the
+    // collected guard must pass it too.
+    const sections = [
+      makeSection(
+        'AB:0',
+        { f: M.call(M.number()).returns(M.any()) },
+        { f: (_: number) => undefined },
+      ),
+      makeSection(
+        'AB:1',
+        { f: M.call().rest(M.string()).returns(M.any()) },
+        { f: (..._args: string[]) => undefined },
+      ),
+    ];
+
+    const guard = collectSheafGuard('AB', sections);
+
+    expect(guardCoversPoint(guard, 'f', ['hello'])).toBe(true); // covered by B
+    expect(guardCoversPoint(guard, 'f', [42])).toBe(true); // covered by A
+    expect(guardCoversPoint(guard, 'f', [])).toBe(true); // covered by B (0 required)
+  });
+
   it('multi-method guard collection', () => {
     const sections = [
       makeSection(

packages/kernel-utils/src/sheaf/guard.ts

@@ -74,7 +74,14 @@ export const collectSheafGuard = <Core extends Methods>(
     if (idx < payload.argGuards.length) {
       return payload.argGuards[idx];
     }
-    return payload.optionalArgGuards?.[idx - payload.argGuards.length];
+    const optIdx = idx - payload.argGuards.length;
+    if (
+      payload.optionalArgGuards &&
+      optIdx < payload.optionalArgGuards.length
+    ) {
+      return payload.optionalArgGuards[optIdx];
+    }
+    return payload.restArgGuard;
   };
 
   const unionMethodGuards: Record<string, MethodGuard> = {};