@buildaureon/sdk 0.1.2 → 0.1.8

package/dist/index.js

@@ -10,11 +10,81 @@ function userAgentHeader(version) {
   return { "X-Aureon-SDK": `@buildaureon/sdk/${version}` };
 }
 
+// src/constants/networks.ts
+var MAINNET_CHAIN_ID = 4663;
+var TESTNET_CHAIN_ID = 46630;
+var MAINNET_API_BASE_URL = "http://127.0.0.1:8788";
+var TESTNET_API_BASE_URL = "https://api.aureonlabs.network";
+var MAINNET_EXPLORER = "https://robinhoodchain.blockscout.com";
+var TESTNET_EXPLORER = "https://explorer.testnet.chain.robinhood.com";
+var AUREON_NETWORKS = {
+  mainnet: {
+    network: "mainnet",
+    chainId: MAINNET_CHAIN_ID,
+    baseUrl: MAINNET_API_BASE_URL,
+    explorer: MAINNET_EXPLORER
+  },
+  testnet: {
+    network: "testnet",
+    chainId: TESTNET_CHAIN_ID,
+    baseUrl: TESTNET_API_BASE_URL,
+    explorer: TESTNET_EXPLORER
+  }
+};
+function parseNetwork(raw) {
+  const n = raw.trim().toLowerCase();
+  if (n === "mainnet" || n === "testnet") return n;
+  throw new Error(
+    `Unknown AUREON network "${raw}". Use "mainnet" or "testnet".`
+  );
+}
+function stripSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function inferAureonNetworkFromUrl(url) {
+  const u = stripSlash(url).toLowerCase();
+  if (u.includes("api.aureonlabs.network")) return "testnet";
+  if (/:(8787)(\/|$)/.test(u) || u.endsWith(":8787")) return "testnet";
+  if (/:(8788)(\/|$)/.test(u) || u.endsWith(":8788")) return "mainnet";
+  return null;
+}
+function mismatchMessage(network, baseUrl) {
+  return `baseUrl "${baseUrl}" does not match network "${network}". mainnet is ${MAINNET_API_BASE_URL} (4663). testnet is ${TESTNET_API_BASE_URL} (46630; public host is still testnet).`;
+}
+function resolveAureonNetwork(input = {}) {
+  const networkRaw = input.network?.trim();
+  const networkSpecified = Boolean(networkRaw);
+  const network = networkSpecified ? parseNetwork(networkRaw) : "mainnet";
+  const explicitUrl = input.baseUrl?.trim();
+  if (!explicitUrl) {
+    return { ...AUREON_NETWORKS[network] };
+  }
+  const baseUrl = stripSlash(explicitUrl);
+  const inferred = inferAureonNetworkFromUrl(baseUrl);
+  if (networkSpecified && inferred && inferred !== network) {
+    throw new Error(mismatchMessage(network, baseUrl));
+  }
+  const resolvedNetwork = networkSpecified ? network : inferred ?? "mainnet";
+  const preset = AUREON_NETWORKS[resolvedNetwork];
+  return {
+    network: resolvedNetwork,
+    chainId: preset.chainId,
+    baseUrl,
+    explorer: preset.explorer
+  };
+}
+function resolveAureonNetworkFromEnv(env = process.env) {
+  return resolveAureonNetwork({
+    network: env.AUREON_NETWORK,
+    baseUrl: env.AUREON_API_URL
+  });
+}
+
 // src/constants/defaults.ts
-var DEFAULT_API_BASE_URL = "https://api.aureonlabs.network";
-var LOCAL_API_BASE_URL = "http://127.0.0.1:8787";
+var DEFAULT_API_BASE_URL = TESTNET_API_BASE_URL;
+var LOCAL_API_BASE_URL = MAINNET_API_BASE_URL;
 var DEFAULT_TIMEOUT_MS = 3e4;
-var SDK_VERSION = "0.1.2";
+var SDK_VERSION = "0.1.7";
 var SDK_NAME = "@buildaureon/sdk";
 var PRODUCT_NAME = "AUREON";
 var PRODUCT_TAGLINE = "Financial Compass for Robinhood Chain";
@@ -45,7 +115,8 @@ var ENDPOINTS = {
   authDevLogin: "/auth/dev-login",
   authMe: "/auth/me",
   developerApiKeys: "/developer/api-keys",
-  registryStatus: "/registry/status"
+  registryStatus: "/registry/status",
+  settlements: "/settlements"
 };
 function objectivePath(id) {
   return `${ENDPOINTS.objectives}/${encodeURIComponent(id)}`;
@@ -74,6 +145,12 @@ function registryPreparePath(id) {
 function registryConfirmPath(id) {
   return `${registryObjectivePath(id)}/confirm`;
 }
+function executionSettlementPath(id) {
+  return `/executions/${encodeURIComponent(id)}/settlement`;
+}
+function executionConfirmSettlementPath(id) {
+  return `/executions/${encodeURIComponent(id)}/confirm-settlement`;
+}
 
 // src/errors/codes.ts
 var RETRYABLE_CODES = [
@@ -168,22 +245,1110 @@ var AureonTimeoutError = class extends AureonError {
   }
 };
 
-// src/errors/http.ts
+// src/formatting/allocation.ts
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["active", "validated"]);
+function isOffPlan(state) {
+  return state === "warning" || state === "violation";
+}
+function buildAllocationComparison(objectives, health) {
+  const healthById = new Map(health.map((h) => [h.objectiveId, h]));
+  return objectives.filter((o) => ACTIVE_STATUSES.has(o.status)).map((objective) => {
+    const record = healthById.get(objective.id);
+    const targetWeight = objective.policy?.targetWeight ?? record?.targetMetric ?? 0;
+    const currentMetric = record?.currentMetric ?? 0;
+    return {
+      objectiveId: objective.id,
+      name: objective.name,
+      kind: objective.kind,
+      targetSymbol: objective.policy?.targetSymbol,
+      targetWeight,
+      currentMetric,
+      deviation: record?.deviation ?? currentMetric - targetWeight,
+      state: record?.state ?? "paused"
+    };
+  });
+}
+function detectPlanParadox(overview, health) {
+  const offPlan = health.filter((h) => isOffPlan(h.state));
+  const offPlanCount = offPlan.length;
+  const bookUp = overview.change24hPct != null && !overview.change24hBaselineOnly ? overview.change24hPct >= 0 : overview.attentionCount > 0 && overview.totalNotionalUsd > 0;
+  const detected = bookUp && offPlanCount > 0;
+  let message = "Portfolio and objectives are aligned.";
+  if (detected) {
+    const pct = overview.change24hPct != null && !overview.change24hBaselineOnly ? `${(overview.change24hPct * 100).toFixed(1)}%` : "recent activity";
+    message = `Book is up (${pct}), but ${offPlanCount} objective${offPlanCount === 1 ? "" : "s"} are off-plan.`;
+  } else if (offPlanCount > 0) {
+    message = `${offPlanCount} objective${offPlanCount === 1 ? "" : "s"} need attention.`;
+  }
+  return { detected, bookUp, offPlanCount, message };
+}
+
+// src/types/objective.ts
+var OBJECTIVE_KINDS = [
+  "stable_allocation",
+  "balanced_portfolio",
+  "risk_ceiling",
+  "reward_reinvestment"
+];
+var OBJECTIVE_PRIORITIES = [
+  "low",
+  "medium",
+  "high",
+  "critical"
+];
+function isObjectiveKind(value) {
+  return OBJECTIVE_KINDS.includes(value);
+}
+function isObjectivePriority(value) {
+  return OBJECTIVE_PRIORITIES.includes(value);
+}
+
+// src/validation/objective-input.ts
+function buildPolicySummary(kind, targetWeight, tolerance) {
+  const targetPct = (targetWeight * 100).toFixed(1);
+  const tolPct = (tolerance * 100).toFixed(1);
+  switch (kind) {
+    case "stable_allocation":
+      return `Maintain ${targetPct}% stable allocation within \xB1${tolPct}%`;
+    case "balanced_portfolio":
+      return `Hold balanced weights near ${targetPct}% primary sleeve within \xB1${tolPct}%`;
+    case "risk_ceiling":
+      return `Keep portfolio risk at or below configured ceiling with ${tolPct}% buffer`;
+    case "reward_reinvestment":
+      return `Reinvest available rewards toward ${targetPct}% target sleeve`;
+    default:
+      return `Objective policy target ${targetPct}% \xB1${tolPct}%`;
+  }
+}
+function normalizeCreateObjectiveInput(input) {
+  const name = input.name?.trim();
+  if (!name || name.length < 3) {
+    throw new AureonValidationError("Objective name must be at least 3 characters");
+  }
+  if (!isObjectiveKind(input.kind)) {
+    throw new AureonValidationError(`Unsupported objective kind: ${input.kind}`);
+  }
+  if (input.targetWeight < 0 || input.targetWeight > 1) {
+    throw new AureonValidationError("targetWeight must be between 0 and 1");
+  }
+  if (input.tolerance < 0 || input.tolerance > 0.5) {
+    throw new AureonValidationError("tolerance must be between 0 and 0.5");
+  }
+  const priority = input.priority ?? "high";
+  if (!isObjectivePriority(priority)) {
+    throw new AureonValidationError(`Unsupported priority: ${priority}`);
+  }
+  if (input.kind === "balanced_portfolio") {
+    const symbol = input.targetSymbol?.trim().toUpperCase();
+    if (!symbol) {
+      throw new AureonValidationError(
+        "balanced_portfolio requires targetSymbol"
+      );
+    }
+    return {
+      ...input,
+      name,
+      priority,
+      targetSymbol: symbol,
+      // SDK / agent path defaults to Automatic. Explicit "manual" is reserved
+      // for the operator utility Approve UX; not recommended for integrations.
+      automationMode: input.automationMode === "manual" ? "manual" : "auto"
+    };
+  }
+  return {
+    ...input,
+    name,
+    priority,
+    targetSymbol: null,
+    automationMode: input.automationMode === "manual" ? "manual" : "auto"
+  };
+}
+function normalizeUpdateObjectiveInput(input) {
+  const next = { ...input };
+  if (next.name !== void 0) {
+    const name = next.name.trim();
+    if (name.length < 3) {
+      throw new AureonValidationError("Objective name must be at least 3 characters");
+    }
+    next.name = name;
+  }
+  if (next.targetWeight !== void 0) {
+    if (next.targetWeight < 0 || next.targetWeight > 1) {
+      throw new AureonValidationError("targetWeight must be between 0 and 1");
+    }
+  }
+  if (next.tolerance !== void 0) {
+    if (next.tolerance < 0 || next.tolerance > 0.5) {
+      throw new AureonValidationError("tolerance must be between 0 and 0.5");
+    }
+  }
+  if (next.priority !== void 0 && !isObjectivePriority(next.priority)) {
+    throw new AureonValidationError(`Unsupported priority: ${next.priority}`);
+  }
+  if (next.automationMode !== void 0) {
+    throw new AureonValidationError(
+      "automationMode cannot be changed after create: recreate the objective instead"
+    );
+  }
+  if (input.targetSymbol !== void 0) {
+    throw new AureonValidationError(
+      "targetSymbol cannot be changed after create: recreate the objective instead"
+    );
+  }
+  return next;
+}
+function assertId(value, label) {
+  if (!value || typeof value !== "string" || value.trim().length < 8) {
+    throw new AureonValidationError(`Invalid ${label}`);
+  }
+}
+
+// src/formatting/drift-restore.ts
+function isOffPlan2(state) {
+  return state === "warning" || state === "violation";
+}
+function inferDriftPhase(health) {
+  if (health.state === "healthy") return "aligned";
+  if (isOffPlan2(health.state)) return "drift_detected";
+  return "aligned";
+}
+function buildDriftRestoreFlow(input) {
+  const targetWeight = input.objective.policy?.targetWeight ?? input.alignedHealth.targetMetric ?? 0;
+  const tolerance = input.objective.policy?.tolerance ?? 0.02;
+  const summary = input.objective.policy?.summary ?? buildPolicySummary(input.objective.kind, targetWeight, tolerance);
+  const restored = input.restoredHealth ? {
+    health: input.restoredHealth,
+    receipt: input.receipt,
+    settlement: input.receipt?.settlement
+  } : void 0;
+  const currentPhase = restored ? restored.health.state === "healthy" || !isOffPlan2(restored.health.state) ? "restored" : "drift_detected" : inferDriftPhase(input.driftHealth);
+  let message = "Rule set and portfolio aligned. Ready to detect drift when marks move.";
+  if (currentPhase === "drift_detected") {
+    message = "We broke the rule on purpose. AUREON detected drift \u2014 allocation moved off policy.";
+  } else if (currentPhase === "restored") {
+    const settlement = input.receipt?.settlement ?? "staged";
+    message = `Drift detected and restore completed (${settlement} settlement). Policy is back within tolerance.`;
+  }
+  return {
+    objectiveId: input.objective.id,
+    rule: { summary, targetWeight, tolerance },
+    phases: {
+      aligned: {
+        health: input.alignedHealth,
+        allocationRow: input.alignedRow
+      },
+      drift: {
+        health: input.driftHealth,
+        allocationRow: input.driftRow,
+        restorePlan: input.driftPlan
+      },
+      restored
+    },
+    currentPhase,
+    message
+  };
+}
+function buildDriftRestoreFlowFromSnapshot(input) {
+  const targetWeight = input.objective.policy?.targetWeight ?? input.health.targetMetric ?? 0;
+  const offPlan = isOffPlan2(input.health.state);
+  const hasRestore = input.latestReceipt && input.latestReceipt.objectiveId === input.objective.id;
+  if (!offPlan && !hasRestore) {
+    return buildDriftRestoreFlow({
+      objective: input.objective,
+      alignedHealth: input.health,
+      driftHealth: input.health,
+      alignedRow: input.allocationRow,
+      driftRow: input.allocationRow
+    });
+  }
+  if (offPlan) {
+    return buildDriftRestoreFlow({
+      objective: input.objective,
+      alignedHealth: {
+        ...input.health,
+        state: "healthy",
+        currentMetric: targetWeight,
+        deviation: 0,
+        message: "On track \u2014 still inside your target range."
+      },
+      driftHealth: input.health,
+      driftPlan: input.restorePlan,
+      alignedRow: input.allocationRow,
+      driftRow: input.allocationRow
+    });
+  }
+  return buildDriftRestoreFlow({
+    objective: input.objective,
+    alignedHealth: {
+      ...input.health,
+      state: "healthy",
+      currentMetric: targetWeight,
+      deviation: 0,
+      message: "On track \u2014 still inside your target range."
+    },
+    driftHealth: {
+      ...input.health,
+      state: "warning",
+      message: "Prior drift detected."
+    },
+    restoredHealth: input.health,
+    receipt: input.latestReceipt,
+    alignedRow: input.allocationRow,
+    driftRow: input.allocationRow
+  });
+}
+
+// src/types/execution.ts
+function shortTransactionHash(hash, head = 10, tail = 6) {
+  if (hash.length <= head + tail + 1) return hash;
+  return `${hash.slice(0, head)}\u2026${hash.slice(-tail)}`;
+}
+function sortExecutionsNewestFirst(receipts) {
+  return [...receipts].sort((a, b) => a.createdAt < b.createdAt ? 1 : -1);
+}
+function isVaultSettlement(receipt) {
+  return receipt.settlement === "vault";
+}
+function isChainVerifiedReceipt(receipt) {
+  return receipt.verifiedOnChain === true;
+}
+function formatReceiptSummary(receipt) {
+  const settlementLabel = receipt.verifiedOnChain ? "vault settlement (chain-verified)" : receipt.settlement === "vault" ? "vault settlement (unverified on-chain)" : "staged settlement (capital book)";
+  const parts = [receipt.action, settlementLabel, receipt.status];
+  if (receipt.explorerUrl) parts.push(receipt.explorerUrl);
+  if (receipt.registryRef) {
+    parts.push(
+      `registry ${shortTransactionHash(receipt.registryRef.objectiveKey, 8, 4)}`
+    );
+  }
+  return parts.join(" \xB7 ");
+}
+function findTimelineEventsForReceipt(events, receipt) {
+  return events.filter((event) => {
+    if (event.type !== "execution_started" && event.type !== "execution_completed") {
+      return false;
+    }
+    const executionId = event.payload?.executionId;
+    return typeof executionId === "string" && executionId === receipt.id;
+  });
+}
+
+// src/validation/receipt-validator.ts
+var EXECUTION_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "submitted",
+  "confirmed",
+  "failed"
+]);
+var SETTLEMENTS = /* @__PURE__ */ new Set(["vault", "staged"]);
+var TX_HASH_0X = /^0x[a-fA-F0-9]{64}$/;
+var ADDRESS_0X = /^0x[a-fA-F0-9]{40}$/;
+var BYTES32_0X = /^0x[a-fA-F0-9]{64}$/;
+var ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T/;
+function issue(code, message, path) {
+  return path ? { code, message, path } : { code, message };
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isVaultTransactionHash(hash) {
+  return hash.startsWith("pending_vault_") || TX_HASH_0X.test(hash);
+}
+function isRealVaultTxHash(hash) {
+  return TX_HASH_0X.test(hash);
+}
+function isStagedTransactionHash(hash) {
+  return !isVaultTransactionHash(hash);
+}
+function validateSettlementRecord(input, options = {}) {
+  const issues = [];
+  if (!isRecord(input)) {
+    return {
+      valid: false,
+      issues: [issue("INVALID_INPUT", "Settlement record must be an object")]
+    };
+  }
+  const requiredStrings = [
+    ["id", "id"],
+    ["walletAddress", "walletAddress"],
+    ["transactionHash", "transactionHash"],
+    ["vaultAddress", "vaultAddress"],
+    ["tokenSell", "tokenSell"],
+    ["tokenBuy", "tokenBuy"],
+    ["amountIn", "amountIn"],
+    ["amountOut", "amountOut"],
+    ["explorerUrl", "explorerUrl"],
+    ["verifiedAt", "verifiedAt"],
+    ["status", "status"]
+  ];
+  for (const [key, path] of requiredStrings) {
+    if (!isNonEmptyString(input[key])) {
+      issues.push(issue("MISSING_FIELD", `Missing ${key}`, path));
+    }
+  }
+  if (input.settlement !== "vault") {
+    issues.push(
+      issue(
+        "INVALID_SETTLEMENT_RECORD",
+        'settlement must be "vault" on chain records',
+        "settlement"
+      )
+    );
+  }
+  if (typeof input.blockNumber !== "number" || !Number.isFinite(input.blockNumber) || input.blockNumber < 0) {
+    issues.push(
+      issue("INVALID_SETTLEMENT_RECORD", "blockNumber must be a non-negative number", "blockNumber")
+    );
+  }
+  if (typeof input.logIndex !== "number" || !Number.isInteger(input.logIndex) || input.logIndex < 0) {
+    issues.push(
+      issue("INVALID_SETTLEMENT_RECORD", "logIndex must be a non-negative integer", "logIndex")
+    );
+  }
+  const tx = String(input.transactionHash ?? "");
+  if (tx && !TX_HASH_0X.test(tx)) {
+    issues.push(
+      issue("INVALID_SETTLEMENT_RECORD", "transactionHash must be a 32-byte hex hash", "transactionHash")
+    );
+  }
+  if (input.status !== "confirmed" && input.status !== "orphan") {
+    issues.push(
+      issue(
+        "INVALID_SETTLEMENT_RECORD",
+        'status must be "confirmed" or "orphan"',
+        "status"
+      )
+    );
+  }
+  if (options.executionId && input.executionId != null && input.executionId !== options.executionId) {
+    issues.push(
+      issue(
+        "VERIFIED_RECORD_MISMATCH",
+        "settlementRecord.executionId must match receipt.id",
+        "executionId"
+      )
+    );
+  }
+  if (isRecord(input.registryRef)) {
+    const refIssues = validateRegistryRef(input.registryRef, "registryRef");
+    issues.push(...refIssues);
+  }
+  return { valid: issues.length === 0, issues };
+}
+function validateRegistryRef(ref, basePath) {
+  const issues = [];
+  const objectiveKey = ref.objectiveKey;
+  const contractAddress = ref.contractAddress;
+  if (!isNonEmptyString(objectiveKey) || !BYTES32_0X.test(objectiveKey)) {
+    issues.push(
+      issue(
+        "INVALID_REGISTRY_REF",
+        "objectiveKey must be a 32-byte hex string",
+        `${basePath}.objectiveKey`
+      )
+    );
+  }
+  if (!isNonEmptyString(contractAddress) || !ADDRESS_0X.test(contractAddress)) {
+    issues.push(
+      issue(
+        "INVALID_REGISTRY_REF",
+        "contractAddress must be a 20-byte hex address",
+        `${basePath}.contractAddress`
+      )
+    );
+  }
+  return issues;
+}
+function validateExecutionReceipt(input) {
+  const issues = [];
+  if (!isRecord(input)) {
+    return {
+      valid: false,
+      issues: [issue("INVALID_INPUT", "Receipt must be an object")]
+    };
+  }
+  const required = [
+    ["id", "id"],
+    ["objectiveId", "objectiveId"],
+    ["action", "action"],
+    ["status", "status"],
+    ["transactionHash", "transactionHash"],
+    ["result", "result"],
+    ["createdAt", "createdAt"],
+    ["settlement", "settlement"]
+  ];
+  for (const [key, path] of required) {
+    if (!isNonEmptyString(input[key])) {
+      issues.push(issue("MISSING_FIELD", `Missing ${key}`, path));
+    }
+  }
+  const settlement = input.settlement;
+  if (settlement != null && !SETTLEMENTS.has(String(settlement))) {
+    issues.push(
+      issue(
+        "INVALID_SETTLEMENT",
+        'settlement must be "vault" or "staged"',
+        "settlement"
+      )
+    );
+  }
+  const status = input.status;
+  if (status != null && !EXECUTION_STATUSES.has(String(status))) {
+    issues.push(
+      issue(
+        "INVALID_STATUS",
+        "status must be pending, submitted, confirmed, or failed",
+        "status"
+      )
+    );
+  }
+  if (status === "confirmed" && !isNonEmptyString(input.confirmedAt)) {
+    issues.push(
+      issue("MISSING_CONFIRMED_AT", "confirmed status requires confirmedAt", "confirmedAt")
+    );
+  }
+  if (isNonEmptyString(input.createdAt) && !ISO_TIMESTAMP.test(input.createdAt)) {
+    issues.push(
+      issue("MISSING_FIELD", "createdAt must be an ISO-8601 timestamp", "createdAt")
+    );
+  }
+  const txHash = String(input.transactionHash ?? "");
+  const settlementStr = String(settlement ?? "");
+  if (settlementStr === "staged") {
+    if (input.explorerUrl != null && input.explorerUrl !== "") {
+      issues.push(
+        issue(
+          "STAGED_WITH_EXPLORER",
+          "staged receipts must not include explorerUrl",
+          "explorerUrl"
+        )
+      );
+    }
+    if (input.verifiedOnChain === true) {
+      issues.push(
+        issue(
+          "STAGED_VERIFIED_ON_CHAIN",
+          "staged receipts cannot be verifiedOnChain",
+          "verifiedOnChain"
+        )
+      );
+    }
+    if (input.settlementRecord != null) {
+      issues.push(
+        issue(
+          "STAGED_WITH_SETTLEMENT_RECORD",
+          "staged receipts must not include settlementRecord",
+          "settlementRecord"
+        )
+      );
+    }
+    if (txHash && !isStagedTransactionHash(txHash)) {
+      issues.push(
+        issue(
+          "INVALID_VAULT_HASH",
+          "staged settlement must not use a vault transaction hash",
+          "transactionHash"
+        )
+      );
+    }
+  }
+  if (settlementStr === "vault") {
+    if (txHash && !isVaultTransactionHash(txHash)) {
+      issues.push(
+        issue(
+          "INVALID_VAULT_HASH",
+          "vault settlement requires 0x\u2026 hash or pending_vault_* prefix",
+          "transactionHash"
+        )
+      );
+    }
+    if (isRealVaultTxHash(txHash)) {
+      if (input.explorerUrl == null || input.explorerUrl === "") {
+        issues.push(
+          issue(
+            "VAULT_MISSING_EXPLORER",
+            "confirmed vault tx must include explorerUrl",
+            "explorerUrl"
+          )
+        );
+      }
+    }
+  }
+  if (input.verifiedOnChain === true) {
+    if (settlementStr !== "vault") {
+      issues.push(
+        issue(
+          "VERIFIED_WITHOUT_RECORD",
+          "verifiedOnChain requires vault settlement",
+          "verifiedOnChain"
+        )
+      );
+    }
+    if (input.settlementRecord == null) {
+      issues.push(
+        issue(
+          "VERIFIED_WITHOUT_RECORD",
+          "verifiedOnChain requires settlementRecord",
+          "verifiedOnChain"
+        )
+      );
+    } else {
+      const nested = validateSettlementRecord(input.settlementRecord, {
+        executionId: isNonEmptyString(input.id) ? input.id : void 0
+      });
+      for (const nestedIssue of nested.issues) {
+        issues.push({
+          ...nestedIssue,
+          path: nestedIssue.path ? `settlementRecord.${nestedIssue.path}` : "settlementRecord"
+        });
+      }
+    }
+  } else if (input.settlementRecord != null && input.verifiedOnChain !== false) {
+    if (input.verifiedOnChain !== true) {
+      issues.push(
+        issue(
+          "VERIFIED_RECORD_MISMATCH",
+          "settlementRecord present but verifiedOnChain is not true",
+          "verifiedOnChain"
+        )
+      );
+    }
+  }
+  if (isRecord(input.registryRef)) {
+    issues.push(...validateRegistryRef(input.registryRef, "registryRef"));
+  }
+  return { valid: issues.length === 0, issues };
+}
+function isValidExecutionReceipt(input) {
+  return validateExecutionReceipt(input).valid;
+}
+function assertValidExecutionReceipt(receipt) {
+  const result = validateExecutionReceipt(receipt);
+  if (!result.valid) {
+    throw new AureonValidationError("Invalid execution receipt", {
+      issues: result.issues
+    });
+  }
+}
+
+// src/formatting/receipt-verification.ts
+function inferProofTier(receipt, validation, settlement) {
+  if (!validation.valid) return "claim_only";
+  if (settlement?.verifiedOnChain === true || isChainVerifiedReceipt(receipt) || receipt.verifiedOnChain === true) {
+    return "chain_verified";
+  }
+  return "schema_valid";
+}
+function inferCurrentPhase(validation, proofTier) {
+  if (!validation.valid) return "validation_failed";
+  if (proofTier === "chain_verified") return "chain_verified";
+  return "validated";
+}
+function buildReceiptVerificationFlow(input) {
+  const validation = input.validation ?? validateExecutionReceipt(input.receipt);
+  const proofTier = inferProofTier(
+    input.receipt,
+    validation,
+    input.settlement
+  );
+  const currentPhase = inferCurrentPhase(validation, proofTier);
+  let message = "An AI saying 'transaction successful' is only a claim \u2014 validate the receipt before trusting it.";
+  if (currentPhase === "validation_failed") {
+    message = "Receipt failed validation \u2014 do not summarize as proof. Fix honesty issues before reporting success.";
+  } else if (currentPhase === "chain_verified") {
+    message = "Receipt passes validation and has independent on-chain settlement proof.";
+  } else if (proofTier === "schema_valid") {
+    const label = input.receipt.settlement === "staged" ? "staged (capital book)" : "vault (not yet chain-observed)";
+    message = `Receipt passes validation (${label}). Schema-valid does not mean chain-verified \u2014 check settlement lookup for vault proof.`;
+  }
+  return {
+    executionId: input.receipt.id,
+    receipt: input.receipt,
+    phases: {
+      claimed: {
+        summary: formatReceiptSummary(input.receipt),
+        status: input.receipt.status,
+        settlement: input.receipt.settlement,
+        result: input.receipt.result
+      },
+      validation,
+      settlement: input.settlement,
+      timelineEvents: input.timelineEvents
+    },
+    proofTier,
+    currentPhase,
+    message
+  };
+}
+
+// src/formatting/portfolio-watch.ts
+var DEFAULT_PORTFOLIO_WATCH_BRIEF = "Watch my portfolio while I'm away \u2014 keep about 20% in stable assets.";
+function isOffPlan3(state) {
+  return state === "warning" || state === "violation";
+}
+function inferPortfolioWatchPhase(input) {
+  if (input.whileAway) return "return_briefing";
+  if (isOffPlan3(input.registerHealth.state)) return "while_away";
+  return "watch_registered";
+}
+function buildPortfolioWatchBriefingLines(input) {
+  const hostLabel = input.host === "cursor" ? "Cursor" : input.host === "claude" ? "Claude" : "MCP agent";
+  const lines = [
+    `You asked ${hostLabel} to watch your portfolio while away.`,
+    `Policy registered: ${input.objective.name} (${input.objective.automationMode ?? "auto"} mode).`
+  ];
+  if (input.whileAway) {
+    lines.push(
+      `While away: ${input.whileAway.symbol} moved ${(input.whileAway.priceChangeRatio * 100).toFixed(0)}% \u2014 health went from ${input.whileAway.healthBefore.state} to ${input.whileAway.healthAfter.state}.`
+    );
+    if (input.whileAway.autoRestored && input.whileAway.receipt) {
+      lines.push(
+        `Automatic restore ran \u2014 settlement ${input.whileAway.receipt.settlement}. Receipt id ${input.whileAway.receipt.id}.`
+      );
+    } else if (input.whileAway.autoRestored) {
+      lines.push("Automatic restore ran \u2014 check executions for receipt.");
+    } else {
+      lines.push("No automatic restore fired \u2014 review health and restore plan.");
+    }
+  } else if (isOffPlan3(input.briefingHealth.state)) {
+    lines.push(
+      `Portfolio is off-plan (${input.briefingHealth.state}) \u2014 agent should surface restore options.`
+    );
+  } else {
+    lines.push("Portfolio remains within policy \u2014 no action required.");
+  }
+  if (input.timelineEvents.length > 0) {
+    const types = [...new Set(input.timelineEvents.map((e) => e.type))].slice(
+      0,
+      4
+    );
+    lines.push(`Timeline: ${input.timelineEvents.length} recent event(s) \u2014 ${types.join(", ")}.`);
+  }
+  lines.push(`Current health: ${input.briefingHealth.state}.`);
+  return lines;
+}
+function buildPortfolioWatchFlow(input) {
+  const targetWeight = input.objective.policy?.targetWeight ?? input.registerHealth.targetMetric ?? 0;
+  const tolerance = input.objective.policy?.tolerance ?? 0.02;
+  const policySummary = input.objective.policy?.summary ?? buildPolicySummary(input.objective.kind, targetWeight, tolerance);
+  const whileAway = input.whileAway ? {
+    marketEventName: input.whileAway.marketEvent.name,
+    symbol: input.whileAway.marketEvent.symbol,
+    priceChangeRatio: input.whileAway.marketEvent.priceChangeRatio,
+    healthBefore: input.whileAway.healthBefore,
+    healthAfter: input.whileAway.healthAfter,
+    autoRestored: input.whileAway.autoRestored,
+    receipt: input.whileAway.receipt
+  } : void 0;
+  const summaryLines = buildPortfolioWatchBriefingLines({
+    userBrief: input.userBrief,
+    host: input.host,
+    objective: input.objective,
+    registerHealth: input.registerHealth,
+    briefingHealth: input.briefingHealth,
+    whileAway,
+    timelineEvents: input.timelineEvents
+  });
+  const currentPhase = inferPortfolioWatchPhase({
+    registerHealth: input.registerHealth,
+    whileAway
+  });
+  let message = "Tell your agent to watch the portfolio \u2014 intent becomes an Automatic objective, then read health and timeline when you return.";
+  if (currentPhase === "return_briefing" && whileAway?.autoRestored) {
+    message = "While you were away, the market moved and Automatic mode restored policy. Review the briefing \u2014 not a blank check, a registered rule.";
+  } else if (currentPhase === "while_away" || isOffPlan3(input.briefingHealth.state)) {
+    message = "Portfolio drifted off-plan. The agent should report health and restore options \u2014 not discretionary trades.";
+  }
+  return {
+    objectiveId: input.objective.id,
+    userBrief: input.userBrief,
+    host: input.host,
+    phases: {
+      register: {
+        objectiveName: input.objective.name,
+        automationMode: input.objective.automationMode ?? "auto",
+        policySummary,
+        health: input.registerHealth,
+        allocationRow: input.registerRow
+      },
+      whileAway,
+      briefing: {
+        health: input.briefingHealth,
+        timelineEventCount: input.timelineEvents.length,
+        timelineEvents: input.timelineEvents,
+        summaryLines
+      }
+    },
+    currentPhase,
+    message
+  };
+}
+function buildPortfolioWatchFlowFromSnapshot(input) {
+  return buildPortfolioWatchFlow({
+    userBrief: input.userBrief,
+    host: input.host,
+    objective: input.objective,
+    registerHealth: input.health,
+    registerRow: input.allocationRow,
+    briefingHealth: input.health,
+    timelineEvents: input.timelineEvents
+  });
+}
+
+// src/formatting/full-aureon-loop.ts
+var DEFAULT_FULL_LOOP_BRIEF = "Keep about 20% in stable assets \u2014 grow the book without abandoning the plan.";
+function inferFullAureonLoopPhase(input) {
+  if (input.hasRestore && input.verificationValid) return "verified";
+  if (input.hasRestore) return "restored";
+  return "plan_check";
+}
+function buildFullAureonLoopFlow(input) {
+  const targetWeight = input.objective.policy?.targetWeight ?? input.baselineHealth.targetMetric ?? 0;
+  const tolerance = input.objective.policy?.tolerance ?? 0.02;
+  const policySummary = input.objective.policy?.summary ?? buildPolicySummary(input.objective.kind, targetWeight, tolerance);
+  const verification = input.verification ?? buildReceiptVerificationFlow({ receipt: input.receipt });
+  const currentPhase = inferFullAureonLoopPhase({
+    hasRestore: true,
+    verificationValid: verification.phases.validation.valid
+  });
+  let message = "We're not building another portfolio tracker. AUREON registers intent, checks the plan, restores when off-plan, and verifies the receipt.";
+  if (!verification.phases.validation.valid) {
+    message = "Loop completed restore, but the receipt failed validation \u2014 do not treat success text as proof.";
+  } else if (verification.proofTier === "chain_verified") {
+    message = "Full loop complete: intent \u2192 plan check \u2192 restore \u2192 chain-verified receipt. Not a tracker \u2014 a Financial Compass.";
+  } else {
+    message = "Full loop complete: intent \u2192 plan check \u2192 restore \u2192 schema-valid receipt. We're not building another portfolio tracker.";
+  }
+  return {
+    objectiveId: input.objective.id,
+    userBrief: input.userBrief,
+    phases: {
+      intent: {
+        objectiveName: input.objective.name,
+        policySummary,
+        automationMode: input.objective.automationMode ?? "auto",
+        health: input.baselineHealth
+      },
+      planCheck: {
+        baselineAligned: input.baselineHealth.state === "healthy",
+        afterShock: {
+          health: input.afterShockHealth,
+          allocationRow: input.afterShockRow,
+          paradox: input.paradox
+        }
+      },
+      driftRestore: {
+        healthBefore: input.afterShockHealth,
+        healthAfter: input.restoredHealth,
+        receipt: input.receipt,
+        settlement: input.receipt.settlement
+      },
+      verification
+    },
+    currentPhase,
+    message
+  };
+}
+function buildFullAureonLoopFlowFromSnapshot(input) {
+  if (!input.latestReceipt) return null;
+  const verification = input.verification ?? buildReceiptVerificationFlow({ receipt: input.latestReceipt });
+  return buildFullAureonLoopFlow({
+    userBrief: input.userBrief,
+    objective: input.objective,
+    baselineHealth: input.health,
+    afterShockHealth: input.health,
+    afterShockRow: input.allocationRow,
+    paradox: input.paradox,
+    restoredHealth: input.health,
+    receipt: input.latestReceipt,
+    verification
+  });
+}
+
+// src/formatting/audit-trail.ts
+function buildFinancialAuditTrail(input) {
+  const targetWeight = input.objective.policy?.targetWeight ?? 0;
+  const tolerance = input.objective.policy?.tolerance ?? 0.02;
+  const policySummary = input.objective.policy?.summary ?? buildPolicySummary(input.objective.kind, targetWeight, tolerance);
+  const registered = input.registry?.registered === true ? input.registry.record : void 0;
+  const receipts = input.receipts.map((receipt) => {
+    const validation = validateExecutionReceipt(receipt);
+    return {
+      id: receipt.id,
+      action: receipt.action,
+      settlement: receipt.settlement,
+      status: receipt.status,
+      valid: validation.valid,
+      verifiedOnChain: receipt.verifiedOnChain === true,
+      explorerUrl: receipt.explorerUrl ?? null,
+      summary: formatReceiptSummary(receipt),
+      validation
+    };
+  });
+  const timeline = input.timeline.map((event) => ({
+    id: event.id,
+    type: event.type,
+    message: event.message,
+    createdAt: event.createdAt,
+    executionId: typeof event.payload?.executionId === "string" ? event.payload.executionId : null
+  }));
+  const gaps = [];
+  if (input.registryLookupFailed || input.settlementsLookupFailed) {
+    const parts = [
+      input.registryLookupFailed ? "Registry lookup failed." : null,
+      input.settlementsLookupFailed ? "Settlement lookup failed." : null
+    ].filter((part) => Boolean(part));
+    gaps.push({
+      code: "lookup_failed",
+      message: `${parts.join(" ")} Do not treat this as a confirmed gap.`
+    });
+  }
+  if (!registered && !input.registryLookupFailed) {
+    gaps.push({
+      code: "not_registered",
+      message: "Objective is not registered on ObjectiveRegistry."
+    });
+  }
+  if (receipts.length === 0) {
+    gaps.push({
+      code: "no_executions",
+      message: "No execution receipts for this objective."
+    });
+  } else {
+    if (receipts.every((row) => row.settlement === "staged")) {
+      gaps.push({
+        code: "staged_only",
+        message: "Every receipt is staged. None are on-chain."
+      });
+    }
+    if (receipts.some((row) => row.settlement === "vault" && !row.verifiedOnChain)) {
+      gaps.push({
+        code: "vault_unverified",
+        message: "At least one vault receipt has no independent settlement record yet."
+      });
+    }
+    if (receipts.some((row) => !row.valid)) {
+      gaps.push({
+        code: "invalid_receipt",
+        message: "At least one receipt failed local validation. Do not trust it."
+      });
+    }
+  }
+  const everyReceiptStaged = receipts.length > 0 && receipts.every((row) => row.settlement === "staged");
+  if (input.settlements.length === 0 && !input.settlementsLookupFailed && !everyReceiptStaged) {
+    gaps.push({
+      code: "no_settlements",
+      message: "No chain settlement records linked to this objective."
+    });
+  }
+  if (timeline.length === 0) {
+    gaps.push({
+      code: "no_timeline",
+      message: "No timeline events for this objective."
+    });
+  }
+  return {
+    objectiveId: input.objective.id,
+    objectiveName: input.objective.name,
+    policySummary,
+    healthState: input.health?.state ?? null,
+    generatedAt: input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    registry: registered ? { present: true, record: registered } : { present: false },
+    receipts,
+    settlements: input.settlements,
+    timeline,
+    gaps,
+    message: auditTrailMessage({
+      registered: Boolean(registered),
+      receiptCount: receipts.length,
+      settlementCount: input.settlements.length,
+      invalid: receipts.some((row) => !row.valid),
+      chainVerified: receipts.some((row) => row.verifiedOnChain)
+    })
+  };
+}
+function formatAuditTrailLines(trail) {
+  const lines = [
+    `Objective  ${trail.objectiveName} (${trail.objectiveId})`,
+    `Policy     ${trail.policySummary}`,
+    `Health     ${trail.healthState ?? "unknown"}`,
+    `Registry   ${trail.registry.present ? "registered on-chain" : "not registered"}`,
+    `Receipts   ${trail.receipts.length}`,
+    `Settlements ${trail.settlements.length}`,
+    `Timeline   ${trail.timeline.length}`
+  ];
+  if (trail.gaps.length > 0) {
+    lines.push("Gaps");
+    for (const gap of trail.gaps) {
+      lines.push(`  - ${gap.message}`);
+    }
+  }
+  lines.push(trail.message);
+  return lines;
+}
+function auditTrailMessage(input) {
+  if (input.invalid) {
+    return "Audit trail assembled with dishonest or incomplete receipts. Do not treat success text as proof.";
+  }
+  if (input.receiptCount === 0) {
+    return "Audit trail shows the objective only. No restore has been recorded yet.";
+  }
+  if (input.chainVerified && input.registered) {
+    return "Audit trail complete on testnet: registered objective, receipts, and chain settlement. Not mainnet.";
+  }
+  if (input.chainVerified) {
+    return "Receipts include chain settlement proof. Objective is not registered on-chain.";
+  }
+  if (input.settlementCount === 0) {
+    return "Audit trail shows receipts without chain settlement records. Staged or unverified vault \u2014 not independent proof.";
+  }
+  return "Audit trail assembled from what exists. Gaps are labeled. Nothing missing was invented.";
+}
+
+// src/formatting/intent.ts
+var DEFAULT_TOLERANCE = 0.02;
+function defaultName(intent) {
+  if (intent.name?.trim()) return intent.name.trim();
+  const pct = (intent.targetWeight * 100).toFixed(0);
+  switch (intent.kind) {
+    case "stable_allocation":
+      return `Maintain ${pct}% Stable Assets`;
+    case "balanced_portfolio":
+      return `Maintain ${pct}% ${intent.targetSymbol ?? "Sleeve"}`;
+    case "risk_ceiling":
+      return `Risk ceiling policy`;
+    case "reward_reinvestment":
+      return `Reinvest rewards toward ${pct}%`;
+    default:
+      return intent.brief.slice(0, 64);
+  }
+}
+function resolveObjectiveFromIntent(intent) {
+  const brief = intent.brief?.trim();
+  if (!brief || brief.length < 3) {
+    throw new AureonValidationError("Intent brief must be at least 3 characters");
+  }
+  if (intent.targetWeight < 0 || intent.targetWeight > 1) {
+    throw new AureonValidationError("targetWeight must be between 0 and 1");
+  }
+  const tolerance = intent.tolerance ?? DEFAULT_TOLERANCE;
+  if (tolerance < 0 || tolerance > 0.5) {
+    throw new AureonValidationError("tolerance must be between 0 and 0.5");
+  }
+  const base = {
+    name: defaultName(intent),
+    kind: intent.kind,
+    targetWeight: intent.targetWeight,
+    tolerance,
+    priority: intent.priority ?? "high",
+    automationMode: "auto"
+  };
+  if (intent.kind === "balanced_portfolio") {
+    const symbol = intent.targetSymbol?.trim().toUpperCase();
+    if (!symbol) {
+      throw new AureonValidationError(
+        "balanced_portfolio intent requires targetSymbol"
+      );
+    }
+    return { ...base, targetSymbol: symbol };
+  }
+  return base;
+}
+function buildObjectivePortfolioFlow(intent, objective, health, portfolio) {
+  const policySummary = objective.policy?.summary ?? buildPolicySummary(intent.kind, intent.targetWeight, intent.tolerance);
+  const state = health?.state ?? "paused";
+  const current = health?.currentMetric;
+  const target = health?.targetMetric ?? intent.targetWeight;
+  let message = "Intent registered as objective. Portfolio is now scored against that policy.";
+  if (health && state === "healthy") {
+    message = `Portfolio aligns with intent \u2014 ${policySummary}.`;
+  } else if (health && (state === "warning" || state === "violation")) {
+    message = `Objective is active but portfolio is off-plan (${state}). Current ${((current ?? 0) * 100).toFixed(1)}% vs target ${(target * 100).toFixed(1)}%.`;
+  }
+  return {
+    intent: { brief: intent.brief.trim(), policySummary },
+    objective,
+    health,
+    portfolio: {
+      totalNotionalUsd: portfolio.totalNotionalUsd,
+      stableWeight: portfolio.stableWeight,
+      positions: portfolio.positions
+    },
+    message
+  };
+}
+function parseFinancialIntent(brief) {
+  const text = brief.trim();
+  if (!text) {
+    throw new AureonValidationError("Intent brief is required");
+  }
+  const stableMatch = text.match(
+    /(\d+(?:\.\d+)?)\s*%?\s*(?:of\s+(?:my\s+)?portfolio\s+in\s+)?stable/i
+  );
+  if (stableMatch) {
+    const pct = Number(stableMatch[1]) / 100;
+    return {
+      brief: text,
+      kind: "stable_allocation",
+      targetWeight: pct,
+      tolerance: DEFAULT_TOLERANCE
+    };
+  }
+  const holdMatch = text.match(
+    /(?:hold|keep|maintain)\s+(?:about\s+)?(\d+(?:\.\d+)?)\s*%?\s*(?:in\s+)?([A-Z]{2,10})/i
+  );
+  if (holdMatch) {
+    const pct = Number(holdMatch[1]) / 100;
+    const symbol = holdMatch[2].toUpperCase();
+    if (symbol === "STABLE" || symbol === "STABLES") {
+      return {
+        brief: text,
+        kind: "stable_allocation",
+        targetWeight: pct,
+        tolerance: DEFAULT_TOLERANCE
+      };
+    }
+    return {
+      brief: text,
+      kind: "balanced_portfolio",
+      targetWeight: pct,
+      tolerance: DEFAULT_TOLERANCE,
+      targetSymbol: symbol
+    };
+  }
+  const pctOnly = text.match(/(\d+(?:\.\d+)?)\s*%/);
+  if (pctOnly && /stable/i.test(text)) {
+    return {
+      brief: text,
+      kind: "stable_allocation",
+      targetWeight: Number(pctOnly[1]) / 100,
+      tolerance: DEFAULT_TOLERANCE
+    };
+  }
+  throw new AureonValidationError(
+    "Could not parse intent from brief \u2014 supply structured FinancialIntent fields"
+  );
+}
+
+// src/errors/http.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function extractMessage(body) {
-  if (!isRecord(body)) return null;
+  if (!isRecord2(body)) return null;
   if (typeof body.message === "string") return body.message;
   if (typeof body.error === "string") return body.error;
-  if (isRecord(body.error) && typeof body.error.message === "string") {
+  if (isRecord2(body.error) && typeof body.error.message === "string") {
     return body.error.message;
   }
   return null;
 }
 function errorFromHttpStatus(status, body) {
   const message = extractMessage(body) ?? defaultMessageForStatus(status);
-  const details = isRecord(body) ? body : { body };
+  const details = isRecord2(body) ? body : { body };
   if (status === 400) return new AureonValidationError(message, details);
   if (status === 404) return new AureonNotFoundError(message, details);
   if (status === 409) return new AureonConflictError(message, details);
@@ -334,208 +1499,126 @@ async function requestJson(transport, path, options = {}) {
           await sleep(retryDelayMs);
           continue;
         }
-        throw error;
-      }
-      const networkError = new AureonNetworkError(
-        error instanceof Error ? error.message : "Network request failed",
-        { url }
-      );
-      if (attempt <= maxRetries) {
-        transport.logger?.warn("aureon.retry", {
-          path,
-          attempt,
-          reason: "network"
-        });
-        await sleep(retryDelayMs);
-        continue;
-      }
-      throw networkError;
-    } finally {
-      clearTimeout(timeout);
-      if (options.signal) options.signal.removeEventListener("abort", onAbort);
-    }
-  }
-}
-
-// src/types/client-options.ts
-var DEFAULT_TIMEOUT_MS2 = 3e4;
-function resolveTimeoutMs(options) {
-  const value = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error("timeoutMs must be a positive finite number");
-  }
-  return value;
-}
-function resolveHeaders(options) {
-  const headers = { ...options.headers ?? {} };
-  return headers;
-}
-function resolveMaxRetries(options) {
-  const value = options.maxRetries ?? 0;
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error("maxRetries must be a non-negative integer");
-  }
-  return value;
-}
-function resolveRetryDelayMs(options) {
-  const value = options.retryDelayMs ?? 250;
-  if (!Number.isFinite(value) || value < 0) {
-    throw new Error("retryDelayMs must be a non-negative finite number");
-  }
-  return value;
-}
-
-// src/types/market.ts
-function normalizeSymbol(symbol) {
-  return symbol.trim().toUpperCase();
-}
-
-// src/validation/market-input.ts
-function normalizeApplyMarketEventInput(input) {
-  const symbol = normalizeSymbol(input.symbol ?? "");
-  if (!symbol) throw new AureonValidationError("symbol is required");
-  if (!Number.isFinite(input.priceChangeRatio)) {
-    throw new AureonValidationError("priceChangeRatio must be a finite number");
-  }
-  if (input.priceChangeRatio <= -0.95) {
-    throw new AureonValidationError(
-      "priceChangeRatio is too extreme for preview runtime"
-    );
-  }
-  return {
-    ...input,
-    symbol,
-    autoRestore: input.autoRestore !== false,
-    name: input.name?.trim() || void 0,
-    description: input.description?.trim() || void 0
-  };
-}
-
-// src/types/objective.ts
-var OBJECTIVE_KINDS = [
-  "stable_allocation",
-  "balanced_portfolio",
-  "risk_ceiling",
-  "reward_reinvestment"
-];
-var OBJECTIVE_PRIORITIES = [
-  "low",
-  "medium",
-  "high",
-  "critical"
-];
-function isObjectiveKind(value) {
-  return OBJECTIVE_KINDS.includes(value);
-}
-function isObjectivePriority(value) {
-  return OBJECTIVE_PRIORITIES.includes(value);
-}
-
-// src/validation/objective-input.ts
-function buildPolicySummary(kind, targetWeight, tolerance) {
-  const targetPct = (targetWeight * 100).toFixed(1);
-  const tolPct = (tolerance * 100).toFixed(1);
-  switch (kind) {
-    case "stable_allocation":
-      return `Maintain ${targetPct}% stable allocation within \xB1${tolPct}%`;
-    case "balanced_portfolio":
-      return `Hold balanced weights near ${targetPct}% primary sleeve within \xB1${tolPct}%`;
-    case "risk_ceiling":
-      return `Keep portfolio risk at or below configured ceiling with ${tolPct}% buffer`;
-    case "reward_reinvestment":
-      return `Reinvest available rewards toward ${targetPct}% target sleeve`;
-    default:
-      return `Objective policy target ${targetPct}% \xB1${tolPct}%`;
-  }
-}
-function normalizeCreateObjectiveInput(input) {
-  const name = input.name?.trim();
-  if (!name || name.length < 3) {
-    throw new AureonValidationError("Objective name must be at least 3 characters");
-  }
-  if (!isObjectiveKind(input.kind)) {
-    throw new AureonValidationError(`Unsupported objective kind: ${input.kind}`);
-  }
-  if (input.targetWeight < 0 || input.targetWeight > 1) {
-    throw new AureonValidationError("targetWeight must be between 0 and 1");
-  }
-  if (input.tolerance < 0 || input.tolerance > 0.5) {
-    throw new AureonValidationError("tolerance must be between 0 and 0.5");
-  }
-  const priority = input.priority ?? "high";
-  if (!isObjectivePriority(priority)) {
-    throw new AureonValidationError(`Unsupported priority: ${priority}`);
-  }
-  if (input.kind === "balanced_portfolio") {
-    const symbol = input.targetSymbol?.trim().toUpperCase();
-    if (!symbol) {
-      throw new AureonValidationError(
-        "balanced_portfolio requires targetSymbol"
+        throw error;
+      }
+      const networkError = new AureonNetworkError(
+        error instanceof Error ? error.message : "Network request failed",
+        { url }
       );
+      if (attempt <= maxRetries) {
+        transport.logger?.warn("aureon.retry", {
+          path,
+          attempt,
+          reason: "network"
+        });
+        await sleep(retryDelayMs);
+        continue;
+      }
+      throw networkError;
+    } finally {
+      clearTimeout(timeout);
+      if (options.signal) options.signal.removeEventListener("abort", onAbort);
     }
-    return {
-      ...input,
-      name,
-      priority,
-      targetSymbol: symbol,
-      // SDK / agent path defaults to Automatic. Explicit "manual" is reserved
-      // for the operator utility Approve UX; not recommended for integrations.
-      automationMode: input.automationMode === "manual" ? "manual" : "auto"
-    };
   }
-  return {
-    ...input,
-    name,
-    priority,
-    targetSymbol: null,
-    automationMode: input.automationMode === "manual" ? "manual" : "auto"
-  };
 }
-function normalizeUpdateObjectiveInput(input) {
-  const next = { ...input };
-  if (next.name !== void 0) {
-    const name = next.name.trim();
-    if (name.length < 3) {
-      throw new AureonValidationError("Objective name must be at least 3 characters");
-    }
-    next.name = name;
-  }
-  if (next.targetWeight !== void 0) {
-    if (next.targetWeight < 0 || next.targetWeight > 1) {
-      throw new AureonValidationError("targetWeight must be between 0 and 1");
-    }
+
+// src/types/client-options.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+function resolveTimeoutMs(options) {
+  const value = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("timeoutMs must be a positive finite number");
   }
-  if (next.tolerance !== void 0) {
-    if (next.tolerance < 0 || next.tolerance > 0.5) {
-      throw new AureonValidationError("tolerance must be between 0 and 0.5");
-    }
+  return value;
+}
+function resolveHeaders(options) {
+  const headers = { ...options.headers ?? {} };
+  return headers;
+}
+function resolveMaxRetries(options) {
+  const value = options.maxRetries ?? 0;
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error("maxRetries must be a non-negative integer");
   }
-  if (next.priority !== void 0 && !isObjectivePriority(next.priority)) {
-    throw new AureonValidationError(`Unsupported priority: ${next.priority}`);
+  return value;
+}
+function resolveRetryDelayMs(options) {
+  const value = options.retryDelayMs ?? 250;
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error("retryDelayMs must be a non-negative finite number");
   }
-  if (next.automationMode !== void 0) {
-    throw new AureonValidationError(
-      "automationMode cannot be changed after create: recreate the objective instead"
-    );
+  return value;
+}
+
+// src/types/market.ts
+function normalizeSymbol(symbol) {
+  return symbol.trim().toUpperCase();
+}
+
+// src/validation/market-input.ts
+function normalizeApplyMarketEventInput(input) {
+  const symbol = normalizeSymbol(input.symbol ?? "");
+  if (!symbol) throw new AureonValidationError("symbol is required");
+  if (!Number.isFinite(input.priceChangeRatio)) {
+    throw new AureonValidationError("priceChangeRatio must be a finite number");
   }
-  if (input.targetSymbol !== void 0) {
+  if (input.priceChangeRatio <= -0.95) {
     throw new AureonValidationError(
-      "targetSymbol cannot be changed after create: recreate the objective instead"
+      "priceChangeRatio is too extreme for preview runtime"
     );
   }
-  return next;
-}
-function assertId(value, label) {
-  if (!value || typeof value !== "string" || value.trim().length < 8) {
-    throw new AureonValidationError(`Invalid ${label}`);
-  }
+  return {
+    ...input,
+    symbol,
+    autoRestore: input.autoRestore === true,
+    name: input.name?.trim() || void 0,
+    description: input.description?.trim() || void 0
+  };
 }
 
 // src/client/aureon-client.ts
+var DEMO_DRIFT_RESTORE_POSITIONS = [
+  {
+    symbol: "USDG",
+    name: "Paxos USDG",
+    category: "stable",
+    quantity: 24e3,
+    markPriceUsd: 1
+  },
+  {
+    symbol: "NVDA",
+    name: "NVIDIA Stock Token",
+    category: "stock_token",
+    quantity: 45,
+    markPriceUsd: 920
+  },
+  {
+    symbol: "AAPL",
+    name: "Apple Stock Token",
+    category: "stock_token",
+    quantity: 80,
+    markPriceUsd: 210
+  },
+  {
+    symbol: "ETH",
+    name: "Ether",
+    category: "gas",
+    quantity: 8.5,
+    markPriceUsd: 3400
+  }
+];
 var AureonClient = class {
   transport;
+  resolvedNetwork;
+  resolvedChainId;
   constructor(options = {}) {
-    const baseUrl = options.baseUrl ?? DEFAULT_API_BASE_URL;
+    const resolved = resolveAureonNetwork({
+      network: options.network,
+      baseUrl: options.baseUrl
+    });
+    this.resolvedNetwork = resolved.network;
+    this.resolvedChainId = resolved.chainId;
+    const baseUrl = resolved.baseUrl;
     const staticToken = options.authToken;
     const getAccessToken = options.getAccessToken ?? (staticToken ? () => staticToken : void 0);
     const staticApiKey = options.apiKey;
@@ -559,6 +1642,14 @@ var AureonClient = class {
   get baseUrl() {
     return this.transport.baseUrl;
   }
+  /** `mainnet` (4663) or `testnet` (46630). */
+  get network() {
+    return this.resolvedNetwork;
+  }
+  /** Chain id bundled with `network`. */
+  get chainId() {
+    return this.resolvedChainId;
+  }
   /** Health probe for connectivity checks. No auth required. */
   async ping() {
     return requestJson(this.transport, ENDPOINTS.healthz);
@@ -744,9 +1835,447 @@ var AureonClient = class {
   async getOverview() {
     return requestJson(this.transport, ENDPOINTS.overview);
   }
+  /**
+   * Objective vs actual portfolio — joins objectives, health, and overview
+   * into comparison rows plus a green-book/off-plan paradox flag.
+   * Auth required.
+   */
+  async getAllocationVsTarget() {
+    const [overview, objectives, health] = await Promise.all([
+      this.getOverview(),
+      this.listObjectives(),
+      this.getHealth()
+    ]);
+    const rows = buildAllocationComparison(objectives, health);
+    const paradox = detectPlanParadox(overview, health);
+    return { rows, paradox, overview };
+  }
+  /**
+   * Registers agent/user intent as an Automatic objective and returns the
+   * AI → objective → portfolio flow snapshot.
+   * Auth required.
+   */
+  async applyFinancialIntent(intent) {
+    const objective = await this.createObjective(
+      resolveObjectiveFromIntent(intent)
+    );
+    try {
+      await this.refreshWatchdog();
+    } catch {
+    }
+    const [healthRecords, portfolio] = await Promise.all([
+      this.getHealth(objective.id),
+      this.getPortfolio()
+    ]);
+    return buildObjectivePortfolioFlow(
+      intent,
+      objective,
+      healthRecords[0] ?? null,
+      portfolio
+    );
+  }
+  /**
+   * Read-only AI → objective → portfolio flow for existing objectives.
+   * Auth required.
+   */
+  async getObjectivePortfolioFlow(objectiveId) {
+    const [objectives, healthRecords, portfolio] = await Promise.all([
+      objectiveId ? [await this.getObjective(objectiveId)] : this.listObjectives(),
+      this.getHealth(objectiveId),
+      this.getPortfolio()
+    ]);
+    const active = objectives.filter(
+      (o) => o.status === "active" || o.status === "validated"
+    );
+    const healthById = new Map(healthRecords.map((h) => [h.objectiveId, h]));
+    return active.map((objective) => {
+      const health = healthById.get(objective.id) ?? null;
+      const intent = {
+        brief: objective.name,
+        kind: objective.kind,
+        targetWeight: objective.policy?.targetWeight ?? 0,
+        tolerance: objective.policy?.tolerance ?? 0.02,
+        targetSymbol: objective.policy?.targetSymbol,
+        name: objective.name,
+        priority: objective.priority
+      };
+      return buildObjectivePortfolioFlow(
+        intent,
+        objective,
+        health,
+        portfolio
+      );
+    });
+  }
+  /**
+   * Controlled drift → detection → restore demo
+   * Seeds book, creates stable objective, applies NVDA rally with auto-restore
+   * disabled, then runs manual restore and returns the three-beat flow.
+   * Auth required.
+   */
+  async runDriftRestoreDemo() {
+    await this.setPortfolio(DEMO_DRIFT_RESTORE_POSITIONS);
+    const objective = await this.createObjective({
+      name: "Maintain 20% Stable Assets",
+      kind: "stable_allocation",
+      targetWeight: 0.2,
+      tolerance: 0.02
+    });
+    try {
+      await this.refreshWatchdog();
+    } catch {
+    }
+    const [alignedHealthRecords, baselineRows] = await Promise.all([
+      this.getHealth(objective.id),
+      this.getAllocationVsTarget()
+    ]);
+    const alignedHealth = alignedHealthRecords[0];
+    if (!alignedHealth) {
+      throw new AureonValidationError(
+        "Baseline health missing after objective create"
+      );
+    }
+    const alignedRow = baselineRows.rows.find(
+      (r) => r.objectiveId === objective.id
+    );
+    await this.applyMarketEvent({
+      name: "NVDA Stock Token Rally",
+      description: "Controlled mark move \u2014 drift demo",
+      symbol: "NVDA",
+      priceChangeRatio: 0.45,
+      autoRestore: false
+    });
+    const [driftHealthRecords, driftRows, restorePlan] = await Promise.all([
+      this.getHealth(objective.id),
+      this.getAllocationVsTarget(),
+      this.getRestorePlan(objective.id)
+    ]);
+    const driftHealth = driftHealthRecords[0];
+    if (!driftHealth) {
+      throw new AureonValidationError("Drift health missing after market event");
+    }
+    const driftRow = driftRows.rows.find((r) => r.objectiveId === objective.id);
+    const receipt = await this.restoreObjective(objective.id);
+    const [restoredHealthRecords] = await Promise.all([
+      this.getHealth(objective.id)
+    ]);
+    const restoredHealth = restoredHealthRecords[0];
+    return buildDriftRestoreFlow({
+      objective,
+      alignedHealth,
+      driftHealth,
+      driftPlan: restorePlan,
+      restoredHealth: restoredHealth ?? driftHealth,
+      receipt,
+      alignedRow,
+      driftRow
+    });
+  }
+  /**
+   * Read-only drift → detection → restore flow for active objectives.
+   * Auth required.
+   */
+  async getDriftRestoreFlow(objectiveId) {
+    const [objectives, healthRecords, allocation, executions] = await Promise.all([
+      objectiveId ? [await this.getObjective(objectiveId)] : this.listObjectives(),
+      this.getHealth(objectiveId),
+      this.getAllocationVsTarget(),
+      this.listExecutions(objectiveId)
+    ]);
+    const active = objectives.filter(
+      (o) => o.status === "active" || o.status === "validated"
+    );
+    const healthById = new Map(healthRecords.map((h) => [h.objectiveId, h]));
+    const rowById = new Map(
+      allocation.rows.map((r) => [r.objectiveId, r])
+    );
+    const receiptsByObjective = /* @__PURE__ */ new Map();
+    for (const receipt of sortExecutionsNewestFirst(executions)) {
+      if (!receiptsByObjective.has(receipt.objectiveId)) {
+        receiptsByObjective.set(receipt.objectiveId, receipt);
+      }
+    }
+    const flows = [];
+    for (const objective of active) {
+      const health = healthById.get(objective.id);
+      if (!health) continue;
+      let restorePlan;
+      if (health.state === "warning" || health.state === "violation") {
+        try {
+          restorePlan = await this.getRestorePlan(objective.id);
+        } catch {
+        }
+      }
+      flows.push(
+        buildDriftRestoreFlowFromSnapshot({
+          objective,
+          health,
+          allocationRow: rowById.get(objective.id),
+          restorePlan,
+          latestReceipt: receiptsByObjective.get(objective.id)
+        })
+      );
+    }
+    return flows;
+  }
+  async buildReceiptVerificationFlowForReceipt(receipt, timelineEvents) {
+    const validation = validateExecutionReceipt(receipt);
+    let settlement;
+    if (receipt.settlement === "vault") {
+      try {
+        settlement = await this.getExecutionSettlement(receipt.id);
+      } catch {
+      }
+    }
+    const events = timelineEvents ?? findTimelineEventsForReceipt(
+      await this.getTimeline(receipt.objectiveId),
+      receipt
+    );
+    return buildReceiptVerificationFlow({
+      receipt,
+      validation,
+      settlement,
+      timelineEvents: events
+    });
+  }
+  /**
+   * Controlled receipt → verification demo.
+   * Runs drift-restore, then validates receipt and looks up settlement.
+   * Auth required.
+   */
+  async runReceiptVerificationDemo() {
+    const driftFlow = await this.runDriftRestoreDemo();
+    const receipt = driftFlow.phases.restored?.receipt;
+    if (!receipt) {
+      throw new AureonValidationError(
+        "Restore receipt missing after drift-restore demo"
+      );
+    }
+    return this.buildReceiptVerificationFlowForReceipt(receipt);
+  }
+  /**
+   * Read-only receipt → verification flow for execution receipts.
+   * Auth required.
+   */
+  async getReceiptVerificationFlow(executionId) {
+    const executions = sortExecutionsNewestFirst(await this.listExecutions());
+    const targets = executionId ? executions.filter((e) => e.id === executionId) : executions.slice(0, 5);
+    if (targets.length === 0) {
+      return [];
+    }
+    const timeline = await this.getTimeline();
+    const flows = [];
+    for (const receipt of targets) {
+      flows.push(
+        await this.buildReceiptVerificationFlowForReceipt(
+          receipt,
+          findTimelineEventsForReceipt(timeline, receipt)
+        )
+      );
+    }
+    return flows;
+  }
+  /**
+   * Controlled portfolio watch demo.
+   * User brief → Automatic objective → market move while away → auto restore → return briefing.
+   * Auth required.
+   */
+  async runPortfolioWatchDemo(input) {
+    const userBrief = input?.brief?.trim() || DEFAULT_PORTFOLIO_WATCH_BRIEF;
+    const host = input?.host ?? "cursor";
+    await this.setPortfolio(DEMO_DRIFT_RESTORE_POSITIONS);
+    const intent = {
+      brief: userBrief,
+      kind: "stable_allocation",
+      targetWeight: 0.2,
+      tolerance: 0.02
+    };
+    const setup = await this.applyFinancialIntent(intent);
+    const objective = setup.objective;
+    const registerHealth = setup.health;
+    if (!registerHealth) {
+      throw new AureonValidationError(
+        "Register health missing after applyFinancialIntent"
+      );
+    }
+    const baselineRows = await this.getAllocationVsTarget();
+    const registerRow = baselineRows.rows.find(
+      (r) => r.objectiveId === objective.id
+    );
+    const healthBeforeRecords = await this.getHealth(objective.id);
+    const healthBefore = healthBeforeRecords[0];
+    if (!healthBefore) {
+      throw new AureonValidationError("Baseline health missing before market event");
+    }
+    const marketResult = await this.applyMarketEvent({
+      name: "NVDA rally while you were away",
+      description: "portfolio watch demo \u2014 auto restore on",
+      symbol: "NVDA",
+      priceChangeRatio: 0.45,
+      autoRestore: true
+    });
+    const healthAfter = marketResult.health.find((h) => h.objectiveId === objective.id) ?? healthBefore;
+    const receipt = marketResult.executions.find(
+      (e) => e.objectiveId === objective.id
+    );
+    const timeline = await this.getTimeline(objective.id);
+    return buildPortfolioWatchFlow({
+      userBrief,
+      host,
+      objective,
+      registerHealth,
+      registerRow,
+      whileAway: {
+        marketEvent: marketResult.event,
+        healthBefore,
+        healthAfter,
+        autoRestored: marketResult.executions.length > 0,
+        receipt
+      },
+      briefingHealth: healthAfter,
+      timelineEvents: timeline.slice(0, 10)
+    });
+  }
+  /**
+   * Read-only portfolio watch briefing for Automatic objectives.
+   * Auth required.
+   */
+  async getPortfolioWatchFlow(input) {
+    const userBrief = input?.brief?.trim() || DEFAULT_PORTFOLIO_WATCH_BRIEF;
+    const host = input?.host ?? "mcp";
+    const [objectives, healthRecords, allocation, timeline] = await Promise.all([
+      input?.objectiveId ? [await this.getObjective(input.objectiveId)] : this.listObjectives(),
+      this.getHealth(input?.objectiveId),
+      this.getAllocationVsTarget(),
+      this.getTimeline(input?.objectiveId)
+    ]);
+    const active = objectives.filter(
+      (o) => (o.status === "active" || o.status === "validated") && (o.automationMode ?? "auto") === "auto"
+    );
+    const healthById = new Map(healthRecords.map((h) => [h.objectiveId, h]));
+    const rowById = new Map(allocation.rows.map((r) => [r.objectiveId, r]));
+    const flows = [];
+    for (const objective of active) {
+      const health = healthById.get(objective.id);
+      if (!health) continue;
+      const objectiveTimeline = timeline.filter(
+        (e) => !e.objectiveId || e.objectiveId === objective.id
+      );
+      flows.push(
+        buildPortfolioWatchFlowFromSnapshot({
+          userBrief,
+          host,
+          objective,
+          health,
+          allocationRow: rowById.get(objective.id),
+          timelineEvents: objectiveTimeline.slice(0, 10)
+        })
+      );
+    }
+    return flows;
+  }
+  /**
+   * Controlled full AUREON loop demo (Content Arc).
+   * Intent → plan check (green vs plan with autoRestore false) → restore → receipt verification.
+   * Auth required.
+   */
+  async runFullAureonLoopDemo(input) {
+    const userBrief = input?.brief?.trim() || DEFAULT_FULL_LOOP_BRIEF;
+    await this.setPortfolio(DEMO_DRIFT_RESTORE_POSITIONS);
+    const intent = {
+      brief: userBrief,
+      kind: "stable_allocation",
+      targetWeight: 0.2,
+      tolerance: 0.02
+    };
+    const setup = await this.applyFinancialIntent(intent);
+    const objective = setup.objective;
+    const baselineHealth = setup.health;
+    if (!baselineHealth) {
+      throw new AureonValidationError(
+        "Baseline health missing after applyFinancialIntent"
+      );
+    }
+    await this.applyMarketEvent({
+      name: "NVDA rally \u2014 green book, off-plan sleeve",
+      description: "Full loop \u2014 autoRestore false to expose plan paradox",
+      symbol: "NVDA",
+      priceChangeRatio: 0.45,
+      autoRestore: false
+    });
+    const [afterShockHealthRecords, allocation] = await Promise.all([
+      this.getHealth(objective.id),
+      this.getAllocationVsTarget()
+    ]);
+    const afterShockHealth = afterShockHealthRecords[0];
+    if (!afterShockHealth) {
+      throw new AureonValidationError("Health missing after market event");
+    }
+    const afterShockRow = allocation.rows.find(
+      (r) => r.objectiveId === objective.id
+    );
+    const receipt = await this.restoreObjective(objective.id);
+    const restoredHealthRecords = await this.getHealth(objective.id);
+    const restoredHealth = restoredHealthRecords[0] ?? afterShockHealth;
+    const verification = await this.buildReceiptVerificationFlowForReceipt(receipt);
+    return buildFullAureonLoopFlow({
+      userBrief,
+      objective,
+      baselineHealth,
+      afterShockHealth,
+      afterShockRow,
+      paradox: allocation.paradox,
+      restoredHealth,
+      receipt,
+      verification
+    });
+  }
+  /**
+   * Read-only full AUREON loop for active objectives with a latest receipt.
+   * Auth required.
+   */
+  async getFullAureonLoopFlow(input) {
+    const userBrief = input?.brief?.trim() || DEFAULT_FULL_LOOP_BRIEF;
+    const [objectives, healthRecords, allocation, executions] = await Promise.all([
+      input?.objectiveId ? [await this.getObjective(input.objectiveId)] : this.listObjectives(),
+      this.getHealth(input?.objectiveId),
+      this.getAllocationVsTarget(),
+      this.listExecutions(input?.objectiveId)
+    ]);
+    const active = objectives.filter(
+      (o) => o.status === "active" || o.status === "validated"
+    );
+    const healthById = new Map(healthRecords.map((h) => [h.objectiveId, h]));
+    const rowById = new Map(allocation.rows.map((r) => [r.objectiveId, r]));
+    const receiptsByObjective = /* @__PURE__ */ new Map();
+    for (const receipt of sortExecutionsNewestFirst(executions)) {
+      if (!receiptsByObjective.has(receipt.objectiveId)) {
+        receiptsByObjective.set(receipt.objectiveId, receipt);
+      }
+    }
+    const flows = [];
+    for (const objective of active) {
+      const health = healthById.get(objective.id);
+      if (!health) continue;
+      const latestReceipt = receiptsByObjective.get(objective.id);
+      if (!latestReceipt) continue;
+      const verification = await this.buildReceiptVerificationFlowForReceipt(latestReceipt);
+      const flow = buildFullAureonLoopFlowFromSnapshot({
+        userBrief,
+        objective,
+        health,
+        allocationRow: rowById.get(objective.id),
+        paradox: allocation.paradox,
+        latestReceipt,
+        verification
+      });
+      if (flow) flows.push(flow);
+    }
+    return flows;
+  }
   /**
    * Applies a controlled market event to portfolio marks.
-   * When autoRestore is true, the API evaluates health and may run staged restorative execution.
+   * When autoRestore is true, the API may run restore. Omit or false = drift only, no restore. Automatic still 409s if the vault cannot execute.
    * Auth required.
    */
   async applyMarketEvent(input) {
@@ -790,7 +2319,8 @@ var AureonClient = class {
     });
   }
   /**
-   * Runs vault-backed restorative execution for an objective outside policy.
+   * Runs restorative execution for an objective outside policy.
+   * Receipt.settlement may be vault or staged. Only verifiedOnChain is proof.
    * Auth required.
    */
   async restoreObjective(objectiveId) {
@@ -808,6 +2338,35 @@ var AureonClient = class {
     );
     return result.executions;
   }
+  /** Returns chain-verified settlement record for an execution when present. Auth required. */
+  async getExecutionSettlement(executionId) {
+    assertId(executionId, "execution id");
+    return requestJson(this.transport, executionSettlementPath(executionId));
+  }
+  /** Lists chain-verified settlement records for the authenticated wallet. Auth required. */
+  async listSettlements(objectiveId) {
+    const path = withQuery(ENDPOINTS.settlements, { objectiveId });
+    const result = await requestJson(
+      this.transport,
+      path
+    );
+    return result.settlements;
+  }
+  /**
+   * Manual backfill: verify a vault tx on-chain and attach settlement proof.
+   * Auth required.
+   */
+  async confirmExecutionSettlement(executionId, transactionHash) {
+    assertId(executionId, "execution id");
+    const hash = transactionHash.trim();
+    if (!hash) {
+      throw new AureonValidationError("transactionHash is required");
+    }
+    return requestJson(this.transport, executionConfirmSettlementPath(executionId), {
+      method: "POST",
+      body: { transactionHash: hash }
+    });
+  }
   /** Returns Phase 2 ObjectiveRegistry deployment status. Auth required. */
   async getRegistryStatus() {
     return requestJson(this.transport, ENDPOINTS.registryStatus);
@@ -928,19 +2487,59 @@ var AureonClient = class {
       method: "POST"
     });
   }
+  /**
+   * Joins objective → registry → receipts → settlements → timeline.
+   * Missing proof is labeled as a gap. Nothing is invented. Auth required.
+   */
+  async getAuditTrail(objectiveId) {
+    assertId(objectiveId, "objective id");
+    const [objective, healthRows, receipts, settlementsResult, timeline] = await Promise.all([
+      this.getObjective(objectiveId),
+      this.getHealth(objectiveId),
+      this.listExecutions(objectiveId),
+      this.listSettlements(objectiveId).then(
+        (rows) => ({ ok: true, rows }),
+        () => ({ ok: false, rows: [] })
+      ),
+      this.getTimeline(objectiveId)
+    ]);
+    let registry = {
+      registered: false,
+      objectiveId
+    };
+    let registryLookupFailed = false;
+    try {
+      registry = await this.getObjectiveRegistry(objectiveId);
+    } catch {
+      registryLookupFailed = true;
+    }
+    return buildFinancialAuditTrail({
+      objective,
+      health: healthRows[0],
+      registry,
+      receipts: sortExecutionsNewestFirst(receipts),
+      settlements: settlementsResult.rows,
+      timeline,
+      registryLookupFailed,
+      settlementsLookupFailed: !settlementsResult.ok
+    });
+  }
 };
 
 // src/client/factory.ts
 function createAureonClient(options = {}) {
-  return new AureonClient({
-    baseUrl: options.baseUrl ?? DEFAULT_API_BASE_URL,
-    ...options
-  });
+  return new AureonClient(options);
 }
 function createLocalAureonClient(overrides = {}) {
+  if (overrides.network && overrides.network !== "mainnet") {
+    throw new Error(
+      'createLocalAureonClient is mainnet-only (8788 / 4663). Use createAureonClient({ network: "testnet" }) for the public host.'
+    );
+  }
   return new AureonClient({
     ...overrides,
-    baseUrl: overrides.baseUrl ?? LOCAL_API_BASE_URL
+    network: "mainnet",
+    baseUrl: overrides.baseUrl ?? MAINNET_API_BASE_URL
   });
 }
 
@@ -1039,15 +2638,24 @@ var TIMELINE_EVENT_TYPES = [
   "capital_provisioned",
   "capital_cleared",
   "capital_synced",
-  "registry_anchored"
+  "registry_registered",
+  "settlement_recorded"
 ];
 function isTimelineEventType(value) {
   return TIMELINE_EVENT_TYPES.includes(value);
 }
 
-// src/types/execution.ts
-function isVaultSettlement(receipt) {
-  return receipt.settlement === "vault";
+// src/types/settlement.ts
+function formatSettlementSummary(record) {
+  const parts = [
+    "vault settlement (chain-verified)",
+    `block ${record.blockNumber}`,
+    record.explorerUrl
+  ];
+  if (record.registryRef) {
+    parts.push(`registry ${record.registryRef.objectiveKey.slice(0, 10)}\u2026`);
+  }
+  return parts.join(" \xB7 ");
 }
 
 // src/adapters/logging-adapter.ts
@@ -1076,6 +2684,6 @@ function createConsoleLogger(prefix = "aureon-sdk") {
   };
 }
 
-export { API_KEY_HEADER, AureonClient, AureonConflictError, AureonError, AureonNetworkError, AureonNotFoundError, AureonTimeoutError, AureonValidationError, DEFAULT_API_BASE_URL, DEFAULT_TIMEOUT_MS, ENDPOINTS, LOCAL_API_BASE_URL, OBJECTIVE_KINDS, OBJECTIVE_PRIORITIES, PRODUCT_NAME, PRODUCT_TAGLINE, SDK_NAME, SDK_VERSION, TIMELINE_EVENT_TYPES, assertBaseUrl, buildPolicySummary, createAureonClient, createConsoleLogger, createLocalAureonClient, createSessionTokenProvider, errorFromHttpStatus, formatIsoTime, formatSignedPercent, formatUsd, formatWeight, healthTone, isAureonError, isHealthState, isObjectiveKind, isObjectivePriority, isTimelineEventType, isVaultSettlement, joinUrl, normalizeCreateObjectiveInput, normalizeUpdateObjectiveInput, pickWorstHealth, requestJson, resolveFetch, silentLogger, withQuery };
+export { API_KEY_HEADER, AUREON_NETWORKS, AureonClient, AureonConflictError, AureonError, AureonNetworkError, AureonNotFoundError, AureonTimeoutError, AureonValidationError, DEFAULT_API_BASE_URL, DEFAULT_FULL_LOOP_BRIEF, DEFAULT_PORTFOLIO_WATCH_BRIEF, DEFAULT_TIMEOUT_MS, ENDPOINTS, LOCAL_API_BASE_URL, MAINNET_API_BASE_URL, MAINNET_CHAIN_ID, OBJECTIVE_KINDS, OBJECTIVE_PRIORITIES, PRODUCT_NAME, PRODUCT_TAGLINE, SDK_NAME, SDK_VERSION, TESTNET_API_BASE_URL, TESTNET_CHAIN_ID, TIMELINE_EVENT_TYPES, assertBaseUrl, assertValidExecutionReceipt, buildAllocationComparison, buildDriftRestoreFlow, buildDriftRestoreFlowFromSnapshot, buildFinancialAuditTrail, buildFullAureonLoopFlow, buildFullAureonLoopFlowFromSnapshot, buildObjectivePortfolioFlow, buildPolicySummary, buildPortfolioWatchBriefingLines, buildPortfolioWatchFlow, buildPortfolioWatchFlowFromSnapshot, buildReceiptVerificationFlow, createAureonClient, createConsoleLogger, createLocalAureonClient, createSessionTokenProvider, detectPlanParadox, errorFromHttpStatus, findTimelineEventsForReceipt, formatAuditTrailLines, formatIsoTime, formatReceiptSummary, formatSettlementSummary, formatSignedPercent, formatUsd, formatWeight, healthTone, inferAureonNetworkFromUrl, inferDriftPhase, inferFullAureonLoopPhase, inferPortfolioWatchPhase, inferProofTier, isAureonError, isChainVerifiedReceipt, isHealthState, isObjectiveKind, isObjectivePriority, isTimelineEventType, isValidExecutionReceipt, isVaultSettlement, joinUrl, normalizeCreateObjectiveInput, normalizeUpdateObjectiveInput, parseFinancialIntent, pickWorstHealth, requestJson, resolveAureonNetwork, resolveAureonNetworkFromEnv, resolveFetch, resolveObjectiveFromIntent, silentLogger, validateExecutionReceipt, validateSettlementRecord, withQuery };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map