stylegallery 0.1.0

package/scripts/agent-native/canonical-json.mjs

@@ -0,0 +1,109 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Errors from the identity kernel carry a stable machine-readable code.  The
+ * callers use these errors at protocol boundaries, so do not rely on the
+ * wording of `message` for branching.
+ */
+export class CanonicalJsonError extends TypeError {
+  constructor(code, message, path = "") {
+    super(message);
+    this.name = "CanonicalJsonError";
+    this.code = code;
+    if (path) this.path = path;
+  }
+}
+
+function fail(code, message, path) {
+  throw new CanonicalJsonError(code, message, path);
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function encode(value, path, stack) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string": return JSON.stringify(value);
+    case "boolean": return value ? "true" : "false";
+    case "number":
+      if (!Number.isFinite(value)) fail("canonical_number_invalid", "numbers must be finite", path);
+      return Object.is(value, -0) ? "0" : JSON.stringify(value);
+    case "bigint": fail("canonical_type_unsupported", "bigint is not JSON data", path);
+    case "undefined": fail("canonical_value_undefined", "undefined is not JSON data", path);
+    case "function": fail("canonical_type_unsupported", "functions are not JSON data", path);
+    case "symbol": fail("canonical_type_unsupported", "symbols are not JSON data", path);
+    default: break;
+  }
+
+  if (stack.has(value)) fail("canonical_cycle", "cyclic values cannot be canonicalized", path);
+  stack.add(value);
+  let result;
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index += 1) {
+      if (!Object.hasOwn(value, index)) fail("canonical_array_hole", "sparse arrays are not canonical JSON", `${path}/${index}`);
+    }
+    for (const key of Object.keys(value)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= value.length) fail("canonical_array_property", "arrays may contain only indexed JSON values", `${path}/${key}`);
+    }
+    result = `[${value.map((item, index) => encode(item, `${path}/${index}`, stack)).join(",")}]`;
+  } else if (isPlainObject(value)) {
+    const keys = Reflect.ownKeys(value);
+    if (keys.some((key) => typeof key !== "string")) fail("canonical_symbol_key", "object keys must be strings", path);
+    const properties = Object.getOwnPropertyDescriptors(value);
+    const parts = keys.sort().map((key) => {
+      const descriptor = properties[key];
+      if (!descriptor || !Object.hasOwn(descriptor, "value")) fail("canonical_accessor", `accessor property ${key} is not canonical data`, `${path}/${key}`);
+      return `${JSON.stringify(key)}:${encode(descriptor.value, `${path}/${key}`, stack)}`;
+    });
+    result = `{${parts.join(",")}}`;
+  } else {
+    fail("canonical_type_unsupported", `unsupported value type ${Object.prototype.toString.call(value)}`, path);
+  }
+  stack.delete(value);
+  return result;
+}
+
+/** Return recursively key-sorted, whitespace-free UTF-8 JSON text. */
+export function canonicalize(value) {
+  return encode(value, "", new WeakSet());
+}
+
+export const canonicalJson = canonicalize;
+export const stringifyCanonical = canonicalize;
+
+/** Return the SHA-256 digest of canonical JSON bytes, with an explicit suite. */
+export function hashCanonical(value) {
+  const bytes = canonicalize(value);
+  return `sha256:${createHash("sha256").update(Buffer.from(bytes, "utf8")).digest("hex")}`;
+}
+
+/** Hash already-canonical UTF-8 JSON bytes when a caller has the bytes. */
+export function hashCanonicalBytes(bytes) {
+  if (typeof bytes !== "string" && !(bytes instanceof Uint8Array)) throw new CanonicalJsonError("canonical_bytes_required", "canonical bytes must be text or Uint8Array");
+  return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+
+export const sha256Canonical = hashCanonical;
+export const digestCanonical = hashCanonical;
+
+/** Deep-freeze canonical records before they cross an append-only boundary. */
+export function deepFreeze(value, seen = new WeakSet()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const key of Reflect.ownKeys(value)) deepFreeze(value[key], seen);
+  return Object.freeze(value);
+}
+
+export function cloneAndFreeze(value) {
+  let clone;
+  try {
+    clone = structuredClone(value);
+  } catch (error) {
+    throw new CanonicalJsonError("canonical_clone_failed", error instanceof Error ? error.message : String(error));
+  }
+  return deepFreeze(clone);
+}

package/scripts/agent-native/cli-adapter.mjs

@@ -0,0 +1,68 @@
+import { deepFreeze } from "./canonical-json.mjs";
+import { agentNativeRegistry } from "./registry.mjs";
+
+const COMMANDS = new Set(["claims", "context", "discover", "ops", "resolve"]);
+const TARGET_COMMANDS = new Set(["claims", "context", "resolve"]);
+
+function issue(code, message, recordPath = "") {
+  return recordPath ? { code, message, path: recordPath } : { code, message };
+}
+
+function failed(operation, failure) {
+  return deepFreeze({ failures: [failure], ok: false, operation });
+}
+
+export function parseCliArguments(args) {
+  if (!Array.isArray(args)) return failed(null, issue("argument_list_invalid", "CLI arguments must be an array"));
+  let command;
+  let format = "json";
+  const operands = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--format") {
+      const value = args[index + 1];
+      if (value === undefined || value.startsWith("--")) {
+        return failed(command ?? null, issue("argument_value_required", "--format requires a value", "--format"));
+      }
+      if (value !== "json") return failed(command ?? null, issue("format_unsupported", `unsupported format ${value}`, "--format"));
+      format = value;
+      index += 1;
+      continue;
+    }
+    if (typeof argument !== "string" || argument.startsWith("--")) {
+      return failed(command ?? null, issue("argument_unknown", `unknown argument ${String(argument)}`, String(argument)));
+    }
+    if (command === undefined) command = argument;
+    else operands.push(argument);
+  }
+  if (command === undefined) return failed(null, issue("argument_value_required", "a command is required", "command"));
+  if (!COMMANDS.has(command)) return failed(command, issue("command_unknown", `unknown command ${command}`, "command"));
+  const required = TARGET_COMMANDS.has(command);
+  if (required && operands.length === 0) {
+    return failed(command, issue("argument_value_required", `${command} requires a StableRef or VersionID`, "reference"));
+  }
+  if ((!required && operands.length > 0) || operands.length > 1) {
+    return failed(command, issue("argument_unknown", `unexpected positional argument ${operands[required ? 1 : 0]}`, "argument"));
+  }
+  return deepFreeze({ command, format, input: required ? { reference: operands[0] } : {}, ok: true });
+}
+
+export function executeCli(args, registry = agentNativeRegistry) {
+  const parsed = parseCliArguments(args);
+  if (!parsed.ok) return parsed;
+  if (!registry || typeof registry.invoke !== "function") {
+    return failed(parsed.command, issue("registry_invalid", "CLI registry must expose invoke"));
+  }
+  return registry.invoke(parsed.command, parsed.input);
+}
+
+export function serializeCliReport(report) {
+  return `${JSON.stringify(report, null, 2)}\n`;
+}
+
+export function runCli(args, registry = agentNativeRegistry) {
+  const report = executeCli(args, registry);
+  return deepFreeze({ exitCode: report.ok ? 0 : 1, output: serializeCliReport(report), report });
+}
+
+export const invokeCli = executeCli;

package/scripts/agent-native/events.mjs

@@ -0,0 +1,113 @@
+import { cloneAndFreeze, canonicalize, hashCanonical } from "./canonical-json.mjs";
+
+function sourceObject(value, name) {
+  if (Array.isArray(value)) return { events: value };
+  if (!value || typeof value !== "object") throw new TypeError(`${name} expects an object`);
+  return value;
+}
+
+function pick(value, ...keys) {
+  if (!value || typeof value !== "object") return undefined;
+  for (const key of keys) if (Object.hasOwn(value, key)) return value[key];
+  return undefined;
+}
+
+function eventId(event) {
+  return pick(event, "event_id", "eventId", "id", "stable_ref", "stableRef");
+}
+
+function parentIds(event) {
+  const parents = pick(event, "parents", "parent_ids", "parentIds");
+  if (parents === undefined || parents === null) return [];
+  if (!Array.isArray(parents)) throw new TypeError("event parents must be an array");
+  return [...new Set(parents.map((parent) => {
+    if (typeof parent !== "string" || parent.length === 0) throw new TypeError("event parent IDs must be non-empty strings");
+    return parent;
+  }))].sort();
+}
+
+function canonicalFreeze(value) {
+  return cloneAndFreeze(JSON.parse(canonicalize(value)));
+}
+
+function normalizeEvent(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new TypeError("event must be an object");
+  const copy = structuredClone(input);
+  const id = eventId(copy);
+  if (id !== undefined && (typeof id !== "string" || id.length === 0)) throw new TypeError("event ID must be a non-empty string");
+  const stableRef = pick(copy, "stable_ref", "stableRef");
+  const parents = parentIds(copy);
+  delete copy.eventId;
+  delete copy.event_id;
+  delete copy.parentIds;
+  delete copy.parent_ids;
+  delete copy.parents;
+  delete copy.id;
+  delete copy.stableRef;
+  delete copy.stable_ref;
+  const body = { ...copy, parents };
+  if (stableRef !== undefined) body.stable_ref = stableRef;
+  const stableId = typeof id === "string" && id.length > 0 ? id : `sg:event/${hashCanonical(body).slice("sha256:".length)}`;
+  return { event_id: stableId, parents, ...body };
+}
+
+function normalizedEvents(value) {
+  const source = sourceObject(value, "event collection");
+  const events = pick(source, "events", "items", "entries");
+  if (!Array.isArray(events)) throw new TypeError("events must be an array");
+  const result = [];
+  const byId = new Map();
+  for (const item of events) {
+    const normalized = normalizeEvent(item);
+    const id = normalized.event_id;
+    const previous = byId.get(id);
+    if (previous) {
+      if (canonicalize(previous) !== canonicalize(normalized)) throw new TypeError(`event ${id} is immutable`);
+      continue;
+    }
+    byId.set(id, normalized);
+    result.push(normalized);
+  }
+  const ids = new Set(result.map((item) => item.event_id));
+  const visiting = new Set();
+  const visited = new Set();
+  const eventById = new Map(result.map((item) => [item.event_id, item]));
+  const visit = (id) => {
+    if (visiting.has(id)) throw new TypeError(`event cycle includes ${id}`);
+    if (visited.has(id)) return;
+    visiting.add(id);
+    for (const parent of eventById.get(id).parents) if (eventById.has(parent)) visit(parent);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  for (const id of ids) visit(id);
+  return result;
+}
+
+/**
+ * Append one event to an immutable causal event collection. Existing IDs are
+ * idempotent only when their canonical bytes are identical; a changed payload
+ * is rejected rather than silently rewriting history.
+ */
+export function appendEvent(input) {
+  const source = sourceObject(input, "appendEvent");
+  const existing = normalizedEvents(source);
+  const appended = normalizeEvent(pick(source, "event") ?? source);
+  const existingById = new Map(existing.map((item) => [item.event_id, item]));
+  const previous = existingById.get(appended.event_id);
+  if (previous && canonicalize(previous) !== canonicalize(appended)) throw new TypeError(`event ${appended.event_id} is immutable`);
+  if (previous) return canonicalFreeze(existing);
+  return canonicalFreeze(normalizedEvents({ events: [...existing, appended] }));
+}
+
+export const appendCausalEvent = appendEvent;
+
+/** Return the deterministic leaf IDs of an append-only causal DAG. */
+export function eventHeads(input) {
+  const events = normalizedEvents(input);
+  const ids = new Set(events.map((item) => item.event_id));
+  const referenced = new Set(events.flatMap((item) => item.parents.filter((parent) => ids.has(parent))));
+  return canonicalFreeze([...ids].filter((id) => !referenced.has(id)).sort());
+}
+
+export const getEventHeads = eventHeads;

package/scripts/agent-native/execution.mjs

@@ -0,0 +1,227 @@
+import { deepFreeze, hashCanonical } from "./canonical-json.mjs";
+import { createVersionId } from "./identity.mjs";
+
+const CONTROL = new Set(["schema_version", "record_kind", "version_id", "versionId"]);
+const EFFECTS = new Set(["NONE", "LOCAL", "EXTERNAL"]);
+
+function sourceObject(input, name) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new TypeError(`${name} expects an object parameter`);
+  return input;
+}
+
+function value(input, ...keys) {
+  if (input === null || input === undefined) return undefined;
+  for (const key of keys) if (Object.hasOwn(input, key) && input[key] !== undefined) return input[key];
+  return undefined;
+}
+
+function copy(input) {
+  return input === undefined ? undefined : structuredClone(input);
+}
+
+function refOf(input, prefixes, name) {
+  const ref = value(input, "stable_ref", "stableRef", "id", ...prefixes);
+  if (typeof ref !== "string" || ref.length === 0) throw new TypeError(`${name} stable reference is required`);
+  return ref.includes("@sha256:") ? ref.slice(0, ref.indexOf("@sha256:")) : ref;
+}
+
+function versionId(stableRef, payload) {
+  return createVersionId({ stableRef, payload });
+}
+
+function record(stableRef, recordKind, payload) {
+  const body = { schema_version: "1.0", record_kind: recordKind, stable_ref: stableRef, ...payload };
+  return deepFreeze({ ...body, version_id: versionId(stableRef, body) });
+}
+
+function normalizedFields(input, omit = []) {
+  const ignored = new Set([...CONTROL, "stable_ref", "stableRef", "id", ...omit]);
+  return Object.fromEntries(Object.entries(input).filter(([key, item]) => !ignored.has(key) && item !== undefined).map(([key, item]) => [key, copy(item)]));
+}
+
+function upper(input, fallback) {
+  return typeof input === "string" ? input.toUpperCase() : fallback;
+}
+
+function operationNames(operation) {
+  if (!operation || typeof operation !== "object") return [];
+  return [value(operation, "operation", "name"), value(operation, "stable_ref", "stableRef")].filter((item) => typeof item === "string");
+}
+
+function wildcardMatch(pattern, candidate) {
+  if (typeof pattern !== "string" || typeof candidate !== "string") return false;
+  if (pattern === "*") return true;
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
+  return new RegExp(`^${escaped}$`).test(candidate);
+}
+
+/** Define a deterministic, immutable operation specification. */
+export function defineOperation(input) {
+  const source = sourceObject(input, "defineOperation");
+  const stableRef = refOf(source, ["operation"], "defineOperation");
+  const effectClass = upper(value(source, "effect_class", "effectClass", "effect"), "NONE");
+  if (!EFFECTS.has(effectClass)) throw new TypeError("defineOperation.effect_class must be NONE, LOCAL, or EXTERNAL");
+  const operationName = value(source, "operation", "name") ?? stableRef.slice(stableRef.lastIndexOf("/") + 1);
+  const payload = {
+    ...normalizedFields(source, ["operation", "name", "effect", "effectClass", "effect_class", "idempotent", "isIdempotent", "requiredCapability", "capability", "inputSchema", "outputSchema"]),
+    adapters: [...new Set((value(source, "adapters", "adapter_exposure", "adapterExposure") ?? []).filter((item) => typeof item === "string"))].sort(),
+    effect_class: effectClass,
+    idempotent: value(source, "idempotent", "isIdempotent") !== false,
+    input_schema: copy(value(source, "input_schema", "inputSchema") ?? { type: "object" }),
+    name: operationName,
+    operation: operationName,
+    output_schema: copy(value(source, "output_schema", "outputSchema") ?? { type: "object" }),
+    required_capability: value(source, "required_capability", "requiredCapability", "capability") ?? null,
+  };
+  return record(stableRef, "operation", payload);
+}
+
+function grantFor(input) {
+  return value(input, "grant", "capability");
+}
+
+function connectorReceiptId(input) {
+  const receipt = value(input, "connector_receipt", "connectorReceipt", "receiptId", "receipt_id");
+  return typeof receipt === "string" && receipt.trim().length > 0 ? receipt : null;
+}
+
+/** Evaluate capability, subject, resource, expiry, and call-limit policy. */
+export function authorizeOperation(input) {
+  const source = sourceObject(input, "authorizeOperation");
+  const operation = value(source, "operation", "operationSpec");
+  const grant = grantFor(source);
+  const subject = value(source, "subject", "principal");
+  const resource = value(source, "resource", "resourceRef", "stable_ref", "stableRef");
+  const now = value(source, "now", "evaluated_at", "evaluatedAt") ?? "1970-01-01T00:00:00.000Z";
+  const names = operationNames(operation);
+  const required = value(operation ?? {}, "required_capability", "requiredCapability", "capability");
+  const grantedCapability = value(grant ?? {}, "capability", "name");
+  const operationGrant = value(grant ?? {}, "operations", "operation");
+  const operations = Array.isArray(operationGrant) ? operationGrant : operationGrant ? [operationGrant] : [];
+  const scopeGrant = value(grant ?? {}, "resource_scope", "resourceScope", "resources");
+  const scopes = Array.isArray(scopeGrant) ? scopeGrant : scopeGrant ? [scopeGrant] : [];
+  const expiresAt = value(grant ?? {}, "expires_at", "expiresAt", "expiry");
+  const used = Number(value(grant ?? {}, "used", "used_calls", "usedCalls", "calls_used", "callsUsed") ?? 0);
+  const limits = value(grant ?? {}, "limits") ?? {};
+  const maxCalls = Number(value(grant ?? {}, "max_calls", "maxCalls") ?? value(limits, "maxCalls", "calls") ?? Number.POSITIVE_INFINITY);
+  const failures = [];
+  if (!grant || typeof grant !== "object") failures.push("capability_missing");
+  if (typeof subject !== "string" || subject !== value(grant ?? {}, "subject", "principal")) failures.push("subject_denied");
+  if (required && grantedCapability !== required) failures.push("capability_denied");
+  if (operations.length === 0 || !names.some((name) => operations.includes(name))) failures.push("operation_denied");
+  if (scopes.length > 0 && !scopes.some((scope) => wildcardMatch(scope, resource))) failures.push("resource_denied");
+  if (expiresAt && String(now) >= String(expiresAt)) failures.push("grant_expired");
+  if (Number.isFinite(maxCalls) && used >= maxCalls) failures.push("grant_limit_exceeded");
+  const allowed = failures.length === 0;
+  const decision = {
+    allowed,
+    capability: grantedCapability ?? null,
+    evaluated_at: String(now),
+    operation: names[0] ?? null,
+    reason: allowed ? "allowed" : failures[0],
+    resource: resource ?? null,
+    subject: subject ?? null,
+  };
+  return deepFreeze({ allowed, decision, policy_decision: decision, failures });
+}
+
+/** Re-check policy immediately before a potentially effectful attempt. */
+export function authorizeEffect(input) {
+  const source = sourceObject(input, "authorizeEffect");
+  return authorizeOperation({ ...source, operation: value(source, "operation", "operationSpec") });
+}
+
+export function createTask(input) {
+  const source = sourceObject(input, "createTask");
+  const stableRef = refOf(source, ["taskId", "task_id"], "createTask");
+  return record(stableRef, "task", {
+    ...normalizedFields(source, ["taskId", "task_id", "intent", "request", "requiredResult", "required_result", "result", "state", "status"]),
+    intent: copy(value(source, "intent", "request") ?? {}),
+    required_result: copy(value(source, "required_result", "requiredResult", "result") ?? {}),
+    state: upper(value(source, "state", "status"), "SUBMITTED"),
+    task_id: stableRef,
+  });
+}
+
+export function startRun(input) {
+  const source = sourceObject(input, "startRun");
+  const task = value(source, "task");
+  const taskId = value(task ?? {}, "task_id", "taskId", "stable_ref", "stableRef") ?? value(source, "task_id", "taskId");
+  if (typeof taskId !== "string" || taskId.length === 0) throw new TypeError("startRun.task_id is required");
+  const stableRef = refOf(source, ["runId", "run_id"], "startRun");
+  return record(stableRef, "run", {
+    ...normalizedFields(source, ["runId", "run_id", "task", "taskId", "task_id", "state", "status"]),
+    input: copy(value(source, "input", "arguments") ?? {}),
+    run_id: stableRef,
+    state: upper(value(source, "state", "status"), "RUNNING"),
+    task_id: taskId,
+  });
+}
+
+export function recordEffectAttempt(input) {
+  const source = sourceObject(input, "recordEffectAttempt");
+  const stableRef = refOf(source, ["effectId", "effect_id", "effect"], "recordEffectAttempt");
+  const effectClass = upper(value(source, "effect_class", "effectClass", "class"), "EXTERNAL");
+  const connectorReceipt = connectorReceiptId(source);
+  const suppliedState = upper(value(source, "state", "status", "effect_state", "effectState"), undefined);
+  const state = effectClass === "EXTERNAL"
+    ? (connectorReceipt ? "COMMITTED" : "UNCERTAIN")
+    : (suppliedState ?? "PLANNED");
+  return record(stableRef, "effect", {
+    ...normalizedFields(source, ["effectId", "effect_id", "effect", "effect_class", "effectClass", "class", "connector_receipt", "connectorReceipt", "receiptId", "receipt_id", "state", "status", "effect_state", "effectState"]),
+    attempt: value(source, "attempt") ?? null,
+    connector_receipt: connectorReceipt,
+    effect_class: effectClass,
+    effect_id: stableRef,
+    idempotency_key: value(source, "idempotency_key", "idempotencyKey") ?? null,
+    run_id: value(source, "run_id", "runId") ?? value(value(source, "run"), "run_id", "runId") ?? null,
+    state,
+    task_id: value(source, "task_id", "taskId") ?? value(value(source, "task"), "task_id", "taskId") ?? null,
+  });
+}
+
+export function reconcileEffect(input) {
+  const source = sourceObject(input, "reconcileEffect");
+  const effect = source.effect && typeof source.effect === "object" ? source.effect : source;
+  const observations = [...(Array.isArray(value(source, "observations")) ? value(source, "observations") : []), ...(value(source, "observation") ? [value(source, "observation")] : [])];
+  const statuses = observations.map((item) => upper(value(item ?? {}, "status", "state", "effect_state", "effectState"), "UNKNOWN"));
+  const positiveStatuses = new Set(["COMMITTED", "SUCCEEDED", "SUCCESS"]);
+  const positive = statuses.some((status) => positiveStatuses.has(status));
+  const negative = statuses.includes("ABSENT") || statuses.includes("FAILED") || statuses.includes("NOT_FOUND");
+  const strategy = upper(value(source, "strategy"), "RECONCILE");
+  let state = upper(value(effect, "state", "status", "effect_state", "effectState"), "UNCERTAIN");
+  const receiptObservation = observations.find((item) => positiveStatuses.has(upper(value(item ?? {}, "status", "state", "effect_state", "effectState"), "UNKNOWN")) && connectorReceiptId(item));
+  const connectorReceipt = connectorReceiptId(receiptObservation) ?? connectorReceiptId(effect);
+  if (positive && negative) state = "UNCERTAIN";
+  else if (positive) state = connectorReceipt ? "COMMITTED" : "UNCERTAIN";
+  else if (negative && strategy === "COMPENSATE") state = "COMPENSATED";
+  else if (negative) state = "FAILED";
+  else if (state === "COMMITTED" && !connectorReceipt) state = "UNCERTAIN";
+  const stableRef = refOf(effect, ["effect_id", "effectId", "effect"], "reconcileEffect");
+  return record(stableRef, "effect", { ...normalizedFields(effect, ["version_id", "versionId", "state", "status", "effect_state", "effectState", "connector_receipt", "connectorReceipt"]), connector_receipt: connectorReceipt, state });
+}
+
+export function createReceipt(input) {
+  const source = sourceObject(input, "createReceipt");
+  const operation = value(source, "operation", "operationSpec");
+  const task = value(source, "task");
+  const run = value(source, "run");
+  const effects = value(source, "effects") ?? (value(source, "effect") ? [value(source, "effect")] : []);
+  const inputValue = value(source, "input", "normalized_input", "normalizedInput") ?? null;
+  const outputValue = value(source, "output", "normalized_output", "normalizedOutput") ?? null;
+  const taskId = value(source, "task_id", "taskId") ?? value(task ?? {}, "task_id", "taskId", "stable_ref", "stableRef") ?? null;
+  const runId = value(source, "run_id", "runId") ?? value(run ?? {}, "run_id", "runId", "stable_ref", "stableRef") ?? null;
+  const effectIds = effects.map((effect) => value(effect ?? {}, "effect_id", "effectId", "stable_ref", "stableRef", "id")).filter((id) => typeof id === "string");
+  const base = { input_digest: hashCanonical(inputValue), operation: value(operation ?? {}, "operation", "name", "stable_ref", "stableRef") ?? null, output_digest: hashCanonical(outputValue), run_id: runId, task_id: taskId, effect_ids: [...new Set(effectIds)].sort() };
+  const stableRef = value(source, "receipt_id", "receiptId", "stable_ref", "stableRef") ?? `sg:receipt/${hashCanonical(base).slice(7, 23)}`;
+  return record(stableRef, "invocation_receipt", {
+    ...base,
+    causal_parents: [...new Set((value(source, "causal_parents", "causalParents", "parents") ?? []).filter((item) => typeof item === "string"))].sort(),
+    effects: copy(effects),
+    policy_decision: copy(value(source, "policy_decision", "policyDecision") ?? null),
+  });
+}
+
+export const defineOperationSpec = defineOperation;
+export const authorizeCapability = authorizeOperation;
+export const createInvocationReceipt = createReceipt;