@kindgi/api 0.1.4 → 0.1.5

package/src/routes/agents.ts

@@ -36,6 +36,7 @@ import {
 } from './agent-releases.js';
 import { liveScopeToWire } from './live-scope-wire.js';
 import { clampLimit } from './pagination.js';
+import { projectMismatch } from './project-mismatch.js';
 import { parseScopeParams } from './scope-params.js';
 
 /**
@@ -64,6 +65,8 @@ export function agentsRouter(
   releases?: AgentReleaseBindings,
   /** What a promotion's gate reads besides the releases (evals step 4b). */
   gateDeps?: AgentReleaseGateDeps,
+  /** What the deployment can do for an agent's turns, for publish warnings. */
+  capabilities: AgentPublishCapabilities = {},
 ): Hono<AppEnv> {
   const r = new Hono<AppEnv>();
   // A read-only registry (under `kindgi dev`, the pack's files) refuses
@@ -170,8 +173,15 @@ export function agentsRouter(
       ...(scopeParsed.scope !== undefined && { scope: scopeParsed.scope }),
       ...(scopeParsed.inherit !== undefined && { inherit: scopeParsed.inherit }),
     });
+    // Only what the caller may read (T243 A), as `GET …/:id` asks.
+    const visible =
+      authorizer === undefined
+        ? page.data
+        : await authorizer.filterByCan(c, 'read', page.data, (a) =>
+            ref('agent', a.id as unknown as string),
+          );
     return c.json({
-      data: page.data.map(serializeAgent),
+      data: visible.map(serializeAgent),
       hasMore: page.nextCursor !== undefined,
       ...(page.nextCursor !== undefined && { nextCursor: page.nextCursor as unknown as string }),
     });
@@ -383,6 +393,9 @@ export function agentsRouter(
     if (outcome.kind === 'already-registered') {
       return alreadyRegistered(c, binding, tenantId, outcome.agentId, outcome.version);
     }
+    if (outcome.kind === 'project-mismatch') {
+      return projectMismatch(c, 'agent', outcome.agentId as unknown as string, outcome.projectId);
+    }
     if (outcome.kind === 'project-not-found') {
       // Caller supplied a `projectId` that does not resolve within
       // this tenant. Distinct signal from `already-registered` so the
@@ -400,10 +413,12 @@ export function agentsRouter(
         ),
       );
     }
+    const warnings = publishWarnings(defined.value, capabilities);
     c.status(201);
     return c.json({
       agentId: outcome.agentId as unknown as string,
       version: outcome.version as unknown as string,
+      ...(warnings.length > 0 && { warnings }),
     });
   });
 
@@ -668,9 +683,120 @@ function derived(
         code: 'bad-input',
         message: `\`projectId\` "${outcome.projectId as unknown as string}" does not resolve to a project in this tenant`,
       });
+    case 'project-mismatch':
+      return projectMismatch(c, 'agent', agentId as unknown as string, outcome.projectId, 'derive');
   }
 }
 
+/** What the deployment can do for an agent's turns, for publish warnings. */
+export interface AgentPublishCapabilities {
+  /** Whether memory can search by meaning (embeddings are on). Absent: unknown, no warning. */
+  readonly semanticSearch?: boolean;
+  /** Whether agents can remember (`memory.remember`). Absent: unknown, no warning. */
+  readonly remember?: boolean;
+  /** Whether agent turns can recall earlier conversations. Absent: unknown, no warning. */
+  readonly conversationRecall?: boolean;
+}
+
+/**
+ * What a published agent should know about this deployment before its
+ * first turn: an intent that searches by meaning on a runtime without
+ * embeddings fails its turns (`semantic`) or searches by keyword only
+ * (`both`); an agent that remembers on a runtime that can't store what
+ * it remembers gets "not remembered" from every call.
+ */
+function publishWarnings(
+  agent: Agent,
+  capabilities: AgentPublishCapabilities,
+): { readonly code: string; readonly message: string }[] {
+  return [
+    ...(capabilities.semanticSearch === false ? semanticWarnings(agent) : []),
+    ...(capabilities.remember === false && agent.memory?.remember !== undefined
+      ? [
+          {
+            code: 'remember-unavailable',
+            message:
+              'The agent declares memory.remember, and this runtime cannot store agent memories: each remember call answers that nothing was remembered.',
+          },
+        ]
+      : []),
+    ...recallWarnings(agent, capabilities),
+  ];
+}
+
+/**
+ * Intents over conversations: `same-segment` and `same-project` quote other
+ * people's conversations (always said); on a runtime that can't recall,
+ * every such intent recalls nothing.
+ */
+function recallWarnings(
+  agent: Agent,
+  capabilities: AgentPublishCapabilities,
+): { readonly code: string; readonly message: string }[] {
+  const answers = agent.retrieval.findIndex(
+    (intent) => intent.source === 'conversations' && intent.roles?.includes('agent') === true,
+  );
+  const answersWarning =
+    answers >= 0 && capabilities.conversationRecall !== false
+      ? [
+          {
+            code: 'recall-agent-answers',
+            message: `Retrieval intent ${answers} recalls the agent's own earlier answers: they can carry its earlier mistakes. They are quoted as "earlier answer by the agent, not verified"; recall only the people's own words (the default) to leave them out.`,
+          },
+        ]
+      : [];
+  return [...answersWarning, ...perIntentRecallWarnings(agent, capabilities)];
+}
+
+function perIntentRecallWarnings(
+  agent: Agent,
+  capabilities: AgentPublishCapabilities,
+): { readonly code: string; readonly message: string }[] {
+  return agent.retrieval.flatMap((intent, i) => {
+    if (intent.source !== 'conversations') return [];
+    if (capabilities.conversationRecall === false) {
+      return [
+        {
+          code: 'recall-unavailable',
+          message: `Retrieval intent ${i} recalls earlier conversations, and this runtime can't: it recalls nothing, and each turn's journal says so (no-recall).`,
+        },
+      ];
+    }
+    if (intent.scope === 'same-segment' || intent.scope === 'same-project') {
+      const where = intent.scope === 'same-segment' ? "the run's segment" : "the run's project";
+      return [
+        {
+          code: 'recall-other-people',
+          message: `Retrieval intent ${i} recalls conversations in ${where}, whoever had them: this agent can quote other users' conversations in ${where}. Their messages are marked as another person's, without saying whose.`,
+        },
+      ];
+    }
+    return [];
+  });
+}
+
+function semanticWarnings(agent: Agent): { readonly code: string; readonly message: string }[] {
+  return agent.retrieval.flatMap((intent, i) => {
+    if (intent.mode === 'semantic') {
+      return [
+        {
+          code: 'semantic-unavailable',
+          message: `Retrieval intent ${i} searches by meaning (mode "semantic"), and this runtime has no embeddings: its turns fail with semantic-unavailable until an operator turns them on (KINDGI_MEMORY_EMBEDDINGS).`,
+        },
+      ];
+    }
+    if (intent.mode === 'both') {
+      return [
+        {
+          code: 'semantic-unavailable',
+          message: `Retrieval intent ${i} (mode "both") runs only its keyword search: this runtime has no embeddings (KINDGI_MEMORY_EMBEDDINGS).`,
+        },
+      ];
+    }
+    return [];
+  });
+}
+
 function serializeAgent(a: AgentVersionRecord): Record<string, unknown> {
   return {
     id: a.id as unknown as string,
@@ -684,6 +810,7 @@ function serializeAgent(a: AgentVersionRecord): Record<string, unknown> {
     capabilities: a.capabilities,
     tools: a.tools,
     retrieval: a.retrieval,
+    ...(a.memory !== undefined && { memory: a.memory }),
     guardrails: a.guardrails,
     ...(a.conversationPolicy !== undefined && { conversationPolicy: a.conversationPolicy }),
     ...(a.budget !== undefined && { budget: a.budget }),

package/src/routes/approvals.ts

@@ -2,39 +2,48 @@
 // Copyright (C) 2026 Kindgi Inc.
 
 import { Hono } from 'hono';
+import type { Context } from 'hono';
 
 import { AGENT_GATE_SUBJECTS, TOOL_CALL_GATE_SUBJECT } from '@kindgi/agents';
 import type { ConversationBinding, GateDecisionValue } from '@kindgi/agents';
-import { REVIEWER_ROLE_RANK, type ReviewerRole } from '@kindgi/authz';
-import { serializePublicKeyPem, signEd25519 } from '@kindgi/crypto';
-import type { SigningKeyBinding } from '@kindgi/crypto';
+import type { AuditEventBinding } from '@kindgi/audit-events';
+import { REVIEWER_ROLE_RANK, type ResourceRef, type ReviewerRole, ref } from '@kindgi/authz';
+import type { ExportSigningBinding } from '@kindgi/crypto';
 import type { RunBinding } from '@kindgi/runtime';
-import { canonicalize } from '@kindgi/schema';
 import type {
   ApprovalId,
   ConversationId,
   Cursor,
   ReviewerId,
   RunId,
-  SigningKeyId,
   TenantId,
   Timestamp,
   UserId,
 } from '@kindgi/types';
 
 import { statusFor, toWireError } from '../errors.js';
-import type { RunHandlerBinding } from '../handler-binding.js';
+import type { RunHandlerBinding, RunTrace } from '../handler-binding.js';
 import type {
   Approval,
+  ApprovalPosition,
   ApprovalStatus,
   HitlBinding,
   ReviewDecisionKind,
   ReviewDecisionRecord,
 } from '../hitl-binding.js';
+import type { Authorizer } from '../middleware/authorize.js';
 import type { ReviewerBinding } from '../reviewer-binding.js';
 import { callerReviewerRole } from '../reviewer-role.js';
+import {
+  exportActor,
+  parseSigningKeyId,
+  readExportBody,
+  signExport,
+  signExportFailure,
+  signingNotConfigured,
+} from '../signed-export.js';
 import type { AppEnv } from '../types.js';
-import { clampLimit } from './pagination.js';
+import { clampLimit, decodeCursor, encodeCursor, isCursorTime } from './pagination.js';
 import { parseListScope } from './scope-params.js';
 
 const APPROVAL_STATUSES: ReadonlySet<ApprovalStatus> = new Set([
@@ -73,11 +82,18 @@ const DECIDED_STATUSES: ReadonlySet<ApprovalStatus> = new Set([
   'withdrawn',
 ]);
 
-/** Audit-bundle body schema version — bump when the bundle wire shape changes. */
-const AUDIT_BUNDLE_SCHEMA_VERSION = 1;
+/**
+ * Audit-bundle body schema version — bump when the bundle wire shape changes.
+ * 2.0.0: a string like the other exports' (was the integer 1), named
+ * `bundleSchemaVersion` in the body too, `exportedAt` signed once.
+ */
+const AUDIT_BUNDLE_SCHEMA_VERSION = '2.0.0';
 
 export interface ApprovalsRouterOptions {
-  readonly signingKey?: SigningKeyBinding;
+  /** Signs audit bundles. Absent: `POST /:approvalId/audit-bundle` answers `404 signing-not-configured`. */
+  readonly exportSigning?: ExportSigningBinding;
+  /** Records each signed export (`export-signed`). */
+  readonly auditEvents?: AuditEventBinding;
   /**
    * When supplied, the POST /:approvalId/complete handler
    * invokes `runHandler.resumeRun(runId)` INLINE after `completeToken`
@@ -111,11 +127,34 @@ export function approvalsRouter(
   hitlBinding: HitlBinding,
   runBinding: RunBinding,
   options: ApprovalsRouterOptions = {},
+  /**
+   * With one (T243 A): on top of the reviewer role, a caller sees and
+   * decides only approvals whose project it may read (the approval's, or
+   * its run's). Another project's approval is not found, as one above the
+   * caller's tier is.
+   */
+  authorizer?: Authorizer,
 ): Hono<AppEnv> {
   const r = new Hono<AppEnv>();
-  const signingKey = options.signingKey;
+  const { exportSigning, auditEvents } = options;
   const runHandler = options.runHandler;
 
+  /** What an approval is checked on: its project, else its run's, else the tenant. */
+  const approvalRef = async (tenantId: TenantId, approval: Approval): Promise<ResourceRef> => {
+    if (approval.projectId !== undefined) {
+      return ref('project', approval.projectId as unknown as string);
+    }
+    const runId = approval.provenanceRef?.runId;
+    const run = runId === undefined ? null : await runBinding.getRun(tenantId, runId as never);
+    return run === null
+      ? ref('tenant', tenantId as unknown as string)
+      : ref('project', run.projectId as unknown as string);
+  };
+  /** Whether the caller may read the approval's project (always, without an authorizer). */
+  const mayRead = async (c: Context<AppEnv>, approval: Approval): Promise<boolean> =>
+    authorizer === undefined ||
+    authorizer.can(c, 'read', await approvalRef(c.get('tenantId') as TenantId, approval));
+
   // ---------- role gate for the whole resource ----------
   // A reviewer: a token that carries a role, or whose user the roster
   // names (a session or API key of a registered reviewer).
@@ -235,10 +274,19 @@ export function approvalsRouter(
       );
     }
 
-    const cursor = c.req.query('cursor');
-    if (cursor !== undefined && cursor.length > 0) {
-      const parsed = new Date(cursor);
-      if (Number.isNaN(parsed.getTime())) {
+    // The cursor: where the last page ended (an approval's exact
+    // `createdAt` and its id), or a bare time from before that (milliseconds,
+    // no tie-breaker), which still answers as it did.
+    const rawCursor = c.req.query('cursor');
+    let after: ApprovalPosition | undefined;
+    let cursor: string | undefined;
+    if (rawCursor !== undefined && rawCursor.length > 0) {
+      const decoded = decodeCursor(rawCursor);
+      if (decoded !== null && isCursorTime(decoded.createdAt)) {
+        after = { createdAt: decoded.createdAt, id: decoded.id as unknown as ApprovalId };
+      } else if (decoded === null && Number.isFinite(Date.parse(rawCursor))) {
+        cursor = rawCursor;
+      } else {
         c.status(statusFor('bad-input') as never);
         return c.json(
           toWireError({ code: 'bad-input', message: '`cursor` is malformed' }, requestId),
@@ -246,10 +294,9 @@ export function approvalsRouter(
       }
     }
 
-    // `listApprovals` takes an ISO-timestamp cursor. Over-fetch up to 4×
-    // the page size (capped at 500) so a page still fills when
-    // role-scoping filters rows out; the extra rows (or the binding's
-    // own cursor) also tell us `hasMore`.
+    // Over-fetch up to 4× the page size (capped at 500) so a page still
+    // fills when role-scoping filters rows out; the extra rows (or the
+    // binding's own cursor) also tell us `hasMore`.
     const HITL_LIMIT_CAP = Math.min(limit * 4, 500);
     const listInput = {
       tenantId,
@@ -258,7 +305,8 @@ export function approvalsRouter(
       ...(statusFilter !== undefined && { status: statusFilter }),
       ...(requiredRoleFilter !== undefined && { requiredRole: requiredRoleFilter }),
       ...(createdAfterIso !== undefined && { since: createdAfterIso as unknown as Timestamp }),
-      ...(cursor !== undefined && cursor.length > 0 && { cursor: cursor as Cursor }),
+      ...(after !== undefined && { after }),
+      ...(cursor !== undefined && { cursor: cursor as Cursor }),
       ...(waitTokenIds.length > 0 && { waitTokenIds }),
     };
     const listed = await hitlBinding.listApprovals(listInput);
@@ -267,14 +315,32 @@ export function approvalsRouter(
       return c.json(toWireError(listed.error as never, requestId));
     }
     const roleRank = REVIEWER_ROLE_RANK[role];
-    const visible = listed.value.approvals.filter(
+    const inTier = listed.value.approvals.filter(
       (a) => REVIEWER_ROLE_RANK[a.requiredRole] <= roleRank,
     );
+    let visible = inTier;
+    if (authorizer !== undefined) {
+      const refs = await Promise.all(inTier.map((a) => approvalRef(tenantId, a)));
+      const readable = await authorizer.filterByCan(
+        c,
+        'read',
+        inTier.map((approval, i) => ({ approval, at: refs[i] as ResourceRef })),
+        (row) => row.at,
+      );
+      visible = readable.map((row) => row.approval);
+    }
     const page = visible.slice(0, limit);
     const hasMore = visible.length > limit || listed.value.nextCursor !== undefined;
     const last = page[page.length - 1];
+    // Continue after the last approval shown: at its exact `createdAt` when
+    // the binding gives it, else (a binding from before) at its time.
+    const exact = last !== undefined ? listed.value.exactCreatedAt?.[last.id] : undefined;
     const nextCursor =
-      hasMore && last !== undefined ? (last.createdAt as unknown as string) : undefined;
+      !hasMore || last === undefined
+        ? undefined
+        : exact !== undefined
+          ? encodeCursor({ createdAt: exact, id: last.id as unknown as string })
+          : (last.createdAt as unknown as string);
     return c.json({
       data: page.map(serializeApproval),
       hasMore,
@@ -297,7 +363,10 @@ export function approvalsRouter(
     const approval = got.value;
     // Out-of-scope reads are 404 (per API-ROUTE-CONVENTIONS.md §2.4 —
     // avoid leaking existence across role tiers).
-    if (REVIEWER_ROLE_RANK[approval.requiredRole] > REVIEWER_ROLE_RANK[role]) {
+    if (
+      REVIEWER_ROLE_RANK[approval.requiredRole] > REVIEWER_ROLE_RANK[role] ||
+      !(await mayRead(c, approval))
+    ) {
       c.status(statusFor('approval-not-found') as never);
       return c.json(
         toWireError(
@@ -356,7 +425,10 @@ export function approvalsRouter(
       return c.json(toWireError(found.error as never, requestId));
     }
     const approval = found.value;
-    if (REVIEWER_ROLE_RANK[approval.requiredRole] > REVIEWER_ROLE_RANK[role]) {
+    if (
+      REVIEWER_ROLE_RANK[approval.requiredRole] > REVIEWER_ROLE_RANK[role] ||
+      !(await mayRead(c, approval))
+    ) {
       c.status(statusFor('approval-not-found') as never);
       return c.json(
         toWireError(
@@ -468,7 +540,13 @@ export function approvalsRouter(
       // whose run couldn't go on (a tool version it started with is gone,
       // say) isn't reported as plain success.
       if (runHandler !== undefined) {
-        resume = await resumeInline(runHandler, tenantId, approval.provenanceRef.runId as RunId);
+        const trace = c.get('trace');
+        resume = await resumeInline(
+          runHandler,
+          tenantId,
+          approval.provenanceRef.runId as RunId,
+          trace !== undefined ? { traceId: trace.traceId, spanId: trace.spanId } : undefined,
+        );
       }
     }
 
@@ -492,36 +570,10 @@ export function approvalsRouter(
     const role = c.get('reviewerRole') as ReviewerRole;
     const approvalId = c.req.param('approvalId') as ApprovalId;
 
-    if (signingKey === undefined) {
-      c.status(statusFor('signing-not-configured') as never);
-      return c.json(
-        toWireError(
-          {
-            code: 'signing-not-configured',
-            message:
-              'This deployment does not have a `signingKey` binding mounted; signed audit bundles are unavailable.',
-          },
-          requestId,
-        ),
-      );
-    }
+    if (exportSigning === undefined) return signingNotConfigured(c, 'signed audit bundles');
 
-    let body: unknown;
-    try {
-      body = await c.req.json();
-    } catch {
-      c.status(statusFor('bad-input') as never);
-      return c.json(
-        toWireError({ code: 'bad-input', message: 'Request body must be valid JSON' }, requestId),
-      );
-    }
-    if (body === null || typeof body !== 'object' || Array.isArray(body)) {
-      c.status(statusFor('bad-input') as never);
-      return c.json(
-        toWireError({ code: 'bad-input', message: 'Request body must be an object' }, requestId),
-      );
-    }
-    const parsed = parseAuditBundleBody(body as Record<string, unknown>);
+    const read = await readExportBody(c);
+    const parsed = read.kind === 'ok' ? parseAuditBundleBody(read.value) : read;
     if (parsed.kind === 'err') {
       c.status(statusFor('bad-input') as never);
       return c.json(toWireError({ code: 'bad-input', message: parsed.message }, requestId));
@@ -535,7 +587,10 @@ export function approvalsRouter(
       return c.json(toWireError(found.error as never, requestId));
     }
     const approval = found.value;
-    if (REVIEWER_ROLE_RANK[approval.requiredRole] > REVIEWER_ROLE_RANK[role]) {
+    if (
+      REVIEWER_ROLE_RANK[approval.requiredRole] > REVIEWER_ROLE_RANK[role] ||
+      !(await mayRead(c, approval))
+    ) {
       c.status(statusFor('approval-not-found') as never);
       return c.json(
         toWireError(
@@ -596,96 +651,54 @@ export function approvalsRouter(
       messages = [];
     }
 
-    // 5. Look up the private key material.
-    const privateKey = signingKey.getPrivateKey(signingKeyId);
-    if (privateKey === null) {
-      c.status(statusFor('signing-key-not-found') as never);
-      return c.json(
-        toWireError(
-          {
-            code: 'signing-key-not-found',
-            message: `No signing key registered with id "${signingKeyId as unknown as string}"`,
-            signingKeyId: signingKeyId as unknown as string,
-          },
-          requestId,
-        ),
-      );
-    }
-    const publicKeyRaw = signingKey.getPublicKey(signingKeyId);
-    if (publicKeyRaw === null) {
-      c.status(statusFor('signing-key-not-found') as never);
-      return c.json(
-        toWireError(
-          {
-            code: 'signing-key-not-found',
-            message: `Signing key "${signingKeyId as unknown as string}" resolved a private key but no public key`,
-            signingKeyId: signingKeyId as unknown as string,
-          },
-          requestId,
-        ),
-      );
-    }
-
-    // 6. Build the canonical bundle body.
+    // 5. Sign the bundle body (and record the export).
     const guardrailResults = extractGuardrailResults(approval.context);
-    const bundleBody: Record<string, unknown> = {
-      bundleVersion: AUDIT_BUNDLE_SCHEMA_VERSION,
-      approvalId: approval.id as unknown as string,
-      tenantId: approval.tenantId as unknown as string,
-      subjectKind: approval.subjectKind,
-      subjectRef: approval.subjectRef,
-      requiredRole: approval.requiredRole,
-      status: approval.status,
-      createdAt: approval.createdAt as unknown as string,
-      ...(approval.decidedAt !== undefined && {
-        decidedAt: approval.decidedAt as unknown as string,
-      }),
-      decision:
-        decisionRow !== null
-          ? {
-              kind: decisionRow.decision,
-              reviewerId: decisionRow.reviewerId,
-              reviewerRoleAtDecision: decisionRow.reviewerRoleAtDecision,
-              decidedAt: decisionRow.decidedAt as unknown as string,
-              ...(decisionRow.rationale !== undefined && { rationale: decisionRow.rationale }),
-            }
-          : null,
-      evidence: {
-        ...(guardrailResults !== undefined && { guardrailResults }),
-        ...(messages !== undefined && { messages }),
-      },
-      exportedAt: new Date().toISOString(),
-    };
-    const canonicalBundleBytes = new TextEncoder().encode(canonicalize(bundleBody));
-
-    // 7. Sign.
-    const signResult = signEd25519(privateKey, canonicalBundleBytes);
-    if (signResult.kind === 'err') {
-      c.status(statusFor('export-key-error') as never);
-      return c.json(
-        toWireError(
-          {
-            code: 'export-key-error',
-            message: `Failed to sign audit bundle: ${signResult.error.message}`,
-          },
-          requestId,
-        ),
-      );
-    }
-
-    return c.json({
-      approvalId: approvalId as unknown as string,
-      bundle: Buffer.from(canonicalBundleBytes).toString('base64'),
+    const runId = approval.provenanceRef?.runId as unknown as string | undefined;
+    const signed = await signExport({
+      signer: exportSigning,
+      kind: 'audit-bundle',
       bundleSchemaVersion: AUDIT_BUNDLE_SCHEMA_VERSION,
-      algorithm: 'ed25519' as const,
-      signingKeyId: signingKeyId as unknown as string,
-      signature: Buffer.from(signResult.value).toString('base64'),
-      publicKey: serializePublicKeyPem(publicKeyRaw),
-      canonicalization: 'sorted-key-json' as const,
-      exportedAt: new Date().toISOString() as unknown as Timestamp,
+      ...(signingKeyId !== undefined && { signingKeyId }),
+      body: {
+        approvalId: approval.id as unknown as string,
+        tenantId: approval.tenantId as unknown as string,
+        subjectKind: approval.subjectKind,
+        subjectRef: approval.subjectRef,
+        requiredRole: approval.requiredRole,
+        status: approval.status,
+        createdAt: approval.createdAt as unknown as string,
+        ...(approval.decidedAt !== undefined && {
+          decidedAt: approval.decidedAt as unknown as string,
+        }),
+        decision:
+          decisionRow !== null
+            ? {
+                kind: decisionRow.decision,
+                reviewerId: decisionRow.reviewerId,
+                reviewerRoleAtDecision: decisionRow.reviewerRoleAtDecision,
+                decidedAt: decisionRow.decidedAt as unknown as string,
+                ...(decisionRow.rationale !== undefined && { rationale: decisionRow.rationale }),
+              }
+            : null,
+        evidence: {
+          ...(guardrailResults !== undefined && { guardrailResults }),
+          ...(messages !== undefined && { messages }),
+        },
+      },
+      ...(auditEvents !== undefined && {
+        record: {
+          auditEvents,
+          tenantId,
+          ...(approval.projectId !== undefined && { projectId: approval.projectId }),
+          ...(runId !== undefined && { runId }),
+          actor: exportActor(c),
+          subject: { approvalId: approval.id as unknown as string },
+        },
+      }),
     });
+    if (signed.kind === 'err') return signExportFailure(c, signed.error, 'export-key-error');
+    return c.json({ approvalId: approvalId as unknown as string, ...signed.value });
   });
-
   return r;
 }
 
@@ -800,7 +813,7 @@ function parseCompleteBody(
 }
 
 interface ParsedAuditBundle {
-  readonly signingKeyId: SigningKeyId;
+  readonly signingKeyId: string | undefined;
   readonly includeMessages: boolean;
 }
 
@@ -809,10 +822,8 @@ function parseAuditBundleBody(
 ):
   | { readonly kind: 'ok'; readonly value: ParsedAuditBundle }
   | { readonly kind: 'err'; readonly message: string } {
-  const raw = body.signingKeyId;
-  if (typeof raw !== 'string' || raw.length === 0) {
-    return { kind: 'err', message: 'Field `signingKeyId` must be a non-empty string' };
-  }
+  const signingKeyId = parseSigningKeyId(body);
+  if (signingKeyId.kind === 'err') return signingKeyId;
   let includeMessages = false;
   if ('includeMessages' in body) {
     const im = body.includeMessages;
@@ -821,13 +832,7 @@ function parseAuditBundleBody(
     }
     includeMessages = im;
   }
-  return {
-    kind: 'ok',
-    value: {
-      signingKeyId: raw as SigningKeyId,
-      includeMessages,
-    },
-  };
+  return { kind: 'ok', value: { signingKeyId: signingKeyId.value, includeMessages } };
 }
 
 /** How the inline resume after a decision went. */
@@ -844,9 +849,14 @@ async function resumeInline(
   runHandler: RunHandlerBinding,
   tenantId: TenantId,
   runId: RunId,
+  trace: RunTrace | undefined,
 ): Promise<ResumeReport> {
   try {
-    const outcome = await runHandler.resumeRun({ tenantId, runId });
+    const outcome = await runHandler.resumeRun({
+      tenantId,
+      runId,
+      ...(trace !== undefined && { trace }),
+    });
     return outcome.kind === 'ok'
       ? { kind: 'ok' }
       : { kind: 'failed', code: outcome.error.code, message: outcome.error.message };