handoff-relay 0.1.0

package/dist/api/server.js

@@ -0,0 +1,2578 @@
+// src/api/server.ts
+import Fastify from "fastify";
+import { z as z2 } from "zod";
+
+// src/errors.ts
+var RelayError = class extends Error {
+  code;
+  statusCode;
+  details;
+  constructor(code, message, statusCode = 400, details) {
+    super(message);
+    this.name = "RelayError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+function relayError(code, message, statusCode = 400, details) {
+  return new RelayError(code, message, statusCode, details);
+}
+function isRelayError(error) {
+  return error instanceof RelayError;
+}
+
+// src/protocol/schema.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { z } from "zod";
+
+// src/audit.ts
+import { createHash, randomUUID } from "crypto";
+function createAuditReceipt(input) {
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const material = JSON.stringify({
+    action: input.action,
+    actor_member_id: input.actorMemberId,
+    packet_id: input.packetId,
+    workspace_id: input.workspaceId,
+    created_at: createdAt,
+    metadata: input.metadata ?? {}
+  });
+  return {
+    receipt_id: `rcp_${randomUUID()}`,
+    action: input.action,
+    actor_member_id: input.actorMemberId,
+    packet_id: input.packetId,
+    workspace_id: input.workspaceId,
+    created_at: createdAt,
+    metadata: input.metadata ?? {},
+    receipt_hash: `sha256:${createHash("sha256").update(material).digest("hex")}`
+  };
+}
+
+// src/protocol/schema.ts
+var packetStatuses = [
+  "draft",
+  "pending_sender_approval",
+  "sent",
+  "delivered",
+  "viewed",
+  "accepted",
+  "clarification_requested",
+  "response_drafting",
+  "pending_recipient_approval",
+  "replied",
+  "hydrated",
+  "archived",
+  "declined",
+  "expired",
+  "superseded",
+  "closed_resolved",
+  "closed_unresolved"
+];
+var packetTypes = ["ask", "share", "reply", "clarification"];
+var confidenceLevels = ["low", "medium", "high"];
+var auditReceiptSchema = z.object({
+  receipt_id: z.string().min(1),
+  action: z.string().min(1),
+  actor_member_id: z.string().min(1),
+  packet_id: z.string().min(1).optional(),
+  workspace_id: z.string().min(1),
+  created_at: z.string().datetime(),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  receipt_hash: z.string().min(1).optional()
+});
+var projectIdentitySchema = z.object({
+  repo_name: z.string().min(1),
+  git_remote_fingerprint: z.string().min(1).optional(),
+  branch: z.string().min(1).optional(),
+  commit_hash: z.string().min(1).optional()
+}).strict();
+var claimSchema = z.object({
+  claim_id: z.string().min(1),
+  text: z.string().min(1),
+  confidence: z.enum(confidenceLevels),
+  status: z.enum(["observed", "inferred", "suspected", "disproven", "superseded"]),
+  evidence_ids: z.array(z.string()).default([]),
+  needs_recheck: z.boolean().default(false)
+}).strict();
+var evidenceSchema = z.object({
+  evidence_id: z.string().min(1),
+  kind: z.enum([
+    "file_excerpt",
+    "command_output",
+    "test_failure",
+    "error_message",
+    "log_excerpt",
+    "diff_summary",
+    "ticket_link",
+    "pr_link",
+    "human_note"
+  ]),
+  label: z.string().min(1),
+  source: z.string().min(1),
+  excerpt: z.string().default(""),
+  hash: z.string().min(1),
+  captured_at: z.string().datetime(),
+  sensitivity: z.enum(["normal", "private", "secret_detected", "restricted"]).default("normal")
+}).strict();
+var redactionFindingSchema = z.object({
+  kind: z.enum([
+    "api_key",
+    "private_key",
+    "credential_url",
+    "env_secret",
+    "local_path",
+    "oversized_excerpt",
+    "user_pattern"
+  ]),
+  field: z.string().min(1),
+  evidence_id: z.string().optional(),
+  severity: z.enum(["warning", "block"]),
+  message: z.string().min(1),
+  preview: z.string().optional()
+}).strict();
+var redactionReportSchema = z.object({
+  blocked: z.boolean(),
+  findings: z.array(redactionFindingSchema).default([]),
+  warnings: z.array(redactionFindingSchema).default([])
+}).strict();
+var hydrationPolicySchema = z.object({
+  requires_recipient_approval: z.boolean().default(true),
+  requires_sender_approval_for_replies: z.boolean().default(true),
+  allow_raw_transcript: z.boolean().default(false),
+  max_characters: z.number().int().positive().default(8e3)
+}).strict();
+var packetSchema = z.object({
+  packet_id: z.string().min(1),
+  packet_type: z.enum(packetTypes),
+  workspace_id: z.string().min(1),
+  sender_member_id: z.string().min(1),
+  recipient_member_ids: z.array(z.string().min(1)).min(1),
+  parent_packet_id: z.string().min(1).optional(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime(),
+  expires_at: z.string().datetime().optional(),
+  recheck_by: z.string().datetime().optional(),
+  status: z.enum(packetStatuses),
+  project: projectIdentitySchema,
+  source_client: z.enum(["claude-code", "codex", "cursor", "generic", "other"]),
+  title: z.string().min(1).max(200),
+  summary: z.string().min(1).max(5e3),
+  question: z.string().optional(),
+  finding: z.string().optional(),
+  answer: z.string().optional(),
+  claims: z.array(claimSchema).default([]),
+  evidence: z.array(evidenceSchema).default([]),
+  files_or_symbols: z.array(z.string()).default([]),
+  commands_or_tests_run: z.array(z.string()).default([]),
+  what_was_tried: z.array(z.string()).default([]),
+  known_failures: z.array(z.string()).default([]),
+  current_hypothesis: z.string().default(""),
+  confidence: z.enum(confidenceLevels).default("medium"),
+  suggested_next_steps: z.array(z.string()).default([]),
+  redaction_report: redactionReportSchema,
+  hydration_policy: hydrationPolicySchema,
+  audit_receipt: auditReceiptSchema
+}).strict().superRefine((packet, ctx) => {
+  if (packet.packet_type === "ask" && !packet.question?.trim()) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["question"],
+      message: "Ask packets require a main question."
+    });
+  }
+  if (packet.packet_type === "share" && !packet.finding?.trim()) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["finding"],
+      message: "Share packets require a finding."
+    });
+  }
+  if (packet.packet_type === "reply" && !packet.answer?.trim()) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["answer"],
+      message: "Reply packets require an answer."
+    });
+  }
+  if (packet.packet_type === "clarification" && !packet.question?.trim()) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["question"],
+      message: "Clarification packets require a question."
+    });
+  }
+  if (packet.packet_type !== "clarification" && !packet.expires_at && !packet.recheck_by) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["expires_at"],
+      message: "Packets require expires_at or recheck_by."
+    });
+  }
+});
+var defaultContextBudget = {
+  summaryCharacters: 1200,
+  mainTextCharacters: 1200,
+  maxClaims: 10,
+  maxEvidence: 8,
+  maxExcerptCharacters: 2e3,
+  maxHydrationCharacters: 32e3
+};
+function hashExcerpt(excerpt) {
+  return `sha256:${createHash2("sha256").update(excerpt).digest("hex")}`;
+}
+function defaultExpiry() {
+  return new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString();
+}
+function normalizeEvidence(evidence, index) {
+  const excerpt = evidence.excerpt ?? "";
+  return evidenceSchema.parse({
+    evidence_id: evidence.evidence_id ?? `ev_${randomUUID2()}`,
+    kind: evidence.kind ?? "human_note",
+    label: evidence.label ?? `Evidence ${index + 1}`,
+    source: evidence.source ?? "handoff",
+    excerpt,
+    hash: evidence.hash ?? hashExcerpt(excerpt),
+    captured_at: evidence.captured_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sensitivity: evidence.sensitivity ?? "normal"
+  });
+}
+function normalizeClaim(claim, index) {
+  return claimSchema.parse({
+    claim_id: claim.claim_id ?? `clm_${randomUUID2()}`,
+    text: claim.text ?? `Claim ${index + 1}`,
+    confidence: claim.confidence ?? "medium",
+    status: claim.status ?? "inferred",
+    evidence_ids: claim.evidence_ids ?? [],
+    needs_recheck: claim.needs_recheck ?? false
+  });
+}
+function buildPacketDraft(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const packetId = `pkt_${randomUUID2()}`;
+  const receipt = createAuditReceipt({
+    action: "draft",
+    actorMemberId: input.sender_member_id,
+    packetId,
+    workspaceId: input.workspace_id,
+    metadata: {
+      source_client: input.source_client,
+      packet_type: input.packet_type
+    }
+  });
+  const packet = {
+    packet_id: packetId,
+    packet_type: input.packet_type,
+    workspace_id: input.workspace_id,
+    sender_member_id: input.sender_member_id,
+    recipient_member_ids: input.recipient_member_ids,
+    parent_packet_id: input.parent_packet_id,
+    created_at: now,
+    updated_at: now,
+    expires_at: input.expires_at ?? defaultExpiry(),
+    recheck_by: input.recheck_by,
+    status: input.status ?? "pending_sender_approval",
+    project: {
+      repo_name: input.project?.repo_name ?? "unknown-project",
+      git_remote_fingerprint: input.project?.git_remote_fingerprint,
+      branch: input.project?.branch,
+      commit_hash: input.project?.commit_hash
+    },
+    source_client: input.source_client,
+    title: input.title,
+    summary: input.summary,
+    question: input.question,
+    finding: input.finding,
+    answer: input.answer,
+    claims: input.claims?.map(normalizeClaim) ?? [],
+    evidence: input.evidence?.map(normalizeEvidence) ?? [],
+    files_or_symbols: input.files_or_symbols ?? [],
+    commands_or_tests_run: input.commands_or_tests_run ?? [],
+    what_was_tried: input.what_was_tried ?? [],
+    known_failures: input.known_failures ?? [],
+    current_hypothesis: input.current_hypothesis ?? "",
+    confidence: input.confidence ?? "medium",
+    suggested_next_steps: input.suggested_next_steps ?? [],
+    redaction_report: input.redaction_report ?? {
+      blocked: false,
+      findings: [],
+      warnings: []
+    },
+    hydration_policy: {
+      requires_recipient_approval: input.hydration_policy?.requires_recipient_approval ?? true,
+      requires_sender_approval_for_replies: input.hydration_policy?.requires_sender_approval_for_replies ?? true,
+      allow_raw_transcript: input.hydration_policy?.allow_raw_transcript ?? false,
+      max_characters: input.hydration_policy?.max_characters ?? 8e3
+    },
+    audit_receipt: receipt
+  };
+  return packetSchema.parse(packet);
+}
+function validateContextBudget(packet, limits = {}) {
+  const budget = { ...defaultContextBudget, ...limits };
+  const violations = [];
+  const mainText2 = packet.question ?? packet.finding ?? packet.answer ?? "";
+  const hydrationCharacters = packet.summary.length + mainText2.length + packet.claims.reduce((total, claim) => total + claim.text.length, 0) + packet.evidence.reduce((total, evidence) => total + evidence.excerpt.length, 0);
+  if (packet.summary.length > budget.summaryCharacters) {
+    violations.push(`summary exceeds ${budget.summaryCharacters} characters`);
+  }
+  if (mainText2.length > budget.mainTextCharacters) {
+    violations.push(`main packet text exceeds ${budget.mainTextCharacters} characters`);
+  }
+  if (packet.claims.length > budget.maxClaims) {
+    violations.push(`claims exceed ${budget.maxClaims} max`);
+  }
+  if (packet.evidence.length > budget.maxEvidence) {
+    violations.push(`evidence exceeds ${budget.maxEvidence} max`);
+  }
+  for (const evidence of packet.evidence) {
+    if (evidence.excerpt.length > budget.maxExcerptCharacters) {
+      violations.push(
+        `evidence excerpt ${evidence.evidence_id} exceeds ${budget.maxExcerptCharacters} characters`
+      );
+    }
+  }
+  if (hydrationCharacters > budget.maxHydrationCharacters) {
+    violations.push(`hydration payload exceeds ${budget.maxHydrationCharacters} characters`);
+  }
+  return { ok: violations.length === 0, violations };
+}
+function compressPacketToBudget(packet, limits = {}) {
+  const budget = { ...defaultContextBudget, ...limits };
+  const clippedEvidence = packet.evidence.slice(0, budget.maxEvidence).map((evidence) => {
+    if (evidence.excerpt.length <= budget.maxExcerptCharacters) {
+      return evidence;
+    }
+    return {
+      ...evidence,
+      excerpt: `${evidence.excerpt.slice(0, budget.maxExcerptCharacters - 80)}
+[truncated by Handoff; hash preserved: ${evidence.hash}]`
+    };
+  });
+  return packetSchema.parse({
+    ...packet,
+    summary: packet.summary.slice(0, budget.summaryCharacters),
+    question: packet.question?.slice(0, budget.mainTextCharacters),
+    finding: packet.finding?.slice(0, budget.mainTextCharacters),
+    answer: packet.answer?.slice(0, budget.mainTextCharacters),
+    claims: packet.claims.slice(0, budget.maxClaims),
+    evidence: clippedEvidence,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// src/hydration.ts
+function isStale(packet) {
+  const now = Date.now();
+  return Boolean(
+    packet.expires_at && Date.parse(packet.expires_at) < now || packet.recheck_by && Date.parse(packet.recheck_by) < now || packet.claims.some((claim) => claim.needs_recheck)
+  );
+}
+function mainText(packet) {
+  if (packet.packet_type === "ask") return packet.question ?? "";
+  if (packet.packet_type === "share") return packet.finding ?? "";
+  if (packet.packet_type === "reply") return packet.answer ?? "";
+  return packet.question ?? "";
+}
+function formatHydrationContext(packet, input) {
+  const maxCharacters = input.maxCharacters ?? packet.hydration_policy.max_characters;
+  const claims = packet.claims.map(
+    (claim) => `- [${claim.confidence}/${claim.status}] ${claim.text}${claim.needs_recheck ? " (needs recheck)" : ""}`
+  ).join("\n");
+  const evidence = packet.evidence.map(
+    (item) => `- ${item.label} (${item.kind}, ${item.sensitivity}, ${item.source}, ${item.hash})
+  ${item.excerpt}`
+  ).join("\n");
+  const staleWarning = isStale(packet) ? "\nSTALE OR RECHECK REQUIRED: verify dates, claims, and evidence before relying on this packet.\n" : "";
+  const context = `
+Handoff Hydration Packet
+============================
+${staleWarning}
+Title: ${packet.title}
+Type: ${packet.packet_type}
+Status at hydration: ${packet.status}
+
+Main content:
+${mainText(packet)}
+
+Summary:
+${packet.summary}
+
+Claims:
+${claims || "- No explicit claims supplied."}
+
+Evidence:
+${evidence || "- No evidence supplied."}
+
+What was tried:
+${packet.what_was_tried.map((item) => `- ${item}`).join("\n") || "- Not supplied."}
+
+Known failures:
+${packet.known_failures.map((item) => `- ${item}`).join("\n") || "- Not supplied."}
+
+Current hypothesis:
+${packet.current_hypothesis || "Not supplied."}
+
+Suggested next steps:
+${packet.suggested_next_steps.map((item) => `- ${item}`).join("\n") || "- Not supplied."}
+
+Provenance:
+- packet_id: ${packet.packet_id}
+- workspace_id: ${packet.workspace_id}
+- sender_member_id: ${packet.sender_member_id}
+- recipient_member_ids: ${packet.recipient_member_ids.join(", ")}
+- source_client: ${packet.source_client}
+- project: ${packet.project.repo_name}${packet.project.branch ? ` on ${packet.project.branch}` : ""}
+- created_at: ${packet.created_at}
+- recheck_by: ${packet.recheck_by ?? "not set"}
+- expires_at: ${packet.expires_at ?? "not set"}
+`.trim();
+  const bounded = context.length > maxCharacters ? `${context.slice(0, Math.max(0, maxCharacters - 120))}
+[truncated by Handoff hydration budget]` : context;
+  return {
+    context: bounded,
+    receipt: createAuditReceipt({
+      action: "hydrate",
+      actorMemberId: input.hydratedBy,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: {
+        client: input.client,
+        session_id: input.sessionId,
+        packet_type: packet.packet_type
+      }
+    })
+  };
+}
+
+// src/identity.ts
+import { createHash as createHash3, randomBytes, randomUUID as randomUUID3 } from "crypto";
+function createId(prefix) {
+  return `${prefix}_${randomUUID3()}`;
+}
+function createToken(prefix = "relay") {
+  return `${prefix}_${randomBytes(24).toString("base64url")}`;
+}
+function hashToken(token) {
+  return createHash3("sha256").update(token).digest("hex");
+}
+function normalizeHandle(handle) {
+  const trimmed = handle.trim().replace(/^@/, "").toLowerCase();
+  if (!/^[a-z][a-z0-9_-]{1,31}$/.test(trimmed)) {
+    throw new Error("Handle must start with a letter and contain only letters, numbers, _, or -");
+  }
+  return trimmed;
+}
+
+// src/protocol/state-machine.ts
+var transitionRules = {
+  draft: [
+    { to: "pending_sender_approval", roles: ["sender"] },
+    { to: "archived", roles: ["sender", "admin"] }
+  ],
+  pending_sender_approval: [
+    { to: "sent", roles: ["sender"] },
+    { to: "replied", roles: ["recipient"], packetTypes: ["reply"] },
+    { to: "archived", roles: ["sender", "admin", "recipient"] }
+  ],
+  sent: [
+    { to: "delivered", roles: ["system"] },
+    { to: "expired", roles: ["system"] },
+    { to: "superseded", roles: ["sender", "admin"] }
+  ],
+  delivered: [
+    { to: "viewed", roles: ["recipient"] },
+    { to: "declined", roles: ["recipient"] },
+    { to: "archived", roles: ["recipient"] },
+    { to: "expired", roles: ["system"] }
+  ],
+  viewed: [
+    { to: "accepted", roles: ["recipient"] },
+    { to: "clarification_requested", roles: ["recipient"] },
+    { to: "declined", roles: ["recipient"] },
+    { to: "archived", roles: ["recipient"] },
+    { to: "hydrated", roles: ["recipient"], packetTypes: ["reply"] }
+  ],
+  accepted: [
+    { to: "hydrated", roles: ["recipient"] },
+    { to: "response_drafting", roles: ["recipient"], packetTypes: ["ask"] },
+    { to: "archived", roles: ["recipient", "sender"] }
+  ],
+  clarification_requested: [
+    { to: "pending_sender_approval", roles: ["sender"] },
+    { to: "declined", roles: ["recipient"] },
+    { to: "archived", roles: ["recipient", "sender"] }
+  ],
+  response_drafting: [
+    { to: "pending_recipient_approval", roles: ["recipient"] },
+    { to: "archived", roles: ["recipient"] }
+  ],
+  pending_recipient_approval: [
+    { to: "replied", roles: ["recipient"] },
+    { to: "archived", roles: ["recipient"] }
+  ],
+  replied: [
+    { to: "viewed", roles: ["recipient"], packetTypes: ["reply"] },
+    { to: "closed_resolved", roles: ["sender"] },
+    { to: "closed_unresolved", roles: ["sender"] },
+    { to: "archived", roles: ["recipient", "sender"] }
+  ],
+  hydrated: [
+    { to: "response_drafting", roles: ["recipient"], packetTypes: ["ask"] },
+    { to: "archived", roles: ["recipient", "sender"] },
+    { to: "closed_resolved", roles: ["sender"] },
+    { to: "closed_unresolved", roles: ["sender"] }
+  ],
+  archived: [],
+  declined: [{ to: "archived", roles: ["recipient", "sender"] }],
+  expired: [{ to: "archived", roles: ["recipient", "sender", "admin"] }],
+  superseded: [{ to: "archived", roles: ["recipient", "sender", "admin"] }],
+  closed_resolved: [{ to: "archived", roles: ["sender", "recipient"] }],
+  closed_unresolved: [{ to: "archived", roles: ["sender", "recipient"] }]
+};
+function assertTransition(input) {
+  const rules = transitionRules[input.from] ?? [];
+  const rule = rules.find(
+    (candidate) => candidate.to === input.to && candidate.roles.includes(input.actorRole) && (!candidate.packetTypes || !input.packetType || candidate.packetTypes.includes(input.packetType))
+  );
+  if (!rule) {
+    const allowed = rules.map((candidate) => `${candidate.to} by ${candidate.roles.join("/")}`).join(", ");
+    throw relayError(
+      "INVALID_STATE_TRANSITION",
+      `Invalid state transition from ${input.from} to ${input.to} by ${input.actorRole}. Allowed: ${allowed || "none"}`,
+      409
+    );
+  }
+}
+
+// src/redaction.ts
+var apiKeyPattern = /\b(?:sk-[A-Za-z0-9_-]{10,}|ghp_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|(?:api[_-]?key|access[_-]?token|secret|password)\s*=\s*[^\s"'`]+)\b/i;
+var privateKeyPattern = /-----BEGIN (?:[A-Z]+ )?PRIVATE KEY-----/;
+var credentialUrlPattern = /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]+:[^@\s]+@/i;
+var envSecretPattern = /(^|\n)\s*(?:[A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL)[A-Z0-9_]*)\s*=\s*[^\s]+/i;
+var localPathPattern = /(?:^|\s)(\/Users\/[^\s"'`]+|\/home\/[^\s"'`]+|[A-Za-z]:\\Users\\[^\s"'`]+)/;
+function preview(value) {
+  return value.replace(/\s+/g, " ").slice(0, 80);
+}
+function scanText(text, field, evidenceId, options) {
+  const findings = [];
+  const warnings = [];
+  const addBlock = (kind, message) => {
+    findings.push({
+      kind,
+      field,
+      evidence_id: evidenceId,
+      severity: "block",
+      message,
+      preview: preview(text)
+    });
+  };
+  const addWarning = (kind, message) => {
+    warnings.push({
+      kind,
+      field,
+      evidence_id: evidenceId,
+      severity: "warning",
+      message,
+      preview: preview(text)
+    });
+  };
+  if (apiKeyPattern.test(text)) {
+    addBlock("api_key", "Secret-looking API key or token detected.");
+  }
+  if (privateKeyPattern.test(text)) {
+    addBlock("private_key", "Private key material detected.");
+  }
+  if (credentialUrlPattern.test(text)) {
+    addBlock("credential_url", "Credential-bearing URL detected.");
+  }
+  if (envSecretPattern.test(text)) {
+    addBlock("env_secret", ".env-like secret content detected.");
+  }
+  if (localPathPattern.test(text)) {
+    addWarning("local_path", "Local absolute path detected; review before sending.");
+  }
+  if (text.length > options.maxExcerptCharacters) {
+    addWarning(
+      "oversized_excerpt",
+      `Evidence excerpt exceeds ${options.maxExcerptCharacters} characters and should be compressed.`
+    );
+  }
+  for (const pattern of options.userPatterns ?? []) {
+    if (pattern.test(text)) {
+      addBlock("user_pattern", "User-defined restricted pattern detected.");
+    }
+  }
+  return { findings, warnings };
+}
+function scanPacketForRedactions(packet, options = {}) {
+  const mergedOptions = {
+    maxExcerptCharacters: options.maxExcerptCharacters ?? 2e3,
+    userPatterns: options.userPatterns
+  };
+  const findings = [];
+  const warnings = [];
+  const textFields = collectRedactionTextFields(packet);
+  for (const [field, value] of textFields) {
+    if (!value) continue;
+    const result = scanText(value, field, void 0, mergedOptions);
+    findings.push(...result.findings);
+    warnings.push(...result.warnings);
+  }
+  for (const [index, evidence] of packet.evidence.entries()) {
+    if (evidence.sensitivity === "secret_detected" || evidence.sensitivity === "restricted") {
+      findings.push({
+        kind: "user_pattern",
+        field: `evidence.${index}.sensitivity`,
+        evidence_id: evidence.evidence_id,
+        severity: "block",
+        message: `Evidence sensitivity ${evidence.sensitivity} cannot be sent without override.`
+      });
+    }
+  }
+  return {
+    blocked: findings.some((finding) => finding.severity === "block"),
+    findings,
+    warnings
+  };
+}
+function collectRedactionTextFields(packet) {
+  const fields = [
+    ["title", packet.title],
+    ["summary", packet.summary],
+    ["current_hypothesis", packet.current_hypothesis],
+    ...optionalField("question", packet.question),
+    ...optionalField("finding", packet.finding),
+    ...optionalField("answer", packet.answer)
+  ];
+  for (const [index, claim] of packet.claims.entries()) {
+    fields.push([`claims.${index}.text`, claim.text]);
+  }
+  pushArrayFields(fields, "files_or_symbols", packet.files_or_symbols);
+  pushArrayFields(fields, "commands_or_tests_run", packet.commands_or_tests_run);
+  pushArrayFields(fields, "what_was_tried", packet.what_was_tried);
+  pushArrayFields(fields, "known_failures", packet.known_failures);
+  pushArrayFields(fields, "suggested_next_steps", packet.suggested_next_steps);
+  for (const [index, evidence] of packet.evidence.entries()) {
+    fields.push([`evidence.${index}.label`, evidence.label]);
+    fields.push([`evidence.${index}.source`, evidence.source]);
+    fields.push([`evidence.${index}.excerpt`, evidence.excerpt]);
+  }
+  return fields;
+}
+function optionalField(field, value) {
+  return value ? [[field, value]] : [];
+}
+function pushArrayFields(fields, prefix, values) {
+  for (const [index, value] of values.entries()) {
+    fields.push([`${prefix}.${index}`, value]);
+  }
+}
+
+// src/service/relay-service.ts
+function rowToMember(row, token, approvalSecret) {
+  return {
+    id: row.id,
+    workspace_id: row.workspace_id,
+    handle: row.handle,
+    display_name: row.display_name,
+    role: row.role,
+    status: row.status,
+    token,
+    approval_secret: approvalSecret,
+    created_at: row.created_at,
+    revoked_at: row.revoked_at ?? void 0
+  };
+}
+function rowToWorkspace(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    admin_body_access: Boolean(row.admin_body_access),
+    created_at: row.created_at
+  };
+}
+function rowToInvite(row) {
+  return {
+    id: row.id,
+    workspace_id: row.workspace_id,
+    handle: row.handle,
+    token: row.token,
+    created_by_member_id: row.created_by_member_id,
+    expires_at: row.expires_at,
+    accepted_at: row.accepted_at ?? void 0,
+    created_at: row.created_at
+  };
+}
+function rowToProjectAlias(row) {
+  return {
+    id: row.id,
+    workspace_id: row.workspace_id,
+    canonical_project: row.canonical_project,
+    alias: row.alias,
+    created_by_member_id: row.created_by_member_id,
+    created_at: row.created_at
+  };
+}
+function normalizeProjectName(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    throw relayError("INVALID_INPUT", "Project alias values cannot be empty.", 400);
+  }
+  return normalized;
+}
+function parseJson(value) {
+  return JSON.parse(value);
+}
+function rowToPacket(row) {
+  return packetSchema.parse({
+    packet_id: row.id,
+    packet_type: row.packet_type,
+    workspace_id: row.workspace_id,
+    sender_member_id: row.sender_member_id,
+    recipient_member_ids: parseJson(row.recipient_member_ids),
+    parent_packet_id: row.parent_packet_id ?? void 0,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    expires_at: row.expires_at ?? void 0,
+    recheck_by: row.recheck_by ?? void 0,
+    status: row.status,
+    project: parseJson(row.project),
+    source_client: row.source_client,
+    title: row.title,
+    summary: row.summary,
+    question: row.question ?? void 0,
+    finding: row.finding ?? void 0,
+    answer: row.answer ?? void 0,
+    claims: parseJson(row.claims),
+    evidence: parseJson(row.evidence),
+    files_or_symbols: parseJson(row.files_or_symbols),
+    commands_or_tests_run: parseJson(row.commands_or_tests_run),
+    what_was_tried: parseJson(row.what_was_tried),
+    known_failures: parseJson(row.known_failures),
+    current_hypothesis: row.current_hypothesis,
+    confidence: row.confidence,
+    suggested_next_steps: parseJson(row.suggested_next_steps),
+    redaction_report: parseJson(row.redaction_report),
+    hydration_policy: parseJson(row.hydration_policy),
+    audit_receipt: parseJson(row.audit_receipt)
+  });
+}
+function packetParams(packet) {
+  return {
+    id: packet.packet_id,
+    workspace_id: packet.workspace_id,
+    packet_type: packet.packet_type,
+    sender_member_id: packet.sender_member_id,
+    recipient_member_ids: JSON.stringify(packet.recipient_member_ids),
+    parent_packet_id: packet.parent_packet_id ?? null,
+    status: packet.status,
+    title: packet.title,
+    summary: packet.summary,
+    question: packet.question ?? null,
+    finding: packet.finding ?? null,
+    answer: packet.answer ?? null,
+    project: JSON.stringify(packet.project),
+    source_client: packet.source_client,
+    claims: JSON.stringify(packet.claims),
+    evidence: JSON.stringify(packet.evidence),
+    files_or_symbols: JSON.stringify(packet.files_or_symbols),
+    commands_or_tests_run: JSON.stringify(packet.commands_or_tests_run),
+    what_was_tried: JSON.stringify(packet.what_was_tried),
+    known_failures: JSON.stringify(packet.known_failures),
+    current_hypothesis: packet.current_hypothesis,
+    confidence: packet.confidence,
+    suggested_next_steps: JSON.stringify(packet.suggested_next_steps),
+    redaction_report: JSON.stringify(packet.redaction_report),
+    hydration_policy: JSON.stringify(packet.hydration_policy),
+    audit_receipt: JSON.stringify(packet.audit_receipt),
+    expires_at: packet.expires_at ?? null,
+    recheck_by: packet.recheck_by ?? null,
+    created_at: packet.created_at,
+    updated_at: packet.updated_at
+  };
+}
+var RelayService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  close() {
+    this.db.close();
+  }
+  createWorkspace(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const workspace = {
+      id: createId("wrk"),
+      name: input.name,
+      admin_body_access: input.adminBodyAccess ?? false,
+      created_at: now
+    };
+    const token = createToken("relay_member");
+    const approvalSecret = createToken("relay_approval_secret");
+    const admin = {
+      id: createId("mem"),
+      workspace_id: workspace.id,
+      handle: normalizeHandle(input.adminHandle),
+      display_name: input.adminName,
+      role: "admin",
+      status: "active",
+      token,
+      approval_secret: approvalSecret,
+      created_at: now
+    };
+    const transaction = this.db.transaction(() => {
+      this.db.prepare(
+        "INSERT INTO workspaces (id, name, admin_body_access, created_at) VALUES (?, ?, ?, ?)"
+      ).run(
+        workspace.id,
+        workspace.name,
+        workspace.admin_body_access ? 1 : 0,
+        workspace.created_at
+      );
+      this.db.prepare(
+        `INSERT INTO members
+          (id, workspace_id, handle, display_name, role, status, token_hash, approval_secret_hash, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        admin.id,
+        admin.workspace_id,
+        admin.handle,
+        admin.display_name,
+        admin.role,
+        admin.status,
+        hashToken(token),
+        hashToken(approvalSecret),
+        admin.created_at
+      );
+    });
+    transaction();
+    return { workspace, admin };
+  }
+  inviteMember(input) {
+    const admin = this.requireAdmin(input.adminToken, input.workspaceId);
+    const handle = normalizeHandle(input.handle);
+    const existing = this.findMemberByHandle(input.workspaceId, handle, true);
+    if (existing?.status === "revoked") {
+      throw relayError("INVALID_RECIPIENT", `Recipient @${handle} is revoked.`, 403);
+    }
+    if (existing) {
+      throw relayError("INVALID_INPUT", `Member @${handle} already exists in this workspace.`, 409);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const invite = {
+      id: createId("inv"),
+      workspace_id: input.workspaceId,
+      handle,
+      token: createToken("relay_invite"),
+      created_by_member_id: admin.id,
+      expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString(),
+      created_at: now
+    };
+    this.db.prepare(
+      `INSERT INTO invites
+        (id, workspace_id, handle, token, created_by_member_id, expires_at, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      invite.id,
+      invite.workspace_id,
+      invite.handle,
+      invite.token,
+      invite.created_by_member_id,
+      invite.expires_at,
+      invite.created_at
+    );
+    return { invite };
+  }
+  acceptInvite(input) {
+    const inviteRow = this.db.prepare("SELECT * FROM invites WHERE token = ?").get(input.inviteToken);
+    if (!inviteRow) {
+      throw relayError("NOT_FOUND", "Invite not found.", 404);
+    }
+    if (inviteRow.accepted_at) {
+      throw relayError("INVALID_INPUT", "Invite has already been accepted.", 409);
+    }
+    if (Date.parse(inviteRow.expires_at) < Date.now()) {
+      throw relayError("INVALID_INPUT", "Invite has expired.", 410);
+    }
+    const workspace = this.getWorkspace(inviteRow.workspace_id);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const token = createToken("relay_member");
+    const approvalSecret = createToken("relay_approval_secret");
+    const member = {
+      id: createId("mem"),
+      workspace_id: inviteRow.workspace_id,
+      handle: inviteRow.handle,
+      display_name: input.displayName,
+      role: "member",
+      status: "active",
+      token,
+      approval_secret: approvalSecret,
+      created_at: now
+    };
+    const transaction = this.db.transaction(() => {
+      this.db.prepare(
+        `INSERT INTO members
+          (id, workspace_id, handle, display_name, role, status, token_hash, approval_secret_hash, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        member.id,
+        member.workspace_id,
+        member.handle,
+        member.display_name,
+        member.role,
+        member.status,
+        hashToken(token),
+        hashToken(approvalSecret),
+        member.created_at
+      );
+      this.db.prepare("UPDATE invites SET accepted_at = ? WHERE id = ?").run(now, inviteRow.id);
+    });
+    transaction();
+    return { member, workspace };
+  }
+  getInvite(input) {
+    const inviteRow = this.db.prepare("SELECT * FROM invites WHERE token = ?").get(input.inviteToken);
+    if (!inviteRow) {
+      throw relayError("NOT_FOUND", "Invite not found.", 404);
+    }
+    return {
+      invite: rowToInvite(inviteRow),
+      workspace: this.getWorkspace(inviteRow.workspace_id)
+    };
+  }
+  listMembers(input) {
+    this.requireMember(input.authToken, input.workspaceId);
+    return this.db.prepare("SELECT * FROM members WHERE workspace_id = ? ORDER BY handle").all(input.workspaceId).map((row) => rowToMember(row));
+  }
+  configureProjectAlias(input) {
+    const admin = this.requireAdmin(input.authToken, input.workspaceId);
+    const canonicalProject = normalizeProjectName(input.canonicalProject);
+    const alias = normalizeProjectName(input.alias);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = createId("pal");
+    this.db.prepare(
+      `INSERT INTO project_aliases
+        (id, workspace_id, canonical_project, alias, created_by_member_id, created_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(workspace_id, alias) DO UPDATE SET
+          id = excluded.id,
+          canonical_project = excluded.canonical_project,
+          created_by_member_id = excluded.created_by_member_id,
+          created_at = excluded.created_at`
+    ).run(id, input.workspaceId, canonicalProject, alias, admin.id, now);
+    this.recordAudit({
+      action: "configure_project_alias",
+      actorMemberId: admin.id,
+      workspaceId: input.workspaceId,
+      metadata: { canonical_project: canonicalProject, alias }
+    });
+    return {
+      alias: {
+        id,
+        workspace_id: input.workspaceId,
+        canonical_project: canonicalProject,
+        alias,
+        created_by_member_id: admin.id,
+        created_at: now
+      }
+    };
+  }
+  listProjectAliases(input) {
+    this.requireMember(input.authToken, input.workspaceId);
+    return this.db.prepare(
+      `SELECT * FROM project_aliases
+          WHERE workspace_id = ?
+          ORDER BY canonical_project, alias`
+    ).all(input.workspaceId).map((row) => rowToProjectAlias(row));
+  }
+  revokeMember(input) {
+    const admin = this.requireAdmin(input.adminToken, input.workspaceId);
+    if (admin.id === input.memberId) {
+      throw relayError("INVALID_INPUT", "Admins cannot revoke themselves.", 400);
+    }
+    const member = this.getMember(input.memberId);
+    if (member.workspace_id !== input.workspaceId) {
+      throw relayError("FORBIDDEN", "Member belongs to a different workspace.", 403);
+    }
+    const revokedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare("UPDATE members SET status = ?, revoked_at = ? WHERE id = ?").run("revoked", revokedAt, input.memberId);
+    this.recordAudit({
+      action: "revoke",
+      actorMemberId: admin.id,
+      workspaceId: input.workspaceId,
+      metadata: { revoked_member_id: input.memberId }
+    });
+    return { member: { ...member, status: "revoked", revoked_at: revokedAt } };
+  }
+  rotateMemberToken(input) {
+    const member = this.authenticate(input.authToken);
+    const token = createToken("relay_member");
+    this.db.prepare("UPDATE members SET token_hash = ? WHERE id = ?").run(hashToken(token), member.id);
+    this.recordAudit({
+      action: "rotate_token",
+      actorMemberId: member.id,
+      workspaceId: member.workspace_id,
+      metadata: {}
+    });
+    return { member, token };
+  }
+  rotateApprovalSecret(input) {
+    const member = this.authenticate(input.authToken);
+    this.requireApprovalSecret(member, input.approvalSecret);
+    const approvalSecret = createToken("relay_approval_secret");
+    const rotatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const rotate = this.db.transaction(() => {
+      this.db.prepare("UPDATE members SET approval_secret_hash = ? WHERE id = ?").run(hashToken(approvalSecret), member.id);
+      const invalidated = this.db.prepare(
+        `UPDATE approval_tokens
+          SET consumed_at = ?
+          WHERE actor_member_id = ?
+            AND consumed_at IS NULL`
+      ).run(rotatedAt, member.id);
+      this.recordAudit({
+        action: "rotate_approval_secret",
+        actorMemberId: member.id,
+        workspaceId: member.workspace_id,
+        metadata: { invalidated_approval_tokens: invalidated.changes }
+      });
+    });
+    rotate();
+    return { member, approval_secret: approvalSecret };
+  }
+  createApprovalToken(input) {
+    const actor = this.authenticate(input.authToken);
+    this.requireApprovalSecret(actor, input.approvalSecret);
+    const packet = this.getPacket(input.packetId);
+    this.assertApprovalTokenAllowed(actor, packet, input.action);
+    const token = createToken("relay_approval");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const expiresAt = new Date(Date.now() + 10 * 60 * 1e3).toISOString();
+    this.db.prepare(
+      `INSERT INTO approval_tokens
+        (id, packet_id, workspace_id, actor_member_id, action, token_hash, expires_at, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      createId("apr"),
+      packet.packet_id,
+      packet.workspace_id,
+      actor.id,
+      input.action,
+      hashToken(token),
+      expiresAt,
+      now
+    );
+    this.recordAudit({
+      action: "approve",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: { approval_action: input.action, token_created: true }
+    });
+    return {
+      approval_token: token,
+      action: input.action,
+      packet_id: packet.packet_id,
+      expires_at: expiresAt
+    };
+  }
+  createAskDraft(input) {
+    return this.createPacketDraft("ask", input, { question: input.question });
+  }
+  createShareDraft(input) {
+    return this.createPacketDraft("share", input, { finding: input.finding });
+  }
+  updateDraft(input) {
+    const actor = this.authenticate(input.authToken);
+    const packet = this.getPacket(input.packetId);
+    this.requireSender(actor, packet);
+    if (!["ask", "share"].includes(packet.packet_type)) {
+      throw relayError("INVALID_INPUT", "Only ask/share drafts can be edited before send.", 400);
+    }
+    if (packet.status !== "pending_sender_approval") {
+      throw relayError(
+        "INVALID_STATE_TRANSITION",
+        "Only drafts pending sender approval can be edited.",
+        409
+      );
+    }
+    const changedFields = Object.entries(input).filter(([key, value]) => !["authToken", "packetId"].includes(key) && value !== void 0).map(([key]) => key);
+    const updated = this.preparePacket(
+      packetSchema.parse({
+        ...packet,
+        title: input.title ?? packet.title,
+        summary: input.summary ?? packet.summary,
+        question: input.question ?? packet.question,
+        finding: input.finding ?? packet.finding,
+        claims: input.claims?.map(normalizeClaim) ?? packet.claims,
+        evidence: input.evidence?.map(normalizeEvidence) ?? packet.evidence,
+        files_or_symbols: input.filesOrSymbols ?? packet.files_or_symbols,
+        commands_or_tests_run: input.commandsOrTestsRun ?? packet.commands_or_tests_run,
+        what_was_tried: input.whatWasTried ?? packet.what_was_tried,
+        known_failures: input.knownFailures ?? packet.known_failures,
+        current_hypothesis: input.currentHypothesis ?? packet.current_hypothesis,
+        confidence: input.confidence ?? packet.confidence,
+        suggested_next_steps: input.suggestedNextSteps ?? packet.suggested_next_steps
+      })
+    );
+    this.updatePacket(updated);
+    this.recordAudit({
+      action: "edit",
+      actorMemberId: actor.id,
+      packetId: updated.packet_id,
+      workspaceId: updated.workspace_id,
+      metadata: { changed_fields: changedFields }
+    });
+    return { id: updated.packet_id, packet: this.getPacket(updated.packet_id) };
+  }
+  approveAndSend(input) {
+    const actor = this.authenticate(input.authToken);
+    let packet = this.getPacket(input.packetId);
+    this.requireSender(actor, packet);
+    if (packet.packet_type === "reply") {
+      return this.approveReply({
+        authToken: input.authToken,
+        replyPacketId: input.packetId,
+        approvalToken: input.approvalToken
+      });
+    }
+    this.consumeApprovalToken({
+      actor,
+      packet,
+      action: "send",
+      approvalToken: input.approvalToken
+    });
+    if (packet.redaction_report.blocked && !input.allowSecretOverride) {
+      throw relayError(
+        "REDACTION_BLOCKED",
+        "Redaction blocked this packet. Remove secret-looking evidence or explicitly override.",
+        422,
+        packet.redaction_report
+      );
+    }
+    for (const recipientId of packet.recipient_member_ids) {
+      const recipient = this.getMember(recipientId);
+      if (recipient.status === "revoked") {
+        throw relayError("INVALID_RECIPIENT", `Recipient @${recipient.handle} is revoked.`, 403);
+      }
+    }
+    packet = this.transitionPacket(packet, "sent", actor, "sender");
+    this.recordAudit({
+      action: "approve",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: { status: "sent" }
+    });
+    this.recordAudit({
+      action: "send",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: { recipient_member_ids: packet.recipient_member_ids }
+    });
+    packet = this.transitionPacket(packet, "delivered", actor, "system");
+    for (const recipientId of packet.recipient_member_ids) {
+      this.createNotification(packet, recipientId);
+    }
+    this.recordAudit({
+      action: "deliver",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: { recipient_member_ids: packet.recipient_member_ids }
+    });
+    return { id: packet.packet_id, packet: this.getPacket(packet.packet_id) };
+  }
+  listInbox(input) {
+    const member = this.requireMember(input.authToken, input.workspaceId);
+    return this.listWorkspacePackets(input.workspaceId).filter((packet) => packet.recipient_member_ids.includes(member.id)).filter(
+      (packet) => ![
+        "archived",
+        "closed_resolved",
+        "closed_unresolved",
+        "declined",
+        "expired",
+        "superseded"
+      ].includes(packet.status)
+    );
+  }
+  viewPacket(input) {
+    const actor = this.authenticate(input.authToken);
+    let packet = this.getPacket(input.packetId);
+    this.requireReadable(actor, packet);
+    const role = this.actorRole(actor, packet);
+    if (role === "recipient" && (packet.status === "delivered" || packet.status === "replied")) {
+      packet = this.transitionPacket(packet, "viewed", actor, "recipient");
+    }
+    this.recordAudit({
+      action: "view",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: { status: packet.status }
+    });
+    return { id: packet.packet_id, packet };
+  }
+  getPacketForMember(input) {
+    const actor = this.authenticate(input.authToken);
+    const packet = this.getPacket(input.packetId);
+    this.requireReadable(actor, packet);
+    return { id: packet.packet_id, packet };
+  }
+  acceptPacket(input) {
+    const actor = this.authenticate(input.authToken);
+    const packet = this.getPacket(input.packetId);
+    this.requireRecipient(actor, packet);
+    const accepted = this.transitionPacket(packet, "accepted", actor, "recipient");
+    this.recordAudit({
+      action: "accept",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: {}
+    });
+    return { id: accepted.packet_id, packet: accepted };
+  }
+  hydratePacket(input) {
+    const actor = this.authenticate(input.authToken);
+    let packet = this.getPacket(input.packetId);
+    this.requireRecipient(actor, packet);
+    this.consumeApprovalToken({
+      actor,
+      packet,
+      action: "hydrate",
+      approvalToken: input.approvalToken
+    });
+    const targetStatus = "hydrated";
+    packet = this.transitionPacket(packet, targetStatus, actor, "recipient");
+    const hydration = formatHydrationContext(packet, {
+      hydratedBy: actor.id,
+      client: input.client,
+      sessionId: input.sessionId
+    });
+    this.insertAuditReceipt(hydration.receipt);
+    this.db.prepare(
+      `INSERT INTO hydration_receipts
+        (receipt_id, packet_id, workspace_id, actor_member_id, client, session_id, context, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      hydration.receipt.receipt_id,
+      packet.packet_id,
+      packet.workspace_id,
+      actor.id,
+      input.client,
+      input.sessionId ?? null,
+      hydration.context,
+      hydration.receipt.created_at
+    );
+    packet = this.updatePacket({ ...packet, audit_receipt: hydration.receipt });
+    return { ...hydration, packet };
+  }
+  createReplyDraft(input) {
+    const actor = this.authenticate(input.authToken);
+    let original = this.getPacket(input.packetId);
+    this.requireRecipient(actor, original);
+    if (!["accepted", "hydrated"].includes(original.status)) {
+      throw relayError(
+        "INVALID_STATE_TRANSITION",
+        "A recipient must accept or hydrate an ask before replying.",
+        409
+      );
+    }
+    if (original.packet_type !== "ask") {
+      throw relayError("INVALID_INPUT", "Replies can only be created for ask packets.", 400);
+    }
+    if (original.status === "accepted" || original.status === "hydrated") {
+      original = this.transitionPacket(original, "response_drafting", actor, "recipient");
+    }
+    const packet = this.preparePacket(
+      buildPacketDraft({
+        packet_type: "reply",
+        workspace_id: original.workspace_id,
+        sender_member_id: actor.id,
+        recipient_member_ids: [original.sender_member_id],
+        parent_packet_id: original.packet_id,
+        status: "pending_recipient_approval",
+        title: input.title ?? `Reply: ${original.title}`,
+        summary: input.summary,
+        answer: input.answer,
+        source_client: input.sourceClient,
+        project: original.project,
+        evidence: input.evidence,
+        confidence: input.confidence
+      })
+    );
+    this.insertPacket(packet);
+    this.insertAuditReceipt(packet.audit_receipt);
+    this.recordAudit({
+      action: "reply",
+      actorMemberId: actor.id,
+      packetId: original.packet_id,
+      workspaceId: original.workspace_id,
+      metadata: { reply_packet_id: packet.packet_id, status: "pending_recipient_approval" }
+    });
+    return { id: packet.packet_id, packet };
+  }
+  approveReply(input) {
+    const actor = this.authenticate(input.authToken);
+    let reply = this.getPacket(input.replyPacketId);
+    this.requireSender(actor, reply);
+    if (reply.packet_type !== "reply") {
+      throw relayError("INVALID_INPUT", "Packet is not a reply.", 400);
+    }
+    this.consumeApprovalToken({
+      actor,
+      packet: reply,
+      action: "reply",
+      approvalToken: input.approvalToken
+    });
+    reply = this.transitionPacket(reply, "replied", actor, "recipient");
+    for (const recipientId of reply.recipient_member_ids) {
+      this.createNotification(reply, recipientId);
+    }
+    this.recordAudit({
+      action: "approve",
+      actorMemberId: actor.id,
+      packetId: reply.packet_id,
+      workspaceId: reply.workspace_id,
+      metadata: { reply_packet_id: reply.packet_id }
+    });
+    if (reply.parent_packet_id) {
+      let parent = this.getPacket(reply.parent_packet_id);
+      if (parent.status === "response_drafting") {
+        parent = this.transitionPacket(parent, "pending_recipient_approval", actor, "recipient");
+      }
+      parent = this.transitionPacket(parent, "replied", actor, "recipient");
+      this.recordAudit({
+        action: "reply",
+        actorMemberId: actor.id,
+        packetId: parent.packet_id,
+        workspaceId: parent.workspace_id,
+        metadata: { reply_packet_id: reply.packet_id, status: "replied" }
+      });
+    }
+    return { id: reply.packet_id, packet: this.getPacket(reply.packet_id) };
+  }
+  declinePacket(input) {
+    const actor = this.authenticate(input.authToken);
+    const packet = this.getPacket(input.packetId);
+    this.requireRecipient(actor, packet);
+    const declined = this.transitionPacket(packet, "declined", actor, "recipient");
+    this.recordAudit({
+      action: "decline",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: { reason: input.reason }
+    });
+    return { id: declined.packet_id, packet: declined };
+  }
+  archivePacket(input) {
+    const actor = this.authenticate(input.authToken);
+    const packet = this.getPacket(input.packetId);
+    this.requireReadable(actor, packet);
+    const role = this.actorRole(actor, packet);
+    const archived = this.transitionPacket(
+      packet,
+      "archived",
+      actor,
+      role === "admin" ? "admin" : role
+    );
+    this.recordAudit({
+      action: "archive",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: {}
+    });
+    return { id: archived.packet_id, packet: archived };
+  }
+  requestClarification(input) {
+    const actor = this.authenticate(input.authToken);
+    let original = this.getPacket(input.packetId);
+    this.requireRecipient(actor, original);
+    original = this.transitionPacket(original, "clarification_requested", actor, "recipient");
+    this.recordAudit({
+      action: "clarify",
+      actorMemberId: actor.id,
+      packetId: original.packet_id,
+      workspaceId: original.workspace_id,
+      metadata: { question: input.question, requested_evidence: input.requestedEvidence ?? [] }
+    });
+    const packet = this.preparePacket(
+      buildPacketDraft({
+        packet_type: "clarification",
+        workspace_id: original.workspace_id,
+        sender_member_id: actor.id,
+        recipient_member_ids: [original.sender_member_id],
+        parent_packet_id: original.packet_id,
+        status: "delivered",
+        title: `Clarification: ${original.title}`,
+        summary: input.question,
+        question: input.question,
+        source_client: original.source_client,
+        project: original.project,
+        suggested_next_steps: input.requestedEvidence
+      })
+    );
+    this.insertPacket(packet);
+    this.insertAuditReceipt(packet.audit_receipt);
+    this.createNotification(packet, original.sender_member_id);
+    return { id: packet.packet_id, packet };
+  }
+  closePacket(input) {
+    const actor = this.authenticate(input.authToken);
+    const packet = this.getPacket(input.packetId);
+    this.requireSender(actor, packet);
+    const status = input.resolution === "resolved" ? "closed_resolved" : "closed_unresolved";
+    const closed = this.transitionPacket(packet, status, actor, "sender");
+    this.recordAudit({
+      action: "close",
+      actorMemberId: actor.id,
+      packetId: packet.packet_id,
+      workspaceId: packet.workspace_id,
+      metadata: { resolution: input.resolution }
+    });
+    return { id: closed.packet_id, packet: closed };
+  }
+  searchPackets(input) {
+    const actor = this.requireMember(input.authToken, input.workspaceId);
+    const query = input.query?.toLowerCase() ?? "";
+    const results = this.listWorkspacePackets(input.workspaceId).filter((packet) => {
+      if (!this.canReadMetadata(actor, packet)) return false;
+      if (!this.matchesPacketQueryFilters(actor, packet, input)) return false;
+      if (!query) return true;
+      const haystack = this.searchHaystackFor(actor, packet);
+      return haystack.includes(query);
+    });
+    this.recordAudit({
+      action: "search",
+      actorMemberId: actor.id,
+      workspaceId: input.workspaceId,
+      metadata: { query, filters: this.auditFilterMetadata(input) }
+    });
+    return results.map((packet) => this.toSearchResult(actor, packet));
+  }
+  listHistory(input) {
+    const actor = this.requireMember(input.authToken, input.workspaceId);
+    const filter = input.filter ?? "all";
+    const query = input.query?.toLowerCase() ?? "";
+    const results = this.listWorkspacePackets(input.workspaceId).filter((packet) => {
+      if (!this.canReadMetadata(actor, packet)) return false;
+      if (!this.matchesHistoryFilter(actor, packet, filter)) return false;
+      if (!this.matchesPacketQueryFilters(actor, packet, input)) return false;
+      if (!query) return true;
+      return this.searchHaystackFor(actor, packet).includes(query);
+    });
+    this.recordAudit({
+      action: "search",
+      actorMemberId: actor.id,
+      workspaceId: input.workspaceId,
+      metadata: { query, history_filter: filter, filters: this.auditFilterMetadata(input) }
+    });
+    return results.map((packet) => this.toSearchResult(actor, packet));
+  }
+  listAuditReceipts(input) {
+    const actor = this.requireMember(input.authToken, input.workspaceId);
+    if (input.packetId) {
+      const packet = this.getPacket(input.packetId);
+      if (!this.canReadMetadata(actor, packet)) {
+        throw relayError("FORBIDDEN", "Packet audit metadata is not visible to this member.", 403);
+      }
+    } else if (actor.role !== "admin") {
+      throw relayError("FORBIDDEN", "Only admins can view workspace audit logs.", 403);
+    }
+    const rows = input.packetId ? this.db.prepare(
+      "SELECT * FROM audit_receipts WHERE workspace_id = ? AND packet_id = ? ORDER BY created_at"
+    ).all(input.workspaceId, input.packetId) : this.db.prepare("SELECT * FROM audit_receipts WHERE workspace_id = ? ORDER BY created_at").all(input.workspaceId);
+    return rows.map((row) => ({
+      receipt_id: row.receipt_id,
+      workspace_id: row.workspace_id,
+      packet_id: row.packet_id ?? void 0,
+      actor_member_id: row.actor_member_id,
+      action: row.action,
+      created_at: row.created_at,
+      metadata: parseJson(row.metadata),
+      receipt_hash: row.receipt_hash
+    }));
+  }
+  getPacket(packetId) {
+    const row = this.db.prepare("SELECT * FROM packets WHERE id = ?").get(packetId);
+    if (!row) {
+      throw relayError("NOT_FOUND", "Packet not found.", 404);
+    }
+    return rowToPacket(row);
+  }
+  createPacketDraft(packetType, input, main) {
+    const actor = this.requireMember(input.authToken, input.workspaceId);
+    const recipient = this.resolveRecipient(input.workspaceId, input.to);
+    const project = input.project ? {
+      ...input.project,
+      repo_name: this.resolveCanonicalProjectName(
+        input.workspaceId,
+        input.project.repo_name ?? "unknown-project"
+      )
+    } : input.project;
+    const base = buildPacketDraft({
+      packet_type: packetType,
+      workspace_id: input.workspaceId,
+      sender_member_id: actor.id,
+      recipient_member_ids: [recipient.id],
+      title: input.title,
+      summary: input.summary,
+      source_client: input.sourceClient,
+      project,
+      evidence: input.evidence,
+      claims: input.claims,
+      files_or_symbols: input.filesOrSymbols,
+      commands_or_tests_run: input.commandsOrTestsRun,
+      what_was_tried: input.whatWasTried,
+      known_failures: input.knownFailures,
+      current_hypothesis: input.currentHypothesis,
+      confidence: input.confidence,
+      suggested_next_steps: input.suggestedNextSteps,
+      ...main
+    });
+    const packet = this.preparePacket(base);
+    this.insertPacket(packet);
+    this.insertAuditReceipt(packet.audit_receipt);
+    return { id: packet.packet_id, packet };
+  }
+  preparePacket(packet) {
+    const redactionReport = scanPacketForRedactions(packet);
+    let prepared = packetSchema.parse({
+      ...packet,
+      redaction_report: redactionReport,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const budget = validateContextBudget(prepared);
+    if (!budget.ok) {
+      prepared = compressPacketToBudget(prepared);
+      prepared = packetSchema.parse({
+        ...prepared,
+        redaction_report: {
+          ...prepared.redaction_report,
+          warnings: [
+            ...prepared.redaction_report.warnings,
+            ...budget.violations.map((violation) => ({
+              kind: "oversized_excerpt",
+              field: "packet",
+              severity: "warning",
+              message: violation
+            }))
+          ]
+        }
+      });
+    }
+    return prepared;
+  }
+  authenticate(token) {
+    if (!token) {
+      throw relayError("AUTH_REQUIRED", "Missing Relay auth token.", 401);
+    }
+    const row = this.db.prepare("SELECT * FROM members WHERE token_hash = ?").get(hashToken(token));
+    if (!row) {
+      throw relayError("AUTH_REQUIRED", "Invalid Relay auth token.", 401);
+    }
+    const member = rowToMember(row);
+    if (member.status === "revoked") {
+      throw relayError("TOKEN_REVOKED", "This member token has been revoked.", 403);
+    }
+    return member;
+  }
+  requireMember(token, workspaceId) {
+    const member = this.authenticate(token);
+    if (member.workspace_id !== workspaceId) {
+      throw relayError("FORBIDDEN", "Token belongs to a different workspace.", 403);
+    }
+    return member;
+  }
+  requireAdmin(token, workspaceId) {
+    const member = this.requireMember(token, workspaceId);
+    if (member.role !== "admin") {
+      throw relayError("FORBIDDEN", "Workspace admin permission required.", 403);
+    }
+    return member;
+  }
+  requireApprovalSecret(member, approvalSecret) {
+    if (!approvalSecret) {
+      throw relayError(
+        "FORBIDDEN",
+        "A local approval secret is required to mint approval tokens.",
+        403
+      );
+    }
+    const row = this.db.prepare("SELECT approval_secret_hash FROM members WHERE id = ?").get(member.id);
+    if (!row?.approval_secret_hash || row.approval_secret_hash !== hashToken(approvalSecret)) {
+      throw relayError("FORBIDDEN", "Invalid local approval secret.", 403);
+    }
+  }
+  getWorkspace(workspaceId) {
+    const row = this.db.prepare("SELECT * FROM workspaces WHERE id = ?").get(workspaceId);
+    if (!row) {
+      throw relayError("NOT_FOUND", "Workspace not found.", 404);
+    }
+    return rowToWorkspace(row);
+  }
+  getMember(memberId) {
+    const row = this.db.prepare("SELECT * FROM members WHERE id = ?").get(memberId);
+    if (!row) {
+      throw relayError("NOT_FOUND", "Member not found.", 404);
+    }
+    return rowToMember(row);
+  }
+  findMemberByHandle(workspaceId, handle, includeRevoked = false) {
+    const row = this.db.prepare("SELECT * FROM members WHERE workspace_id = ? AND handle = ?").get(workspaceId, normalizeHandle(handle));
+    if (!row) return void 0;
+    const member = rowToMember(row);
+    if (!includeRevoked && member.status === "revoked") {
+      return void 0;
+    }
+    return member;
+  }
+  resolveRecipient(workspaceId, handle) {
+    const normalized = normalizeHandle(handle);
+    const member = this.findMemberByHandle(workspaceId, normalized, true);
+    if (!member) {
+      throw relayError("INVALID_RECIPIENT", `Invalid recipient @${normalized}.`, 404);
+    }
+    if (member.status === "revoked") {
+      throw relayError("INVALID_RECIPIENT", `Recipient @${normalized} is revoked.`, 403);
+    }
+    return member;
+  }
+  actorRole(actor, packet) {
+    if (packet.sender_member_id === actor.id) return "sender";
+    if (packet.recipient_member_ids.includes(actor.id)) return "recipient";
+    if (actor.role === "admin" && actor.workspace_id === packet.workspace_id) return "admin";
+    return "system";
+  }
+  canReadMetadata(actor, packet) {
+    return actor.workspace_id === packet.workspace_id && actor.status === "active" && (packet.sender_member_id === actor.id || packet.recipient_member_ids.includes(actor.id) || actor.role === "admin");
+  }
+  canReadBody(actor, packet) {
+    if (actor.workspace_id !== packet.workspace_id || actor.status !== "active") {
+      return false;
+    }
+    if (packet.sender_member_id === actor.id || packet.recipient_member_ids.includes(actor.id)) {
+      return true;
+    }
+    if (actor.role === "admin") {
+      return this.getWorkspace(packet.workspace_id).admin_body_access;
+    }
+    return false;
+  }
+  requireReadable(actor, packet) {
+    if (!this.canReadBody(actor, packet)) {
+      if (this.canReadMetadata(actor, packet)) {
+        throw relayError(
+          "FORBIDDEN",
+          "Workspace admin metadata access does not include packet body access by default.",
+          403
+        );
+      }
+      throw relayError("FORBIDDEN", "Packet is not addressed to this member.", 403);
+    }
+  }
+  searchHaystackFor(actor, packet) {
+    const metadataFields = [
+      packet.packet_id,
+      packet.packet_type,
+      packet.workspace_id,
+      packet.sender_member_id,
+      ...packet.recipient_member_ids,
+      packet.status,
+      packet.title,
+      packet.summary,
+      packet.project.repo_name,
+      packet.project.branch,
+      packet.project.commit_hash,
+      packet.project.git_remote_fingerprint,
+      packet.source_client,
+      packet.created_at,
+      packet.updated_at,
+      packet.expires_at,
+      packet.recheck_by
+    ];
+    const bodyFields = this.canReadBody(actor, packet) ? [
+      packet.question,
+      packet.finding,
+      packet.answer,
+      packet.current_hypothesis,
+      ...packet.files_or_symbols,
+      ...packet.commands_or_tests_run,
+      ...packet.what_was_tried,
+      ...packet.known_failures,
+      ...packet.suggested_next_steps,
+      ...packet.claims.map((claim) => claim.text),
+      ...packet.evidence.map((item) => `${item.label} ${item.source} ${item.excerpt}`)
+    ] : [];
+    return [...metadataFields, ...bodyFields].filter(Boolean).join(" ").toLowerCase();
+  }
+  toSearchResult(actor, packet) {
+    return {
+      packet_id: packet.packet_id,
+      packet_type: packet.packet_type,
+      workspace_id: packet.workspace_id,
+      sender_member_id: packet.sender_member_id,
+      recipient_member_ids: packet.recipient_member_ids,
+      status: packet.status,
+      title: packet.title,
+      summary: packet.summary,
+      project: packet.project,
+      source_client: packet.source_client,
+      created_at: packet.created_at,
+      updated_at: packet.updated_at,
+      expires_at: packet.expires_at,
+      recheck_by: packet.recheck_by,
+      body_access: this.canReadBody(actor, packet)
+    };
+  }
+  auditFilterMetadata(input) {
+    return Object.fromEntries(
+      Object.entries({
+        project: input.project,
+        sender: input.sender,
+        recipient: input.recipient,
+        status: input.status,
+        file_or_symbol: input.fileOrSymbol,
+        ticket_or_pr: input.ticketOrPr
+      }).filter((entry) => typeof entry[1] === "string" && !!entry[1])
+    );
+  }
+  matchesPacketQueryFilters(actor, packet, filters) {
+    if (filters.project && this.resolveCanonicalProjectName(packet.workspace_id, packet.project.repo_name) !== this.resolveCanonicalProjectName(packet.workspace_id, filters.project)) {
+      return false;
+    }
+    if (filters.sender && !this.memberSelectorMatches(packet.workspace_id, packet.sender_member_id, filters.sender)) {
+      return false;
+    }
+    if (filters.recipient && !packet.recipient_member_ids.some(
+      (memberId) => this.memberSelectorMatches(packet.workspace_id, memberId, filters.recipient)
+    )) {
+      return false;
+    }
+    if (filters.status && packet.status !== filters.status) {
+      return false;
+    }
+    if (filters.fileOrSymbol) {
+      if (!this.canReadBody(actor, packet)) return false;
+      const needle = filters.fileOrSymbol.trim().toLowerCase();
+      if (needle && !packet.files_or_symbols.some((entry) => entry.toLowerCase().includes(needle))) {
+        return false;
+      }
+    }
+    if (filters.ticketOrPr) {
+      if (!this.canReadBody(actor, packet)) return false;
+      const needle = filters.ticketOrPr.trim().toLowerCase();
+      if (needle && !packet.evidence.filter((item) => item.kind === "ticket_link" || item.kind === "pr_link").some(
+        (item) => [item.label, item.source, item.excerpt].join(" ").toLowerCase().includes(needle)
+      )) {
+        return false;
+      }
+    }
+    return true;
+  }
+  resolveCanonicalProjectName(workspaceId, projectName) {
+    const name = normalizeProjectName(projectName);
+    const row = this.db.prepare(
+      `SELECT canonical_project FROM project_aliases
+        WHERE workspace_id = ? AND alias = ?`
+    ).get(workspaceId, name);
+    return row?.canonical_project ?? name;
+  }
+  memberSelectorMatches(workspaceId, memberId, selector) {
+    const trimmed = selector.trim();
+    if (!trimmed) return true;
+    if (memberId === trimmed) return true;
+    try {
+      return this.findMemberByHandle(workspaceId, trimmed, true)?.id === memberId;
+    } catch {
+      return false;
+    }
+  }
+  matchesHistoryFilter(actor, packet, filter) {
+    if (filter === "all") return true;
+    const terminalStatuses = [
+      "archived",
+      "closed_resolved",
+      "closed_unresolved",
+      "declined",
+      "expired",
+      "superseded"
+    ];
+    if (filter === "closed") {
+      return terminalStatuses.includes(packet.status);
+    }
+    if (filter === "drafts") {
+      return packet.sender_member_id === actor.id && ["pending_sender_approval", "pending_recipient_approval", "draft"].includes(packet.status);
+    }
+    if (filter === "sent") {
+      return packet.sender_member_id === actor.id && packet.status !== "pending_sender_approval";
+    }
+    return !terminalStatuses.includes(packet.status) && !["draft", "pending_sender_approval", "pending_recipient_approval"].includes(packet.status);
+  }
+  requireSender(actor, packet) {
+    if (packet.sender_member_id !== actor.id) {
+      throw relayError("FORBIDDEN", "Only the packet sender can perform this action.", 403);
+    }
+  }
+  requireRecipient(actor, packet) {
+    if (!packet.recipient_member_ids.includes(actor.id)) {
+      throw relayError("FORBIDDEN", "Packet is not addressed to this member.", 403);
+    }
+  }
+  assertApprovalTokenAllowed(actor, packet, action) {
+    if (action === "send") {
+      this.requireSender(actor, packet);
+      if (packet.packet_type === "reply") {
+        throw relayError("INVALID_INPUT", "Use reply approval for reply packets.", 400);
+      }
+      if (packet.status !== "pending_sender_approval") {
+        throw relayError(
+          "INVALID_STATE_TRANSITION",
+          "Only pending drafts can be approved for send.",
+          409
+        );
+      }
+      return;
+    }
+    if (action === "reply") {
+      this.requireSender(actor, packet);
+      if (packet.packet_type !== "reply" || packet.status !== "pending_recipient_approval") {
+        throw relayError(
+          "INVALID_STATE_TRANSITION",
+          "Only pending reply drafts can be approved.",
+          409
+        );
+      }
+      return;
+    }
+    this.requireRecipient(actor, packet);
+    if (packet.packet_type === "reply") {
+      if (packet.status !== "viewed") {
+        throw relayError(
+          "INVALID_STATE_TRANSITION",
+          "Replies must be viewed before hydration approval.",
+          409
+        );
+      }
+      return;
+    }
+    if (packet.status !== "accepted") {
+      throw relayError(
+        "INVALID_STATE_TRANSITION",
+        "Packets must be accepted before hydration approval.",
+        409
+      );
+    }
+  }
+  consumeApprovalToken(input) {
+    if (!input.approvalToken) {
+      throw relayError(
+        "FORBIDDEN",
+        `A human approval token is required to ${input.action} this packet.`,
+        403
+      );
+    }
+    const row = this.db.prepare(
+      `SELECT * FROM approval_tokens
+        WHERE packet_id = ? AND actor_member_id = ? AND action = ? AND token_hash = ?`
+    ).get(input.packet.packet_id, input.actor.id, input.action, hashToken(input.approvalToken));
+    if (!row || row.consumed_at || Date.parse(row.expires_at) < Date.now()) {
+      throw relayError("FORBIDDEN", "Invalid, expired, or consumed approval token.", 403);
+    }
+    this.assertApprovalTokenAllowed(input.actor, input.packet, input.action);
+    this.db.prepare("UPDATE approval_tokens SET consumed_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), row.id);
+  }
+  transitionPacket(packet, status, actor, role) {
+    assertTransition({
+      from: packet.status,
+      to: status,
+      actorRole: role,
+      packetType: packet.packet_type
+    });
+    return this.updatePacket({
+      ...packet,
+      status,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  insertPacket(packet) {
+    this.db.prepare(
+      `INSERT INTO packets
+        (id, workspace_id, packet_type, sender_member_id, recipient_member_ids, parent_packet_id,
+         status, title, summary, question, finding, answer, project, source_client, claims, evidence,
+         files_or_symbols, commands_or_tests_run, what_was_tried, known_failures, current_hypothesis,
+         confidence, suggested_next_steps, redaction_report, hydration_policy, audit_receipt,
+         expires_at, recheck_by, created_at, updated_at)
+        VALUES
+        (@id, @workspace_id, @packet_type, @sender_member_id, @recipient_member_ids, @parent_packet_id,
+         @status, @title, @summary, @question, @finding, @answer, @project, @source_client, @claims,
+         @evidence, @files_or_symbols, @commands_or_tests_run, @what_was_tried, @known_failures,
+         @current_hypothesis, @confidence, @suggested_next_steps, @redaction_report, @hydration_policy,
+         @audit_receipt, @expires_at, @recheck_by, @created_at, @updated_at)`
+    ).run(packetParams(packet));
+    return packet;
+  }
+  updatePacket(packet) {
+    this.db.prepare(
+      `UPDATE packets SET
+          recipient_member_ids = @recipient_member_ids,
+          parent_packet_id = @parent_packet_id,
+          status = @status,
+          title = @title,
+          summary = @summary,
+          question = @question,
+          finding = @finding,
+          answer = @answer,
+          project = @project,
+          source_client = @source_client,
+          claims = @claims,
+          evidence = @evidence,
+          files_or_symbols = @files_or_symbols,
+          commands_or_tests_run = @commands_or_tests_run,
+          what_was_tried = @what_was_tried,
+          known_failures = @known_failures,
+          current_hypothesis = @current_hypothesis,
+          confidence = @confidence,
+          suggested_next_steps = @suggested_next_steps,
+          redaction_report = @redaction_report,
+          hydration_policy = @hydration_policy,
+          audit_receipt = @audit_receipt,
+          expires_at = @expires_at,
+          recheck_by = @recheck_by,
+          updated_at = @updated_at
+        WHERE id = @id`
+    ).run(packetParams(packet));
+    return packet;
+  }
+  listWorkspacePackets(workspaceId) {
+    return this.db.prepare("SELECT * FROM packets WHERE workspace_id = ? ORDER BY created_at DESC").all(workspaceId).map(rowToPacket);
+  }
+  createNotification(packet, memberId) {
+    this.db.prepare(
+      `INSERT INTO notifications (id, packet_id, workspace_id, member_id, status, created_at)
+        VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      createId("ntf"),
+      packet.packet_id,
+      packet.workspace_id,
+      memberId,
+      "unread",
+      (/* @__PURE__ */ new Date()).toISOString()
+    );
+  }
+  recordAudit(input) {
+    const receipt = createAuditReceipt(input);
+    this.insertAuditReceipt(receipt);
+    if (input.packetId) {
+      const packet = this.getPacket(input.packetId);
+      this.updatePacket({ ...packet, audit_receipt: receipt });
+    }
+    return receipt;
+  }
+  insertAuditReceipt(receipt) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO audit_receipts
+        (receipt_id, workspace_id, packet_id, actor_member_id, action, created_at, metadata, receipt_hash)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      receipt.receipt_id,
+      receipt.workspace_id,
+      receipt.packet_id ?? null,
+      receipt.actor_member_id,
+      receipt.action,
+      receipt.created_at,
+      JSON.stringify(receipt.metadata),
+      receipt.receipt_hash
+    );
+  }
+};
+
+// src/storage/database.ts
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import Database from "better-sqlite3";
+var schema = `
+CREATE TABLE IF NOT EXISTS workspaces (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  admin_body_access INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS members (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL,
+  handle TEXT NOT NULL,
+  display_name TEXT NOT NULL,
+  role TEXT NOT NULL,
+  status TEXT NOT NULL,
+  token_hash TEXT NOT NULL,
+  approval_secret_hash TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  revoked_at TEXT,
+  UNIQUE(workspace_id, handle),
+  FOREIGN KEY(workspace_id) REFERENCES workspaces(id)
+);
+
+CREATE TABLE IF NOT EXISTS project_aliases (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL,
+  canonical_project TEXT NOT NULL,
+  alias TEXT NOT NULL,
+  created_by_member_id TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  UNIQUE(workspace_id, alias),
+  FOREIGN KEY(workspace_id) REFERENCES workspaces(id),
+  FOREIGN KEY(created_by_member_id) REFERENCES members(id)
+);
+
+CREATE INDEX IF NOT EXISTS project_alias_workspace_idx ON project_aliases(workspace_id);
+
+CREATE TABLE IF NOT EXISTS invites (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL,
+  handle TEXT NOT NULL,
+  token TEXT NOT NULL UNIQUE,
+  created_by_member_id TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  accepted_at TEXT,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY(workspace_id) REFERENCES workspaces(id)
+);
+
+CREATE TABLE IF NOT EXISTS packets (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL,
+  packet_type TEXT NOT NULL,
+  sender_member_id TEXT NOT NULL,
+  recipient_member_ids TEXT NOT NULL,
+  parent_packet_id TEXT,
+  status TEXT NOT NULL,
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  question TEXT,
+  finding TEXT,
+  answer TEXT,
+  project TEXT NOT NULL,
+  source_client TEXT NOT NULL,
+  claims TEXT NOT NULL,
+  evidence TEXT NOT NULL,
+  files_or_symbols TEXT NOT NULL,
+  commands_or_tests_run TEXT NOT NULL,
+  what_was_tried TEXT NOT NULL,
+  known_failures TEXT NOT NULL,
+  current_hypothesis TEXT NOT NULL,
+  confidence TEXT NOT NULL,
+  suggested_next_steps TEXT NOT NULL,
+  redaction_report TEXT NOT NULL,
+  hydration_policy TEXT NOT NULL,
+  audit_receipt TEXT NOT NULL,
+  expires_at TEXT,
+  recheck_by TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY(workspace_id) REFERENCES workspaces(id)
+);
+
+CREATE INDEX IF NOT EXISTS packets_workspace_idx ON packets(workspace_id);
+CREATE INDEX IF NOT EXISTS packets_sender_idx ON packets(sender_member_id);
+CREATE INDEX IF NOT EXISTS packets_status_idx ON packets(status);
+
+CREATE TABLE IF NOT EXISTS audit_receipts (
+  receipt_id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL,
+  packet_id TEXT,
+  actor_member_id TEXT NOT NULL,
+  action TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  metadata TEXT NOT NULL,
+  receipt_hash TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS audit_packet_idx ON audit_receipts(packet_id);
+
+CREATE TABLE IF NOT EXISTS hydration_receipts (
+  receipt_id TEXT PRIMARY KEY,
+  packet_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  actor_member_id TEXT NOT NULL,
+  client TEXT NOT NULL,
+  session_id TEXT,
+  context TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS notifications (
+  id TEXT PRIMARY KEY,
+  packet_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  member_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  read_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS approval_tokens (
+  id TEXT PRIMARY KEY,
+  packet_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  actor_member_id TEXT NOT NULL,
+  action TEXT NOT NULL,
+  token_hash TEXT NOT NULL UNIQUE,
+  expires_at TEXT NOT NULL,
+  consumed_at TEXT,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS approval_packet_idx ON approval_tokens(packet_id, actor_member_id, action);
+`;
+function createRelayDatabase(path = ":memory:") {
+  if (path !== ":memory:") {
+    mkdirSync(dirname(path), { recursive: true });
+  }
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(schema);
+  ensureColumn(db, "members", "approval_secret_hash", "TEXT NOT NULL DEFAULT ''");
+  return db;
+}
+function ensureColumn(db, table, column, definition) {
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (!columns.some((entry) => entry.name === column)) {
+    db.prepare(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`).run();
+  }
+}
+
+// src/api/server.ts
+var sourceClients = ["claude-code", "codex", "cursor", "generic", "other"];
+function bearer(request) {
+  const value = request.headers.authorization;
+  if (typeof value !== "string" || !value.startsWith("Bearer ")) {
+    return "";
+  }
+  return value.slice("Bearer ".length);
+}
+function buildApiServer(options) {
+  const app = Fastify({ logger: false });
+  const service = options.service;
+  const packetQuerySchema = {
+    project: z2.string().optional(),
+    sender: z2.string().optional(),
+    recipient: z2.string().optional(),
+    status: z2.enum(packetStatuses).optional(),
+    fileOrSymbol: z2.string().optional(),
+    ticketOrPr: z2.string().optional()
+  };
+  app.get("/health", async () => ({
+    name: "handoff",
+    ok: true,
+    pid: process.pid,
+    server_id: process.env.HANDOFF_SERVER_ID,
+    version: "0.1.0"
+  }));
+  app.setErrorHandler((error, _request, reply) => {
+    if (isRelayError(error)) {
+      reply.status(error.statusCode).send({
+        error: {
+          code: error.code,
+          message: error.message,
+          details: error.details
+        }
+      });
+      return;
+    }
+    if (error instanceof z2.ZodError) {
+      const unsupportedClient = error.issues.some(
+        (issue) => issue.path.some((segment) => segment === "sourceClient")
+      );
+      reply.status(400).send({
+        error: unsupportedClient ? {
+          code: "UNSUPPORTED_CLIENT",
+          message: `Unsupported source client. Supported clients: ${sourceClients.join(", ")}.`,
+          details: { issues: error.issues }
+        } : {
+          code: "INVALID_INPUT",
+          message: "Invalid Relay API request.",
+          details: { issues: error.issues }
+        }
+      });
+      return;
+    }
+    reply.status(500).send({
+      error: {
+        code: "INTERNAL_ERROR",
+        message: error instanceof Error ? error.message : "Unknown internal error."
+      }
+    });
+  });
+  app.post("/workspaces", async (request) => {
+    const body = z2.object({
+      name: z2.string(),
+      adminHandle: z2.string(),
+      adminName: z2.string(),
+      adminBodyAccess: z2.boolean().optional()
+    }).parse(request.body);
+    return service.createWorkspace(body);
+  });
+  app.post("/workspaces/:workspaceId/invites", async (request) => {
+    const params = z2.object({ workspaceId: z2.string() }).parse(request.params);
+    const body = z2.object({ handle: z2.string() }).parse(request.body);
+    return service.inviteMember({
+      adminToken: bearer(request),
+      workspaceId: params.workspaceId,
+      handle: body.handle
+    });
+  });
+  app.post("/invites/:inviteToken/accept", async (request) => {
+    const params = z2.object({ inviteToken: z2.string() }).parse(request.params);
+    const body = z2.object({ displayName: z2.string() }).parse(request.body);
+    return service.acceptInvite({ inviteToken: params.inviteToken, displayName: body.displayName });
+  });
+  app.get("/invite/:inviteToken", async (request, reply) => {
+    const params = z2.object({ inviteToken: z2.string() }).parse(request.params);
+    const invite = service.getInvite({ inviteToken: params.inviteToken });
+    const host = request.headers.host ?? "127.0.0.1:3737";
+    const protocol = typeof request.headers["x-forwarded-proto"] === "string" ? request.headers["x-forwarded-proto"] : "http";
+    const link = `${protocol}://${host}/invite/${encodeURIComponent(params.inviteToken)}`;
+    const joinCommand = `npx -y handoff-relay join ${link}`;
+    let status = `Invite for @${invite.invite.handle} to join ${invite.workspace.name}.`;
+    if (invite.invite.accepted_at) {
+      status = `Invite for @${invite.invite.handle} has already been accepted.`;
+    } else if (Date.parse(invite.invite.expires_at) < Date.now()) {
+      status = `Invite for @${invite.invite.handle} has expired.`;
+    }
+    reply.type("text/plain").send(
+      [
+        "Handoff invite",
+        "",
+        status,
+        `Expires: ${invite.invite.expires_at}`,
+        "",
+        "Join with:",
+        joinCommand,
+        "",
+        "Opening this page does not accept the invite."
+      ].join("\n")
+    );
+  });
+  app.get("/members", async (request) => {
+    const query = z2.object({ workspaceId: z2.string() }).parse(request.query);
+    return service.listMembers({ authToken: bearer(request), workspaceId: query.workspaceId });
+  });
+  app.post("/workspaces/:workspaceId/project-aliases", async (request) => {
+    const params = z2.object({ workspaceId: z2.string() }).parse(request.params);
+    const body = z2.object({ canonicalProject: z2.string(), alias: z2.string() }).parse(request.body);
+    return service.configureProjectAlias({
+      authToken: bearer(request),
+      workspaceId: params.workspaceId,
+      canonicalProject: body.canonicalProject,
+      alias: body.alias
+    });
+  });
+  app.get("/workspaces/:workspaceId/project-aliases", async (request) => {
+    const params = z2.object({ workspaceId: z2.string() }).parse(request.params);
+    return service.listProjectAliases({
+      authToken: bearer(request),
+      workspaceId: params.workspaceId
+    });
+  });
+  app.post("/members/:memberId/revoke", async (request) => {
+    const params = z2.object({ memberId: z2.string() }).parse(request.params);
+    const body = z2.object({ workspaceId: z2.string() }).parse(request.body);
+    return service.revokeMember({
+      adminToken: bearer(request),
+      workspaceId: body.workspaceId,
+      memberId: params.memberId
+    });
+  });
+  app.post("/members/rotate-token", async (request) => {
+    return service.rotateMemberToken({ authToken: bearer(request) });
+  });
+  app.post("/members/rotate-approval-secret", async (request) => {
+    const body = z2.object({ approvalSecret: z2.string().optional() }).parse(request.body ?? {});
+    return service.rotateApprovalSecret({
+      authToken: bearer(request),
+      approvalSecret: body.approvalSecret
+    });
+  });
+  app.post("/packets/ask", async (request) => {
+    const body = z2.object({
+      workspaceId: z2.string(),
+      to: z2.string(),
+      question: z2.string(),
+      title: z2.string(),
+      summary: z2.string(),
+      sourceClient: z2.enum(sourceClients).default("generic"),
+      project: z2.record(z2.string(), z2.unknown()).optional(),
+      claims: z2.array(z2.record(z2.string(), z2.unknown())).optional(),
+      evidence: z2.array(z2.record(z2.string(), z2.unknown())).optional(),
+      filesOrSymbols: z2.array(z2.string()).optional(),
+      commandsOrTestsRun: z2.array(z2.string()).optional(),
+      whatWasTried: z2.array(z2.string()).optional(),
+      knownFailures: z2.array(z2.string()).optional(),
+      currentHypothesis: z2.string().optional(),
+      confidence: z2.enum(["low", "medium", "high"]).optional(),
+      suggestedNextSteps: z2.array(z2.string()).optional()
+    }).parse(request.body);
+    return service.createAskDraft({
+      authToken: bearer(request),
+      workspaceId: body.workspaceId,
+      to: body.to,
+      question: body.question,
+      title: body.title,
+      summary: body.summary,
+      sourceClient: body.sourceClient,
+      project: body.project,
+      claims: body.claims,
+      evidence: body.evidence,
+      filesOrSymbols: body.filesOrSymbols,
+      commandsOrTestsRun: body.commandsOrTestsRun,
+      whatWasTried: body.whatWasTried,
+      knownFailures: body.knownFailures,
+      currentHypothesis: body.currentHypothesis,
+      confidence: body.confidence,
+      suggestedNextSteps: body.suggestedNextSteps
+    });
+  });
+  app.post("/packets/share", async (request) => {
+    const body = z2.object({
+      workspaceId: z2.string(),
+      to: z2.string(),
+      finding: z2.string(),
+      title: z2.string(),
+      summary: z2.string(),
+      sourceClient: z2.enum(sourceClients).default("generic"),
+      project: z2.record(z2.string(), z2.unknown()).optional(),
+      claims: z2.array(z2.record(z2.string(), z2.unknown())).optional(),
+      evidence: z2.array(z2.record(z2.string(), z2.unknown())).optional(),
+      filesOrSymbols: z2.array(z2.string()).optional(),
+      commandsOrTestsRun: z2.array(z2.string()).optional(),
+      whatWasTried: z2.array(z2.string()).optional(),
+      knownFailures: z2.array(z2.string()).optional(),
+      currentHypothesis: z2.string().optional(),
+      confidence: z2.enum(["low", "medium", "high"]).optional(),
+      suggestedNextSteps: z2.array(z2.string()).optional()
+    }).parse(request.body);
+    return service.createShareDraft({
+      authToken: bearer(request),
+      workspaceId: body.workspaceId,
+      to: body.to,
+      finding: body.finding,
+      title: body.title,
+      summary: body.summary,
+      sourceClient: body.sourceClient,
+      project: body.project,
+      claims: body.claims,
+      evidence: body.evidence,
+      filesOrSymbols: body.filesOrSymbols,
+      commandsOrTestsRun: body.commandsOrTestsRun,
+      whatWasTried: body.whatWasTried,
+      knownFailures: body.knownFailures,
+      currentHypothesis: body.currentHypothesis,
+      confidence: body.confidence,
+      suggestedNextSteps: body.suggestedNextSteps
+    });
+  });
+  app.patch("/packets/:packetId/draft", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    const body = z2.object({
+      title: z2.string().optional(),
+      summary: z2.string().optional(),
+      question: z2.string().optional(),
+      finding: z2.string().optional(),
+      claims: z2.array(z2.record(z2.string(), z2.unknown())).optional(),
+      evidence: z2.array(z2.record(z2.string(), z2.unknown())).optional(),
+      filesOrSymbols: z2.array(z2.string()).optional(),
+      commandsOrTestsRun: z2.array(z2.string()).optional(),
+      whatWasTried: z2.array(z2.string()).optional(),
+      knownFailures: z2.array(z2.string()).optional(),
+      currentHypothesis: z2.string().optional(),
+      confidence: z2.enum(["low", "medium", "high"]).optional(),
+      suggestedNextSteps: z2.array(z2.string()).optional()
+    }).parse(request.body);
+    return service.updateDraft({
+      authToken: bearer(request),
+      packetId: params.packetId,
+      title: body.title,
+      summary: body.summary,
+      question: body.question,
+      finding: body.finding,
+      claims: body.claims,
+      evidence: body.evidence,
+      filesOrSymbols: body.filesOrSymbols,
+      commandsOrTestsRun: body.commandsOrTestsRun,
+      whatWasTried: body.whatWasTried,
+      knownFailures: body.knownFailures,
+      currentHypothesis: body.currentHypothesis,
+      confidence: body.confidence,
+      suggestedNextSteps: body.suggestedNextSteps
+    });
+  });
+  app.post("/packets/:packetId/approval-token", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    const body = z2.object({
+      action: z2.enum(["send", "reply", "hydrate"]),
+      approvalSecret: z2.string().optional()
+    }).parse(request.body);
+    return service.createApprovalToken({
+      authToken: bearer(request),
+      approvalSecret: body.approvalSecret,
+      packetId: params.packetId,
+      action: body.action
+    });
+  });
+  app.post("/packets/:packetId/approve", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    const body = z2.object({ allowSecretOverride: z2.boolean().optional(), approvalToken: z2.string().optional() }).parse(request.body ?? {});
+    return service.approveAndSend({
+      authToken: bearer(request),
+      packetId: params.packetId,
+      allowSecretOverride: body.allowSecretOverride,
+      approvalToken: body.approvalToken
+    });
+  });
+  app.get("/inbox", async (request) => {
+    const query = z2.object({ workspaceId: z2.string() }).parse(request.query);
+    return service.listInbox({ authToken: bearer(request), workspaceId: query.workspaceId });
+  });
+  app.get("/packets/:packetId/view", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    return service.viewPacket({ authToken: bearer(request), packetId: params.packetId });
+  });
+  app.get("/packets/:packetId/status", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    return service.getPacketForMember({ authToken: bearer(request), packetId: params.packetId });
+  });
+  app.post("/packets/:packetId/accept", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    return service.acceptPacket({ authToken: bearer(request), packetId: params.packetId });
+  });
+  app.post("/packets/:packetId/hydrate", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    const body = z2.object({
+      client: z2.string().default("generic"),
+      sessionId: z2.string().optional(),
+      approvalToken: z2.string().optional()
+    }).parse(request.body ?? {});
+    return service.hydratePacket({
+      authToken: bearer(request),
+      packetId: params.packetId,
+      client: body.client,
+      sessionId: body.sessionId,
+      approvalToken: body.approvalToken
+    });
+  });
+  app.post("/packets/:packetId/reply", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    const body = z2.object({
+      answer: z2.string(),
+      summary: z2.string(),
+      sourceClient: z2.enum(sourceClients).default("generic"),
+      evidence: z2.array(z2.record(z2.string(), z2.unknown())).optional(),
+      confidence: z2.enum(["low", "medium", "high"]).optional()
+    }).parse(request.body);
+    return service.createReplyDraft({
+      authToken: bearer(request),
+      packetId: params.packetId,
+      answer: body.answer,
+      summary: body.summary,
+      sourceClient: body.sourceClient,
+      evidence: body.evidence,
+      confidence: body.confidence
+    });
+  });
+  app.post("/packets/:packetId/clarify", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    const body = z2.object({
+      question: z2.string(),
+      requestedEvidence: z2.array(z2.string()).optional()
+    }).parse(request.body);
+    return service.requestClarification({
+      authToken: bearer(request),
+      packetId: params.packetId,
+      question: body.question,
+      requestedEvidence: body.requestedEvidence
+    });
+  });
+  app.post("/packets/:packetId/decline", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    const body = z2.object({ reason: z2.string().optional() }).parse(request.body ?? {});
+    return service.declinePacket({
+      authToken: bearer(request),
+      packetId: params.packetId,
+      reason: body.reason
+    });
+  });
+  app.post("/packets/:packetId/archive", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    return service.archivePacket({ authToken: bearer(request), packetId: params.packetId });
+  });
+  app.post("/packets/:packetId/close", async (request) => {
+    const params = z2.object({ packetId: z2.string() }).parse(request.params);
+    const body = z2.object({ resolution: z2.enum(["resolved", "unresolved"]) }).parse(request.body);
+    return service.closePacket({
+      authToken: bearer(request),
+      packetId: params.packetId,
+      resolution: body.resolution
+    });
+  });
+  app.get("/search", async (request) => {
+    const query = z2.object({ workspaceId: z2.string(), q: z2.string().optional(), ...packetQuerySchema }).parse(request.query);
+    return service.searchPackets({
+      authToken: bearer(request),
+      workspaceId: query.workspaceId,
+      query: query.q,
+      project: query.project,
+      sender: query.sender,
+      recipient: query.recipient,
+      status: query.status,
+      fileOrSymbol: query.fileOrSymbol,
+      ticketOrPr: query.ticketOrPr
+    });
+  });
+  app.get("/history", async (request) => {
+    const query = z2.object({
+      workspaceId: z2.string(),
+      filter: z2.enum(["all", "drafts", "sent", "open", "closed"]).optional(),
+      q: z2.string().optional(),
+      ...packetQuerySchema
+    }).parse(request.query);
+    return service.listHistory({
+      authToken: bearer(request),
+      workspaceId: query.workspaceId,
+      filter: query.filter,
+      query: query.q,
+      project: query.project,
+      sender: query.sender,
+      recipient: query.recipient,
+      status: query.status,
+      fileOrSymbol: query.fileOrSymbol,
+      ticketOrPr: query.ticketOrPr
+    });
+  });
+  app.get("/audit", async (request) => {
+    const query = z2.object({ workspaceId: z2.string(), packetId: z2.string().optional() }).parse(request.query);
+    return service.listAuditReceipts({
+      authToken: bearer(request),
+      workspaceId: query.workspaceId,
+      packetId: query.packetId
+    });
+  });
+  return app;
+}
+async function startApiServer(input) {
+  const service = new RelayService(createRelayDatabase(input.dbPath));
+  const app = buildApiServer({ service });
+  await app.listen({ host: input.host ?? "127.0.0.1", port: input.port ?? 3737 });
+  return app;
+}
+export {
+  buildApiServer,
+  startApiServer
+};