letagents 0.12.12 → 0.12.14

package/dist/shared/desktop-release.js

@@ -0,0 +1,60 @@
+const MAC_DESKTOP_BETA_VERSION = "0.1.5";
+const MAC_DESKTOP_PUBLIC_BASE_URL = "https://downloads.letagents.chat/desktop";
+function macDesktopAsset(architecture, sha256) {
+    const fileName = `LetAgents-${MAC_DESKTOP_BETA_VERSION}-darwin-${architecture}.dmg`;
+    return {
+        fileName,
+        publicUrl: `${MAC_DESKTOP_PUBLIC_BASE_URL}/v${MAC_DESKTOP_BETA_VERSION}/${fileName}`,
+        sha256,
+    };
+}
+export const MAC_DESKTOP_BETA_RELEASE = {
+    version: MAC_DESKTOP_BETA_VERSION,
+    tag: `desktop-v${MAC_DESKTOP_BETA_VERSION}`,
+    assets: {
+        arm64: macDesktopAsset("arm64", "704355796cee5214a9cfbb79105a035e0e00dc3a3aa57be7d389b97cf35fc804"),
+        x64: macDesktopAsset("x64", "1e4b0b8b2c42ad8eaaf652fc887ab089445c8dd83233d763a6acdaa6617c2471"),
+    },
+};
+export const MAC_DESKTOP_BETA_CHECKSUM_RELEASES = [
+    MAC_DESKTOP_BETA_RELEASE,
+    {
+        version: "0.1.4",
+        assets: {
+            arm64: {
+                fileName: "LetAgents-0.1.4-darwin-arm64.dmg",
+                sha256: "27abe236232d33db10ed4533f4a7443a66f93568e9fa73a2ca472b6467fcf1cb",
+            },
+            x64: {
+                fileName: "LetAgents-0.1.4-darwin-x64.dmg",
+                sha256: "4c807ad0c799b4e46ab81d1098e5b65934d6b0b49f0a99ced2713897e1c2bc35",
+            },
+        },
+    },
+    {
+        version: "0.1.3",
+        assets: {
+            arm64: {
+                fileName: "LetAgents-0.1.3-darwin-arm64.dmg",
+                sha256: "6010454bc7375a38571d707f90c077207a7d2b49b01a1db1655b03f4def9b502",
+            },
+            x64: {
+                fileName: "LetAgents-0.1.3-darwin-x64.dmg",
+                sha256: "b7574e17ef87aebf418926478de10d9937fd1a96ca0c7a53b826a109302c5560",
+            },
+        },
+    },
+    {
+        version: "0.1.2",
+        assets: {
+            arm64: {
+                fileName: "LetAgents-0.1.2-darwin-arm64.dmg",
+                sha256: "e5355deced8383bc7d024ec60b109a38dde69dfeb6b6339352e1f5bc5c53bd43",
+            },
+            x64: {
+                fileName: "LetAgents-0.1.2-darwin-x64.dmg",
+                sha256: "67d2896b806695dae8c0224b3bc2780aee6902e897569c983ecc1bdb0330b6b0",
+            },
+        },
+    },
+];

package/dist/shared/scoped-ids.js

@@ -0,0 +1,6 @@
+import { POSTGRES_INTEGER_MAX, parsePositivePgIntegerScopedId as parseSharedPositivePgIntegerScopedId, } from "../../shared/message-contracts.mjs";
+export { POSTGRES_INTEGER_MAX };
+/** Parse the canonical `<prefix>_<positive PostgreSQL integer>` wire form. */
+export function parsePositivePgIntegerScopedId(value, prefix) {
+    return parseSharedPositivePgIntegerScopedId(value, prefix);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.12",
+  "version": "0.12.14",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",
@@ -11,6 +11,7 @@
     "dist/mcp/**",
     "dist/api/board-intent-payloads.js",
     "dist/shared/**",
+    "shared/**",
     "README.md"
   ],
   "scripts": {
@@ -24,6 +25,9 @@
     "test:orchestrator": "node --import tsx --test src/orchestrator/__tests__/*.test.ts",
     "test:web": "node --import tsx --test src/web/tests/*.test.ts src/web/src/composables/*.test.ts",
     "test:dependency-age": "node --test scripts/verify-dependency-age.test.mjs",
+    "test:docker-context": "node --test scripts/verify-docker-context.test.mjs",
+    "test:workflow-supply-chain": "node --test scripts/verify-workflow-supply-chain.test.mjs scripts/verify-dependency-advisories.test.mjs",
+    "test:notifications": "node --import tsx --test src/api/notifications/__tests__/*.test.ts",
     "verify:dependency-age": "node scripts/verify-dependency-age.mjs",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "tsx src/api/migrate.ts",
@@ -31,7 +35,7 @@
     "prepublishOnly": "npm run build",
     "dev:api": "tsx src/api/server.ts",
     "dev:mcp": "tsx src/mcp/server.ts",
-    "dev:desktop": "npm --prefix apps/desktop run dev"
+    "dev:desktop": "node scripts/ensure-desktop-dependencies.mjs && npm --prefix apps/desktop run dev"
   },
   "keywords": [
     "mcp",
@@ -66,7 +70,7 @@
     "@esbuild-kit/core-utils": {
       "esbuild": "^0.25.12"
     },
-    "fast-uri": "3.1.5",
+    "fast-uri": "3.1.6",
     "hono": "4.12.34",
     "ip-address": "10.3.1"
   }

package/shared/execution-approval-projection.d.mts

@@ -0,0 +1,32 @@
+export const EXECUTION_APPROVAL_PROJECTION_VERSION: 1;
+export const EXECUTION_APPROVAL_PROJECTION_MAX_FILES: 128;
+export const EXECUTION_APPROVAL_PROJECTION_MAX_PATH_BYTES: 4096;
+export const EXECUTION_APPROVAL_PROJECTION_MAX_BYTES: number;
+
+export type ExecutionApprovalProjectionChangeKind = "add" | "delete" | "update" | "move";
+export type ExecutionApprovalProjectionChange = {
+  path: string;
+  kind: ExecutionApprovalProjectionChangeKind;
+  move_path: string | null;
+  added_lines: number;
+  removed_lines: number;
+  diff_bytes: number;
+};
+export type ExecutionApprovalProjectionV1 = {
+  version: 1;
+  category: "file_change";
+  path_scope: "workspace_relative";
+  changes: ExecutionApprovalProjectionChange[];
+  totals: {
+    file_count: number;
+    added_lines: number;
+    removed_lines: number;
+    diff_bytes: number;
+  };
+};
+
+export function isExecutionApprovalProjectionPath(value: unknown): value is string;
+/** Return the canonical allowlisted projection, or reject it as a whole. */
+export function parseExecutionApprovalProjectionV1(value: unknown): ExecutionApprovalProjectionV1 | null;
+/** Serialize only the canonical, bounded bytes that a delegate may see. */
+export function serializeExecutionApprovalProjectionV1(value: unknown): string | null;

package/shared/execution-approval-projection.mjs

@@ -0,0 +1,107 @@
+export const EXECUTION_APPROVAL_PROJECTION_VERSION = 1;
+export const EXECUTION_APPROVAL_PROJECTION_MAX_FILES = 128;
+export const EXECUTION_APPROVAL_PROJECTION_MAX_PATH_BYTES = 4096;
+export const EXECUTION_APPROVAL_PROJECTION_MAX_BYTES = 24 * 1024;
+
+const ROOT_KEYS = ["version", "category", "path_scope", "changes", "totals"];
+const CHANGE_KEYS = ["path", "kind", "move_path", "added_lines", "removed_lines", "diff_bytes"];
+const TOTAL_KEYS = ["file_count", "added_lines", "removed_lines", "diff_bytes"];
+const CHANGE_KINDS = ["add", "delete", "update", "move"];
+const UNSAFE_PATH_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/;
+
+function exactKeys(value, keys) {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+    && Object.keys(value).length === keys.length
+    && keys.every((key) => Object.hasOwn(value, key));
+}
+
+function count(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+export function isExecutionApprovalProjectionPath(value) {
+  return typeof value === "string"
+    && value.length > 0
+    && value.normalize("NFC") === value
+    && new TextEncoder().encode(value).byteLength <= EXECUTION_APPROVAL_PROJECTION_MAX_PATH_BYTES
+    && !value.startsWith("/")
+    && !value.includes("\\")
+    && !UNSAFE_PATH_CHARACTERS.test(value)
+    && value.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+
+function compareChanges(left, right) {
+  for (const [a, b] of [[left.path, right.path], [left.kind, right.kind], [left.move_path ?? "", right.move_path ?? ""]]) {
+    if (a < b) return -1;
+    if (a > b) return 1;
+  }
+  return 0;
+}
+
+/** Return the canonical allowlisted projection, or reject it as a whole. */
+export function parseExecutionApprovalProjectionV1(value) {
+  if (!exactKeys(value, ROOT_KEYS)
+    || value.version !== EXECUTION_APPROVAL_PROJECTION_VERSION
+    || value.category !== "file_change"
+    || value.path_scope !== "workspace_relative"
+    || !Array.isArray(value.changes)
+    || value.changes.length < 1
+    || value.changes.length > EXECUTION_APPROVAL_PROJECTION_MAX_FILES
+    || !exactKeys(value.totals, TOTAL_KEYS)) return null;
+
+  const changes = [];
+  for (const candidate of value.changes) {
+    if (!exactKeys(candidate, CHANGE_KEYS)
+      || !isExecutionApprovalProjectionPath(candidate.path)
+      || !CHANGE_KINDS.includes(candidate.kind)
+      || !count(candidate.added_lines)
+      || !count(candidate.removed_lines)
+      || !count(candidate.diff_bytes)
+      || (candidate.kind === "move") !== (candidate.move_path !== null)
+      || (candidate.move_path !== null && !isExecutionApprovalProjectionPath(candidate.move_path))) return null;
+    changes.push({
+      path: candidate.path,
+      kind: candidate.kind,
+      move_path: candidate.move_path,
+      added_lines: candidate.added_lines,
+      removed_lines: candidate.removed_lines,
+      diff_bytes: candidate.diff_bytes,
+    });
+  }
+  changes.sort(compareChanges);
+  const occupied = new Set();
+  for (const change of changes) {
+    if (occupied.has(change.path)) return null;
+    occupied.add(change.path);
+    if (change.move_path !== null) {
+      if (occupied.has(change.move_path)) return null;
+      occupied.add(change.move_path);
+    }
+  }
+  const totals = changes.reduce((result, change) => ({
+    file_count: result.file_count + 1,
+    added_lines: result.added_lines + change.added_lines,
+    removed_lines: result.removed_lines + change.removed_lines,
+    diff_bytes: result.diff_bytes + change.diff_bytes,
+  }), { file_count: 0, added_lines: 0, removed_lines: 0, diff_bytes: 0 });
+  if (!Object.values(totals).every(Number.isSafeInteger)
+    || TOTAL_KEYS.some((key) => value.totals[key] !== totals[key])) return null;
+
+  return {
+    version: EXECUTION_APPROVAL_PROJECTION_VERSION,
+    category: "file_change",
+    path_scope: "workspace_relative",
+    changes,
+    totals,
+  };
+}
+
+/** Serialize only the canonical, bounded bytes that a delegate may see. */
+export function serializeExecutionApprovalProjectionV1(value) {
+  const parsed = parseExecutionApprovalProjectionV1(value);
+  if (!parsed) return null;
+  const serialized = JSON.stringify(parsed);
+  return new TextEncoder().encode(serialized).byteLength <= EXECUTION_APPROVAL_PROJECTION_MAX_BYTES
+    ? serialized
+    : null;
+}

package/shared/execution-approval-publication-item.d.mts

@@ -0,0 +1,20 @@
+export type ExecutionApprovalPublicationItem = {
+  publication_id: string;
+  room_id: string;
+  agent_key: string;
+  delegation_instance_id: string;
+  delegation_revision: number;
+  request_id: string;
+  request_version: number;
+  request_sha256: string;
+  projection_sha256: string;
+  published_at: string;
+  expires_at: string;
+};
+
+export function isExecutionApprovalPublicationIdentity(value: unknown): value is string;
+export function isExecutionApprovalPublicationDigest(value: unknown): value is string;
+export function isExecutionApprovalPublicationVersion(value: unknown): value is number;
+export function parseExecutionApprovalPublicationItem(
+  value: unknown,
+): ExecutionApprovalPublicationItem | null;

package/shared/execution-approval-publication-item.mjs

@@ -0,0 +1,61 @@
+const ITEM_KEYS = [
+  "publication_id",
+  "room_id",
+  "agent_key",
+  "delegation_instance_id",
+  "delegation_revision",
+  "request_id",
+  "request_version",
+  "request_sha256",
+  "projection_sha256",
+  "published_at",
+  "expires_at",
+];
+
+function exactKeys(value, keys) {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+    && Object.keys(value).length === keys.length
+    && keys.every((key) => Object.hasOwn(value, key));
+}
+
+export function isExecutionApprovalPublicationIdentity(value) {
+  return typeof value === "string"
+    && value.length > 0
+    && value.length <= 512
+    && value.trim() === value
+    && !/[\u0000-\u001f\u007f]/.test(value);
+}
+
+export function isExecutionApprovalPublicationDigest(value) {
+  return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+}
+
+export function isExecutionApprovalPublicationVersion(value) {
+  return Number.isSafeInteger(value) && value >= 1 && value <= 2_147_483_647;
+}
+
+function canonicalTimestamp(value) {
+  if (typeof value !== "string") return null;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value
+    ? timestamp
+    : null;
+}
+
+/** Parse the exact public inventory item shared by the API and browser. */
+export function parseExecutionApprovalPublicationItem(value) {
+  if (!exactKeys(value, ITEM_KEYS)
+    || !isExecutionApprovalPublicationIdentity(value.publication_id)
+    || !isExecutionApprovalPublicationIdentity(value.room_id)
+    || !isExecutionApprovalPublicationIdentity(value.agent_key)
+    || !isExecutionApprovalPublicationIdentity(value.delegation_instance_id)
+    || !isExecutionApprovalPublicationVersion(value.delegation_revision)
+    || !isExecutionApprovalPublicationIdentity(value.request_id)
+    || !isExecutionApprovalPublicationVersion(value.request_version)
+    || !isExecutionApprovalPublicationDigest(value.request_sha256)
+    || !isExecutionApprovalPublicationDigest(value.projection_sha256)) return null;
+  const publishedAt = canonicalTimestamp(value.published_at);
+  const expiresAt = canonicalTimestamp(value.expires_at);
+  if (publishedAt === null || expiresAt === null || expiresAt <= publishedAt) return null;
+  return Object.fromEntries(ITEM_KEYS.map((key) => [key, value[key]]));
+}

package/shared/execution-approval-publication.d.mts

@@ -0,0 +1,53 @@
+import type { ExecutionApprovalProjectionV1 } from "./execution-approval-projection.mjs";
+import type { ExecutionApprovalPublicationItem } from "./execution-approval-publication-item.mjs";
+
+export {
+  isExecutionApprovalPublicationDigest,
+  isExecutionApprovalPublicationIdentity,
+  isExecutionApprovalPublicationVersion,
+  parseExecutionApprovalPublicationItem,
+} from "./execution-approval-publication-item.mjs";
+export type { ExecutionApprovalPublicationItem } from "./execution-approval-publication-item.mjs";
+
+export const EXECUTION_APPROVAL_PUBLICATION_VERSION: 1;
+export const EXECUTION_APPROVAL_PUBLICATION_MAX_JSON_BYTES: number;
+
+export type ExecutionApprovalPublicationInput = {
+  version: 1;
+  room_id: string;
+  source_message_id: string;
+  delegation_instance_id: string;
+  delegation_revision: number;
+  request_id: string;
+  request_version: number;
+  request_sha256: string;
+  projection_sha256: string;
+  projection_json: string;
+  produced_at: string;
+  expires_at: string;
+};
+
+export type ExecutionApprovalPublicationReceipt = {
+  status: "created" | "replayed";
+  publication_digest: string;
+  publication: ExecutionApprovalPublicationItem;
+};
+
+export type ExecutionApprovalPublicationCloseInput = {
+  publication_digest: string;
+};
+
+export type ExecutionApprovalPublicationCloseReceipt = {
+  status: "closed" | "replayed";
+  publication_id: string;
+  publication_digest: string;
+  closed_at: string;
+};
+
+export function parseExecutionApprovalPublicationInput(value: unknown): ExecutionApprovalPublicationInput | null;
+export function parseExecutionApprovalPublicationReceipt(value: unknown): ExecutionApprovalPublicationReceipt | null;
+export function parseExecutionApprovalPublicationCloseInput(value: unknown): ExecutionApprovalPublicationCloseInput | null;
+export function parseExecutionApprovalPublicationCloseReceipt(value: unknown): ExecutionApprovalPublicationCloseReceipt | null;
+export function executionApprovalPublicationSha256(value: unknown): string | null;
+
+export type { ExecutionApprovalProjectionV1 };

package/shared/execution-approval-publication.mjs

@@ -0,0 +1,136 @@
+import { createHash } from "node:crypto";
+
+import {
+  parseExecutionApprovalProjectionV1,
+  serializeExecutionApprovalProjectionV1,
+} from "./execution-approval-projection.mjs";
+import {
+  isExecutionApprovalPublicationDigest,
+  isExecutionApprovalPublicationIdentity,
+  isExecutionApprovalPublicationVersion,
+  parseExecutionApprovalPublicationItem,
+} from "./execution-approval-publication-item.mjs";
+
+export {
+  isExecutionApprovalPublicationDigest,
+  isExecutionApprovalPublicationIdentity,
+  isExecutionApprovalPublicationVersion,
+  parseExecutionApprovalPublicationItem,
+} from "./execution-approval-publication-item.mjs";
+
+export const EXECUTION_APPROVAL_PUBLICATION_VERSION = 1;
+export const EXECUTION_APPROVAL_PUBLICATION_MAX_JSON_BYTES = 24 * 1024;
+
+const INPUT_KEYS = [
+  "version",
+  "room_id",
+  "source_message_id",
+  "delegation_instance_id",
+  "delegation_revision",
+  "request_id",
+  "request_version",
+  "request_sha256",
+  "projection_sha256",
+  "projection_json",
+  "produced_at",
+  "expires_at",
+];
+const RECEIPT_KEYS = ["status", "publication_digest", "publication"];
+const CLOSE_INPUT_KEYS = ["publication_digest"];
+const CLOSE_RECEIPT_KEYS = ["status", "publication_id", "publication_digest", "closed_at"];
+
+function exactKeys(value, keys) {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+    && Object.keys(value).length === keys.length
+    && keys.every((key) => Object.hasOwn(value, key));
+}
+
+function canonicalTimestamp(value) {
+  if (typeof value !== "string") return null;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value
+    ? timestamp
+    : null;
+}
+
+function sourceMessage(value) {
+  return typeof value === "string"
+    && /^msg_[1-9]\d{0,9}$/.test(value)
+    && Number(value.slice(4)) <= 2_147_483_647;
+}
+
+function canonicalProjection(value) {
+  if (typeof value !== "string"
+    || new TextEncoder().encode(value).byteLength > EXECUTION_APPROVAL_PUBLICATION_MAX_JSON_BYTES) return false;
+  let parsed;
+  try { parsed = JSON.parse(value); } catch { return false; }
+  const projection = parseExecutionApprovalProjectionV1(parsed);
+  return projection !== null && serializeExecutionApprovalProjectionV1(projection) === value;
+}
+
+/** Parse exact daemon-to-server publication bytes; digest verification remains the receiver's job. */
+export function parseExecutionApprovalPublicationInput(value) {
+  if (!exactKeys(value, INPUT_KEYS)
+    || value.version !== EXECUTION_APPROVAL_PUBLICATION_VERSION
+    || !isExecutionApprovalPublicationIdentity(value.room_id)
+    || !sourceMessage(value.source_message_id)
+    || !isExecutionApprovalPublicationIdentity(value.delegation_instance_id)
+    || !isExecutionApprovalPublicationVersion(value.delegation_revision)
+    || !isExecutionApprovalPublicationIdentity(value.request_id)
+    || !isExecutionApprovalPublicationVersion(value.request_version)
+    || !isExecutionApprovalPublicationDigest(value.request_sha256)
+    || !isExecutionApprovalPublicationDigest(value.projection_sha256)
+    || !canonicalProjection(value.projection_json)) return null;
+  const producedAt = canonicalTimestamp(value.produced_at);
+  const expiresAt = canonicalTimestamp(value.expires_at);
+  if (producedAt === null || expiresAt === null || expiresAt <= producedAt) return null;
+  return Object.fromEntries(INPUT_KEYS.map((key) => [key, value[key]]));
+}
+
+export function parseExecutionApprovalPublicationReceipt(value) {
+  if (!exactKeys(value, RECEIPT_KEYS)
+    || !["created", "replayed"].includes(value.status)
+    || !isExecutionApprovalPublicationDigest(value.publication_digest)) return null;
+  const publication = parseExecutionApprovalPublicationItem(value.publication);
+  return publication ? {
+    status: value.status,
+    publication_digest: value.publication_digest,
+    publication,
+  } : null;
+}
+
+/** Parse the content-free host acknowledgement that a publication is no longer actionable. */
+export function parseExecutionApprovalPublicationCloseInput(value) {
+  return exactKeys(value, CLOSE_INPUT_KEYS)
+    && isExecutionApprovalPublicationDigest(value.publication_digest)
+    ? { publication_digest: value.publication_digest }
+    : null;
+}
+
+export function parseExecutionApprovalPublicationCloseReceipt(value) {
+  if (!exactKeys(value, CLOSE_RECEIPT_KEYS)
+    || !["closed", "replayed"].includes(value.status)
+    || !isExecutionApprovalPublicationIdentity(value.publication_id)
+    || !isExecutionApprovalPublicationDigest(value.publication_digest)
+    || canonicalTimestamp(value.closed_at) === null) return null;
+  return Object.fromEntries(CLOSE_RECEIPT_KEYS.map((key) => [key, value[key]]));
+}
+
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value)
+      .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+      .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+/** Digest exact, validated publication input with the server's stable-key wire algorithm. */
+export function executionApprovalPublicationSha256(value) {
+  const publication = parseExecutionApprovalPublicationInput(value);
+  return publication === null
+    ? null
+    : createHash("sha256").update(stableJson(publication), "utf8").digest("hex");
+}

package/shared/execution-delegation-decision.d.mts

@@ -0,0 +1,37 @@
+export const EXECUTION_DELEGATION_DECISIONS: readonly ["allow_once", "deny"];
+export const EXECUTION_DELEGATION_DECISION_APPLICABILITY_MS: number;
+
+export type ExecutionDelegationDecisionChoice =
+  typeof EXECUTION_DELEGATION_DECISIONS[number];
+
+export function isExecutionDelegationDecision(
+  value: unknown,
+): value is ExecutionDelegationDecisionChoice;
+export function isExecutionDelegationIdentity(value: unknown): value is string;
+export function isExecutionDelegationDigest(value: unknown): value is string;
+export function isExecutionDelegationPositiveInt32(value: unknown): value is number;
+
+export type ExecutionDelegationDecisionIntent = {
+  decision_id: string;
+  delegation_instance_id: string;
+  delegation_revision: number;
+  actor_account_id: string;
+  request_id: string;
+  request_version: number;
+  request_sha256: string;
+  projection_sha256: string;
+  decision: ExecutionDelegationDecisionChoice;
+  decided_at: string;
+  owner_account_id: string;
+  room_id: string;
+  agent_key: string;
+  approver_account_id: string;
+  category: "file_change";
+  risk_ceiling: "low";
+  scope_sha256: string;
+};
+
+/** Return the exact host-delivered decision intent, or reject it as a whole. */
+export function parseExecutionDelegationDecisionIntent(
+  value: unknown,
+): ExecutionDelegationDecisionIntent | null;

package/shared/execution-delegation-decision.mjs

@@ -0,0 +1,73 @@
+export const EXECUTION_DELEGATION_DECISIONS = ["allow_once", "deny"];
+export const EXECUTION_DELEGATION_DECISION_APPLICABILITY_MS = 24 * 60 * 60 * 1000;
+
+export function isExecutionDelegationDecision(value) {
+  return EXECUTION_DELEGATION_DECISIONS.includes(value);
+}
+
+const INTENT_KEYS = [
+  "decision_id",
+  "delegation_instance_id",
+  "delegation_revision",
+  "actor_account_id",
+  "request_id",
+  "request_version",
+  "request_sha256",
+  "projection_sha256",
+  "decision",
+  "decided_at",
+  "owner_account_id",
+  "room_id",
+  "agent_key",
+  "approver_account_id",
+  "category",
+  "risk_ceiling",
+  "scope_sha256",
+];
+
+function exactKeys(value, keys) {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+    && Object.keys(value).length === keys.length
+    && keys.every((key) => Object.hasOwn(value, key));
+}
+
+export function isExecutionDelegationIdentity(value) {
+  return typeof value === "string"
+    && value.length > 0
+    && value.length <= 512
+    && value.trim() === value
+    && !/[\u0000-\u001f\u007f]/.test(value);
+}
+
+export function isExecutionDelegationDigest(value) {
+  return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+}
+
+export function isExecutionDelegationPositiveInt32(value) {
+  return Number.isSafeInteger(value) && value >= 1 && value <= 2_147_483_647;
+}
+
+/** Return the exact host-delivered decision intent, or reject it as a whole. */
+export function parseExecutionDelegationDecisionIntent(value) {
+  if (!exactKeys(value, INTENT_KEYS)
+    || !isExecutionDelegationIdentity(value.decision_id)
+    || !isExecutionDelegationIdentity(value.delegation_instance_id)
+    || !isExecutionDelegationPositiveInt32(value.delegation_revision)
+    || !isExecutionDelegationIdentity(value.actor_account_id)
+    || !isExecutionDelegationIdentity(value.request_id)
+    || !isExecutionDelegationPositiveInt32(value.request_version)
+    || !isExecutionDelegationDigest(value.request_sha256)
+    || !isExecutionDelegationDigest(value.projection_sha256)
+    || !isExecutionDelegationDecision(value.decision)
+    || typeof value.decided_at !== "string" || !Number.isFinite(Date.parse(value.decided_at))
+    || !isExecutionDelegationIdentity(value.owner_account_id)
+    || !isExecutionDelegationIdentity(value.room_id)
+    || !isExecutionDelegationIdentity(value.agent_key)
+    || !isExecutionDelegationIdentity(value.approver_account_id)
+    || value.actor_account_id !== value.approver_account_id
+    || value.category !== "file_change"
+    || value.risk_ceiling !== "low"
+    || !isExecutionDelegationDigest(value.scope_sha256)) return null;
+
+  return Object.fromEntries(INTENT_KEYS.map((key) => [key, value[key]]));
+}

package/shared/message-contracts.d.mts

@@ -0,0 +1,32 @@
+export const POSTGRES_INTEGER_MAX: number;
+export const MESSAGE_SENDER_MAX_CODE_POINTS: number;
+export const MESSAGE_SENDER_MAX_UTF8_BYTES: number;
+export function parsePositivePgIntegerScopedId(value: unknown, prefix: string): number | null;
+export function isMessageSenderWithinBounds(sender: unknown): sender is string;
+export type ParsedAccountAgentRouting =
+  | { version: 1; authority: "invalid" }
+  | {
+      version: 1;
+      authority: "receipts";
+      recipientAgentKeys: string[];
+      recipientSessions: Array<{
+        agentKey: string;
+        agentSessionId: string;
+        successorAgentSessionId?: string;
+      }>;
+      controlAuthorized: boolean;
+    }
+  | {
+      version: 1;
+      authority: "legacy";
+      recipientAgentKeys: string[];
+      recipientSessions: Array<{
+        agentKey: string;
+        agentSessionId: string;
+        activationReason: string;
+      }>;
+      controlAuthorized: boolean;
+    };
+export function parseAccountAgentRoutingEnvelope(
+  routing: unknown,
+): ParsedAccountAgentRouting | undefined;