@ikenga/contract 0.9.1 → 0.11.0

package/dist/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAE5D,gFAAgF;;YA/BhF,4DAA4D;;YAE5D,0DAA0D;;;;;;;;;QA+B1D;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaH,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAIxD,eAAO,MAAM,mBAAmB;IAC9B,qBAAqB;;IAErB,qBAAqB;;IAErB;;;;;OAKG;;IAEH,4EAA4E;;IAE5E,2EAA2E;;IAE3E;;;;OAIG;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;EAEH,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,mBAAmB;;IAE9B,wDAAwD;;;QAnCxD,qBAAqB;;QAErB,qBAAqB;;QAErB;;;;;WAKG;;QAEH,4EAA4E;;QAE5E,2EAA2E;;QAE3E;;;;WAIG;;QAEH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUH,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAIhE;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikenga/contract",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "Shared contract for the Ikenga pkg system: manifest schema, RPC types, Engine interface, capability scopes.",
   "license": "Apache-2.0",
   "repository": {
@@ -51,6 +51,10 @@
     "./browser": {
       "types": "./dist/browser.d.ts",
       "import": "./dist/browser.js"
+    },
+    "./pa-actions": {
+      "types": "./dist/pa-actions.d.ts",
+      "import": "./dist/pa-actions.js"
     }
   },
   "files": [

package/src/browser.ts

@@ -43,6 +43,21 @@ export const BrowserRefSchema = z
 
 export type BrowserRef = z.infer<typeof BrowserRefSchema>;
 
+// ---------- Engine ----------
+//
+// Which underlying browser engine backs a pane. `webkit` (default) is the
+// in-shell child-webview (WebKitGTK on Linux / WKWebView / WebView2). `chrome`
+// is "Managed mode": the shell launches the user's installed Google Chrome with
+// a dedicated `--user-data-dir` + `--remote-debugging-port` and drives it over
+// CDP. The engine is chosen at `open()`; subsequent actions address the pane by
+// id and inherit its engine. See plans/chrome-pkg/01-plan.md §Architecture.
+
+export const BROWSER_ENGINES = ['webkit', 'chrome'] as const;
+
+export const BrowserEngineSchema = z.enum(BROWSER_ENGINES);
+
+export type BrowserEngine = z.infer<typeof BrowserEngineSchema>;
+
 // ---------- Snapshot ----------
 //
 // Mirrors the shape of Iyke's `DomResult` so models can move between the
@@ -119,8 +134,17 @@ export const BrowserOpenInputSchema = z
      * Optional initial rect in main-window-client coordinates. Omitted when
      * the FE owns layout (the kernel will refuse without a rect; the MCP
      * layer is expected to supply a sane default if the caller didn't).
+     *
+     * Ignored for `engine: "chrome"` — Managed Chrome renders in its own OS
+     * window, not a shell pane.
      */
     rect: RectSchema.optional(),
+    /**
+     * Which engine backs this pane. Defaults to `"webkit"` (the in-shell
+     * child-webview). `"chrome"` is Managed mode (installed Chrome over CDP).
+     * The pkg must declare the engine in `capabilities.webview.engines`.
+     */
+    engine: BrowserEngineSchema.default('webkit'),
   })
   .refine((v) => !(v.partition && v.session), {
     message: 'pass at most one of `partition` / `session`',
@@ -132,6 +156,8 @@ export const BrowserOpenResultSchema = z.object({
   id: BrowserPaneIdSchema,
   url: z.string(),
   partition: z.string(),
+  /** The resolved engine backing this pane (`"webkit"` if absent, for back-compat). */
+  engine: BrowserEngineSchema.default('webkit'),
 });
 
 export type BrowserOpenResult = z.infer<typeof BrowserOpenResultSchema>;
@@ -147,6 +173,8 @@ export const BrowserListEntrySchema = z.object({
   url: z.string(),
   partition: z.string(),
   focused: z.boolean(),
+  /** Which engine backs this pane (`"webkit"` if absent, for back-compat). */
+  engine: BrowserEngineSchema.default('webkit'),
 });
 
 export type BrowserListEntry = z.infer<typeof BrowserListEntrySchema>;

package/src/canvas/Canvas.tsx

@@ -51,6 +51,8 @@ function CanvasInner<T>(props: CanvasProps<T>, ref: React.Ref<CanvasHandle>) {
     onEditModeChange,
     onSelectionChange,
     autoFitOnResize = true,
+    keyboardPan = true,
+    ariaLabel = 'Canvas',
     className,
   } = props;
 
@@ -58,6 +60,7 @@ function CanvasInner<T>(props: CanvasProps<T>, ref: React.Ref<CanvasHandle>) {
     layout,
     editMode,
     autoFitOnResize,
+    keyboardPan,
     onViewportChange,
     onEditModeChange,
     onSelectionChange,
@@ -83,6 +86,14 @@ function CanvasInner<T>(props: CanvasProps<T>, ref: React.Ref<CanvasHandle>) {
       const id = itemEl.getAttribute('data-id') as ItemId | null;
       if (!id) return;
       onSelectionChange?.(id);
+      // Move DOM focus to the newly-selected item so keyboard users land on it
+      // and screen readers announce the selection (WCAG 2.4.3 Focus Order). The
+      // rAF waits for React to commit the tabIndex={0} / aria-selected update.
+      requestAnimationFrame(() =>
+        canvasRef.current
+          ?.querySelector<HTMLElement>(`[data-id="${CSS.escape(id)}"]`)
+          ?.focus()
+      );
       beginDrag(id, e.clientX, e.clientY);
       e.preventDefault();
       return;
@@ -107,6 +118,9 @@ function CanvasInner<T>(props: CanvasProps<T>, ref: React.Ref<CanvasHandle>) {
       ref={canvasRef}
       className={className ? `ikenga-canvas ${className}` : 'ikenga-canvas'}
       data-mode-edit={editMode ? 'true' : 'false'}
+      role="application"
+      aria-label={ariaLabel}
+      tabIndex={0}
       onMouseDown={onMouseDown}
       onDoubleClick={onDoubleClick}
     >
@@ -144,7 +158,17 @@ function CanvasInner<T>(props: CanvasProps<T>, ref: React.Ref<CanvasHandle>) {
             'data-id': id,
             style: injected,
             className,
-          } as Partial<typeof el.props> & { key: string; 'data-id': string });
+            // Selected item is programmatically focusable (tabIndex 0) and
+            // announces its selected state; unselected items stay out of the
+            // tab sequence (tabIndex -1) like a roving tablist (WCAG 2.4.3).
+            'aria-selected': isSelected,
+            tabIndex: isSelected ? 0 : -1,
+          } as Partial<typeof el.props> & {
+            key: string;
+            'data-id': string;
+            'aria-selected': boolean;
+            tabIndex: number;
+          });
         })}
       </div>
 

package/src/canvas/types.ts

@@ -38,6 +38,10 @@ export interface CanvasProps<T> {
   onEditModeChange?: (editMode: boolean) => void;
   onSelectionChange?: (selectedId: ItemId | null) => void;
   autoFitOnResize?: boolean; // default true
+  /** Arrow-key pan + +/- zoom when the canvas root is focused. Default true (WCAG 2.5.7). */
+  keyboardPan?: boolean;
+  /** Accessible name on the role="application" canvas root. Default 'Canvas'. */
+  ariaLabel?: string;
   className?: string;
   /** Consumer chrome (top bar, palette) rendered inside the canvas surface. */
   children?: ReactNode;

package/src/canvas/use-pan-zoom.ts

@@ -18,6 +18,8 @@ export interface UsePanZoomArgs {
   editMode: boolean;
   /** Re-fit on window resize. Default true. */
   autoFitOnResize?: boolean;
+  /** Arrow-key pan + +/- zoom when the canvas root is focused. Default true (WCAG 2.5.7). */
+  keyboardPan?: boolean;
   /** Notified whenever the viewport pan/scale changes (controlled mirror). */
   onViewportChange?: (viewport: Viewport) => void;
   /** Escape exits edit mode → parent owns the state flip. */
@@ -49,6 +51,7 @@ export function usePanZoom(args: UsePanZoomArgs): UsePanZoom {
     layout,
     editMode,
     autoFitOnResize = true,
+    keyboardPan = true,
     onViewportChange,
     onEditModeChange,
     onSelectionChange,
@@ -130,7 +133,9 @@ export function usePanZoom(args: UsePanZoomArgs): UsePanZoom {
     autoFit(true);
   }, [editMode, autoFit]);
 
-  // Keyboard — Escape exits edit, Space arms the pan-grab cursor.
+  // Keyboard — Escape exits edit, Space arms the pan-grab cursor. When the
+  // canvas root itself holds focus, arrow keys pan and +/- zoom: the keyboard
+  // alternative to space+drag / pinch-zoom (WCAG 2.5.7 Dragging Movements).
   useEffect(() => {
     const down = (e: KeyboardEvent) => {
       if (e.key === 'Escape' && editMode) {
@@ -147,6 +152,42 @@ export function usePanZoom(args: UsePanZoomArgs): UsePanZoom {
         canvasRef.current.style.cursor = 'grab';
         e.preventDefault();
       }
+      // Arrow-pan / +/- zoom only when the canvas surface itself is focused,
+      // so widget-internal controls keep their own arrow-key semantics.
+      if (keyboardPan && canvasRef.current && document.activeElement === canvasRef.current) {
+        // 24 canvas units per step, scaled so the on-screen nudge feels
+        // consistent at any zoom level.
+        const PAN_STEP = 24;
+        const ZOOM_STEP = 0.1;
+        switch (e.key) {
+          case 'ArrowUp':
+            setPan((p) => ({ ...p, y: p.y + PAN_STEP * p.scale }));
+            e.preventDefault();
+            break;
+          case 'ArrowDown':
+            setPan((p) => ({ ...p, y: p.y - PAN_STEP * p.scale }));
+            e.preventDefault();
+            break;
+          case 'ArrowLeft':
+            setPan((p) => ({ ...p, x: p.x + PAN_STEP * p.scale }));
+            e.preventDefault();
+            break;
+          case 'ArrowRight':
+            setPan((p) => ({ ...p, x: p.x - PAN_STEP * p.scale }));
+            e.preventDefault();
+            break;
+          default:
+            // '=' shares the key with '+'; both Equal and NumpadAdd zoom in.
+            if (e.code === 'Equal' || e.code === 'NumpadAdd') {
+              setPan((p) => ({ ...p, scale: Math.min(2, p.scale + ZOOM_STEP) }));
+              e.preventDefault();
+            } else if (e.code === 'Minus' || e.code === 'NumpadSubtract') {
+              setPan((p) => ({ ...p, scale: Math.max(0.2, p.scale - ZOOM_STEP) }));
+              e.preventDefault();
+            }
+            break;
+        }
+      }
     };
     const up = (e: KeyboardEvent) => {
       if (e.code === 'Space') {
@@ -160,7 +201,7 @@ export function usePanZoom(args: UsePanZoomArgs): UsePanZoom {
       window.removeEventListener('keydown', down);
       window.removeEventListener('keyup', up);
     };
-  }, [editMode, onEditModeChange, onSelectionChange]);
+  }, [editMode, keyboardPan, onEditModeChange, onSelectionChange]);
 
   const beginPan = useCallback((clientX: number, clientY: number) => {
     const p = panRef.current;

package/src/index.ts

@@ -7,6 +7,7 @@ export * from './iyke.js';
 export * from './artifact.js';
 export * from './registry.js';
 export * from './browser.js';
+export * from './pa-actions.js';
 
 /** This package's own version. */
 export const CONTRACT_PACKAGE_VERSION = '0.5.0' as const;

package/src/manifest.test.ts

@@ -2,9 +2,14 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 import {
+  HttpCapabilitySchema,
+  IKENGA_API_VERSION,
+  InvokeCapabilitySchema,
   ManifestSchema,
+  NamedSecretSchema,
   RequiresEntrySchema,
   RequireSourceSchema,
+  SecretsCapabilitySchema,
 } from './manifest.js';
 
 // ─── WP-11 — `requires` field (ADR-015 §3) ──────────────────────────────────
@@ -82,6 +87,96 @@ test('Manifest: requires defaults to [] when absent (pre-Phase-4 manifest)', ()
   assert.deepEqual(m.requires, []);
 });
 
+// ─── WP-01 — trusted-cap tier (ADR-017): http / secrets / invoke + signature ─
+
+test('IKENGA_API_VERSION is 3 (ADR-017 soft bump)', () => {
+  assert.equal(IKENGA_API_VERSION, 3);
+});
+
+test('HttpCapability: auth_header defaults to Authorization; auth_secret optional', () => {
+  const h = HttpCapabilitySchema.parse({});
+  assert.equal(h.auth_header, 'Authorization');
+  assert.equal(h.auth_secret, undefined);
+});
+
+test('HttpCapability: .strict rejects unknown field (mirrors Rust deny_unknown_fields)', () => {
+  assert.throws(() => HttpCapabilitySchema.parse({ bogus: true }));
+});
+
+test('NamedSecret: full shape parses; required defaults false', () => {
+  const s = NamedSecretSchema.parse({ name: 'twenty', vault_key: 'TWENTY_API_KEY' });
+  assert.equal(s.required, false);
+  const r = NamedSecretSchema.parse({
+    name: 'k',
+    vault_key: 'K',
+    required: true,
+    format: 'bearer',
+  });
+  assert.equal(r.required, true);
+  assert.equal(r.format, 'bearer');
+});
+
+test('NamedSecret: .strict rejects unknown field', () => {
+  assert.throws(() =>
+    NamedSecretSchema.parse({ name: 'k', vault_key: 'K', bogus: true }),
+  );
+});
+
+test('SecretsCapability: declarations default to []', () => {
+  const s = SecretsCapabilitySchema.parse({});
+  assert.deepEqual(s.declarations, []);
+});
+
+test('InvokeCapability: empty object parses; commands defaults to [] (presence gate)', () => {
+  assert.deepEqual(InvokeCapabilitySchema.parse({}), { commands: [] });
+});
+
+test('InvokeCapability (D-06): commands allowlist parses + survives', () => {
+  const i = InvokeCapabilitySchema.parse({ commands: ['pa_actions_commit', 'pa_actions_reject'] });
+  assert.deepEqual(i.commands, ['pa_actions_commit', 'pa_actions_reject']);
+});
+
+test('InvokeCapability: .strict rejects unknown field (mirrors Rust deny_unknown_fields)', () => {
+  assert.throws(() => InvokeCapabilitySchema.parse({ commands: [], bogus: true }));
+});
+
+test('Manifest: fully-populated trusted-cap manifest round-trips (G-MANIFEST DoD)', () => {
+  // The contract-side half of the round-trip parse-fixture: a manifest carrying
+  // ALL FOUR new fields — top-level `signature`, `capabilities.http` (with
+  // auth_secret + custom header), `capabilities.secrets` (with a declaration),
+  // and the presence-gate `capabilities.invoke` — parses and the values survive.
+  const m = ManifestSchema.parse({
+    ...BASE,
+    ikenga_api: '3',
+    signature: 'ed25519:Zm9vYmFyYmF6',
+    permissions: { net: ['https://api.twenty.com/'], 'vault.keys': ['TWENTY_API_KEY'] },
+    capabilities: {
+      http: { auth_secret: 'twenty', auth_header: 'X-Api-Key' },
+      secrets: {
+        declarations: [
+          { name: 'twenty', vault_key: 'TWENTY_API_KEY', required: true, format: 'bearer' },
+        ],
+      },
+      invoke: { commands: ['pa_actions_commit'] },
+    },
+  });
+  assert.equal(m.signature, 'ed25519:Zm9vYmFyYmF6');
+  assert.equal(m.capabilities?.http?.auth_secret, 'twenty');
+  assert.equal(m.capabilities?.http?.auth_header, 'X-Api-Key');
+  assert.equal(m.capabilities?.secrets?.declarations.length, 1);
+  assert.equal(m.capabilities?.secrets?.declarations[0].vault_key, 'TWENTY_API_KEY');
+  assert.equal(m.capabilities?.secrets?.declarations[0].required, true);
+  assert.ok(m.capabilities?.invoke !== undefined);
+  // D-06: the invoke command allowlist survives the round-trip.
+  assert.deepEqual(m.capabilities?.invoke?.commands, ['pa_actions_commit']);
+});
+
+test('Manifest: api=1 manifest without new fields parses (back-compat)', () => {
+  const m = ManifestSchema.parse({ ...BASE });
+  assert.equal(m.signature, undefined);
+  assert.equal(m.capabilities, undefined);
+});
+
 test('Manifest: retired bundling fields are no longer part of the type (WP-17)', () => {
   // ADR-015 decision 4: `skills`/`commands`/`agents` were hard-retired from the
   // schema (lockstep with the Rust `deny_unknown_fields` Manifest, which REJECTS

package/src/manifest.ts

@@ -10,10 +10,14 @@
 
 import { z } from 'zod';
 import { EngineProvidesSchema } from './engine/index.js';
+import { BrowserEngineSchema } from './browser.js';
 
 // v2 (WP-05): added capabilities.sqlite + permissions["sqlite.tables"];
 // permissions["supabase.tables"] kept as a compat alias for api=1 manifests.
-export const IKENGA_API_VERSION = 2 as const;
+// v3 (ADR-017): added capabilities.http / .secrets / .invoke (trusted-cap tier)
+// + top-level optional `signature`. All additive; api=1/2 manifests parse
+// unchanged. Elevated caps are inert unless the pkg is trusted.
+export const IKENGA_API_VERSION = 3 as const;
 export const IKENGA_API_MIN_SUPPORTED = 1 as const;
 
 // ---------- Sub-schemas ----------
@@ -170,6 +174,11 @@ export const WebviewCapabilitySchema = z.object({
   child_webviews: z.boolean().default(false),
   /** Named cookie/data partitions; empty = the implicit "default" partition. */
   partitions: z.array(z.string()).default([]),
+  /** Browser engines this pkg may open panes with. `"webkit"` is the in-shell
+   *  child-webview; `"chrome"` is Managed mode (installed Chrome over CDP, its
+   *  own OS window). Defaults to `["webkit"]` so existing manifests are
+   *  unchanged. Mirrors `engines` in `WebviewCapability` (manifest.rs). */
+  engines: z.array(BrowserEngineSchema).default(['webkit']),
 });
 export type WebviewCapability = z.infer<typeof WebviewCapabilitySchema>;
 
@@ -183,6 +192,65 @@ export type WebviewCapability = z.infer<typeof WebviewCapabilitySchema>;
 export const AgentOpsCapabilitySchema = z.object({});
 export type AgentOpsCapability = z.infer<typeof AgentOpsCapabilitySchema>;
 
+/** host.fetch capability (ADR-017, TRUSTED-only). Host-mediated HTTP proxy;
+ *  the shell makes the request and attaches auth from Stronghold — the key
+ *  never enters the iframe. URL allowlist = `permissions.net`. Mirrors
+ *  `HttpCapability` in `shell/src-tauri/src/pkg/manifest.rs`. */
+export const HttpCapabilitySchema = z
+  .object({
+    /** Name of a `capabilities.secrets` declaration whose resolved value the
+     *  shell attaches as the auth header. Omit = unauthenticated proxy. */
+    auth_secret: z.string().optional(),
+    /** Header name for the auth secret. Default "Authorization". */
+    auth_header: z.string().default('Authorization'),
+  })
+  .strict();
+export type HttpCapability = z.infer<typeof HttpCapabilitySchema>;
+
+/** One named-secret declaration. `vault_key` is resolved host-side and never
+ *  reaches the iframe; the iframe sees only `hostContext.secrets[name]`.
+ *  Mirrors `NamedSecret` in `shell/src-tauri/src/pkg/manifest.rs`. */
+export const NamedSecretSchema = z
+  .object({
+    name: z.string(),
+    /** Vault key (must be within permissions["vault.keys"]). Host-only. */
+    vault_key: z.string(),
+    /** When true, mount fails if the key is missing (Supabase `required`). */
+    required: z.boolean().default(false),
+    /** Optional value-format hint: "jwt" | "bearer" | "raw". String, not enum. */
+    format: z.string().optional(),
+  })
+  .strict();
+export type NamedSecret = z.infer<typeof NamedSecretSchema>;
+
+/** Named-secret injection capability (ADR-017, TRUSTED-only). Generalizes the
+ *  Supabase hostContext handshake. Mirrors `SecretsCapability` in
+ *  `shell/src-tauri/src/pkg/manifest.rs`. */
+export const SecretsCapabilitySchema = z
+  .object({
+    declarations: z.array(NamedSecretSchema).default([]),
+  })
+  .strict();
+export type SecretsCapability = z.infer<typeof SecretsCapabilitySchema>;
+
+/** Scoped Tauri invoke passthrough (ADR-017, TRUSTED-only). Presence gates
+ *  `host.invoke`; `commands` is the named-command allowlist matched (glob) by
+ *  `permissions_check::check_shell_execute` against the `host.invoke` command.
+ *
+ *  D-06: the allowlist is `invoke`'s OWN field, NOT `permissions["shell.execute"]`.
+ *  Reusing `shell.execute` would trip `requires_trust` → the pkg only ever reaches
+ *  user-`Granted`, never `AutoTrusted`, so `is_trusted_for_elevated()` is false and
+ *  `host.invoke` would always deny. Keeping the allowlist here lets a signed/builtin
+ *  pkg declare invokable commands while leaving `shell.execute` empty → AutoTrusted →
+ *  elevated. POLICY: named commands only, never `*` (not a general shell).
+ *  Mirrors `InvokeCapability` in `shell/src-tauri/src/pkg/manifest.rs`. */
+export const InvokeCapabilitySchema = z
+  .object({
+    commands: z.array(z.string()).default([]),
+  })
+  .strict();
+export type InvokeCapability = z.infer<typeof InvokeCapabilitySchema>;
+
 export const WindowBlockSchema = z.object({
   label: z.string(),
   url: z.string(),
@@ -283,6 +351,12 @@ export const ManifestSchema = z.object({
     sqlite: SqliteCapabilitySchema.optional(),
     webview: WebviewCapabilitySchema.optional(),
     agentOps: AgentOpsCapabilitySchema.optional(),
+    /** host.fetch proxy (ADR-017). Inert unless the pkg is trusted. */
+    http: HttpCapabilitySchema.optional(),
+    /** Named-secret injection (ADR-017). Inert unless trusted. */
+    secrets: SecretsCapabilitySchema.optional(),
+    /** host.invoke passthrough (ADR-017). Inert unless trusted. */
+    invoke: InvokeCapabilitySchema.optional(),
   }).optional(),
 
   /**
@@ -310,6 +384,13 @@ export const ManifestSchema = z.object({
    * (`pkg/manifest.rs`) — keep in lockstep (`deny_unknown_fields`).
    */
   requires: z.array(RequiresEntrySchema).default([]),
+
+  /** Optional ed25519 signature over the normalized manifest JSON (sort keys,
+   *  strip `signature` before signing). Format `"ed25519:<base64>"`. Present
+   *  on notarized registry pkgs; verified at install against the publisher key
+   *  the signed registry index named. Absent → pkg isn't trusted (no elevated
+   *  caps). Mirrors `signature: Option<String>` on the Rust `Manifest`. */
+  signature: z.string().optional(),
 });
 
 export type Manifest = z.infer<typeof ManifestSchema>;

package/src/pa-actions.test.ts

@@ -0,0 +1,92 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { type ApproveGateMeta, type DraftItem, draftPreview, fromDraftItem } from './pa-actions.js';
+
+const META: ApproveGateMeta = {
+	actionId: 'com.ikenga.skill-mail/reply',
+	actionName: 'Reply',
+	agent: 'PA',
+	model: 'Opus 4.7',
+};
+
+function item(over: Partial<DraftItem> = {}): DraftItem {
+	return {
+		id: 'd1',
+		recipient: 'Valentim de Carvalho',
+		recipientEmail: 'valentim@valentimdc.pt',
+		subject: 'Re: Catalog import',
+		body: 'Olá Valentim,\n\nRecebido.   Vou processar agora.',
+		channel: 'smtp',
+		senderAddress: 'chinedum@royalti.io',
+		fromProvider: 'SMTP · Fastmail',
+		scheduledIso: null,
+		scheduledLabel: 'today',
+		...over,
+	};
+}
+
+// Anchor everything to LOCAL time so the day-bucketing assertions are
+// timezone-independent (new Date(y, m, d, h) is local-time construction).
+const NOW = new Date(2026, 5, 7, 11, 0, 0).getTime(); // 11:00 local, 2026-06-07
+const TODAY_ISO = new Date(2026, 5, 7, 17, 0, 0).toISOString(); // same local day, future
+const OVERDUE_ISO = new Date(2026, 5, 5, 9, 0, 0).toISOString(); // two days earlier
+
+test('fromDraftItem maps producer fields + meta', () => {
+	const d = fromDraftItem(item(), META, NOW);
+	assert.equal(d.id, 'd1');
+	assert.equal(d.agent, 'PA');
+	assert.equal(d.model, 'Opus 4.7');
+	assert.equal(d.channel, 'smtp');
+	assert.equal(d.consequence.channel, 'SMTP');
+	assert.equal(d.consequence.target, 'Valentim de Carvalho');
+	assert.equal(d.consequence.recipients, 1);
+	assert.equal(d.consequence.undoMs, 10_000);
+	assert.equal(d.everEdited, false);
+	assert.equal(d.cold, false);
+});
+
+test('fromDraftItem buckets an overdue draft', () => {
+	const d = fromDraftItem(item({ scheduledIso: OVERDUE_ISO }), META, NOW);
+	assert.equal(d.overdue, true);
+	assert.equal(d.timeVariant, 'is-overdue');
+	assert.equal(d.section, 'Overdue');
+	assert.equal(d.status, 'overdue');
+});
+
+test('fromDraftItem buckets a same-day draft as today', () => {
+	const d = fromDraftItem(item({ scheduledIso: TODAY_ISO }), META, NOW);
+	assert.equal(d.overdue, false);
+	assert.equal(d.timeVariant, 'is-today');
+	assert.equal(d.section, 'Today');
+	assert.equal(d.status, 'awaiting');
+});
+
+test('an explicit section overrides time bucketing', () => {
+	const d = fromDraftItem(item({ scheduledIso: OVERDUE_ISO, section: 'This week' }), META, NOW);
+	assert.equal(d.section, 'This week');
+	assert.equal(d.overdue, true); // overdue flag still reflects the clock
+});
+
+test('sequence recipient count flows into the consequence', () => {
+	const d = fromDraftItem(
+		item({
+			recipients: 388,
+			sequence: { name: 'L5 Winback', step: 3, total: 5, recipients: 388 },
+		}),
+		META,
+		NOW
+	);
+	assert.equal(d.consequence.recipients, 388);
+	assert.equal(d.sequence?.step, 3);
+});
+
+test('undoMs falls back to 10s when meta omits it', () => {
+	const d = fromDraftItem(item(), { ...META, undoMs: undefined }, NOW);
+	assert.equal(d.consequence.undoMs, 10_000);
+});
+
+test('draftPreview collapses whitespace and truncates', () => {
+	assert.equal(draftPreview('a   b\n\nc'), 'a b c');
+	assert.ok(draftPreview('x'.repeat(300)).length <= 160);
+	assert.ok(draftPreview('x'.repeat(300)).endsWith('…'));
+});