@manifest-network/manifest-agent-core 0.9.0

package/dist/internals/classify-deploy-error.js

@@ -0,0 +1,79 @@
+//#region src/internals/classify-deploy-error.ts
+/**
+* Classify the MCP error envelope thrown by `mcp__manifest-fred__deploy_app`
+* when the call fails AFTER the create-lease tx already confirmed.
+*
+* Companion to `classify-deploy-response.ts`: that file handles the RETURN
+* path; this file handles the THROW path. The split exists because
+* `manifest-mcp-fred` 0.8.0 `deployApp` throws `ManifestMCPError` with the
+* message prefix `Deploy partially succeeded: lease ${uuid} was created
+* but subsequent steps failed.` and `details.lease_uuid` populated when
+* create-lease succeeded but something downstream (set-domain, manifest
+* upload, readiness poll) fell over.
+*
+* Recognised input envelope shapes:
+*   - `{ message, details?, code? }`
+*   - `{ error: { message, details?, code? } }`
+*
+* Returns deterministically — never throws. A malformed envelope is
+* classified as `outcome: 'failed'` with a stable `reason`, so the
+* orchestrator can branch on the JSON without an outer try/catch.
+*
+* `outcome: 'partially_succeeded'` triggers ONLY when `err.message` starts
+* with the exact prefix `Deploy partially succeeded:`. Looser matching
+* would risk false positives on wrapper errors that happen to contain the
+* phrase nested inside other text.
+*/
+/** Permissive UUID pattern (RFC-4122 8-4-4-4-12, version byte lenient). */
+const UUID_PATTERN = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+const PARTIAL_PREFIX = "Deploy partially succeeded:";
+/**
+* Pick the inner envelope when the error is wrapped as `{ error: {...} }`.
+* `JSON.stringify(err)` produces this shape in some SDKs.
+*/
+function pickEnvelope(raw) {
+	if (raw !== null && typeof raw === "object") {
+		const r = raw;
+		if (r.error !== null && typeof r.error === "object") return r.error;
+	}
+	return raw;
+}
+function classifyDeployError(err, opts = {}) {
+	const expectedCustomDomain = opts.expectedCustomDomain;
+	const e = pickEnvelope(err);
+	if (e === null || typeof e !== "object") return finalize({
+		outcome: "failed",
+		reason: "stdin envelope is not an object"
+	}, expectedCustomDomain);
+	const envelope = e;
+	const message = typeof envelope.message === "string" ? envelope.message : "";
+	const details = envelope.details !== null && typeof envelope.details === "object" && !Array.isArray(envelope.details) ? envelope.details : {};
+	if (message.startsWith(PARTIAL_PREFIX)) {
+		let leaseUuid;
+		if (typeof details.lease_uuid === "string") leaseUuid = details.lease_uuid;
+		else {
+			const m = message.match(UUID_PATTERN);
+			if (m) leaseUuid = m[0];
+		}
+		return finalize({
+			outcome: "partially_succeeded",
+			...leaseUuid !== void 0 && { leaseUuid },
+			reason: message
+		}, expectedCustomDomain);
+	}
+	return finalize({
+		outcome: "failed",
+		reason: message || "deploy_app threw an empty error"
+	}, expectedCustomDomain);
+}
+function finalize(base, expectedCustomDomain) {
+	if (expectedCustomDomain !== void 0) return {
+		...base,
+		requestedCustomDomain: expectedCustomDomain
+	};
+	return base;
+}
+//#endregion
+export { classifyDeployError };
+
+//# sourceMappingURL=classify-deploy-error.js.map

package/dist/internals/classify-deploy-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-deploy-error.js","names":[],"sources":["../../src/internals/classify-deploy-error.ts"],"sourcesContent":["/**\n * Classify the MCP error envelope thrown by `mcp__manifest-fred__deploy_app`\n * when the call fails AFTER the create-lease tx already confirmed.\n *\n * Companion to `classify-deploy-response.ts`: that file handles the RETURN\n * path; this file handles the THROW path. The split exists because\n * `manifest-mcp-fred` 0.8.0 `deployApp` throws `ManifestMCPError` with the\n * message prefix `Deploy partially succeeded: lease ${uuid} was created\n * but subsequent steps failed.` and `details.lease_uuid` populated when\n * create-lease succeeded but something downstream (set-domain, manifest\n * upload, readiness poll) fell over.\n *\n * Recognised input envelope shapes:\n *   - `{ message, details?, code? }`\n *   - `{ error: { message, details?, code? } }`\n *\n * Returns deterministically — never throws. A malformed envelope is\n * classified as `outcome: 'failed'` with a stable `reason`, so the\n * orchestrator can branch on the JSON without an outer try/catch.\n *\n * `outcome: 'partially_succeeded'` triggers ONLY when `err.message` starts\n * with the exact prefix `Deploy partially succeeded:`. Looser matching\n * would risk false positives on wrapper errors that happen to contain the\n * phrase nested inside other text.\n */\n\n/** Permissive UUID pattern (RFC-4122 8-4-4-4-12, version byte lenient). */\nconst UUID_PATTERN =\n  /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;\n\nconst PARTIAL_PREFIX = 'Deploy partially succeeded:';\n\nexport interface DeployErrorClassification {\n  outcome: 'partially_succeeded' | 'failed';\n  /** Present when create-lease confirmed (outcome partially_succeeded), or when a UUID was extractable from a non-partial error. */\n  leaseUuid?: string;\n  /** Echoed from `opts.expectedCustomDomain` so downstream prompts can name the FQDN. */\n  requestedCustomDomain?: string;\n  /** Human-readable summary — the raw error message (or a stable placeholder if missing). */\n  reason: string;\n}\n\n/**\n * Pick the inner envelope when the error is wrapped as `{ error: {...} }`.\n * `JSON.stringify(err)` produces this shape in some SDKs.\n */\nfunction pickEnvelope(raw: unknown): unknown {\n  if (raw !== null && typeof raw === 'object') {\n    const r = raw as { error?: unknown };\n    if (r.error !== null && typeof r.error === 'object') return r.error;\n  }\n  return raw;\n}\n\nexport function classifyDeployError(\n  err: unknown,\n  opts: { expectedCustomDomain?: string } = {},\n): DeployErrorClassification {\n  const expectedCustomDomain = opts.expectedCustomDomain;\n  const e = pickEnvelope(err);\n\n  if (e === null || typeof e !== 'object') {\n    return finalize(\n      {\n        outcome: 'failed',\n        reason: 'stdin envelope is not an object',\n      },\n      expectedCustomDomain,\n    );\n  }\n\n  const envelope = e as { message?: unknown; details?: unknown };\n  const message = typeof envelope.message === 'string' ? envelope.message : '';\n  const details =\n    envelope.details !== null &&\n    typeof envelope.details === 'object' &&\n    !Array.isArray(envelope.details)\n      ? (envelope.details as { lease_uuid?: unknown })\n      : {};\n\n  // Partial-success trigger: EXACT upstream prefix. Anything looser risks\n  // mis-classifying wrapper errors whose message merely contains the\n  // phrase as a substring (defended by case #5 in the CJS test).\n  if (message.startsWith(PARTIAL_PREFIX)) {\n    let leaseUuid: string | undefined;\n    if (typeof details.lease_uuid === 'string') {\n      leaseUuid = details.lease_uuid;\n    } else {\n      const m = message.match(UUID_PATTERN);\n      if (m) leaseUuid = m[0];\n    }\n    return finalize(\n      {\n        outcome: 'partially_succeeded',\n        ...(leaseUuid !== undefined && { leaseUuid }),\n        reason: message,\n      },\n      expectedCustomDomain,\n    );\n  }\n\n  // Anything else: terminal failure — the create-lease tx didn't confirm,\n  // or the error happened before broadcast.\n  return finalize(\n    {\n      outcome: 'failed',\n      reason: message || 'deploy_app threw an empty error',\n    },\n    expectedCustomDomain,\n  );\n}\n\nfunction finalize(\n  base: DeployErrorClassification,\n  expectedCustomDomain: string | undefined,\n): DeployErrorClassification {\n  if (expectedCustomDomain !== undefined) {\n    return { ...base, requestedCustomDomain: expectedCustomDomain };\n  }\n  return base;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAM,eACJ;AAEF,MAAM,iBAAiB;;;;;AAgBvB,SAAS,aAAa,KAAuB;AAC3C,KAAI,QAAQ,QAAQ,OAAO,QAAQ,UAAU;EAC3C,MAAM,IAAI;AACV,MAAI,EAAE,UAAU,QAAQ,OAAO,EAAE,UAAU,SAAU,QAAO,EAAE;;AAEhE,QAAO;;AAGT,SAAgB,oBACd,KACA,OAA0C,EAAE,EACjB;CAC3B,MAAM,uBAAuB,KAAK;CAClC,MAAM,IAAI,aAAa,IAAI;AAE3B,KAAI,MAAM,QAAQ,OAAO,MAAM,SAC7B,QAAO,SACL;EACE,SAAS;EACT,QAAQ;EACT,EACD,qBACD;CAGH,MAAM,WAAW;CACjB,MAAM,UAAU,OAAO,SAAS,YAAY,WAAW,SAAS,UAAU;CAC1E,MAAM,UACJ,SAAS,YAAY,QACrB,OAAO,SAAS,YAAY,YAC5B,CAAC,MAAM,QAAQ,SAAS,QAAQ,GAC3B,SAAS,UACV,EAAE;AAKR,KAAI,QAAQ,WAAW,eAAe,EAAE;EACtC,IAAI;AACJ,MAAI,OAAO,QAAQ,eAAe,SAChC,aAAY,QAAQ;OACf;GACL,MAAM,IAAI,QAAQ,MAAM,aAAa;AACrC,OAAI,EAAG,aAAY,EAAE;;AAEvB,SAAO,SACL;GACE,SAAS;GACT,GAAI,cAAc,KAAA,KAAa,EAAE,WAAW;GAC5C,QAAQ;GACT,EACD,qBACD;;AAKH,QAAO,SACL;EACE,SAAS;EACT,QAAQ,WAAW;EACpB,EACD,qBACD;;AAGH,SAAS,SACP,MACA,sBAC2B;AAC3B,KAAI,yBAAyB,KAAA,EAC3B,QAAO;EAAE,GAAG;EAAM,uBAAuB;EAAsB;AAEjE,QAAO"}

package/dist/internals/classify-deploy-response.d.ts

@@ -0,0 +1,56 @@
+//#region src/internals/classify-deploy-response.d.ts
+/**
+ * Classify the RETURN envelope of `mcp__manifest-fred__deploy_app` into one
+ * of three outcomes for the orchestrator to branch on.
+ *
+ * Companion to `classify-deploy-error.ts` (which handles the THROW path).
+ *
+ * Outcomes:
+ *   - `'active'`     — state is LEASE_STATE_ACTIVE AND at least one
+ *                      running instance exists. Internal-only deploys
+ *                      (every port `ingress: false`) have running
+ *                      instances but no FQDN, so the URL count alone
+ *                      can't gate this; `hasRunningInstances` covers it.
+ *                      Orchestrator can skip `wait_for_app_ready`.
+ *   - `'needs_wait'` — lease created but not yet active, OR no running
+ *                      instances yet (provider hasn't started the
+ *                      container). Orchestrator polls `wait_for_app_ready`.
+ *   - `'failed'`     — no `lease_uuid` present, OR state is a terminal
+ *                      failure state (CLOSED / REJECTED / EXPIRED, plus
+ *                      the legacy INSUFFICIENT_FUNDS defense-in-depth).
+ *                      Orchestrator routes to troubleshoot/cleanup.
+ *
+ * Terminal-state set is the union of `TERMINAL_STATES` from `lease-state.ts`
+ * — extended from the CJS's `{CLOSED, INSUFFICIENT_FUNDS}` to also cover
+ * `REJECTED` and `EXPIRED` since those are emitted by manifestjs 2.4.1
+ * (chain v2.1.0) as terminal states. INSUFFICIENT_FUNDS is unreachable
+ * from `decode()` on the current chain but retained as defense-in-depth.
+ * See `lease-state.ts` for the divergence rationale.
+ *
+ * Error summary format (qa-engineer's parity pin):
+ *   - Lease present + terminal: `Lease ${leaseUuid} reached terminal state ${stateName || 'UNKNOWN'}`
+ *   - Lease missing: `deploy_app returned no lease_uuid`
+ *   - `connectionError` string present: passed through verbatim
+ */
+interface DeployResponseShape {
+  lease_uuid?: unknown;
+  provider_uuid?: unknown;
+  provider_url?: unknown;
+  state?: unknown;
+  url?: unknown;
+  connection?: unknown;
+  connectionError?: unknown;
+}
+interface DeployResponseClassification {
+  outcome: 'active' | 'needs_wait' | 'failed';
+  leaseUuid?: string;
+  providerUuid?: string;
+  providerUrl?: string;
+  urls: string[];
+  stateName?: string;
+  errorSummary?: string;
+}
+declare function classifyDeployResponse(response: DeployResponseShape): DeployResponseClassification;
+//#endregion
+export { DeployResponseClassification, DeployResponseShape, classifyDeployResponse };
+//# sourceMappingURL=classify-deploy-response.d.ts.map

package/dist/internals/classify-deploy-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-deploy-response.d.ts","names":[],"sources":["../../src/internals/classify-deploy-response.ts"],"mappings":";;AA0CA;;;;;;;;;;;;;AAUA;;;;;;;;;;;;;AAUA;;;;;;UApBiB,mBAAA;EACf,UAAA;EACA,aAAA;EACA,YAAA;EACA,KAAA;EACA,GAAA;EACA,UAAA;EACA,eAAA;AAAA;AAAA,UAGe,4BAAA;EACf,OAAA;EACA,SAAA;EACA,YAAA;EACA,WAAA;EACA,IAAA;EACA,SAAA;EACA,YAAA;AAAA;AAAA,iBAGc,sBAAA,CACd,QAAA,EAAU,mBAAA,GACT,4BAAA"}

package/dist/internals/classify-deploy-response.js

@@ -0,0 +1,33 @@
+import { decode, isTerminal } from "./lease-state.js";
+import { extractRunningEndpoints, formatEndpointAsUrl, hasRunningInstances, normalizeFredUrl } from "./connection.js";
+//#region src/internals/classify-deploy-response.ts
+function classifyDeployResponse(response) {
+	const stateName = decode(typeof response.state === "number" || typeof response.state === "string" ? response.state : void 0);
+	const urls = extractRunningEndpoints(response.connection).map(formatEndpointAsUrl);
+	if (typeof response.url === "string" && response.url.length > 0) {
+		const u = normalizeFredUrl(response.url);
+		if (u.length > 0 && !urls.includes(u)) urls.unshift(u);
+	}
+	const leaseUuid = typeof response.lease_uuid === "string" ? response.lease_uuid : void 0;
+	let outcome;
+	if (!leaseUuid) outcome = "failed";
+	else if (stateName === "LEASE_STATE_ACTIVE" && (urls.length > 0 || hasRunningInstances(response.connection))) outcome = "active";
+	else if (stateName !== void 0 && isTerminal(stateName)) outcome = "failed";
+	else outcome = "needs_wait";
+	const out = {
+		outcome,
+		...leaseUuid !== void 0 && { leaseUuid },
+		...typeof response.provider_uuid === "string" && { providerUuid: response.provider_uuid },
+		...typeof response.provider_url === "string" && { providerUrl: response.provider_url },
+		urls,
+		...stateName !== void 0 && { stateName }
+	};
+	if (outcome === "failed") if (typeof response.connectionError === "string") out.errorSummary = response.connectionError;
+	else if (!leaseUuid) out.errorSummary = "deploy_app returned no lease_uuid";
+	else out.errorSummary = `Lease ${leaseUuid} reached terminal state ${stateName || "UNKNOWN"}`;
+	return out;
+}
+//#endregion
+export { classifyDeployResponse };
+
+//# sourceMappingURL=classify-deploy-response.js.map

package/dist/internals/classify-deploy-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-deploy-response.js","names":["decodeLeaseState"],"sources":["../../src/internals/classify-deploy-response.ts"],"sourcesContent":["import {\n  extractRunningEndpoints,\n  formatEndpointAsUrl,\n  hasRunningInstances,\n  normalizeFredUrl,\n} from './connection.js';\nimport { decode as decodeLeaseState, isTerminal } from './lease-state.js';\n\n/**\n * Classify the RETURN envelope of `mcp__manifest-fred__deploy_app` into one\n * of three outcomes for the orchestrator to branch on.\n *\n * Companion to `classify-deploy-error.ts` (which handles the THROW path).\n *\n * Outcomes:\n *   - `'active'`     — state is LEASE_STATE_ACTIVE AND at least one\n *                      running instance exists. Internal-only deploys\n *                      (every port `ingress: false`) have running\n *                      instances but no FQDN, so the URL count alone\n *                      can't gate this; `hasRunningInstances` covers it.\n *                      Orchestrator can skip `wait_for_app_ready`.\n *   - `'needs_wait'` — lease created but not yet active, OR no running\n *                      instances yet (provider hasn't started the\n *                      container). Orchestrator polls `wait_for_app_ready`.\n *   - `'failed'`     — no `lease_uuid` present, OR state is a terminal\n *                      failure state (CLOSED / REJECTED / EXPIRED, plus\n *                      the legacy INSUFFICIENT_FUNDS defense-in-depth).\n *                      Orchestrator routes to troubleshoot/cleanup.\n *\n * Terminal-state set is the union of `TERMINAL_STATES` from `lease-state.ts`\n * — extended from the CJS's `{CLOSED, INSUFFICIENT_FUNDS}` to also cover\n * `REJECTED` and `EXPIRED` since those are emitted by manifestjs 2.4.1\n * (chain v2.1.0) as terminal states. INSUFFICIENT_FUNDS is unreachable\n * from `decode()` on the current chain but retained as defense-in-depth.\n * See `lease-state.ts` for the divergence rationale.\n *\n * Error summary format (qa-engineer's parity pin):\n *   - Lease present + terminal: `Lease ${leaseUuid} reached terminal state ${stateName || 'UNKNOWN'}`\n *   - Lease missing: `deploy_app returned no lease_uuid`\n *   - `connectionError` string present: passed through verbatim\n */\n\nexport interface DeployResponseShape {\n  lease_uuid?: unknown;\n  provider_uuid?: unknown;\n  provider_url?: unknown;\n  state?: unknown;\n  url?: unknown;\n  connection?: unknown;\n  connectionError?: unknown;\n}\n\nexport interface DeployResponseClassification {\n  outcome: 'active' | 'needs_wait' | 'failed';\n  leaseUuid?: string;\n  providerUuid?: string;\n  providerUrl?: string;\n  urls: string[];\n  stateName?: string;\n  errorSummary?: string;\n}\n\nexport function classifyDeployResponse(\n  response: DeployResponseShape,\n): DeployResponseClassification {\n  const stateName = decodeLeaseState(\n    typeof response.state === 'number' || typeof response.state === 'string'\n      ? response.state\n      : undefined,\n  );\n\n  // URL synthesis from connection payload + optional top-level `url`.\n  const urls: string[] = extractRunningEndpoints(response.connection).map(\n    formatEndpointAsUrl,\n  );\n  if (typeof response.url === 'string' && response.url.length > 0) {\n    const u = normalizeFredUrl(response.url);\n    if (u.length > 0 && !urls.includes(u)) urls.unshift(u);\n  }\n\n  const leaseUuid =\n    typeof response.lease_uuid === 'string' ? response.lease_uuid : undefined;\n\n  let outcome: DeployResponseClassification['outcome'];\n  if (!leaseUuid) {\n    outcome = 'failed';\n  } else if (\n    stateName === 'LEASE_STATE_ACTIVE' &&\n    (urls.length > 0 || hasRunningInstances(response.connection))\n  ) {\n    outcome = 'active';\n  } else if (stateName !== undefined && isTerminal(stateName)) {\n    outcome = 'failed';\n  } else {\n    // Pending / unspecified / active-without-any-running-instance / unknown.\n    outcome = 'needs_wait';\n  }\n\n  const out: DeployResponseClassification = {\n    outcome,\n    ...(leaseUuid !== undefined && { leaseUuid }),\n    ...(typeof response.provider_uuid === 'string' && {\n      providerUuid: response.provider_uuid,\n    }),\n    ...(typeof response.provider_url === 'string' && {\n      providerUrl: response.provider_url,\n    }),\n    urls,\n    ...(stateName !== undefined && { stateName }),\n  };\n\n  if (outcome === 'failed') {\n    if (typeof response.connectionError === 'string') {\n      out.errorSummary = response.connectionError;\n    } else if (!leaseUuid) {\n      out.errorSummary = 'deploy_app returned no lease_uuid';\n    } else {\n      // Byte-exact format (qa-engineer's parity pin):\n      // `Lease ${lease_uuid} reached terminal state ${stateName || 'UNKNOWN'}`\n      out.errorSummary = `Lease ${leaseUuid} reached terminal state ${\n        stateName || 'UNKNOWN'\n      }`;\n    }\n  }\n\n  return out;\n}\n"],"mappings":";;;AA8DA,SAAgB,uBACd,UAC8B;CAC9B,MAAM,YAAYA,OAChB,OAAO,SAAS,UAAU,YAAY,OAAO,SAAS,UAAU,WAC5D,SAAS,QACT,KAAA,EACL;CAGD,MAAM,OAAiB,wBAAwB,SAAS,WAAW,CAAC,IAClE,oBACD;AACD,KAAI,OAAO,SAAS,QAAQ,YAAY,SAAS,IAAI,SAAS,GAAG;EAC/D,MAAM,IAAI,iBAAiB,SAAS,IAAI;AACxC,MAAI,EAAE,SAAS,KAAK,CAAC,KAAK,SAAS,EAAE,CAAE,MAAK,QAAQ,EAAE;;CAGxD,MAAM,YACJ,OAAO,SAAS,eAAe,WAAW,SAAS,aAAa,KAAA;CAElE,IAAI;AACJ,KAAI,CAAC,UACH,WAAU;UAEV,cAAc,yBACb,KAAK,SAAS,KAAK,oBAAoB,SAAS,WAAW,EAE5D,WAAU;UACD,cAAc,KAAA,KAAa,WAAW,UAAU,CACzD,WAAU;KAGV,WAAU;CAGZ,MAAM,MAAoC;EACxC;EACA,GAAI,cAAc,KAAA,KAAa,EAAE,WAAW;EAC5C,GAAI,OAAO,SAAS,kBAAkB,YAAY,EAChD,cAAc,SAAS,eACxB;EACD,GAAI,OAAO,SAAS,iBAAiB,YAAY,EAC/C,aAAa,SAAS,cACvB;EACD;EACA,GAAI,cAAc,KAAA,KAAa,EAAE,WAAW;EAC7C;AAED,KAAI,YAAY,SACd,KAAI,OAAO,SAAS,oBAAoB,SACtC,KAAI,eAAe,SAAS;UACnB,CAAC,UACV,KAAI,eAAe;KAInB,KAAI,eAAe,SAAS,UAAU,0BACpC,aAAa;AAKnB,QAAO"}

package/dist/internals/connection.d.ts

@@ -0,0 +1,76 @@
+//#region src/internals/connection.d.ts
+/**
+ * Helpers for walking the provider's `connection` payload returned by
+ * `mcp__manifest-fred__deploy_app` / `app_status` / `wait_for_app_ready`.
+ *
+ * The provider emits instance lists in one or both of:
+ *   - top-level `connection.instances[]` (single-service / non-services-map shape)
+ *   - per-service `connection.services.<name>.instances[]` (stack /
+ *     services-map shape — emitted whenever the spec uses services-map form,
+ *     which `build_manifest_preview` does even for single-service deploys to
+ *     enable per-port `ingress: bool`)
+ *
+ * Subdomain-based routing on the provider: port is NOT part of the URL.
+ * One user-facing URL per FQDN regardless of container port count.
+ *
+ * Unrecognized payload shape: returns `[]` and invokes the logger
+ * (defaults to `console.warn`; override via `opts.logger`) so a future
+ * provider-shape divergence is loud rather than silent. The CJS uses
+ * `process.stderr.write`; the TS port surfaces via an injectable logger
+ * to keep agent-core platform-neutral while preserving the always-loud
+ * CJS posture by default.
+ */
+interface RunningEndpoint {
+  readonly fqdn: string;
+}
+interface ConnectionWalkOptions {
+  /**
+   * Sink for warnings about unrecognized connection shapes. Defaults to
+   * `console.warn` (Web Standard; platform-neutral across Node, browsers,
+   * Deno, Bun) so a future provider-shape divergence is loud rather than
+   * silent. Host surfaces that want to route elsewhere (structured
+   * stderr, UI toast, log file) can override; surfaces that want to
+   * suppress entirely can pass `() => {}` explicitly — silence becomes a
+   * consumer-controlled opt-out instead of the easy-to-forget default.
+   */
+  logger?: (reason: string) => void;
+}
+/**
+ * Returns a deduped list of running instances (status === 'running' AND
+ * `fqdn` populated) found anywhere under `connection.instances` or
+ * `connection.services.<name>.instances`.
+ */
+declare function extractRunningEndpoints(connection: unknown, opts?: ConnectionWalkOptions): RunningEndpoint[];
+/** Render an endpoint as a bare FQDN string (for ingress lists). */
+declare function formatEndpointAsIngress(ep: RunningEndpoint): string;
+/** Render an endpoint as a full `https://<fqdn>/` URL. */
+declare function formatEndpointAsUrl(ep: RunningEndpoint): string;
+/**
+ * Normalize fred's top-level `url` field to a full `http(s)://...`
+ * string. Defensive fallback for the legacy `connection.host` / `ports`
+ * shape: fred surfaces a top-level `url` when no `connection.instances`
+ * FQDN is available, and the value may or may not carry a scheme.
+ *
+ * Mirrors the inline logic that lived in three call sites
+ * (`classify-deploy-response.ts:76-80`, `format-success.ts` ingress
+ * fallback, `deploy-app.ts` `DeployResult.urls` fallback) — factored
+ * here so all three share one source of truth.
+ *
+ * - Returns `''` for empty input (caller branches into a different
+ *   render path if needed).
+ * - Passes through unchanged if already prefixed `http://` or
+ *   `https://` (case-insensitive).
+ * - Otherwise wraps as `https://${raw}/`.
+ */
+declare function normalizeFredUrl(raw: string): string;
+/**
+ * True iff any instance anywhere in the connection payload has
+ * `status === 'running'`, regardless of `fqdn`. Used by
+ * `classify-deploy-response.ts` to recognize internal-only deploys
+ * (every port `ingress: false`) as `active` rather than misclassifying
+ * them as `needs_wait` because they have no public URLs to surface.
+ */
+declare function hasRunningInstances(connection: unknown): boolean;
+//#endregion
+export { ConnectionWalkOptions, RunningEndpoint, extractRunningEndpoints, formatEndpointAsIngress, formatEndpointAsUrl, hasRunningInstances, normalizeFredUrl };
+//# sourceMappingURL=connection.d.ts.map

package/dist/internals/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","names":[],"sources":["../../src/internals/connection.ts"],"mappings":";;AAsBA;;;;;AAIA;;;;;AAkBA;;;;;;;;;;UAtBiB,eAAA;EAAA,SACN,IAAA;AAAA;AAAA,UAGM,qBAAA;EAuE0C;AAK3D;;;;;AAqBA;;;EAvFE,MAAA,IAAU,MAAA;AAAA;AAmGZ;;;;;AAAA,iBA3FgB,uBAAA,CACd,UAAA,WACA,IAAA,GAAM,qBAAA,GACL,eAAA;;iBAkDa,uBAAA,CAAwB,EAAA,EAAI,eAAA;;iBAK5B,mBAAA,CAAoB,EAAA,EAAI,eAAA;;;;;;;;;;;;;;;;;;iBAqBxB,gBAAA,CAAiB,GAAA;;;;;;;;iBAYjB,mBAAA,CAAoB,UAAA"}

package/dist/internals/connection.js

@@ -0,0 +1,94 @@
+//#region src/internals/connection.ts
+/**
+* Returns a deduped list of running instances (status === 'running' AND
+* `fqdn` populated) found anywhere under `connection.instances` or
+* `connection.services.<name>.instances`.
+*/
+function extractRunningEndpoints(connection, opts = {}) {
+	if (!isPlainObject(connection)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const endpoints = [];
+	const pushFromInstances = (instances) => {
+		if (!Array.isArray(instances)) return;
+		for (const inst of instances) {
+			if (!isPlainObject(inst)) continue;
+			if (inst.status !== "running") continue;
+			if (typeof inst.fqdn !== "string" || inst.fqdn.length === 0) continue;
+			if (seen.has(inst.fqdn)) continue;
+			seen.add(inst.fqdn);
+			endpoints.push({ fqdn: inst.fqdn });
+		}
+	};
+	pushFromInstances(connection.instances);
+	const services = connection.services;
+	if (isPlainObject(services)) {
+		for (const svc of Object.values(services)) if (isPlainObject(svc)) pushFromInstances(svc.instances);
+	}
+	const ownKeys = Object.keys(connection);
+	if (!(ownKeys.includes("instances") || ownKeys.includes("services"))) {
+		const keys = Object.keys(connection).slice(0, 8).join(", ") || "(empty)";
+		(opts.logger ?? defaultLogger)(`connection: unrecognized shape (no 'instances' or 'services' key found; keys present: ${keys}). Returning empty endpoints — the orchestrator will report no ingresses for this lease. Provider may have shipped a new shape; check manifest-mcp-fred ConnectionDetails.`);
+	}
+	return endpoints;
+}
+/** Render an endpoint as a bare FQDN string (for ingress lists). */
+function formatEndpointAsIngress(ep) {
+	return ep.fqdn;
+}
+/** Render an endpoint as a full `https://<fqdn>/` URL. */
+function formatEndpointAsUrl(ep) {
+	return `https://${ep.fqdn}/`;
+}
+/**
+* Normalize fred's top-level `url` field to a full `http(s)://...`
+* string. Defensive fallback for the legacy `connection.host` / `ports`
+* shape: fred surfaces a top-level `url` when no `connection.instances`
+* FQDN is available, and the value may or may not carry a scheme.
+*
+* Mirrors the inline logic that lived in three call sites
+* (`classify-deploy-response.ts:76-80`, `format-success.ts` ingress
+* fallback, `deploy-app.ts` `DeployResult.urls` fallback) — factored
+* here so all three share one source of truth.
+*
+* - Returns `''` for empty input (caller branches into a different
+*   render path if needed).
+* - Passes through unchanged if already prefixed `http://` or
+*   `https://` (case-insensitive).
+* - Otherwise wraps as `https://${raw}/`.
+*/
+function normalizeFredUrl(raw) {
+	if (raw.length === 0) return "";
+	return /^https?:\/\//i.test(raw) ? raw : `https://${raw}/`;
+}
+/**
+* True iff any instance anywhere in the connection payload has
+* `status === 'running'`, regardless of `fqdn`. Used by
+* `classify-deploy-response.ts` to recognize internal-only deploys
+* (every port `ingress: false`) as `active` rather than misclassifying
+* them as `needs_wait` because they have no public URLs to surface.
+*/
+function hasRunningInstances(connection) {
+	if (!isPlainObject(connection)) return false;
+	const runs = (instances) => Array.isArray(instances) && instances.some((i) => isPlainObject(i) && i.status === "running");
+	if (runs(connection.instances)) return true;
+	const services = connection.services;
+	if (isPlainObject(services)) {
+		for (const svc of Object.values(services)) if (isPlainObject(svc) && runs(svc.instances)) return true;
+	}
+	return false;
+}
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Default logger — `console.warn`. Defined as a module-level constant so
+* test code can spy on it (`vi.spyOn(console, 'warn')`) without races
+* around the import order of the binding.
+*/
+const defaultLogger = (reason) => {
+	console.warn(reason);
+};
+//#endregion
+export { extractRunningEndpoints, formatEndpointAsIngress, formatEndpointAsUrl, hasRunningInstances, normalizeFredUrl };
+
+//# sourceMappingURL=connection.js.map

package/dist/internals/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.js","names":[],"sources":["../../src/internals/connection.ts"],"sourcesContent":["/**\n * Helpers for walking the provider's `connection` payload returned by\n * `mcp__manifest-fred__deploy_app` / `app_status` / `wait_for_app_ready`.\n *\n * The provider emits instance lists in one or both of:\n *   - top-level `connection.instances[]` (single-service / non-services-map shape)\n *   - per-service `connection.services.<name>.instances[]` (stack /\n *     services-map shape — emitted whenever the spec uses services-map form,\n *     which `build_manifest_preview` does even for single-service deploys to\n *     enable per-port `ingress: bool`)\n *\n * Subdomain-based routing on the provider: port is NOT part of the URL.\n * One user-facing URL per FQDN regardless of container port count.\n *\n * Unrecognized payload shape: returns `[]` and invokes the logger\n * (defaults to `console.warn`; override via `opts.logger`) so a future\n * provider-shape divergence is loud rather than silent. The CJS uses\n * `process.stderr.write`; the TS port surfaces via an injectable logger\n * to keep agent-core platform-neutral while preserving the always-loud\n * CJS posture by default.\n */\n\nexport interface RunningEndpoint {\n  readonly fqdn: string;\n}\n\nexport interface ConnectionWalkOptions {\n  /**\n   * Sink for warnings about unrecognized connection shapes. Defaults to\n   * `console.warn` (Web Standard; platform-neutral across Node, browsers,\n   * Deno, Bun) so a future provider-shape divergence is loud rather than\n   * silent. Host surfaces that want to route elsewhere (structured\n   * stderr, UI toast, log file) can override; surfaces that want to\n   * suppress entirely can pass `() => {}` explicitly — silence becomes a\n   * consumer-controlled opt-out instead of the easy-to-forget default.\n   */\n  logger?: (reason: string) => void;\n}\n\n/**\n * Returns a deduped list of running instances (status === 'running' AND\n * `fqdn` populated) found anywhere under `connection.instances` or\n * `connection.services.<name>.instances`.\n */\nexport function extractRunningEndpoints(\n  connection: unknown,\n  opts: ConnectionWalkOptions = {},\n): RunningEndpoint[] {\n  if (!isPlainObject(connection)) return [];\n  const seen = new Set<string>();\n  const endpoints: RunningEndpoint[] = [];\n\n  const pushFromInstances = (instances: unknown): void => {\n    if (!Array.isArray(instances)) return;\n    for (const inst of instances) {\n      if (!isPlainObject(inst)) continue;\n      if (inst.status !== 'running') continue;\n      if (typeof inst.fqdn !== 'string' || inst.fqdn.length === 0) continue;\n      if (seen.has(inst.fqdn)) continue;\n      seen.add(inst.fqdn);\n      endpoints.push({ fqdn: inst.fqdn });\n    }\n  };\n\n  pushFromInstances(connection.instances);\n\n  const services = connection.services;\n  if (isPlainObject(services)) {\n    for (const svc of Object.values(services)) {\n      if (isPlainObject(svc)) pushFromInstances(svc.instances);\n    }\n  }\n\n  // Only warn when neither `instances` nor `services` is present at all.\n  // The empty-but-present case (no instance has status 'running') is a\n  // legitimate \"lease pending, wait_for_app_ready hasn't returned yet\" state\n  // — returning [] there is the correct, non-warning behavior.\n  // Object.keys + includes avoids both ES2022's `Object.hasOwn` (base\n  // tsconfig targets ES2020) and biome's `noPrototypeBuiltins` rule on\n  // `Object.prototype.hasOwnProperty.call`.\n  const ownKeys = Object.keys(connection);\n  const hasModernShape =\n    ownKeys.includes('instances') || ownKeys.includes('services');\n  if (!hasModernShape) {\n    const keys = Object.keys(connection).slice(0, 8).join(', ') || '(empty)';\n    const logger = opts.logger ?? defaultLogger;\n    logger(\n      `connection: unrecognized shape (no 'instances' or 'services' key found; keys present: ${keys}). ` +\n        'Returning empty endpoints — the orchestrator will report no ingresses for this lease. ' +\n        'Provider may have shipped a new shape; check manifest-mcp-fred ConnectionDetails.',\n    );\n  }\n\n  return endpoints;\n}\n\n/** Render an endpoint as a bare FQDN string (for ingress lists). */\nexport function formatEndpointAsIngress(ep: RunningEndpoint): string {\n  return ep.fqdn;\n}\n\n/** Render an endpoint as a full `https://<fqdn>/` URL. */\nexport function formatEndpointAsUrl(ep: RunningEndpoint): string {\n  return `https://${ep.fqdn}/`;\n}\n\n/**\n * Normalize fred's top-level `url` field to a full `http(s)://...`\n * string. Defensive fallback for the legacy `connection.host` / `ports`\n * shape: fred surfaces a top-level `url` when no `connection.instances`\n * FQDN is available, and the value may or may not carry a scheme.\n *\n * Mirrors the inline logic that lived in three call sites\n * (`classify-deploy-response.ts:76-80`, `format-success.ts` ingress\n * fallback, `deploy-app.ts` `DeployResult.urls` fallback) — factored\n * here so all three share one source of truth.\n *\n * - Returns `''` for empty input (caller branches into a different\n *   render path if needed).\n * - Passes through unchanged if already prefixed `http://` or\n *   `https://` (case-insensitive).\n * - Otherwise wraps as `https://${raw}/`.\n */\nexport function normalizeFredUrl(raw: string): string {\n  if (raw.length === 0) return '';\n  return /^https?:\\/\\//i.test(raw) ? raw : `https://${raw}/`;\n}\n\n/**\n * True iff any instance anywhere in the connection payload has\n * `status === 'running'`, regardless of `fqdn`. Used by\n * `classify-deploy-response.ts` to recognize internal-only deploys\n * (every port `ingress: false`) as `active` rather than misclassifying\n * them as `needs_wait` because they have no public URLs to surface.\n */\nexport function hasRunningInstances(connection: unknown): boolean {\n  if (!isPlainObject(connection)) return false;\n  const runs = (instances: unknown): boolean =>\n    Array.isArray(instances) &&\n    instances.some((i) => isPlainObject(i) && i.status === 'running');\n  if (runs(connection.instances)) return true;\n  const services = connection.services;\n  if (isPlainObject(services)) {\n    for (const svc of Object.values(services)) {\n      if (isPlainObject(svc) && runs(svc.instances)) return true;\n    }\n  }\n  return false;\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\n/**\n * Default logger — `console.warn`. Defined as a module-level constant so\n * test code can spy on it (`vi.spyOn(console, 'warn')`) without races\n * around the import order of the binding.\n */\nconst defaultLogger: (reason: string) => void = (reason) => {\n  console.warn(reason);\n};\n"],"mappings":";;;;;;AA4CA,SAAgB,wBACd,YACA,OAA8B,EAAE,EACb;AACnB,KAAI,CAAC,cAAc,WAAW,CAAE,QAAO,EAAE;CACzC,MAAM,uBAAO,IAAI,KAAa;CAC9B,MAAM,YAA+B,EAAE;CAEvC,MAAM,qBAAqB,cAA6B;AACtD,MAAI,CAAC,MAAM,QAAQ,UAAU,CAAE;AAC/B,OAAK,MAAM,QAAQ,WAAW;AAC5B,OAAI,CAAC,cAAc,KAAK,CAAE;AAC1B,OAAI,KAAK,WAAW,UAAW;AAC/B,OAAI,OAAO,KAAK,SAAS,YAAY,KAAK,KAAK,WAAW,EAAG;AAC7D,OAAI,KAAK,IAAI,KAAK,KAAK,CAAE;AACzB,QAAK,IAAI,KAAK,KAAK;AACnB,aAAU,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;AAIvC,mBAAkB,WAAW,UAAU;CAEvC,MAAM,WAAW,WAAW;AAC5B,KAAI,cAAc,SAAS;OACpB,MAAM,OAAO,OAAO,OAAO,SAAS,CACvC,KAAI,cAAc,IAAI,CAAE,mBAAkB,IAAI,UAAU;;CAW5D,MAAM,UAAU,OAAO,KAAK,WAAW;AAGvC,KAAI,EADF,QAAQ,SAAS,YAAY,IAAI,QAAQ,SAAS,WAAW,GAC1C;EACnB,MAAM,OAAO,OAAO,KAAK,WAAW,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,KAAK,IAAI;AAE/D,GADe,KAAK,UAAU,eAE5B,yFAAyF,KAAK,4KAG/F;;AAGH,QAAO;;;AAIT,SAAgB,wBAAwB,IAA6B;AACnE,QAAO,GAAG;;;AAIZ,SAAgB,oBAAoB,IAA6B;AAC/D,QAAO,WAAW,GAAG,KAAK;;;;;;;;;;;;;;;;;;;AAoB5B,SAAgB,iBAAiB,KAAqB;AACpD,KAAI,IAAI,WAAW,EAAG,QAAO;AAC7B,QAAO,gBAAgB,KAAK,IAAI,GAAG,MAAM,WAAW,IAAI;;;;;;;;;AAU1D,SAAgB,oBAAoB,YAA8B;AAChE,KAAI,CAAC,cAAc,WAAW,CAAE,QAAO;CACvC,MAAM,QAAQ,cACZ,MAAM,QAAQ,UAAU,IACxB,UAAU,MAAM,MAAM,cAAc,EAAE,IAAI,EAAE,WAAW,UAAU;AACnE,KAAI,KAAK,WAAW,UAAU,CAAE,QAAO;CACvC,MAAM,WAAW,WAAW;AAC5B,KAAI,cAAc,SAAS;OACpB,MAAM,OAAO,OAAO,OAAO,SAAS,CACvC,KAAI,cAAc,IAAI,IAAI,KAAK,IAAI,UAAU,CAAE,QAAO;;AAG1D,QAAO;;AAGT,SAAS,cAAc,OAAkD;AACvE,QAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,MAAM;;;;;;;AAQ7E,MAAM,iBAA2C,WAAW;AAC1D,SAAQ,KAAK,OAAO"}

package/dist/internals/evaluate-readiness.d.ts

@@ -0,0 +1,55 @@
+import { Coin, DenomMap, Readiness } from "../types.js";
+//#region src/internals/evaluate-readiness.d.ts
+/**
+ * Inputs passed to `evaluateReadiness`. camelCase throughout — high-level
+ * callers translate the snake_case MCP response shape before invocation.
+ */
+interface EvaluateReadinessInputs {
+  /** Tenant address (bech32). Not consumed by the algorithm; included for journal/log context. */
+  tenant: string;
+  /** Image ref being considered (may be `null` when only the size is selected). */
+  image: string | null;
+  /** SKU size string the caller wants (`'docker-micro'`, etc.). `null` when not yet chosen. */
+  size: string | null;
+  /** Wallet bank balances. */
+  walletBalances: Coin[];
+  /** Credit account data, or `null` when no credit account is funded. */
+  credits: {
+    availableBalances?: Coin[]; /** Older response variant — fallback when `availableBalances` is absent. */
+    balances?: Coin[]; /** Live current credit balance(s) when the tenant has at least one active lease. */
+    currentBalance?: Coin[]; /** Hours of runtime at the user's current overall burn rate (string-encoded number). */
+    hoursRemaining?: string;
+  } | null;
+  /** Chosen SKU + price, or `null` when no size selected. */
+  sku: {
+    name: string;
+    price: Coin;
+  } | null;
+  /** All active SKU names the chain currently advertises. */
+  availableSkuNames: string[];
+  /** Gas-price string (e.g. `'1umfx'`, `'0.37upwr'`). Required — drives the wallet-gas check denom. */
+  gasPrice: string;
+  /** Override the per-denom warn floor (smallest unit). When omitted, uses the per-denom default or 50_000n fallback. */
+  gasWarnFloor?: bigint;
+  /**
+   * Pre-loaded `DenomMap` for symbol humanization. The orchestrator
+   * (`deploy-app.ts` and PR-4 callers) is responsible for composing the
+   * map via `loadChainDenomMap(chainDataFile)` and passing it in. This
+   * keeps `evaluateReadiness` pure-sync — I/O lives at the orchestrator
+   * boundary, not inside the decision function (post-Q4 Bii verdict).
+   *
+   * When omitted, the no-op map is used; balances + SKU prices render
+   * with raw on-chain denoms.
+   */
+  denomMap?: DenomMap;
+}
+/**
+ * Compute the `Readiness` verdict for a prospective deployment.
+ *
+ * Throws `TypeError` on malformed `gasPrice` (the only input field whose
+ * runtime shape isn't enforced by the typed signature).
+ */
+declare function evaluateReadiness(inputs: EvaluateReadinessInputs): Readiness;
+//#endregion
+export { EvaluateReadinessInputs, evaluateReadiness };
+//# sourceMappingURL=evaluate-readiness.d.ts.map

package/dist/internals/evaluate-readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-readiness.d.ts","names":[],"sources":["../../src/internals/evaluate-readiness.ts"],"mappings":";;;;AAwDA;;UAAiB,uBAAA;EAQC;EANhB,MAAA;EAWa;EATb,KAAA;EAgB4B;EAd5B,IAAA;EA+BmB;EA7BnB,cAAA,EAAgB,IAAA;EANhB;EAQA,OAAA;IACE,iBAAA,GAAoB,IAAA,IAHtB;IAKE,QAAA,GAAW,IAAA,IAHb;IAKE,cAAA,GAAiB,IAAA,IAJG;IAMpB,cAAA;EAAA;EAFA;EAKF,GAAA;IAAO,IAAA;IAAc,KAAA,EAAO,IAAA;EAAA;EAAP;EAErB,iBAAA;EAAA;EAEA,QAAA;EAEA;EAAA,YAAA;EAWW;;;AASb;;;;;;;EATE,QAAA,GAAW,QAAA;AAAA;;;;;;;iBASG,iBAAA,CAAkB,MAAA,EAAQ,uBAAA,GAA0B,SAAA"}

package/dist/internals/evaluate-readiness.js

@@ -0,0 +1,131 @@
+import { EMPTY_DENOM_MAP, denomToSymbol, humanizeCoin } from "./humanize-denom.js";
+//#region src/internals/evaluate-readiness.ts
+/**
+* Evaluate `check_deployment_readiness` MCP response data into the frozen
+* `Readiness` shape (camelCase typed input + the `Readiness` contract from
+* ENG-128).
+*
+* Thresholds are encoded here (not in skill prose or caller config) so the
+* rules stay consistent across runs:
+*   - HOURS_REMAINING_WARN_FLOOR = 24
+*   - GAS_BALANCE_WARN_FLOOR (per-denom) = 50_000n umfx | upwr
+*
+* Status semantics (CJS-parity):
+*   - `'block'` — cannot proceed (SKU unavailable, wallet empty)
+*   - `'warn'`  — proceedable but risky (low credits, low gas balance, no credit account)
+*   - `'ok'`    — silent pass
+*
+* `suggestedActions` are semantic tokens from the frozen `ReadinessAction`
+* union — not prose for the user. Surfaces map these to UI affordances.
+*
+* Walked-from-CJS field-rename: the MCP response uses snake_case
+* (`wallet_balances`, `available_balances`, `hours_remaining`,
+* `available_sku_names`, `current_balance`); the TS-port input is
+* camelCase, and high-level callers (PR 3's `deployApp`) translate the
+* snake_case wire shape into camelCase before passing in.
+*/
+const HOURS_REMAINING_WARN_FLOOR = 24;
+const GAS_BALANCE_WARN_FLOOR_DEFAULTS = {
+	umfx: 50000n,
+	upwr: 50000n
+};
+const GAS_BALANCE_WARN_FLOOR_FALLBACK = 50000n;
+/**
+* Cosmos convention for gas-price strings: leading numeric (digits +
+* optional decimal point), then the denom. Denom grammar mirrors
+* `sdk.ValidateDenom`: `[a-zA-Z][a-zA-Z0-9/:._-]{2,127}`.
+* Anchored both ends so trailing whitespace fails fast.
+*/
+const GAS_PRICE_RE = /^[0-9]+(?:\.[0-9]+)?([a-zA-Z][a-zA-Z0-9/:._-]{2,127})$/;
+/**
+* Compute the `Readiness` verdict for a prospective deployment.
+*
+* Throws `TypeError` on malformed `gasPrice` (the only input field whose
+* runtime shape isn't enforced by the typed signature).
+*/
+function evaluateReadiness(inputs) {
+	const gasDenomMatch = inputs.gasPrice.match(GAS_PRICE_RE);
+	if (!gasDenomMatch || gasDenomMatch[1] === void 0) throw new TypeError(`evaluateReadiness: gasPrice must match <numeric><denom> (e.g. "1umfx" or "0.37upwr"); got "${inputs.gasPrice}"`);
+	const gasDenom = gasDenomMatch[1];
+	const gasWarnFloor = inputs.gasWarnFloor !== void 0 ? validateGasWarnFloor(inputs.gasWarnFloor) : GAS_BALANCE_WARN_FLOOR_DEFAULTS[gasDenom] ?? GAS_BALANCE_WARN_FLOOR_FALLBACK;
+	const denomMap = inputs.denomMap ?? EMPTY_DENOM_MAP;
+	const reasons = [];
+	const actions = /* @__PURE__ */ new Set();
+	let status = "ok";
+	if (inputs.size !== null && !inputs.availableSkuNames.includes(inputs.size)) {
+		status = "block";
+		const available = inputs.availableSkuNames.length > 0 ? inputs.availableSkuNames.join(", ") : "(none)";
+		reasons.push(`Requested SKU "${inputs.size}" is not currently offered. Available: ${available}.`);
+		actions.add("pick_different_sku");
+	}
+	const gasEntry = inputs.walletBalances.find((b) => b.denom === gasDenom);
+	const gasAmount = gasEntry ? asBigInt(gasEntry.amount) : 0n;
+	if (inputs.walletBalances.length === 0 || gasAmount === 0n) {
+		status = "block";
+		reasons.push(`Wallet has no ${denomToSymbol(gasDenom, denomMap)} balance for gas.`);
+		actions.add("request_faucet");
+		actions.add("topup_wallet");
+	} else if (gasAmount < gasWarnFloor) {
+		if (status === "ok") status = "warn";
+		reasons.push(`Wallet balance (${humanizeCoin(gasAmount.toString(), gasDenom, denomMap)}) is below ${humanizeCoin(gasWarnFloor.toString(), gasDenom, denomMap)}; broadcast may run out of gas.`);
+		actions.add("topup_wallet");
+	}
+	const credits = inputs.credits;
+	if (credits === null) {
+		if (status === "ok") status = "warn";
+		reasons.push("No credit account funded for compute leases.");
+		actions.add("fund_credit");
+	} else if (inputs.sku !== null && inputs.sku.price.amount.length > 0 && inputs.sku.price.denom.length > 0) {
+		const skuPrice = inputs.sku.price;
+		const creditBalances = Array.isArray(credits.availableBalances) ? credits.availableBalances : Array.isArray(credits.balances) ? credits.balances : Array.isArray(credits.currentBalance) ? credits.currentBalance : [];
+		const creditEntry = creditBalances.find((b) => b.denom === skuPrice.denom);
+		const pricePerHour = asBigInt(skuPrice.amount);
+		if (creditEntry === void 0) {
+			const fundedDenoms = creditBalances.map((b) => b.denom).filter((d) => typeof d === "string" && d.length > 0);
+			const skuSymbol = denomToSymbol(skuPrice.denom, denomMap);
+			const fundedSymbols = fundedDenoms.map((d) => denomToSymbol(d, denomMap));
+			if (status === "ok") status = "warn";
+			reasons.push(fundedDenoms.length > 0 ? `Credit account has no ${skuSymbol} balance (the ${inputs.sku.name} SKU charges in ${skuSymbol}; account holds ${fundedSymbols.join(", ")}). Fund ${skuSymbol} credits before deploying.` : `Credit account is empty for the ${inputs.sku.name} SKU's ${skuSymbol} denom. Fund ${skuSymbol} credits before deploying.`);
+			actions.add("fund_credit");
+		} else if (pricePerHour > 0n) {
+			const creditAmount = asBigInt(creditEntry.amount);
+			const hrsForThisSku = Number(creditAmount) / Number(pricePerHour);
+			if (hrsForThisSku < HOURS_REMAINING_WARN_FLOOR) {
+				if (status === "ok") status = "warn";
+				reasons.push(`Credits cover ~${hrsForThisSku.toFixed(1)}h of runtime at the ${inputs.sku.name} SKU (${humanizeCoin(creditAmount.toString(), skuPrice.denom, denomMap)} / ${humanizeCoin(pricePerHour.toString(), skuPrice.denom, denomMap)} per hour); below the ${HOURS_REMAINING_WARN_FLOOR}h floor.`);
+				actions.add("fund_credit");
+			}
+		}
+	} else if (credits.hoursRemaining !== void 0) {
+		const hrs = Number(credits.hoursRemaining);
+		if (Number.isFinite(hrs) && hrs > 0 && hrs < HOURS_REMAINING_WARN_FLOOR) {
+			if (status === "ok") status = "warn";
+			reasons.push(`Credits cover ~${hrs.toFixed(1)}h of runtime at the current burn rate; below the ${HOURS_REMAINING_WARN_FLOOR}h floor.`);
+			actions.add("fund_credit");
+		}
+	}
+	const creditsOut = credits === null ? null : { availableBalances: Array.isArray(credits.availableBalances) ? credits.availableBalances : Array.isArray(credits.balances) ? credits.balances : Array.isArray(credits.currentBalance) ? credits.currentBalance : [] };
+	return {
+		status,
+		reasons,
+		suggestedActions: Array.from(actions),
+		walletBalances: inputs.walletBalances,
+		credits: creditsOut,
+		sku: inputs.sku
+	};
+}
+function asBigInt(s) {
+	try {
+		return BigInt(s);
+	} catch {
+		return 0n;
+	}
+}
+function validateGasWarnFloor(value) {
+	if (value < 0n) throw new TypeError(`evaluateReadiness: gasWarnFloor must be a non-negative integer, got ${value}`);
+	return value;
+}
+//#endregion
+export { evaluateReadiness };
+
+//# sourceMappingURL=evaluate-readiness.js.map

package/dist/internals/evaluate-readiness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-readiness.js","names":[],"sources":["../../src/internals/evaluate-readiness.ts"],"sourcesContent":["import type { Coin, Readiness, ReadinessAction } from '../types.js';\nimport {\n  type DenomMap,\n  denomToSymbol,\n  EMPTY_DENOM_MAP,\n  humanizeCoin,\n} from './humanize-denom.js';\n\n/**\n * Evaluate `check_deployment_readiness` MCP response data into the frozen\n * `Readiness` shape (camelCase typed input + the `Readiness` contract from\n * ENG-128).\n *\n * Thresholds are encoded here (not in skill prose or caller config) so the\n * rules stay consistent across runs:\n *   - HOURS_REMAINING_WARN_FLOOR = 24\n *   - GAS_BALANCE_WARN_FLOOR (per-denom) = 50_000n umfx | upwr\n *\n * Status semantics (CJS-parity):\n *   - `'block'` — cannot proceed (SKU unavailable, wallet empty)\n *   - `'warn'`  — proceedable but risky (low credits, low gas balance, no credit account)\n *   - `'ok'`    — silent pass\n *\n * `suggestedActions` are semantic tokens from the frozen `ReadinessAction`\n * union — not prose for the user. Surfaces map these to UI affordances.\n *\n * Walked-from-CJS field-rename: the MCP response uses snake_case\n * (`wallet_balances`, `available_balances`, `hours_remaining`,\n * `available_sku_names`, `current_balance`); the TS-port input is\n * camelCase, and high-level callers (PR 3's `deployApp`) translate the\n * snake_case wire shape into camelCase before passing in.\n */\n\nconst HOURS_REMAINING_WARN_FLOOR = 24;\n\n// Per-denom warn floors for low gas balance (in smallest unit). Mirrors the\n// CJS values: 50_000 umfx = 0.05 MFX (1 MFX = 1,000,000 umfx); comparable\n// headroom for upwr.\nconst GAS_BALANCE_WARN_FLOOR_DEFAULTS: Readonly<Record<string, bigint>> = {\n  umfx: 50_000n,\n  upwr: 50_000n,\n};\nconst GAS_BALANCE_WARN_FLOOR_FALLBACK = 50_000n;\n\n/**\n * Cosmos convention for gas-price strings: leading numeric (digits +\n * optional decimal point), then the denom. Denom grammar mirrors\n * `sdk.ValidateDenom`: `[a-zA-Z][a-zA-Z0-9/:._-]{2,127}`.\n * Anchored both ends so trailing whitespace fails fast.\n */\nconst GAS_PRICE_RE = /^[0-9]+(?:\\.[0-9]+)?([a-zA-Z][a-zA-Z0-9/:._-]{2,127})$/;\n\n/**\n * Inputs passed to `evaluateReadiness`. camelCase throughout — high-level\n * callers translate the snake_case MCP response shape before invocation.\n */\nexport interface EvaluateReadinessInputs {\n  /** Tenant address (bech32). Not consumed by the algorithm; included for journal/log context. */\n  tenant: string;\n  /** Image ref being considered (may be `null` when only the size is selected). */\n  image: string | null;\n  /** SKU size string the caller wants (`'docker-micro'`, etc.). `null` when not yet chosen. */\n  size: string | null;\n  /** Wallet bank balances. */\n  walletBalances: Coin[];\n  /** Credit account data, or `null` when no credit account is funded. */\n  credits: {\n    availableBalances?: Coin[];\n    /** Older response variant — fallback when `availableBalances` is absent. */\n    balances?: Coin[];\n    /** Live current credit balance(s) when the tenant has at least one active lease. */\n    currentBalance?: Coin[];\n    /** Hours of runtime at the user's current overall burn rate (string-encoded number). */\n    hoursRemaining?: string;\n  } | null;\n  /** Chosen SKU + price, or `null` when no size selected. */\n  sku: { name: string; price: Coin } | null;\n  /** All active SKU names the chain currently advertises. */\n  availableSkuNames: string[];\n  /** Gas-price string (e.g. `'1umfx'`, `'0.37upwr'`). Required — drives the wallet-gas check denom. */\n  gasPrice: string;\n  /** Override the per-denom warn floor (smallest unit). When omitted, uses the per-denom default or 50_000n fallback. */\n  gasWarnFloor?: bigint;\n  /**\n   * Pre-loaded `DenomMap` for symbol humanization. The orchestrator\n   * (`deploy-app.ts` and PR-4 callers) is responsible for composing the\n   * map via `loadChainDenomMap(chainDataFile)` and passing it in. This\n   * keeps `evaluateReadiness` pure-sync — I/O lives at the orchestrator\n   * boundary, not inside the decision function (post-Q4 Bii verdict).\n   *\n   * When omitted, the no-op map is used; balances + SKU prices render\n   * with raw on-chain denoms.\n   */\n  denomMap?: DenomMap;\n}\n\n/**\n * Compute the `Readiness` verdict for a prospective deployment.\n *\n * Throws `TypeError` on malformed `gasPrice` (the only input field whose\n * runtime shape isn't enforced by the typed signature).\n */\nexport function evaluateReadiness(inputs: EvaluateReadinessInputs): Readiness {\n  // --- Parse + validate gasPrice via String.match (avoids RegExp.exec) ---\n  const gasDenomMatch = inputs.gasPrice.match(GAS_PRICE_RE);\n  if (!gasDenomMatch || gasDenomMatch[1] === undefined) {\n    throw new TypeError(\n      `evaluateReadiness: gasPrice must match <numeric><denom> (e.g. \"1umfx\" or \"0.37upwr\"); got \"${inputs.gasPrice}\"`,\n    );\n  }\n  const gasDenom = gasDenomMatch[1];\n\n  // --- Resolve gas warn floor ---\n  const gasWarnFloor =\n    inputs.gasWarnFloor !== undefined\n      ? validateGasWarnFloor(inputs.gasWarnFloor)\n      : (GAS_BALANCE_WARN_FLOOR_DEFAULTS[gasDenom] ??\n        GAS_BALANCE_WARN_FLOOR_FALLBACK);\n\n  // --- Resolve denom map ---\n  // Pure-sync decision function: callers pre-load the map via\n  // `loadChainDenomMap(chainDataFile)` and pass it in. When absent, the\n  // empty no-op map is used (raw on-chain denom rendering downstream).\n  // See Q4 Bii rationale in EvaluateReadinessInputs.denomMap docstring.\n  const denomMap = inputs.denomMap ?? EMPTY_DENOM_MAP;\n\n  // --- Walk readiness rules ---\n  const reasons: string[] = [];\n  const actions = new Set<ReadinessAction>();\n  let status: Readiness['status'] = 'ok';\n\n  // 1. SKU availability — hard block when the user's chosen size isn't offered.\n  if (inputs.size !== null && !inputs.availableSkuNames.includes(inputs.size)) {\n    status = 'block';\n    const available =\n      inputs.availableSkuNames.length > 0\n        ? inputs.availableSkuNames.join(', ')\n        : '(none)';\n    reasons.push(\n      `Requested SKU \"${inputs.size}\" is not currently offered. Available: ${available}.`,\n    );\n    actions.add('pick_different_sku');\n  }\n\n  // 2. Wallet gas balance — hard block on absent/zero, warn on below-floor.\n  const gasEntry = inputs.walletBalances.find((b) => b.denom === gasDenom);\n  const gasAmount = gasEntry ? asBigInt(gasEntry.amount) : 0n;\n  if (inputs.walletBalances.length === 0 || gasAmount === 0n) {\n    status = 'block';\n    reasons.push(\n      `Wallet has no ${denomToSymbol(gasDenom, denomMap)} balance for gas.`,\n    );\n    actions.add('request_faucet');\n    actions.add('topup_wallet');\n  } else if (gasAmount < gasWarnFloor) {\n    if (status === 'ok') status = 'warn';\n    reasons.push(\n      `Wallet balance (${humanizeCoin(\n        gasAmount.toString(),\n        gasDenom,\n        denomMap,\n      )}) is below ${humanizeCoin(\n        gasWarnFloor.toString(),\n        gasDenom,\n        denomMap,\n      )}; broadcast may run out of gas.`,\n    );\n    actions.add('topup_wallet');\n  }\n\n  // 3. Credits.\n  //\n  // CJS preserves a subtle source-of-truth selection: `credits.availableBalances`\n  // is the \"right now\" balance net of pending reservations; `credits.balances`\n  // (older variant) is the gross-funded fallback; `currentBalance` is from\n  // the chain's credit estimator and is only present when the tenant has at\n  // least one ACTIVE lease. A fresh deployer with credits but no active\n  // leases would have `currentBalance` ABSENT — reading that field FIRST as\n  // the credit source produces a false \"Credit account is empty\" warning.\n  // Mirror the CJS precedence: availableBalances → balances → currentBalance.\n  const credits = inputs.credits;\n  if (credits === null) {\n    if (status === 'ok') status = 'warn';\n    reasons.push('No credit account funded for compute leases.');\n    actions.add('fund_credit');\n  } else if (\n    inputs.sku !== null &&\n    inputs.sku.price.amount.length > 0 &&\n    inputs.sku.price.denom.length > 0\n  ) {\n    const skuPrice = inputs.sku.price;\n    const creditBalances: Coin[] = Array.isArray(credits.availableBalances)\n      ? credits.availableBalances\n      : Array.isArray(credits.balances)\n        ? credits.balances\n        : Array.isArray(credits.currentBalance)\n          ? credits.currentBalance\n          : [];\n    const creditEntry = creditBalances.find((b) => b.denom === skuPrice.denom);\n    const pricePerHour = asBigInt(skuPrice.amount);\n    if (creditEntry === undefined) {\n      // The credit account has NO entry in the SKU's price denom. Distinct\n      // from \"credits ran out\" — usually means credits are funded in a\n      // different denom than the SKU charges in. Emit a specific\n      // diagnostic so the user knows to fund_credit in the right denom\n      // rather than seeing a false \"0 hours of runtime\" warning.\n      const fundedDenoms = creditBalances\n        .map((b) => b.denom)\n        .filter((d): d is string => typeof d === 'string' && d.length > 0);\n      const skuSymbol = denomToSymbol(skuPrice.denom, denomMap);\n      const fundedSymbols = fundedDenoms.map((d) => denomToSymbol(d, denomMap));\n      if (status === 'ok') status = 'warn';\n      reasons.push(\n        fundedDenoms.length > 0\n          ? `Credit account has no ${skuSymbol} balance (the ${inputs.sku.name} SKU charges in ${skuSymbol}; account holds ${fundedSymbols.join(\n              ', ',\n            )}). Fund ${skuSymbol} credits before deploying.`\n          : `Credit account is empty for the ${inputs.sku.name} SKU's ${skuSymbol} denom. Fund ${skuSymbol} credits before deploying.`,\n      );\n      actions.add('fund_credit');\n    } else if (pricePerHour > 0n) {\n      const creditAmount = asBigInt(creditEntry.amount);\n      // Convert via Number for the human-readable hours figure. Credit\n      // amounts are in the chain's smallest unit and bounded well below\n      // Number.MAX_SAFE_INTEGER for any realistic balance.\n      const hrsForThisSku = Number(creditAmount) / Number(pricePerHour);\n      if (hrsForThisSku < HOURS_REMAINING_WARN_FLOOR) {\n        if (status === 'ok') status = 'warn';\n        reasons.push(\n          `Credits cover ~${hrsForThisSku.toFixed(1)}h of runtime at the ${inputs.sku.name} SKU (${humanizeCoin(\n            creditAmount.toString(),\n            skuPrice.denom,\n            denomMap,\n          )} / ${humanizeCoin(\n            pricePerHour.toString(),\n            skuPrice.denom,\n            denomMap,\n          )} per hour); below the ${HOURS_REMAINING_WARN_FLOOR}h floor.`,\n        );\n        actions.add('fund_credit');\n      }\n    }\n  } else if (credits.hoursRemaining !== undefined) {\n    // Fallback for cases where SKU pricing is not available (e.g. caller\n    // didn't pass --size). Use the chain's hoursRemaining but ONLY warn\n    // when it's a meaningful positive number below the floor — `0` here\n    // means \"no current burn\", not \"low credits\".\n    const hrs = Number(credits.hoursRemaining);\n    if (Number.isFinite(hrs) && hrs > 0 && hrs < HOURS_REMAINING_WARN_FLOOR) {\n      if (status === 'ok') status = 'warn';\n      reasons.push(\n        `Credits cover ~${hrs.toFixed(1)}h of runtime at the current burn rate; below the ${HOURS_REMAINING_WARN_FLOOR}h floor.`,\n      );\n      actions.add('fund_credit');\n    }\n  }\n\n  // --- Map input shape into the frozen `Readiness` carrier fields ---\n  const creditsOut: Readiness['credits'] =\n    credits === null\n      ? null\n      : {\n          availableBalances: Array.isArray(credits.availableBalances)\n            ? credits.availableBalances\n            : Array.isArray(credits.balances)\n              ? credits.balances\n              : Array.isArray(credits.currentBalance)\n                ? credits.currentBalance\n                : [],\n        };\n\n  return {\n    status,\n    reasons,\n    suggestedActions: Array.from(actions),\n    walletBalances: inputs.walletBalances,\n    credits: creditsOut,\n    sku: inputs.sku,\n  };\n}\n\nfunction asBigInt(s: string): bigint {\n  try {\n    return BigInt(s);\n  } catch {\n    return 0n;\n  }\n}\n\nfunction validateGasWarnFloor(value: bigint): bigint {\n  if (value < 0n) {\n    throw new TypeError(\n      `evaluateReadiness: gasWarnFloor must be a non-negative integer, got ${value}`,\n    );\n  }\n  return value;\n}\n"],"mappings":"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"}