@odla-ai/cli 0.25.19 → 0.25.21

package/dist/{chunk-S3EJ66VG.js → chunk-L2NG4UR4.js}

@@ -17,22 +17,22 @@ function readJsonFile(path) {
     return null;
   }
 }
-function writePrivateJson(path, value) {
-  writePrivateText(path, `${JSON.stringify(value, null, 2)}
+function writePrivateJson(path, value2) {
+  writePrivateText(path, `${JSON.stringify(value2, null, 2)}
 `);
 }
 function readCredentials(path) {
   if (!existsSync(path)) return null;
-  let value;
+  let value2;
   try {
-    value = JSON.parse(readFileSync(path, "utf8"));
+    value2 = JSON.parse(readFileSync(path, "utf8"));
   } catch {
     throw new Error(`credentials file ${path} is not valid JSON; fix or remove it before provisioning`);
   }
-  if (!value || typeof value !== "object" || typeof value.appId !== "string" || !value.envs || typeof value.envs !== "object") {
+  if (!value2 || typeof value2 !== "object" || typeof value2.appId !== "string" || !value2.envs || typeof value2.envs !== "object") {
     throw new Error(`credentials file ${path} has an invalid shape; fix or remove it before provisioning`);
   }
-  return value;
+  return value2;
 }
 function mergeCredential(current, update) {
   const next = current ?? {
@@ -366,8 +366,8 @@ function stillPending(pending, email) {
     { retryable: true }
   );
 }
-function handshakeEmail(value, cached) {
-  const email = (value ?? process4.env.ODLA_USER_EMAIL ?? cached ?? "").trim().toLowerCase();
+function handshakeEmail(value2, cached) {
+  const email = (value2 ?? process4.env.ODLA_USER_EMAIL ?? cached ?? "").trim().toLowerCase();
   if (email.length > 254 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
     throw new Error("a fresh odla handshake requires --email <account> or ODLA_USER_EMAIL");
   }
@@ -391,10 +391,10 @@ function handshakeUrl(platformUrl, userCode) {
   url.searchParams.set("code", userCode);
   return url.toString();
 }
-function platformAudience(value) {
+function platformAudience(value2) {
   let url;
   try {
-    url = new URL(value);
+    url = new URL(value2);
   } catch {
     throw new Error("platform must be an absolute URL");
   }
@@ -436,6 +436,7 @@ function audienceBoundEnvToken(token, platform) {
   return token;
 }
 var SCOPE_PURPOSE = {
+  "platform:status:read": "read the platform fleet health and deployment snapshot",
   "platform:runbook:write": "add or edit odla's operational runbooks",
   "platform:ai:policy:write": "change System AI model routing",
   "platform:ai:policy:read": "read System AI model routing",
@@ -499,11 +500,11 @@ var SYSTEM_AI_PURPOSES = [
   "security.validation",
   "runbook.answer"
 ];
-function requireSystemAiPurpose(value) {
-  if (!SYSTEM_AI_PURPOSES.includes(value)) {
+function requireSystemAiPurpose(value2) {
+  if (!SYSTEM_AI_PURPOSES.includes(value2)) {
     throw new Error(`purpose must be one of: ${SYSTEM_AI_PURPOSES.join(", ")}`);
   }
-  return value;
+  return value2;
 }
 
 // src/admin-ai.ts
@@ -514,22 +515,22 @@ import process6 from "process";
 var MAX_BYTES = 64 * 1024;
 async function secretInputValue(options, kind = "credential") {
   if (options.fromEnv && options.stdin) throw new Error("choose exactly one of --from-env or --stdin");
-  let value;
-  if (options.fromEnv) value = process6.env[options.fromEnv];
-  else if (options.stdin) value = await (options.readStdin ?? (() => readSecretStream(kind)))();
+  let value2;
+  if (options.fromEnv) value2 = process6.env[options.fromEnv];
+  else if (options.stdin) value2 = await (options.readStdin ?? (() => readSecretStream(kind)))();
   else throw new Error(`${kind} input required: use --from-env <NAME> or --stdin; values are never accepted as arguments`);
-  value = value?.replace(/[\r\n]+$/, "");
-  if (!value) throw new Error(options.fromEnv ? `environment variable ${options.fromEnv} is empty or unset` : `stdin ${kind} is empty`);
-  if (new TextEncoder().encode(value).byteLength > MAX_BYTES) throw new Error(`${kind} exceeds 64 KiB`);
-  return value;
+  value2 = value2?.replace(/[\r\n]+$/, "");
+  if (!value2) throw new Error(options.fromEnv ? `environment variable ${options.fromEnv} is empty or unset` : `stdin ${kind} is empty`);
+  if (new TextEncoder().encode(value2).byteLength > MAX_BYTES) throw new Error(`${kind} exceeds 64 KiB`);
+  return value2;
 }
 async function readSecretStream(kind, stream = process6.stdin) {
-  let value = "";
+  let value2 = "";
   for await (const chunk of stream) {
-    value += String(chunk);
-    if (value.length > MAX_BYTES) throw new Error(`${kind} exceeds 64 KiB`);
+    value2 += String(chunk);
+    if (value2.length > MAX_BYTES) throw new Error(`${kind} exceeds 64 KiB`);
   }
-  return value;
+  return value2;
 }
 
 // src/admin-ai-audit.ts
@@ -579,13 +580,13 @@ function apiError(status, body) {
   const message2 = error && typeof error.message === "string" ? error.message : isRecord(body) && typeof body.message === "string" ? body.message : "request failed";
   return `read System AI admin changes failed (${status}): ${message2}`;
 }
-function timestamp(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return String(value ?? "");
-  const date = new Date(value);
+function timestamp(value2) {
+  if (typeof value2 !== "number" || !Number.isFinite(value2)) return String(value2 ?? "");
+  const date = new Date(value2);
   return Number.isFinite(date.valueOf()) ? date.toISOString() : "";
 }
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function isRecord(value2) {
+  return Boolean(value2) && typeof value2 === "object" && !Array.isArray(value2);
 }
 
 // src/admin-ai-usage.ts
@@ -607,11 +608,11 @@ async function readAdminAiUsage(request2) {
   if (request2.json) request2.stdout.log(JSON.stringify(body, null, 2));
   else printUsage(body, request2.stdout);
 }
-function usageLimit(value) {
-  if (!Number.isSafeInteger(value) || value < 1 || value > 500) {
+function usageLimit(value2) {
+  if (!Number.isSafeInteger(value2) || value2 < 1 || value2 > 500) {
     throw new Error("usage limit must be an integer from 1 to 500");
   }
-  return value;
+  return value2;
 }
 function printUsage(body, out) {
   const aggregates = isRecord2(body) && isRecord2(body.aggregates) && Array.isArray(body.aggregates.byStatus) ? body.aggregates.byStatus.filter(isRecord2) : [];
@@ -647,15 +648,15 @@ when	app/env	run	actor	purpose/role	route / policy	tokens	cost	status`);
     ].join("	"));
   }
 }
-function numeric(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+function numeric(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? value2 : 0;
 }
-function formatMicrousd(value) {
-  return typeof value === "number" && Number.isFinite(value) ? `$${(value / 1e6).toFixed(6)}` : "unpriced";
+function formatMicrousd(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? `$${(value2 / 1e6).toFixed(6)}` : "unpriced";
 }
-function timestamp2(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return String(value ?? "");
-  const date = new Date(value);
+function timestamp2(value2) {
+  if (typeof value2 !== "number" || !Number.isFinite(value2)) return String(value2 ?? "");
+  const date = new Date(value2);
   return Number.isFinite(date.valueOf()) ? date.toISOString() : "";
 }
 async function responseBody2(res) {
@@ -672,8 +673,8 @@ function apiError2(action, status, body) {
   const message2 = error && typeof error.message === "string" ? error.message : isRecord2(body) && typeof body.message === "string" ? body.message : "request failed";
   return `${action} failed (${status}): ${message2}`;
 }
-function isRecord2(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function isRecord2(value2) {
+  return Boolean(value2) && typeof value2 === "object" && !Array.isArray(value2);
 }
 
 // src/admin-ai.ts
@@ -718,11 +719,11 @@ async function adminAi(options) {
   }
   if (options.action === "credential-set") {
     const provider = requireProvider(options.credentialProvider);
-    const value = await secretInputValue(options);
+    const value2 = await secretInputValue(options);
     const res2 = await doFetch(`${platform}/registry/platform/ai-credentials/${encodeURIComponent(provider)}`, {
       method: "PUT",
       headers,
-      body: JSON.stringify({ value })
+      body: JSON.stringify({ value: value2 })
     });
     const body2 = await responseBody3(res2);
     if (!res2.ok) throw new Error(apiError3(`store ${provider} platform credential`, res2.status, body2));
@@ -822,11 +823,11 @@ async function adminAi(options) {
   const policy = isRecord3(response2) && isRecord3(response2.policy) ? response2.policy : isRecord3(response2) ? response2 : {};
   out.log(options.json ? JSON.stringify({ policy }, null, 2) : `updated ${purpose}: ${String(policy.provider ?? "unchanged")}/${String(policy.model ?? "unchanged")}`);
 }
-function requireProvider(value) {
-  if (value !== "anthropic" && value !== "openai" && value !== "google") {
+function requireProvider(value2) {
+  if (value2 !== "anthropic" && value2 !== "openai" && value2 !== "google") {
     throw new Error("provider must be one of: anthropic, openai, google");
   }
-  return value;
+  return value2;
 }
 function policyArray(body) {
   if (isRecord3(body) && Array.isArray(body.policies)) return body.policies.filter(isRecord3);
@@ -837,7 +838,7 @@ function catalogModels(body) {
   if (!isRecord3(body) || !isRecord3(body.catalog) || !Array.isArray(body.catalog.models)) {
     throw new Error("platform returned an invalid System AI model catalog");
   }
-  return body.catalog.models.filter((value) => isRecord3(value) && typeof value.id === "string" && typeof value.provider === "string");
+  return body.catalog.models.filter((value2) => isRecord3(value2) && typeof value2.id === "string" && typeof value2.provider === "string");
 }
 async function responseBody3(res) {
   const text = await res.text();
@@ -853,14 +854,15 @@ function apiError3(action, status, body) {
   const message2 = error && typeof error.message === "string" ? error.message : isRecord3(body) && typeof body.message === "string" ? body.message : "request failed";
   return `${action} failed (${status}): ${message2}`;
 }
-function isRecord3(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function isRecord3(value2) {
+  return Boolean(value2) && typeof value2 === "object" && !Array.isArray(value2);
 }
 
 // src/config.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname3, isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
 import { pathToFileURL } from "url";
+import { appServiceDefinition, appServiceIds } from "@odla-ai/apps";
 
 // src/integration-validation.ts
 function validateIntegrations(cfg, path, defaultServices) {
@@ -915,17 +917,17 @@ function validateProbes(integration, at) {
     }
   }
 }
-function isRecord4(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function isRecord4(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
-function safeText(value, max) {
-  return typeof value === "string" && value.trim().length > 0 && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
+function safeText(value2, max) {
+  return typeof value2 === "string" && value2.trim().length > 0 && value2.length <= max && !/[\u0000-\u001f\u007f]/.test(value2);
 }
-function safeProbePath(value) {
-  return typeof value === "string" && /^\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]*$/.test(value);
+function safeProbePath(value2) {
+  return typeof value2 === "string" && /^\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]*$/.test(value2);
 }
-function validId(value) {
-  return typeof value === "string" && /^[a-z0-9][a-z0-9-]*$/.test(value);
+function validId(value2) {
+  return typeof value2 === "string" && /^[a-z0-9][a-z0-9-]*$/.test(value2);
 }
 function unique(values) {
   return [...new Set(values.filter(Boolean))];
@@ -948,6 +950,7 @@ async function loadProjectConfig(configPath = "odla.config.mjs") {
   const dbEndpoint = trimSlash(process.env.ODLA_DB_ENDPOINT || raw.dbEndpoint || platformUrl);
   const envs = unique2(raw.envs?.length ? raw.envs : DEFAULT_ENVS);
   const services = unique2(raw.services?.length ? raw.services : DEFAULT_SERVICES);
+  validateServices(services, resolved);
   validateCalendarConfig(raw, envs, services, resolved);
   const local = {
     tokenFile: resolve2(rootDir, raw.local?.tokenFile ?? ".odla/dev-token.json"),
@@ -966,10 +969,10 @@ async function loadProjectConfig(configPath = "odla.config.mjs") {
     local
   };
 }
-async function resolveDataExport(cfg, value, names) {
-  if (value === void 0 || value === null || value === false) return void 0;
-  if (typeof value !== "string") return value;
-  const target = isAbsolute2(value) ? value : resolve2(cfg.rootDir, value);
+async function resolveDataExport(cfg, value2, names) {
+  if (value2 === void 0 || value2 === null || value2 === false) return void 0;
+  if (typeof value2 !== "string") return value2;
+  const target = isAbsolute2(value2) ? value2 : resolve2(cfg.rootDir, value2);
   if (target.endsWith(".json")) {
     return JSON.parse(readFileSync2(target, "utf8"));
   }
@@ -978,7 +981,7 @@ async function resolveDataExport(cfg, value, names) {
     if (mod[name] !== void 0) return mod[name];
   }
   if (mod.default !== void 0) return mod.default;
-  throw new Error(`${value} did not export ${names.join(", ")} or default`);
+  throw new Error(`${value2} did not export ${names.join(", ")} or default`);
 }
 function buildPlan(cfg) {
   const integrationSchema = cfg.integrations?.some((integration) => integration.schema) ?? false;
@@ -1012,9 +1015,9 @@ function calendarServiceConfig(cfg, env) {
   };
 }
 function calendarBookingPageUrl(cfg, env) {
-  const value = cfg.calendar?.google.bookingPageUrl?.[env];
-  if (value === void 0 || value === null) return value;
-  return new URL(value).toString();
+  const value2 = cfg.calendar?.google.bookingPageUrl?.[env];
+  if (value2 === void 0 || value2 === null) return value2;
+  return new URL(value2).toString();
 }
 function rulesFromSchema(schema) {
   const entities = serializedEntities(schema);
@@ -1028,10 +1031,10 @@ function serializedEntities(schema) {
   if (!entities || typeof entities !== "object" || Array.isArray(entities)) return [];
   return Object.keys(entities);
 }
-function envValue(value) {
-  if (!value) return void 0;
-  if (value.startsWith("$")) return process.env[value.slice(1)];
-  return value;
+function envValue(value2) {
+  if (!value2) return void 0;
+  if (value2.startsWith("$")) return process.env[value2.slice(1)];
+  return value2;
 }
 function validateRawConfig(raw, path) {
   if (!raw || typeof raw !== "object") throw new Error(`${path} must export an object`);
@@ -1087,8 +1090,8 @@ function validateCalendarConfig(cfg, envs, services, path) {
     if (!isRecord5(google.bookingCalendar)) throw new Error(`${path}: calendar.google.bookingCalendar must map env names to one calendar id`);
     const unknownBookingEnv = Object.keys(google.bookingCalendar).find((env) => !envs.includes(env));
     if (unknownBookingEnv) throw new Error(`${path}: calendar.google.bookingCalendar.${unknownBookingEnv} is not in config envs`);
-    for (const [env, value] of Object.entries(google.bookingCalendar)) {
-      if (!safeText2(value, 1024)) {
+    for (const [env, value2] of Object.entries(google.bookingCalendar)) {
+      if (!safeText2(value2, 1024)) {
         throw new Error(`${path}: calendar.google.bookingCalendar.${env} must be a calendar id`);
       }
     }
@@ -1097,45 +1100,57 @@ function validateCalendarConfig(cfg, envs, services, path) {
     if (!isRecord5(google.bookingPageUrl)) throw new Error(`${path}: calendar.google.bookingPageUrl must map env names to HTTPS URLs or null`);
     const unknownBookingEnv = Object.keys(google.bookingPageUrl).find((env) => !envs.includes(env));
     if (unknownBookingEnv) throw new Error(`${path}: calendar.google.bookingPageUrl.${unknownBookingEnv} is not in config envs`);
-    for (const [env, value] of Object.entries(google.bookingPageUrl)) {
-      if (value !== null && !safeHttpsUrl(value)) {
+    for (const [env, value2] of Object.entries(google.bookingPageUrl)) {
+      if (value2 !== null && !safeHttpsUrl(value2)) {
         throw new Error(`${path}: calendar.google.bookingPageUrl.${env} must be an HTTPS URL without credentials or fragment`);
       }
     }
   }
-  if (enabled && !services.includes("db")) throw new Error(`${path}: calendar service requires the db service`);
 }
-function assertOnly(value, allowed, label) {
-  const extra = Object.keys(value).find((key) => !allowed.includes(key));
+function validateServices(services, path) {
+  for (const service of services) {
+    const definition = appServiceDefinition(service);
+    if (!definition) {
+      throw new Error(`${path}: unknown service "${service}" (known: ${appServiceIds().join(", ")})`);
+    }
+    for (const dependency of definition.requires) {
+      if (!services.includes(dependency)) {
+        throw new Error(`${path}: ${service} service requires the ${dependency} service`);
+      }
+    }
+  }
+}
+function assertOnly(value2, allowed, label) {
+  const extra = Object.keys(value2).find((key) => !allowed.includes(key));
   if (extra) throw new Error(`${label}.${extra} is not supported`);
 }
-function isRecord5(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function isRecord5(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
-function safeText2(value, max) {
-  return typeof value === "string" && value.trim().length > 0 && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
+function safeText2(value2, max) {
+  return typeof value2 === "string" && value2.trim().length > 0 && value2.length <= max && !/[\u0000-\u001f\u007f]/.test(value2);
 }
-function safeHttpsUrl(value) {
-  if (typeof value !== "string" || value.length > 2048) return false;
+function safeHttpsUrl(value2) {
+  if (typeof value2 !== "string" || value2.length > 2048) return false;
   try {
-    const url = new URL(value);
+    const url = new URL(value2);
     return url.protocol === "https:" && !url.username && !url.password && !url.hash;
   } catch {
     return false;
   }
 }
-function validId2(value) {
-  return typeof value === "string" && /^[a-z0-9][a-z0-9-]*$/.test(value);
+function validId2(value2) {
+  return typeof value2 === "string" && /^[a-z0-9][a-z0-9-]*$/.test(value2);
 }
 async function loadConfigModule(path) {
   if (path.endsWith(".json")) return JSON.parse(readFileSync2(path, "utf8"));
   const mod = await import(`${pathToFileURL(path).href}?t=${Date.now()}`);
-  const value = mod.default ?? mod.config;
-  if (typeof value === "function") return await value();
-  return value;
+  const value2 = mod.default ?? mod.config;
+  if (typeof value2 === "function") return await value2();
+  return value2;
 }
-function trimSlash(value) {
-  return value.replace(/\/+$/, "");
+function trimSlash(value2) {
+  return value2.replace(/\/+$/, "");
 }
 function unique2(values) {
   return [...new Set(values.filter(Boolean))];
@@ -1151,44 +1166,44 @@ var REPLACEMENTS = [
   [/\b(ghp|gho|github_pat)_[A-Za-z0-9_]+/g, "$1_[redacted]"],
   [/\bAKIA[A-Z0-9]{12,}/g, "AKIA[redacted]"]
 ];
-function redactSecrets(value) {
-  let result = value;
+function redactSecrets(value2) {
+  let result = value2;
   for (const [pattern, replacement] of REPLACEMENTS) result = result.replace(pattern, replacement);
   return result;
 }
 function redactingOutput(output) {
-  const redactArgs = (args) => args.map((value) => redactOutputValue(value, /* @__PURE__ */ new WeakMap()));
+  const redactArgs = (args) => args.map((value2) => redactOutputValue(value2, /* @__PURE__ */ new WeakMap()));
   return {
     log: (...args) => output.log(...redactArgs(args)),
     error: (...args) => output.error(...redactArgs(args))
   };
 }
-function redactOutputValue(value, seen) {
-  if (typeof value === "string") return redactSecrets(value);
-  if (value instanceof Error) {
-    const redacted = new Error(redactSecrets(value.message));
-    redacted.name = value.name;
-    if (value.stack) redacted.stack = redactSecrets(value.stack);
+function redactOutputValue(value2, seen) {
+  if (typeof value2 === "string") return redactSecrets(value2);
+  if (value2 instanceof Error) {
+    const redacted = new Error(redactSecrets(value2.message));
+    redacted.name = value2.name;
+    if (value2.stack) redacted.stack = redactSecrets(value2.stack);
     return redacted;
   }
-  if (!value || typeof value !== "object") return value;
-  const prior = seen.get(value);
+  if (!value2 || typeof value2 !== "object") return value2;
+  const prior = seen.get(value2);
   if (prior) return prior;
-  if (Array.isArray(value)) {
+  if (Array.isArray(value2)) {
     const next2 = [];
-    seen.set(value, next2);
-    for (const item of value) next2.push(redactOutputValue(item, seen));
+    seen.set(value2, next2);
+    for (const item of value2) next2.push(redactOutputValue(item, seen));
     return next2;
   }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) return value;
+  const prototype = Object.getPrototypeOf(value2);
+  if (prototype !== Object.prototype && prototype !== null) return value2;
   const next = {};
-  seen.set(value, next);
-  for (const [key, item] of Object.entries(value)) next[key] = redactOutputValue(item, seen);
+  seen.set(value2, next);
+  for (const [key, item] of Object.entries(value2)) next[key] = redactOutputValue(item, seen);
   return next;
 }
-function looksSecret(value) {
-  return redactSecrets(value) !== value || value.includes("-----BEGIN");
+function looksSecret(value2) {
+  return redactSecrets(value2) !== value2 || value2.includes("-----BEGIN");
 }
 
 // src/calendar-errors.ts
@@ -1230,9 +1245,9 @@ async function readCalendarStatus(ctx) {
 }
 async function discoverGoogleCalendars(ctx) {
   const raw = await calendarJson(ctx, "/calendars", {});
-  const value = record(raw);
-  if (!value || !Array.isArray(value.calendars)) throw new Error("calendar discovery returned an invalid response");
-  return value.calendars.map((item, index) => {
+  const value2 = record(raw);
+  if (!value2 || !Array.isArray(value2.calendars)) throw new Error("calendar discovery returned an invalid response");
+  return value2.calendars.map((item, index) => {
     const calendar = record(item);
     const id = textField(calendar?.id, 1024);
     if (!calendar || !id) throw new Error(`calendar discovery returned an invalid calendar at index ${index}`);
@@ -1254,10 +1269,10 @@ async function applyCalendarSettings(ctx, bookingPageUrl) {
 }
 async function startCalendarConnection(ctx) {
   const raw = await calendarJson(ctx, "/google/connect", { method: "POST", body: "{}" });
-  const value = wrapped(raw, "attempt");
-  const attemptId = textField(value.attemptId, 180);
-  const consentUrl = textField(value.consentUrl, 4096);
-  const expiresAt = timestamp3(value.expiresAt);
+  const value2 = wrapped(raw, "attempt");
+  const attemptId = textField(value2.attemptId, 180);
+  const consentUrl = textField(value2.consentUrl, 4096);
+  const expiresAt = timestamp3(value2.expiresAt);
   if (!attemptId || !consentUrl || expiresAt === void 0) throw new Error("calendar connect returned an invalid attempt");
   return { attemptId, consentUrl, expiresAt };
 }
@@ -1275,42 +1290,42 @@ async function requestCalendarDisconnect(ctx) {
 }
 function parseCalendarStatus(raw, env) {
   const outer = wrapped(raw, "calendar");
-  const value = record(outer.attempt) ?? record(outer.status) ?? outer;
-  const connection = record(value.connection) ?? {};
-  const config = record(value.config) ?? record(outer.config) ?? {};
+  const value2 = record(outer.attempt) ?? record(outer.status) ?? outer;
+  const connection = record(value2.connection) ?? {};
+  const config = record(value2.config) ?? record(outer.config) ?? {};
   const googleConfig = record(config.google) ?? config;
-  const stateValue = calendarState(value.status ?? value.state ?? connection.status ?? connection.state);
+  const stateValue = calendarState(value2.status ?? value2.state ?? connection.status ?? connection.state);
   if (!stateValue) {
     throw new Error("calendar status returned an invalid connection state");
   }
-  const providerValue = value.provider ?? connection.provider ?? config.provider ?? (config.google ? "google" : void 0);
+  const providerValue = value2.provider ?? connection.provider ?? config.provider ?? (config.google ? "google" : void 0);
   if (providerValue !== void 0 && providerValue !== null && providerValue !== "google") {
     throw new Error("calendar status returned an unsupported provider");
   }
-  const accessValue = value.access ?? connection.access ?? config.access ?? googleConfig.access;
+  const accessValue = value2.access ?? connection.access ?? config.access ?? googleConfig.access;
   if (accessValue !== void 0 && accessValue !== "book" && accessValue !== "read") {
     throw new Error("calendar status returned unsupported access");
   }
-  const errorValue = record(value.error) ?? record(connection.error);
-  const errorCode = textField(value.lastErrorCode, 128);
-  const bookingPageValue = Object.hasOwn(value, "bookingPageUrl") ? value.bookingPageUrl : Object.hasOwn(config, "bookingPageUrl") ? config.bookingPageUrl : googleConfig.bookingPageUrl;
-  const connected = typeof (value.connected ?? connection.connected) === "boolean" ? Boolean(value.connected ?? connection.connected) : ["healthy", "degraded"].includes(stateValue);
-  const bookingCalendarId = textField(value.bookingCalendarId ?? config.bookingCalendarId, 1024);
+  const errorValue = record(value2.error) ?? record(connection.error);
+  const errorCode = textField(value2.lastErrorCode, 128);
+  const bookingPageValue = Object.hasOwn(value2, "bookingPageUrl") ? value2.bookingPageUrl : Object.hasOwn(config, "bookingPageUrl") ? config.bookingPageUrl : googleConfig.bookingPageUrl;
+  const connected = typeof (value2.connected ?? connection.connected) === "boolean" ? Boolean(value2.connected ?? connection.connected) : ["healthy", "degraded"].includes(stateValue);
+  const bookingCalendarId = textField(value2.bookingCalendarId ?? config.bookingCalendarId, 1024);
   return {
     env,
-    enabled: typeof value.enabled === "boolean" ? value.enabled : true,
+    enabled: typeof value2.enabled === "boolean" ? value2.enabled : true,
     connected,
-    writable: typeof value.writable === "boolean" ? value.writable : stateValue === "healthy",
+    writable: typeof value2.writable === "boolean" ? value2.writable : stateValue === "healthy",
     provider: providerValue === "google" ? "google" : null,
     status: stateValue,
     ...accessValue !== void 0 ? { access: "book" } : {},
     ...bookingCalendarId ? { bookingCalendarId } : {},
     calendars: calendarIds(
-      value.availabilityCalendars ?? config.availabilityCalendars ?? value.configuredCalendars ?? value.calendars ?? config.calendars ?? googleConfig.calendars
+      value2.availabilityCalendars ?? config.availabilityCalendars ?? value2.configuredCalendars ?? value2.calendars ?? config.calendars ?? googleConfig.calendars
     ),
     ...optionalNullableUrl("bookingPageUrl", bookingPageValue),
-    grantedScopes: stringList(value.grantedScopes ?? connection.grantedScopes ?? connection.scopes),
-    ...optionalText("attemptId", value.attemptId ?? connection.attemptId, 180),
+    grantedScopes: stringList(value2.grantedScopes ?? connection.grantedScopes ?? connection.scopes),
+    ...optionalText("attemptId", value2.attemptId ?? connection.attemptId, 180),
     ...errorValue || errorCode ? { error: {
       ...textField(errorValue?.code, 128) ? { code: textField(errorValue?.code, 128) } : {},
       ...textField(errorValue?.message, 500) ? { message: textField(errorValue?.message, 500) } : {},
@@ -1318,9 +1333,9 @@ function parseCalendarStatus(raw, env) {
     } } : {}
   };
 }
-function calendarState(value) {
-  if (typeof value !== "string") return null;
-  if (CALENDAR_STATES.includes(value)) return value;
+function calendarState(value2) {
+  if (typeof value2 !== "string") return null;
+  if (CALENDAR_STATES.includes(value2)) return value2;
   const legacy = {
     disabled: "not_connected",
     disconnected: "disconnected",
@@ -1331,7 +1346,7 @@ function calendarState(value) {
     ready: "healthy",
     error: "failed"
   };
-  return legacy[value] ?? null;
+  return legacy[value2] ?? null;
 }
 async function calendarJson(ctx, suffix, init) {
   const platform = platformAudience(ctx.platform);
@@ -1365,50 +1380,50 @@ function wrapped(raw, key) {
   if (!outer) throw new Error("calendar returned an invalid response");
   return record(outer[key]) ?? outer;
 }
-function record(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+function record(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
-function textField(value, max) {
-  return typeof value === "string" && value.length > 0 && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value) ? value : void 0;
+function textField(value2, max) {
+  return typeof value2 === "string" && value2.length > 0 && value2.length <= max && !/[\u0000-\u001f\u007f]/.test(value2) ? value2 : void 0;
 }
-function stringList(value) {
-  return Array.isArray(value) ? [...new Set(value.filter((item) => !!textField(item, 4096)))] : [];
+function stringList(value2) {
+  return Array.isArray(value2) ? [...new Set(value2.filter((item) => !!textField(item, 4096)))] : [];
 }
-function calendarIds(value) {
-  if (!Array.isArray(value)) return [];
-  return [...new Set(value.flatMap((item) => {
+function calendarIds(value2) {
+  if (!Array.isArray(value2)) return [];
+  return [...new Set(value2.flatMap((item) => {
     if (typeof item === "string") return textField(item, 4096) ? [item] : [];
     const calendar = record(item);
     const id = textField(calendar?.id, 4096);
     return id && calendar?.selected !== false ? [id] : [];
   }))];
 }
-function timestamp3(value) {
-  if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
-  if (typeof value === "string") {
-    const parsed = Date.parse(value);
+function timestamp3(value2) {
+  if (typeof value2 === "number" && Number.isFinite(value2) && value2 >= 0) return value2;
+  if (typeof value2 === "string") {
+    const parsed = Date.parse(value2);
     if (Number.isFinite(parsed)) return parsed;
   }
   return void 0;
 }
-function optionalText(key, value, max) {
-  const parsed = textField(value, max);
+function optionalText(key, value2, max) {
+  const parsed = textField(value2, max);
   return parsed ? { [key]: parsed } : {};
 }
-function optionalNullableUrl(key, value) {
-  if (value === null) return { [key]: null };
-  const parsed = textField(value, 4096);
+function optionalNullableUrl(key, value2) {
+  if (value2 === null) return { [key]: null };
+  const parsed = textField(value2, 4096);
   return parsed ? { [key]: parsed } : {};
 }
-function identifier(value, name) {
-  if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,179}$/.test(value)) throw new Error(`${name} is invalid`);
-  return value;
+function identifier(value2, name) {
+  if (typeof value2 !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,179}$/.test(value2)) throw new Error(`${name} is invalid`);
+  return value2;
 }
-function credential(value) {
-  if (typeof value !== "string" || value.length < 8 || value.length > 8192 || /\s|[\u0000-\u001f\u007f]/.test(value)) {
+function credential(value2) {
+  if (typeof value2 !== "string" || value2.length < 8 || value2.length > 8192 || /\s|[\u0000-\u001f\u007f]/.test(value2)) {
     throw new Error("calendar requires an odla developer token");
   }
-  return value;
+  return value2;
 }
 
 // src/calendar-poll.ts
@@ -1569,11 +1584,11 @@ async function connectWithContext(ctx, options) {
   }
   throw new Error('Google Calendar consent timed out; run "odla-ai calendar status" and retry connect');
 }
-function trustedCalendarConsentUrl(platform, value) {
+function trustedCalendarConsentUrl(platform, value2) {
   const origin = platformAudience(platform);
   let url;
   try {
-    url = value.startsWith("/") ? new URL(value, origin) : new URL(value);
+    url = value2.startsWith("/") ? new URL(value2, origin) : new URL(value2);
   } catch {
     throw new Error("odla.ai returned an invalid calendar consent URL");
   }
@@ -1584,9 +1599,9 @@ function trustedCalendarConsentUrl(platform, value) {
   }
   return url.toString();
 }
-function pollTimeout(value = 10 * 6e4) {
-  if (!Number.isSafeInteger(value) || value < 1e3 || value > 60 * 6e4) throw new Error("calendar poll timeout must be 1000-3600000ms");
-  return value;
+function pollTimeout(value2 = 10 * 6e4) {
+  if (!Number.isSafeInteger(value2) || value2 < 1e3 || value2 > 60 * 6e4) throw new Error("calendar poll timeout must be 1000-3600000ms");
+  return value2;
 }
 function productionConsent(env, yes, action) {
   if ((env === "prod" || env === "production") && !yes) throw new Error(`refusing to ${action} for "${env}" without --yes`);
@@ -1618,6 +1633,7 @@ var CAPABILITIES = {
     "validate integration contracts offline and smoke-test a provisioned db environment plus anonymous capability routes",
     "save and explicitly select non-secret named operator contexts with isolated credential caches; resolve and explain platform, app, environment, and credential provenance without authenticating; then run PM, Discussions, o11y, runbook, and identity operations outside a project checkout",
     "read one versioned o11y status envelope spanning application RED, exact Worker versions and Cloudflare colos observed in traffic, current live-sync freshness/load, the protected commit-to-visible canary, collector ingest/scheduler trust, provider-owned runtime metrics, account-scoped Durable Object, D1, and R2 evidence under odla-db, and a bounded machine verdict",
+    "read one canonical platform fleet snapshot over private service bindings, including release identities, probe latency, Cloudflare load/runtime freshness, explicit unknowns, and stable next actions through a read-only capability",
     "inspect durable agent wakeups as a versioned JSON envelope and explicitly requeue one dead-lettered job with a scoped environment credential",
     "run app-attributed hosted security discovery and independent validation without provider keys",
     "connect/revoke source-read-only GitHub sources and drive commit-pinned hosted security jobs without PATs or provider keys",
@@ -1801,8 +1817,8 @@ function wranglerWarnings(rootDir) {
     }
     const vars = block.vars;
     if (vars && typeof vars === "object") {
-      for (const [name, value] of Object.entries(vars)) {
-        if (name === "ODLA_API_KEY" || name === "ODLA_O11Y_TOKEN" || typeof value === "string" && looksSecret(value)) {
+      for (const [name, value2] of Object.entries(vars)) {
+        if (name === "ODLA_API_KEY" || name === "ODLA_O11Y_TOKEN" || typeof value2 === "string" && looksSecret(value2)) {
           warnings.push(`wrangler ${label}vars.${name} looks like a secret \u2014 use "odla-ai secrets push" / wrangler secret put, never vars`);
         }
       }
@@ -1970,27 +1986,27 @@ function isUniqueAttr(schema, ns, attr) {
   const definition = entity.attrs[attr];
   return isRecord6(definition) && definition.unique === true;
 }
-function normalizeSchema(value) {
-  if (value === void 0 || value === null) return { entities: {}, links: {} };
-  if (!isRecord6(value) || !isRecord6(value.entities)) {
+function normalizeSchema(value2) {
+  if (value2 === void 0 || value2 === null) return { entities: {}, links: {} };
+  if (!isRecord6(value2) || !isRecord6(value2.entities)) {
     throw new Error("db schema must be a serialized schema object with an entities map");
   }
-  if (value.links !== void 0 && !isRecord6(value.links)) throw new Error("db schema links must be an object");
+  if (value2.links !== void 0 && !isRecord6(value2.links)) throw new Error("db schema links must be an object");
   return {
-    entities: { ...value.entities },
-    links: { ...value.links ?? {} }
+    entities: { ...value2.entities },
+    links: { ...value2.links ?? {} }
   };
 }
 function mergeMap(target, fragment, label) {
-  for (const [name, value] of Object.entries(fragment)) {
-    if (Object.hasOwn(target, name) && !isDeepStrictEqual(target[name], value)) {
+  for (const [name, value2] of Object.entries(fragment)) {
+    if (Object.hasOwn(target, name) && !isDeepStrictEqual(target[name], value2)) {
       throw new Error(`${label} "${name}" conflicts with an existing definition`);
     }
-    target[name] = value;
+    target[name] = value2;
   }
 }
-function isRecord6(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function isRecord6(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
 
 // src/doctor.ts
@@ -2031,9 +2047,9 @@ async function doctor(options) {
   warnings.push(...integrationWarnings(database.integrations, schema, rules));
   if (cfg.services.includes("ai") && !cfg.ai?.provider) warnings.push("ai service is enabled but ai.provider is not set");
   if (cfg.auth?.clerk) {
-    for (const [env, value] of Object.entries(cfg.auth.clerk)) {
-      if (typeof value === "string" && value.startsWith("$") && !process.env[value.slice(1)]) {
-        warnings.push(`auth.clerk.${env} references unset env var ${value}`);
+    for (const [env, value2] of Object.entries(cfg.auth.clerk)) {
+      if (typeof value2 === "string" && value2.startsWith("$") && !process.env[value2.slice(1)]) {
+        warnings.push(`auth.clerk.${env} references unset env var ${value2}`);
       }
     }
   }
@@ -2070,6 +2086,7 @@ async function doctor(options) {
 // src/init.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname4, resolve as resolve4 } from "path";
+import { appServiceDefinition as appServiceDefinition2, appServiceIds as appServiceIds2 } from "@odla-ai/apps";
 function initProject(options) {
   const out = options.stdout ?? console;
   const rootDir = resolve4(options.rootDir ?? process.cwd());
@@ -2082,7 +2099,13 @@ function initProject(options) {
   }
   const envs = options.envs?.length ? options.envs : ["dev"];
   const services = options.services?.length ? options.services : ["db", "ai"];
-  if (services.includes("calendar") && !services.includes("db")) throw new Error("--services calendar requires db");
+  for (const service of services) {
+    const definition = appServiceDefinition2(service);
+    if (!definition) throw new Error(`--services contains unknown service "${service}" (known: ${appServiceIds2().join(", ")})`);
+    for (const dependency of definition.requires) {
+      if (!services.includes(dependency)) throw new Error(`--services ${service} requires ${dependency}`);
+    }
+  }
   const aiProvider = options.aiProvider ?? "anthropic";
   mkdirSync2(dirname4(configPath), { recursive: true });
   mkdirSync2(resolve4(rootDir, "src/odla"), { recursive: true });
@@ -2280,38 +2303,38 @@ async function secretsSet(options) {
   if (name.startsWith("$")) {
     throw new Error('"$"-prefixed vault names are platform-reserved; for the Clerk secret key use "odla-ai secrets set-clerk-key"');
   }
-  const { cfg, tenantId, value, doFetch, out } = await resolveVaultWrite(options);
+  const { cfg, tenantId, value: value2, doFetch, out } = await resolveVaultWrite(options);
   const token = await getDeveloperToken(cfg, options, doFetch, out);
   try {
-    await putSecret({ endpoint: cfg.dbEndpoint, token, fetch: doFetch }, tenantId, name, value);
+    await putSecret({ endpoint: cfg.dbEndpoint, token, fetch: doFetch }, tenantId, name, value2);
   } catch (err) {
-    throw new Error(scrubValue(err instanceof Error ? err.message : String(err), value));
+    throw new Error(scrubValue(err instanceof Error ? err.message : String(err), value2));
   }
   out.log(`${name} stored in the ${tenantId} vault (write-only; the value was never echoed and cannot be read back here)`);
 }
 async function secretsSetClerkKey(options) {
-  const { cfg, tenantId, value, doFetch, out } = await resolveVaultWrite(options);
-  if (!value.startsWith("sk_")) throw new Error("the Clerk secret key must start with sk_ (sk_test_\u2026 or sk_live_\u2026)");
-  if (value.startsWith("sk_test_") && PROD_ENV_NAMES2.has(options.env)) {
+  const { cfg, tenantId, value: value2, doFetch, out } = await resolveVaultWrite(options);
+  if (!value2.startsWith("sk_")) throw new Error("the Clerk secret key must start with sk_ (sk_test_\u2026 or sk_live_\u2026)");
+  if (value2.startsWith("sk_test_") && PROD_ENV_NAMES2.has(options.env)) {
     throw new Error(`refusing to store an sk_test_ Clerk key for "${options.env}" \u2014 use the production instance's sk_live_ key`);
   }
-  if (value.startsWith("sk_live_") && !PROD_ENV_NAMES2.has(options.env) && !options.yes) {
+  if (value2.startsWith("sk_live_") && !PROD_ENV_NAMES2.has(options.env) && !options.yes) {
     throw new Error(`refusing to store an sk_live_ Clerk key for "${options.env}" without --yes (live users would sync into a non-prod tenant)`);
   }
   const token = await getDeveloperToken(cfg, options, doFetch, out);
   const res = await doFetch(`${cfg.dbEndpoint}/admin/apps/${encodeURIComponent(tenantId)}/clerk-secret`, {
     method: "POST",
     headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
-    body: JSON.stringify({ value })
+    body: JSON.stringify({ value: value2 })
   });
   if (!res.ok) {
-    const text = scrubValue((await res.text().catch(() => "")).slice(0, 300), value);
+    const text = scrubValue((await res.text().catch(() => "")).slice(0, 300), value2);
     throw new Error(`store Clerk secret key failed (${res.status}): ${text || "request failed"}`);
   }
   out.log(`Clerk secret key stored for ${tenantId} ($clerk_secret, reserved + write-only; the value was never echoed)`);
 }
-function scrubValue(text, value) {
-  return redactSecrets(text).split(value).join("[value redacted]");
+function scrubValue(text, value2) {
+  return redactSecrets(text).split(value2).join("[value redacted]");
 }
 async function resolveVaultWrite(options) {
   const out = options.stdout ?? console;
@@ -2323,8 +2346,8 @@ async function resolveVaultWrite(options) {
   if (PROD_ENV_NAMES2.has(options.env) && !options.yes) {
     throw new Error(`refusing to store a secret for "${options.env}" without --yes`);
   }
-  const value = await secretInputValue(options, "secret");
-  return { cfg, tenantId: tenantIdFor(cfg.app.id, options.env), value, doFetch, out };
+  const value2 = await secretInputValue(options, "secret");
+  return { cfg, tenantId: tenantIdFor(cfg.app.id, options.env), value: value2, doFetch, out };
 }
 
 // src/skill.ts
@@ -2765,31 +2788,31 @@ async function requestHostedSecurityJson(options, path, init, action) {
   }
   return body;
 }
-function hostedIdentifier(value, name) {
-  const result = optionalHostedText(value, name, 180);
+function hostedIdentifier(value2, name) {
+  const result = optionalHostedText(value2, name, 180);
   if (!result || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(result)) {
     throw new Error(`${name} is invalid`);
   }
   return result;
 }
-function positivePolicyVersion(value, name) {
-  if (!Number.isSafeInteger(value) || value < 1) {
+function positivePolicyVersion(value2, name) {
+  if (!Number.isSafeInteger(value2) || value2 < 1) {
     throw new Error(`${name} is invalid`);
   }
-  return value;
+  return value2;
 }
-function optionalHostedText(value, name, maxLength) {
-  if (value === void 0 || value === null || value === "") return void 0;
-  if (typeof value !== "string" || value.length > maxLength || /[\u0000-\u001f\u007f]/.test(value)) {
+function optionalHostedText(value2, name, maxLength) {
+  if (value2 === void 0 || value2 === null || value2 === "") return void 0;
+  if (typeof value2 !== "string" || value2.length > maxLength || /[\u0000-\u001f\u007f]/.test(value2)) {
     throw new Error(`${name} is invalid`);
   }
-  return value;
+  return value2;
 }
-function githubRepositoryName(value) {
-  if (typeof value !== "string" || value.length > 201) {
+function githubRepositoryName(value2) {
+  if (typeof value2 !== "string" || value2.length > 201) {
     throw new Error("repository must be owner/name");
   }
-  const parts = value.split("/");
+  const parts = value2.split("/");
   const owner = parts[0] ?? "";
   const name = (parts[1] ?? "").replace(/\.git$/i, "");
   if (parts.length !== 2 || !/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,98}[A-Za-z0-9])?$/.test(owner) || !/^[A-Za-z0-9_.-]{1,100}$/.test(name) || name === "." || name === "..") {
@@ -2797,10 +2820,10 @@ function githubRepositoryName(value) {
   }
   return `${owner}/${name}`;
 }
-function trustedGitHubInstallUrl(value) {
+function trustedGitHubInstallUrl(value2) {
   let url;
   try {
-    url = new URL(value);
+    url = new URL(value2);
   } catch {
     throw new Error("odla.ai returned an invalid GitHub installation URL");
   }
@@ -2809,17 +2832,17 @@ function trustedGitHubInstallUrl(value) {
   }
   return url.toString();
 }
-function hostedPollInterval(value = 2e3) {
-  if (!Number.isSafeInteger(value) || value < 100 || value > 3e4) {
+function hostedPollInterval(value2 = 2e3) {
+  if (!Number.isSafeInteger(value2) || value2 < 100 || value2 > 3e4) {
     throw new Error("poll interval must be 100-30000ms");
   }
-  return value;
+  return value2;
 }
-function hostedPollTimeout(value = 10 * 6e4) {
-  if (!Number.isSafeInteger(value) || value < 1e3 || value > 60 * 6e4) {
+function hostedPollTimeout(value2 = 10 * 6e4) {
+  if (!Number.isSafeInteger(value2) || value2 < 1e3 || value2 > 60 * 6e4) {
     throw new Error("poll timeout must be 1000-3600000ms");
   }
-  return value;
+  return value2;
 }
 async function waitForHostedPoll(milliseconds, signal) {
   if (signal?.aborted) throw signal.reason ?? new DOMException("aborted", "AbortError");
@@ -2831,16 +2854,16 @@ async function waitForHostedPoll(milliseconds, signal) {
     }, { once: true });
   });
 }
-function isValidHostedSecurityPlan(value, env) {
-  if (!value || value.env !== env || !/^sha256:[a-f0-9]{64}$/.test(value.planDigest) || value.consentContract !== "odla.hosted-security-consent.v1" || value.reportProjection !== "odla.hosted-security-report.v1" || value.redactionContract !== "odla.best-effort-credential-pattern-redaction.v1" || typeof value.promptBundle !== "string" || value.promptBundle.length < 1 || value.promptBundle.length > 100 || typeof value.ready !== "boolean" || typeof value.independent !== "boolean" || value.sourceDisclosure !== "redacted" || value.targetExecution !== false || !Number.isSafeInteger(value.reportRetentionDays) || value.reportRetentionDays < 1) return false;
+function isValidHostedSecurityPlan(value2, env) {
+  if (!value2 || value2.env !== env || !/^sha256:[a-f0-9]{64}$/.test(value2.planDigest) || value2.consentContract !== "odla.hosted-security-consent.v1" || value2.reportProjection !== "odla.hosted-security-report.v1" || value2.redactionContract !== "odla.best-effort-credential-pattern-redaction.v1" || typeof value2.promptBundle !== "string" || value2.promptBundle.length < 1 || value2.promptBundle.length > 100 || typeof value2.ready !== "boolean" || typeof value2.independent !== "boolean" || value2.sourceDisclosure !== "redacted" || value2.targetExecution !== false || !Number.isSafeInteger(value2.reportRetentionDays) || value2.reportRetentionDays < 1) return false;
   const validRoute = (route2, purpose) => !!route2 && route2.purpose === purpose && typeof route2.enabled === "boolean" && typeof route2.credentialReady === "boolean" && typeof route2.provider === "string" && route2.provider.length > 0 && route2.provider.length <= 100 && typeof route2.model === "string" && route2.model.length > 0 && route2.model.length <= 200 && Number.isSafeInteger(route2.policyVersion) && route2.policyVersion >= 1 && Number.isSafeInteger(route2.maxCallsPerRun) && route2.maxCallsPerRun >= 1 && Number.isSafeInteger(route2.maxInputBytes) && route2.maxInputBytes >= 1 && Number.isSafeInteger(route2.maxOutputTokens) && route2.maxOutputTokens >= 1;
-  return validRoute(value.routes?.discovery, "security.discovery") && validRoute(value.routes?.validation, "security.validation");
+  return validRoute(value2.routes?.discovery, "security.discovery") && validRoute(value2.routes?.validation, "security.validation");
 }
-function hostedSecurityCredential(value) {
-  if (typeof value !== "string" || value.length < 8 || value.length > 8192 || /\s|[\u0000-\u001f\u007f]/.test(value)) {
+function hostedSecurityCredential(value2) {
+  if (typeof value2 !== "string" || value2.length < 8 || value2.length > 8192 || /\s|[\u0000-\u001f\u007f]/.test(value2)) {
     throw new Error("Hosted security requires an injected odla developer token");
   }
-  return value;
+  return value2;
 }
 
 // src/security-hosted-github.ts
@@ -3068,24 +3091,24 @@ var CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/;
 var HarnessProtocolError = class extends Error {
   name = "HarnessProtocolError";
 };
-function record2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+function record2(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
-function boundedText(value, label, max) {
-  if (typeof value !== "string" || !value || value.length > max || CONTROL.test(value)) {
+function boundedText(value2, label, max) {
+  if (typeof value2 !== "string" || !value2 || value2.length > max || CONTROL.test(value2)) {
     throw new HarnessProtocolError(`${label} must be a non-empty string of at most ${max} characters`);
   }
-  return value;
+  return value2;
 }
 function parseAgentOutput(line) {
   if (Buffer.byteLength(line, "utf8") > 1e6) throw new HarnessProtocolError("agent message exceeds 1 MB");
-  let value;
+  let value2;
   try {
-    value = JSON.parse(line);
+    value2 = JSON.parse(line);
   } catch {
     throw new HarnessProtocolError("agent emitted invalid JSON");
   }
-  const message2 = record2(value);
+  const message2 = record2(value2);
   if (!message2 || message2.protocolVersion !== HARNESS_PROTOCOL_VERSION) {
     throw new HarnessProtocolError(`agent protocolVersion must be ${HARNESS_PROTOCOL_VERSION}`);
   }
@@ -3394,7 +3417,7 @@ async function gitOutput(cwd, args, maxBytes) {
     else stdout.push(chunk);
   });
   child.stderr.on("data", (chunk) => {
-    if (stderr.reduce((sum, value) => sum + value.byteLength, 0) < 16384) stderr.push(chunk);
+    if (stderr.reduce((sum, value2) => sum + value2.byteLength, 0) < 16384) stderr.push(chunk);
   });
   const code = await new Promise((accept, reject) => {
     child.once("error", reject);
@@ -3415,7 +3438,7 @@ async function gitBlobs(cwd, entries, maxBytes) {
     else stdout.push(chunk);
   });
   child.stderr.on("data", (chunk) => {
-    if (stderr.reduce((sum, value) => sum + value.byteLength, 0) < 16384) stderr.push(chunk);
+    if (stderr.reduce((sum, value2) => sum + value2.byteLength, 0) < 16384) stderr.push(chunk);
   });
   child.stdin.end(`${entries.map((entry) => entry.hash).join("\n")}
 `);
@@ -3453,8 +3476,8 @@ async function materializeGitTree(source, commitSha, options = {}) {
   const maxFiles = options.maxFiles ?? 2e4;
   const maxBytes = options.maxBytes ?? 512 * 1024 * 1024;
   const inventory = (await gitOutput(sourceDir, ["ls-tree", "-rz", commitSha], 16 * 1024 * 1024)).toString("utf8").split("\0").filter(Boolean);
-  const entries = inventory.flatMap((record7) => {
-    const match = /^(100644|100755) blob ([0-9a-f]{40,64})\t([\s\S]+)$/.exec(record7);
+  const entries = inventory.flatMap((record8) => {
+    const match = /^(100644|100755) blob ([0-9a-f]{40,64})\t([\s\S]+)$/.exec(record8);
     return match && allowedWorkspacePath(match[3]) ? [{ mode: match[1], hash: match[2], path: match[3] }] : [];
   });
   if (entries.length > maxFiles) throw new Error(`workspace exceeds ${maxFiles} files`);
@@ -3529,7 +3552,7 @@ async function gitSourceFiles(sourceDir, maxFiles, maxBytes) {
     else stdout.push(chunk);
   });
   child.stderr.on("data", (chunk) => {
-    if (stderr.reduce((sum, value) => sum + value.byteLength, 0) < 16384) stderr.push(chunk);
+    if (stderr.reduce((sum, value2) => sum + value2.byteLength, 0) < 16384) stderr.push(chunk);
   });
   const code = await new Promise((accept, reject) => {
     child.once("error", reject);
@@ -3589,7 +3612,7 @@ async function captureGitDiff(root, maxBytes) {
     else stdout.push(chunk);
   });
   child.stderr.on("data", (chunk) => {
-    if (stderr.reduce((sum, value) => sum + value.byteLength, 0) < 16384) stderr.push(chunk);
+    if (stderr.reduce((sum, value2) => sum + value2.byteLength, 0) < 16384) stderr.push(chunk);
   });
   const code = await new Promise((accept, reject) => {
     child.once("error", reject);
@@ -3676,34 +3699,34 @@ var CamelError = class extends Error {
 };
 
 // ../camel/dist/chunk-L5DYU2E2.js
-function canonicalJson(value) {
-  return JSON.stringify(normalize(value));
+function canonicalJson(value2) {
+  return JSON.stringify(normalize(value2));
 }
-async function sha256Hex(value) {
-  const bytes = typeof value === "string" ? new TextEncoder().encode(value) : value;
+async function sha256Hex(value2) {
+  const bytes = typeof value2 === "string" ? new TextEncoder().encode(value2) : value2;
   const digest = await crypto.subtle.digest("SHA-256", Uint8Array.from(bytes).buffer);
   return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function utf8Length(value) {
-  if (typeof value === "string") return new TextEncoder().encode(value).byteLength;
-  if (value instanceof Uint8Array) return value.byteLength;
+function utf8Length(value2) {
+  if (typeof value2 === "string") return new TextEncoder().encode(value2).byteLength;
+  if (value2 instanceof Uint8Array) return value2.byteLength;
   try {
-    return new TextEncoder().encode(canonicalJson(value)).byteLength;
+    return new TextEncoder().encode(canonicalJson(value2)).byteLength;
   } catch {
     throw new CamelError("conversion_rejected", "Unsafe input could not be canonically measured.");
   }
 }
-function normalize(value) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new CamelError("state_conflict", "Canonical JSON rejects non-finite numbers.");
-    return value;
+function normalize(value2) {
+  if (value2 === null || typeof value2 === "string" || typeof value2 === "boolean") return value2;
+  if (typeof value2 === "number") {
+    if (!Number.isFinite(value2)) throw new CamelError("state_conflict", "Canonical JSON rejects non-finite numbers.");
+    return value2;
   }
-  if (Array.isArray(value)) return value.map(normalize);
-  if (value instanceof Uint8Array) return { $bytes: [...value] };
-  if (typeof value === "object") {
-    const record7 = value;
-    return Object.fromEntries(Object.keys(record7).filter((key) => record7[key] !== void 0).sort().map((key) => [key, normalize(record7[key])]));
+  if (Array.isArray(value2)) return value2.map(normalize);
+  if (value2 instanceof Uint8Array) return { $bytes: [...value2] };
+  if (typeof value2 === "object") {
+    const record8 = value2;
+    return Object.fromEntries(Object.keys(record8).filter((key) => record8[key] !== void 0).sort().map((key) => [key, normalize(record8[key])]));
   }
   throw new CamelError("state_conflict", "Canonical JSON rejects unsupported values.");
 }
@@ -3712,10 +3735,10 @@ function canRead(readers, readerId) {
 }
 function dependenciesOf(values, influence = "data") {
   const result = [];
-  for (const value of values) {
-    result.push(...value.label.dependencies);
-    for (const ref of value.label.provenance) {
-      result.push({ ref, influence, promptSafetyAtUse: value.label.promptSafety });
+  for (const value2 of values) {
+    result.push(...value2.label.dependencies);
+    for (const ref of value2.label.provenance) {
+      result.push({ ref, influence, promptSafetyAtUse: value2.label.promptSafety });
     }
   }
   const unique3 = /* @__PURE__ */ new Map();
@@ -3726,32 +3749,32 @@ function dependenciesOf(values, influence = "data") {
 // ../camel/dist/chunk-S7EVNA2U.js
 var camelValueBrand = /* @__PURE__ */ Symbol("@odla-ai/camel/value");
 var authenticCamelValues = /* @__PURE__ */ new WeakSet();
-function isCamelValue(value) {
-  return typeof value === "object" && value !== null && authenticCamelValues.has(value);
+function isCamelValue(value2) {
+  return typeof value2 === "object" && value2 !== null && authenticCamelValues.has(value2);
 }
-function isSafe(value) {
-  return isCamelValue(value) && value.label.promptSafety === "safe";
+function isSafe(value2) {
+  return isCamelValue(value2) && value2.label.promptSafety === "safe";
 }
-function isUnsafe(value) {
-  return isCamelValue(value) && value.label.promptSafety === "unsafe";
+function isUnsafe(value2) {
+  return isCamelValue(value2) && value2.label.promptSafety === "unsafe";
 }
-function createSafeInternal(value, safeBasis, metadata2) {
-  return createValue(value, {
+function createSafeInternal(value2, safeBasis, metadata2) {
+  return createValue(value2, {
     schemaVersion: 1,
     promptSafety: "safe",
     safeBasis,
     ...copyMetadata(metadata2)
   });
 }
-function createUnsafeInternal(value, metadata2) {
-  return createValue(value, {
+function createUnsafeInternal(value2, metadata2) {
+  return createValue(value2, {
     schemaVersion: 1,
     promptSafety: "unsafe",
     ...copyMetadata(metadata2)
   });
 }
-function createValue(value, label) {
-  const result = { value, label: Object.freeze(label) };
+function createValue(value2, label) {
+  const result = { value: value2, label: Object.freeze(label) };
   Object.defineProperty(result, camelValueBrand, { value: label.promptSafety, enumerable: false });
   authenticCamelValues.add(result);
   return Object.freeze(result);
@@ -3857,8 +3880,8 @@ async function createCodePortableCheckpoint(input) {
   const checkpointDigest = `sha256:${await sha256Hex(canonicalJson(fields))}`;
   return freeze({ ...fields, patch: input.patch, checkpointDigest });
 }
-async function verifyCodePortableCheckpoint(value) {
-  const input = object(value, "checkpoint");
+async function verifyCodePortableCheckpoint(value2) {
+  const input = object(value2, "checkpoint");
   exact2(input, ["schemaVersion", "baseCommitSha", "patch", "patchDigest", "state", "stateDigest", "checkpointDigest"]);
   if (input.schemaVersion !== 1 || typeof input.baseCommitSha !== "string" || typeof input.patch !== "string" || typeof input.patchDigest !== "string" || typeof input.stateDigest !== "string" || typeof input.checkpointDigest !== "string") {
     throw invalid2("Portable checkpoint fields are malformed.");
@@ -3873,8 +3896,8 @@ async function verifyCodePortableCheckpoint(value) {
   }
   return created;
 }
-function normalizeState(value) {
-  const state2 = object(value, "state");
+function normalizeState(value2) {
+  const state2 = object(value2, "state");
   exact2(state2, [
     "planCursor",
     "conversationRefs",
@@ -3932,30 +3955,30 @@ function validateBaseAndPatch(baseCommitSha, patch2) {
     throw invalid2("Portable checkpoint base or patch is malformed or outside its bounds.");
   }
 }
-function strings(value, name, pattern, maximum, sort) {
-  if (!Array.isArray(value) || value.length > maximum || value.some((item) => typeof item !== "string" || !pattern.test(item)) || new Set(value).size !== value.length) {
+function strings(value2, name, pattern, maximum, sort) {
+  if (!Array.isArray(value2) || value2.length > maximum || value2.some((item) => typeof item !== "string" || !pattern.test(item)) || new Set(value2).size !== value2.length) {
     throw invalid2(`Portable checkpoint ${name} is malformed or outside its bounds.`);
   }
-  const result = [...value];
+  const result = [...value2];
   return sort ? result.sort() : result;
 }
-function object(value, name) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw invalid2(`Portable ${name} must be an object.`);
-  return value;
+function object(value2, name) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw invalid2(`Portable ${name} must be an object.`);
+  return value2;
 }
-function exact2(value, keys) {
-  if (Object.keys(value).some((key) => !keys.includes(key)) || keys.some((key) => !(key in value))) {
+function exact2(value2, keys) {
+  if (Object.keys(value2).some((key) => !keys.includes(key)) || keys.some((key) => !(key in value2))) {
     throw invalid2("Portable checkpoint contains missing or unsupported fields.");
   }
 }
-function freeze(value) {
+function freeze(value2) {
   return Object.freeze({
-    ...value,
+    ...value2,
     state: Object.freeze({
-      ...value.state,
-      conversationRefs: Object.freeze([...value.state.conversationRefs]),
-      completedEffects: Object.freeze(value.state.completedEffects.map((item) => Object.freeze({ ...item }))),
-      unresolvedApprovals: Object.freeze([...value.state.unresolvedApprovals])
+      ...value2.state,
+      conversationRefs: Object.freeze([...value2.state.conversationRefs]),
+      completedEffects: Object.freeze(value2.state.completedEffects.map((item) => Object.freeze({ ...item }))),
+      unresolvedApprovals: Object.freeze([...value2.state.unresolvedApprovals])
     })
   });
 }
@@ -4046,61 +4069,61 @@ async function createConversionRegistry(config) {
     if (utf8Length(source.value) > policy.maximumSourceBytes) throw new CamelError("limit_exceeded", "Unsafe conversion input exceeds its byte bound.");
     return policy;
   };
-  const emit3 = (source, policy, value) => convert(source, policy, value, outputCounts);
+  const emit3 = (source, policy, value2) => convert(source, policy, value2, outputCounts);
   const operations = Object.freeze({
-    boolean: async (value, id) => {
-      const policy = checked(value, id, "boolean");
-      return emit3(value, policy, requireBoolean(value.value));
+    boolean: async (value2, id) => {
+      const policy = checked(value2, id, "boolean");
+      return emit3(value2, policy, requireBoolean(value2.value));
     },
-    integer: async (value, id) => {
-      const policy = checked(value, id, "integer");
-      return emit3(value, policy, boundedInteger(value.value, policy.output));
+    integer: async (value2, id) => {
+      const policy = checked(value2, id, "integer");
+      return emit3(value2, policy, boundedInteger(value2.value, policy.output));
     },
-    finiteNumber: async (value, id) => {
-      const policy = checked(value, id, "finite_number");
-      return emit3(value, policy, boundedNumber(value.value, policy.output));
+    finiteNumber: async (value2, id) => {
+      const policy = checked(value2, id, "finite_number");
+      return emit3(value2, policy, boundedNumber(value2.value, policy.output));
     },
-    enum: async (value, id) => {
-      const policy = checked(value, id, "enum");
-      return emit3(value, policy, enumMember(value.value, policy.output));
+    enum: async (value2, id) => {
+      const policy = checked(value2, id, "enum");
+      return emit3(value2, policy, enumMember(value2.value, policy.output));
     },
-    date: async (value, id) => {
-      const policy = checked(value, id, "date");
-      return emit3(value, policy, canonicalDate(value.value, policy.output));
+    date: async (value2, id) => {
+      const policy = checked(value2, id, "date");
+      return emit3(value2, policy, canonicalDate(value2.value, policy.output));
     },
-    registeredId: async (value, id) => {
-      const policy = checked(value, id, "registered_id");
+    registeredId: async (value2, id) => {
+      const policy = checked(value2, id, "registered_id");
       const registry = config.registeredIds?.[policy.output.registryId];
-      const output = typeof value.value === "string" ? registry?.values[value.value] : void 0;
+      const output = typeof value2.value === "string" ? registry?.values[value2.value] : void 0;
       if (!output) throw new CamelError("conversion_rejected", "Registered-ID conversion rejected the candidate.");
-      return emit3(value, policy, output);
+      return emit3(value2, policy, output);
     },
-    digest: async (value, id) => {
-      const policy = checked(value, id, "digest");
-      if (!(value.value instanceof Uint8Array)) throw new CamelError("conversion_rejected", "Digest conversion requires bytes.");
-      return emit3(value, policy, await sha256Hex(value.value));
+    digest: async (value2, id) => {
+      const policy = checked(value2, id, "digest");
+      if (!(value2.value instanceof Uint8Array)) throw new CamelError("conversion_rejected", "Digest conversion requires bytes.");
+      return emit3(value2, policy, await sha256Hex(value2.value));
     },
-    measure: async (value, metric, id) => {
-      const policy = checked(value, id, "integer");
-      const measured = measure(value.value, metric);
-      return emit3(value, policy, boundedInteger(measured, policy.output));
+    measure: async (value2, metric, id) => {
+      const policy = checked(value2, id, "integer");
+      const measured = measure(value2.value, metric);
+      return emit3(value2, policy, boundedInteger(measured, policy.output));
     },
-    test: async (value, predicateId, id) => {
-      const policy = checked(value, id, "boolean");
+    test: async (value2, predicateId, id) => {
+      const policy = checked(value2, id, "boolean");
       const predicate = config.predicates?.[predicateId];
       if (!predicate) throw new CamelError("conversion_rejected", "Predicate is not registered.");
-      return emit3(value, policy, evaluatePredicate(value.value, predicate, config.registeredIds));
+      return emit3(value2, policy, evaluatePredicate(value2.value, predicate, config.registeredIds));
     }
   });
   return Object.freeze({ operations, policy: (id) => policies.get(id) ?? missingPolicy() });
 }
-async function convert(source, policy, value, counts) {
+async function convert(source, policy, value2, counts) {
   const sourceKey = sourceIdentity(source);
   const countKey = `${policy.conversionId}\0${sourceKey}`;
   const count = counts.get(countKey) ?? 0;
   if (count >= policy.maximumOutputsPerArtifact) throw new CamelError("limit_exceeded", "Conversion output count exceeds its per-source bound.");
   counts.set(countKey, count + 1);
-  return createSafeInternal(value, "atomic_conversion", {
+  return createSafeInternal(value2, "atomic_conversion", {
     readers: source.label.readers,
     provenance: [...source.label.provenance, { kind: "converter", id: policy.conversionId, digest: policy.digest }],
     dependencies: dependenciesOf([source])
@@ -4112,49 +4135,49 @@ function validatePolicyShape(policy) {
   const output = policy.output;
   if ((output.kind === "integer" || output.kind === "finite_number") && (!Number.isFinite(output.minimum) || !Number.isFinite(output.maximum) || output.minimum > output.maximum)) throw new CamelError("state_conflict", "Numeric conversion bounds are invalid.");
   if (output.kind === "finite_number" && (!Number.isSafeInteger(output.maximumDecimalPlaces) || output.maximumDecimalPlaces < 0 || output.maximumDecimalPlaces > 15)) throw new CamelError("state_conflict", "Decimal-place bound is invalid.");
-  if (output.kind === "enum" && (output.values.length === 0 || output.values.some((value) => typeof value !== "string" || !value) || new Set(output.values).size !== output.values.length)) throw new CamelError("state_conflict", "Enum conversion members must be unique and non-empty.");
+  if (output.kind === "enum" && (output.values.length === 0 || output.values.some((value2) => typeof value2 !== "string" || !value2) || new Set(output.values).size !== output.values.length)) throw new CamelError("state_conflict", "Enum conversion members must be unique and non-empty.");
   if (output.kind === "registered_id" && (!output.registryId || !output.registryDigest)) throw new CamelError("state_conflict", "Registered-ID conversion identity is invalid.");
   if (output.kind === "date" && output.format !== "date" && output.format !== "rfc3339") throw new CamelError("state_conflict", "Date conversion format is invalid.");
   if (output.kind === "digest" && output.algorithm !== "sha256") throw new CamelError("state_conflict", "Digest conversion algorithm is invalid.");
 }
-function requireBoolean(value) {
-  if (typeof value !== "boolean") throw new CamelError("conversion_rejected", "Boolean conversion requires a structured boolean.");
-  return value;
+function requireBoolean(value2) {
+  if (typeof value2 !== "boolean") throw new CamelError("conversion_rejected", "Boolean conversion requires a structured boolean.");
+  return value2;
 }
-function boundedInteger(value, spec) {
-  if (spec.kind !== "integer" || typeof value !== "number" || !Number.isSafeInteger(value) || value < spec.minimum || value > spec.maximum) throw new CamelError("conversion_rejected", "Integer conversion rejected the structured value.");
-  return value;
+function boundedInteger(value2, spec) {
+  if (spec.kind !== "integer" || typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < spec.minimum || value2 > spec.maximum) throw new CamelError("conversion_rejected", "Integer conversion rejected the structured value.");
+  return value2;
 }
-function boundedNumber(value, spec) {
-  if (spec.kind !== "finite_number" || typeof value !== "number" || !Number.isFinite(value) || value < spec.minimum || value > spec.maximum) throw new CamelError("conversion_rejected", "Finite-number conversion rejected the structured value.");
-  const text = String(value);
+function boundedNumber(value2, spec) {
+  if (spec.kind !== "finite_number" || typeof value2 !== "number" || !Number.isFinite(value2) || value2 < spec.minimum || value2 > spec.maximum) throw new CamelError("conversion_rejected", "Finite-number conversion rejected the structured value.");
+  const text = String(value2);
   if (/e/i.test(text) || (text.split(".")[1]?.length ?? 0) > spec.maximumDecimalPlaces) throw new CamelError("conversion_rejected", "Finite-number conversion rejected a non-canonical decimal.");
-  return value;
+  return value2;
 }
-function enumMember(value, spec) {
-  if (spec.kind !== "enum" || typeof value !== "string") throw new CamelError("conversion_rejected", "Enum conversion requires a structured string member.");
-  const member = spec.caseSensitive ? spec.values.find((item) => item === value) : spec.values.find((item) => item.toLocaleLowerCase("en-US") === value.toLocaleLowerCase("en-US"));
+function enumMember(value2, spec) {
+  if (spec.kind !== "enum" || typeof value2 !== "string") throw new CamelError("conversion_rejected", "Enum conversion requires a structured string member.");
+  const member = spec.caseSensitive ? spec.values.find((item) => item === value2) : spec.values.find((item) => item.toLocaleLowerCase("en-US") === value2.toLocaleLowerCase("en-US"));
   if (member === void 0) throw new CamelError("conversion_rejected", "Enum conversion rejected a non-member.");
   return member;
 }
-function canonicalDate(value, spec) {
-  if (spec.kind !== "date" || typeof value !== "string") throw new CamelError("conversion_rejected", "Date conversion requires a canonical structured string.");
+function canonicalDate(value2, spec) {
+  if (spec.kind !== "date" || typeof value2 !== "string") throw new CamelError("conversion_rejected", "Date conversion requires a canonical structured string.");
   const pattern = spec.format === "date" ? /^\d{4}-\d{2}-\d{2}$/ : /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/;
-  const instant = Date.parse(spec.format === "date" ? `${value}T00:00:00Z` : value);
-  if (!pattern.test(value) || !Number.isFinite(instant) || spec.format === "date" && new Date(instant).toISOString().slice(0, 10) !== value) throw new CamelError("conversion_rejected", "Date conversion rejected a non-canonical value.");
-  if (spec.earliest && value < spec.earliest || spec.latest && value > spec.latest) throw new CamelError("conversion_rejected", "Date conversion rejected an out-of-range value.");
-  return value;
-}
-function measure(value, metric) {
-  if (metric === "byte_length" && (typeof value === "string" || value instanceof Uint8Array)) return utf8Length(value);
-  if (metric === "codepoint_length" && typeof value === "string") return [...value].length;
-  if (metric === "item_count" && Array.isArray(value)) return value.length;
+  const instant = Date.parse(spec.format === "date" ? `${value2}T00:00:00Z` : value2);
+  if (!pattern.test(value2) || !Number.isFinite(instant) || spec.format === "date" && new Date(instant).toISOString().slice(0, 10) !== value2) throw new CamelError("conversion_rejected", "Date conversion rejected a non-canonical value.");
+  if (spec.earliest && value2 < spec.earliest || spec.latest && value2 > spec.latest) throw new CamelError("conversion_rejected", "Date conversion rejected an out-of-range value.");
+  return value2;
+}
+function measure(value2, metric) {
+  if (metric === "byte_length" && (typeof value2 === "string" || value2 instanceof Uint8Array)) return utf8Length(value2);
+  if (metric === "codepoint_length" && typeof value2 === "string") return [...value2].length;
+  if (metric === "item_count" && Array.isArray(value2)) return value2.length;
   throw new CamelError("conversion_rejected", "Measurement input does not match the registered metric.");
 }
-function evaluatePredicate(value, predicate, registries) {
-  if (predicate.kind === "has_fields") return typeof value === "object" && value !== null && !Array.isArray(value) && predicate.fields.every((field) => Object.hasOwn(value, field));
-  if (predicate.kind === "registered_id") return typeof value === "string" && registries?.[predicate.registryId]?.values[value] !== void 0;
-  const actual = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+function evaluatePredicate(value2, predicate, registries) {
+  if (predicate.kind === "has_fields") return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) && predicate.fields.every((field) => Object.hasOwn(value2, field));
+  if (predicate.kind === "registered_id") return typeof value2 === "string" && registries?.[predicate.registryId]?.values[value2] !== void 0;
+  const actual = value2 === null ? "null" : Array.isArray(value2) ? "array" : typeof value2;
   return actual === predicate.valueType;
 }
 function sourceIdentity(source) {
@@ -4177,17 +4200,17 @@ function createCamelIngress(constants2 = []) {
     byId.set(item.id, item);
   }
   const ingress = {
-    userInstruction: (value, input) => createSafeInternal(value, "user_instruction", metadata("user_instruction", input.id, input.readers)),
-    systemPolicy: (value, input) => createSafeInternal(value, "system_policy", metadata("system_policy", input.id, input.readers)),
+    userInstruction: (value2, input) => createSafeInternal(value2, "user_instruction", metadata("user_instruction", input.id, input.readers)),
+    systemPolicy: (value2, input) => createSafeInternal(value2, "system_policy", metadata("system_policy", input.id, input.readers)),
     control: (id) => {
       const item = byId.get(id);
       if (!item) throw new CamelError("permission_denied", "Unknown control constant.");
       return createSafeInternal(item.value, "harness_constant", metadata("harness", id, item.readers));
     },
-    external: (value, label) => createUnsafeInternal(value, label),
-    quarantinedOutput: (value, input) => {
+    external: (value2, label) => createUnsafeInternal(value2, label),
+    quarantinedOutput: (value2, input) => {
       if (!input.runId) throw new CamelError("state_conflict", "Quarantined run IDs must be non-empty.");
-      return createUnsafeInternal(value, {
+      return createUnsafeInternal(value2, {
         readers: input.readers,
         dependencies: input.dependencies,
         provenance: [{ kind: "quarantined_llm", id: input.runId, digest: input.digest }]
@@ -4196,15 +4219,15 @@ function createCamelIngress(constants2 = []) {
   };
   return Object.freeze(ingress);
 }
-function assertNoUnsafeConstant(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (typeof value !== "object" || value === null || seen.has(value)) return;
-  seen.add(value);
-  if (isCamelValue(value)) {
-    if (isUnsafe(value)) throw new CamelError("unsafe_privileged_flow", "Control constants cannot contain Prompt-Unsafe values.");
-    assertNoUnsafeConstant(value.value, seen);
+function assertNoUnsafeConstant(value2, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value2 !== "object" || value2 === null || seen.has(value2)) return;
+  seen.add(value2);
+  if (isCamelValue(value2)) {
+    if (isUnsafe(value2)) throw new CamelError("unsafe_privileged_flow", "Control constants cannot contain Prompt-Unsafe values.");
+    assertNoUnsafeConstant(value2.value, seen);
     return;
   }
-  for (const child of Object.values(value)) assertNoUnsafeConstant(child, seen);
+  for (const child of Object.values(value2)) assertNoUnsafeConstant(child, seen);
 }
 function metadata(kind, id, readers) {
   if (!id) throw new CamelError("state_conflict", "Provenance IDs must be non-empty.");
@@ -4235,7 +4258,7 @@ async function evaluate(input, registries, approvals) {
     if (invalid3) return deny(invalid3);
     if (arg.role === "selector" && !isSafe(arg.value)) confined.add(arg.value);
   }
-  if (input.controlDependencies.some((value) => !isSafe(value) && !confined.has(value))) return deny("unsafe_control_dependency");
+  if (input.controlDependencies.some((value2) => !isSafe(value2) && !confined.has(value2))) return deny("unsafe_control_dependency");
   if (confined.size > 0) {
     const fixed = input.tool.unsafeSelectorPolicy?.fixedProviderIds ?? [];
     const destinations = Object.values(input.args).filter((arg) => arg.role === "destination");
@@ -4262,29 +4285,29 @@ async function validateArgument(path, arg, tool, registries) {
     if (!isSafe(arg.value)) return "unsafe_destination_argument";
     if (!isControlOwned(arg.value)) return "destination_not_control_owned";
     const registry = registries[arg.registryId];
-    const validValues = registry && registry.values.length > 0 && registry.values.every((value) => typeof value === "string" && value.length > 0) && new Set(registry.values).size === registry.values.length;
+    const validValues = registry && registry.values.length > 0 && registry.values.every((value2) => typeof value2 === "string" && value2.length > 0) && new Set(registry.values).size === registry.values.length;
     if (!registry || !validValues || registry.digest !== arg.registryDigest || await destinationRegistryDigest(registry.values) !== registry.digest || !registry.values.includes(arg.value.value)) return "destination_not_registered";
   }
   if (arg.role === "selector" && !isSafe(arg.value)) return validateUnsafeSelector(path, arg.value, tool);
   return void 0;
 }
-function isControlOwned(value) {
-  return value.label.safeBasis === "system_policy" || value.label.safeBasis === "harness_constant";
+function isControlOwned(value2) {
+  return value2.label.safeBasis === "system_policy" || value2.label.safeBasis === "harness_constant";
 }
 function copyRegistries(registries) {
   return Object.freeze(Object.fromEntries(Object.entries(registries).map(([id, registry]) => [id, Object.freeze({ digest: registry.digest, values: Object.freeze([...registry.values]) })])));
 }
-function validateUnsafeSelector(path, value, tool) {
+function validateUnsafeSelector(path, value2, tool) {
   const policy = tool.unsafeSelectorPolicy;
   if (!policy || policy.effect !== tool.effect || !policy.selectorPaths.includes(path)) return "unsafe_selector_not_confined";
   if (!policy.fixedDestination || !policy.unsafeOutput || policy.fixedProviderIds.length === 0) return "unsafe_selector_not_confined";
   if (![policy.maximumCalls, policy.maximumResultsPerCall, policy.maximumOutputBytes, policy.maximumSelectorBytes].every((bound) => Number.isSafeInteger(bound) && bound > 0)) return "unsafe_selector_not_confined";
-  if (utf8Length(value.value) > policy.maximumSelectorBytes) return "unsafe_selector_too_large";
-  if (typeof value.value === "string" && looksLikeDestination(value.value)) return "unsafe_selector_is_destination";
+  if (utf8Length(value2.value) > policy.maximumSelectorBytes) return "unsafe_selector_too_large";
+  if (typeof value2.value === "string" && looksLikeDestination(value2.value)) return "unsafe_selector_is_destination";
   return void 0;
 }
-function looksLikeDestination(value) {
-  const text = value.trim();
+function looksLikeDestination(value2) {
+  const text = value2.trim();
   return /^(?:[a-z][a-z0-9+.-]*:\/\/|\/|\\\\)/i.test(text) || /^[\w.-]+\.[a-z]{2,}(?:[/:]|$)/i.test(text);
 }
 
@@ -4370,9 +4393,9 @@ var CodeRuntimeReconciler = class {
     }
   }
 };
-function retryableControlFailure(value) {
-  if (!value || typeof value !== "object") return false;
-  const failure = value;
+function retryableControlFailure(value2) {
+  if (!value2 || typeof value2 !== "object") return false;
+  const failure = value2;
   if (failure.code === "invalid_response" || typeof failure.status !== "number") return false;
   return failure.status === 408 || failure.status === 425 || failure.status === 429 || failure.status >= 500;
 }
@@ -4424,16 +4447,16 @@ function createCodeRuntimeControlClient(options) {
       if (options.signal?.aborted) throw cause;
       throw new CodeRuntimeControlError("Code runtime control plane is unavailable", 503, "transport_unavailable");
     }
-    const value = await response2.json().catch(() => null);
+    const value2 = await response2.json().catch(() => null);
     if (!response2.ok) {
-      const problem = record3(record3(value)?.error);
+      const problem = record3(record3(value2)?.error);
       throw new CodeRuntimeControlError(
         typeof problem?.message === "string" ? problem.message : `Code runtime request failed (${response2.status})`,
         response2.status,
         typeof problem?.code === "string" ? problem.code : void 0
       );
     }
-    return value;
+    return value2;
   };
   return {
     heartbeat: async (version, capabilities) => {
@@ -4448,15 +4471,15 @@ function createCodeRuntimeControlClient(options) {
       await call2(`/registry/code/runtime/sessions/${validSessionId(sessionId)}/source`, {})
     ),
     infer: async (sessionId, inference) => {
-      const value = record3(await call2(
+      const value2 = record3(await call2(
         `/registry/code/runtime/sessions/${validSessionId(sessionId)}/inference`,
         inference,
         modelRequestTimeoutMs
       ));
-      if (!value || value.requestId !== inference.requestId || !record3(value.response) || !record3(value.receipt)) {
+      if (!value2 || value2.requestId !== inference.requestId || !record3(value2.response) || !record3(value2.receipt)) {
         throw new CodeRuntimeControlError("invalid Code inference response", 502, "invalid_response");
       }
-      return value;
+      return value2;
     },
     review: async (sessionId, review) => parseReview(
       await call2(`/registry/code/runtime/sessions/${validSessionId(sessionId)}/review`, review, modelRequestTimeoutMs)
@@ -4481,8 +4504,8 @@ function createCodeRuntimeControlClient(options) {
     }
   };
 }
-function validatedEndpoint(value) {
-  const endpoint = value.replace(/\/+$/, "");
+function validatedEndpoint(value2) {
+  const endpoint = value2.replace(/\/+$/, "");
   let url;
   try {
     url = new URL(endpoint);
@@ -4495,9 +4518,9 @@ function validatedEndpoint(value) {
   }
   return endpoint;
 }
-function validSessionId(value) {
-  if (!/^csess_[0-9a-f]{32}$/.test(value)) throw new TypeError("invalid Code session id");
-  return value;
+function validSessionId(value2) {
+  if (!/^csess_[0-9a-f]{32}$/.test(value2)) throw new TypeError("invalid Code session id");
+  return value2;
 }
 function validateHeartbeat(version, capabilities) {
   if (!version.trim() || version.length > 80) throw new TypeError("runtimeVersion is required and at most 80 characters");
@@ -4510,8 +4533,8 @@ function validateHeartbeat(version, capabilities) {
     throw new TypeError("runtime resources must be positive integers");
   }
 }
-function parseSnapshot(value) {
-  const root = record3(value);
+function parseSnapshot(value2) {
+  const root = record3(value2);
   const host = record3(root?.host);
   if (!host || typeof host.hostId !== "string" || typeof host.runtimeVersion !== "string" || !Number.isSafeInteger(host.lastSeenAt) || host.revokedAt !== null || !Array.isArray(root?.bindings) || root.bindings.length > 1024 || !Array.isArray(root?.commands) || root.commands.length > 64) throw invalid("heartbeat");
   const bindingIds = /* @__PURE__ */ new Set();
@@ -4536,11 +4559,11 @@ function parseSnapshot(value) {
   });
   return { host, bindings, commands };
 }
-async function parseSource(value) {
-  const snapshot = record3(record3(value)?.snapshot);
+async function parseSource(value2) {
+  const snapshot = record3(record3(value2)?.snapshot);
   if (!snapshot || typeof snapshot.repository !== "string" || typeof snapshot.commitSha !== "string" || typeof snapshot.treeDigest !== "string" || !Array.isArray(snapshot.files)) throw invalid("source");
-  const files = snapshot.files.map((value2) => {
-    const file = record3(value2);
+  const files = snapshot.files.map((value22) => {
+    const file = record3(value22);
     if (!file || typeof file.path !== "string" || typeof file.content !== "string") throw invalid("source file");
     return { path: file.path, content: file.content };
   });
@@ -4567,19 +4590,19 @@ async function parseSource(value) {
   if (digest !== snapshot.treeDigest) throw invalid("source digest");
   return { ...source, treeDigest: digest, ...references.length ? { references } : {} };
 }
-function parseReview(value) {
-  const review = record3(record3(value)?.review);
+function parseReview(value2) {
+  const review = record3(record3(value2)?.review);
   if (!review || !["approved", "rejected"].includes(String(review.verdict)) || typeof review.reviewDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(review.reviewDigest) || typeof review.provider !== "string" || !review.provider || typeof review.model !== "string" || !review.model || !Number.isSafeInteger(review.policyVersion) || Number(review.policyVersion) < 1) throw invalid("review");
   return review;
 }
-function parseCandidate(value) {
-  const candidate = record3(record3(value)?.candidate);
+function parseCandidate(value2) {
+  const candidate = record3(record3(value2)?.candidate);
   if (!candidate || typeof candidate.candidateId !== "string" || !/^ccand_[0-9a-f]{32}$/.test(candidate.candidateId) || !["submitted", "approved", "published", "failed"].includes(String(candidate.status))) {
     throw invalid("candidate");
   }
   return { candidateId: candidate.candidateId, status: candidate.status };
 }
-var record3 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var record3 = (value2) => value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 var invalid = (part) => new CodeRuntimeControlError(`invalid Code runtime ${part} response`, 502, "invalid_response");
 var RESERVED = /* @__PURE__ */ new Set([".git", ".odla", ".wrangler", "node_modules", "dist", "coverage"]);
 var SECRET = /^(?:\.env(?:\..+)?|\.dev\.vars|credentials(?:\..+)?\.json|dev-token(?:\..+)?\.json)$/i;
@@ -4613,8 +4636,8 @@ function validateCodePatch(patch2, maxBytes) {
   if (!paths.length || new Set(paths).size !== paths.length) throw new TypeError("patch has no diffs or repeats a path");
   return paths;
 }
-function validHeaderPath(value, path, prefix) {
-  return value === "/dev/null" || value === `${prefix}/${path}`;
+function validHeaderPath(value2, path, prefix) {
+  return value2 === "/dev/null" || value2 === `${prefix}/${path}`;
 }
 function validateRelativePath(path) {
   const parts = path.split("/");
@@ -4760,8 +4783,8 @@ function assertCodeBuildRecipe(recipe2) {
     throw new TypeError("build recipe is malformed or exceeds its control bounds");
   }
 }
-function parseMemory(value) {
-  const match = /^([1-9][0-9]{0,4})([kmg])$/.exec(value.toLowerCase());
+function parseMemory(value2) {
+  const match = /^([1-9][0-9]{0,4})([kmg])$/.exec(value2.toLowerCase());
   if (!match?.[1] || !match[2]) return 0;
   const scale = match[2] === "k" ? 1024 : match[2] === "m" ? 1024 ** 2 : 1024 ** 3;
   return Number(match[1]) * scale;
@@ -4996,14 +5019,14 @@ function normalizedRecipe(recipe2) {
     expectedArtifacts: [...recipe2.expectedArtifacts ?? []].sort((left, right) => left.id.localeCompare(right.id)).map((artifact) => ({ id: artifact.id, path: artifact.path, maximumBytes: artifact.maximumBytes }))
   };
 }
-function digestJson(value) {
-  return digestBytes(JSON.stringify(value));
+function digestJson(value2) {
+  return digestBytes(JSON.stringify(value2));
 }
-function digestBytes(value) {
-  return `sha256:${createHash22("sha256").update(value).digest("hex")}`;
+function digestBytes(value2) {
+  return `sha256:${createHash22("sha256").update(value2).digest("hex")}`;
 }
-function integer(value, minimum, maximum) {
-  return Number.isSafeInteger(value) && value >= minimum && value <= maximum;
+function integer(value2, minimum, maximum) {
+  return Number.isSafeInteger(value2) && value2 >= minimum && value2 <= maximum;
 }
 async function prepareRuntimeCheckpoint(input) {
   const patch2 = await input.workspace.patch(256 * 1024);
@@ -5056,7 +5079,7 @@ async function prepareRuntimeCheckpoint(input) {
   });
   return { checkpoint, verification, review, note };
 }
-var message = (value) => (value instanceof Error ? value.message : String(value)).slice(0, 500);
+var message = (value2) => (value2 instanceof Error ? value2.message : String(value2)).slice(0, 500);
 var CodeRuntimeCheckpointManager = class {
   constructor(options) {
     this.options = options;
@@ -5250,7 +5273,7 @@ async function conversionPolicy(id, output) {
   return { ...definition, digest: await conversionPolicyDigest(definition) };
 }
 async function registeredPolicy(id, registryId, values) {
-  const mapping = Object.fromEntries(values.map((value) => [value, value]));
+  const mapping = Object.fromEntries(values.map((value2) => [value2, value2]));
   return conversionPolicy(id, {
     kind: "registered_id",
     registryId,
@@ -5259,7 +5282,7 @@ async function registeredPolicy(id, registryId, values) {
 }
 async function conversionRegistry(policies, values) {
   const registeredIds = Object.fromEntries(await Promise.all(Object.entries(values).map(async ([id, entries]) => {
-    const mapping = Object.fromEntries(entries.map((value) => [value, value]));
+    const mapping = Object.fromEntries(entries.map((value2) => [value2, value2]));
     return [id, { values: mapping, digest: await registeredIdRegistryDigest(mapping) }];
   })));
   return createConversionRegistry({ policies, registeredIds });
@@ -5283,8 +5306,8 @@ async function environment(input, options, tool) {
   };
   return { ingress, policy, fixedArgs, reader: ingress.control("reader"), runId: `${input.request.requestId}:${tool}` };
 }
-function unsafe(base, value, field) {
-  return base.ingress.quarantinedOutput(value, {
+function unsafe(base, value2, field) {
+  return base.ingress.quarantinedOutput(value2, {
     readers: base.reader.label.readers,
     runId: `${base.runId}:${field}`
   });
@@ -5364,14 +5387,14 @@ async function read(context, request2, options, policy) {
 }
 async function patch(context, request2, options, policy) {
   exactKeys(request2.input, ["patch"]);
-  const value = stringField(request2.input, "patch");
-  const paths = validateCodePatch(value, options.maxPatchBytes ?? 256 * 1024);
+  const value2 = stringField(request2.input, "patch");
+  const paths = validateCodePatch(value2, options.maxPatchBytes ?? 256 * 1024);
   if (paths.some((path) => options.readOnlyPrefixes?.some((prefix) => path === prefix || path.startsWith(`${prefix}/`)))) {
     throw new TypeError("patch targets a read-only reference source");
   }
-  const allowed = await policy.patch(policyContext(context, request2, options, { patch: value }));
+  const allowed = await policy.patch(policyContext(context, request2, options, { patch: value2 }));
   if (!allowed) return response(request2, false, "tool denied by CaMeL policy");
-  await applyCodePatch(context.workspaceDir, value, paths);
+  await applyCodePatch(context.workspaceDir, value2, paths);
   return response(request2, true, `Applied patch to ${paths.length} file(s).`, { paths });
 }
 async function recipe(context, request2, options, recipes, policy) {
@@ -5462,14 +5485,14 @@ function exactKeys(input, allowed) {
   if (Object.keys(input).some((key) => !allowed.includes(key))) throw new TypeError("tool input contains an unsupported field");
 }
 function stringField(input, name) {
-  const value = input[name];
-  if (typeof value !== "string" || !value) throw new TypeError(`${name} must be a non-empty string`);
-  return value;
+  const value2 = input[name];
+  if (typeof value2 !== "string" || !value2) throw new TypeError(`${name} must be a non-empty string`);
+  return value2;
 }
-function optionalInteger(value) {
-  if (value === void 0) return void 0;
-  if (!Number.isSafeInteger(value) || value < 1) throw new TypeError("line bounds must be positive integers");
-  return value;
+function optionalInteger(value2) {
+  if (value2 === void 0) return void 0;
+  if (!Number.isSafeInteger(value2) || value2 < 1) throw new TypeError("line bounds must be positive integers");
+  return value2;
 }
 function response(request2, ok, content2, details) {
   return { requestId: request2.requestId, ok, content: content2, ...details ? { details } : {} };
@@ -5515,9 +5538,9 @@ function codeLocalSource(payload) {
   return source;
 }
 function codeCheckpointPayload(payload) {
-  const value = payload.checkpoint;
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("resume checkpoint is missing");
-  return value;
+  const value2 = payload.checkpoint;
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new TypeError("resume checkpoint is missing");
+  return value2;
 }
 function fakeCodeLease(command, metadata2) {
   return {
@@ -5541,7 +5564,7 @@ function fakeCodeLease(command, metadata2) {
     }
   };
 }
-var record22 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var record22 = (value2) => value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 var SOURCE_LIMITS = { maxFiles: 2e4, maxBytes: 512 * 1024 * 1024 };
 async function prepareRuntimeLocalSource(input) {
   const { command, descriptor: descriptor2, available, repository, baseCommitSha, resume } = input;
@@ -5631,24 +5654,24 @@ async function appendCodeRuntimeEvent(control, command, event, refs) {
   const bounded = event.type === "message" ? { ...event, body: event.body.trim().slice(0, 2e4) || `${event.actor} event` } : event;
   await control.appendSessionEvent(command.sessionId, eventId, bounded);
 }
-var digestRuntimeValue = (value) => `sha256:${createHash3("sha256").update(value).digest("hex")}`;
-var runtimeErrorMessage = (value) => value instanceof Error ? value.message : String(value);
-var runtimeRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var safeRuntimeJson = (value) => {
+var digestRuntimeValue = (value2) => `sha256:${createHash3("sha256").update(value2).digest("hex")}`;
+var runtimeErrorMessage = (value2) => value2 instanceof Error ? value2.message : String(value2);
+var runtimeRecord = (value2) => value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
+var safeRuntimeJson = (value2) => {
   try {
-    return JSON.stringify(value).slice(0, 1e4);
+    return JSON.stringify(value2).slice(0, 1e4);
   } catch {
     return "[event]";
   }
 };
-function runtimeResultText(value) {
-  const record32 = runtimeRecord(value);
+function runtimeResultText(value2) {
+  const record32 = runtimeRecord(value2);
   if (record32 && typeof record32.text === "string") return record32.text.slice(0, 2e4);
   if (record32 && typeof record32.error === "string") return `Pi failed: ${record32.error.slice(0, 19989)}`;
   return null;
 }
-function runtimeResultError(value) {
-  const record32 = runtimeRecord(value);
+function runtimeResultError(value2) {
+  const record32 = runtimeRecord(value2);
   return record32 && typeof record32.error === "string" && record32.error.trim() ? record32.error.trim().slice(0, 2e3) : null;
 }
 var CodePiRuntimeEngine = class {
@@ -5922,14 +5945,14 @@ var CodePiRuntimeEngine = class {
     this.#active.delete(command.sessionId);
     return result;
   }
-  async #failure(command, active, value) {
-    active.failure = value.slice(0, 2e3);
+  async #failure(command, active, value2) {
+    active.failure = value2.slice(0, 2e3);
     if (active.acknowledged) {
       await this.options.control.reportSessionFailure(command.sessionId, active.failure).catch(() => void 0);
     }
   }
-  async #diagnostic(command, active, value) {
-    const detail = value.trim().slice(0, 2e3) || "Pi runtime failed";
+  async #diagnostic(command, active, value2) {
+    const detail = value2.trim().slice(0, 2e3) || "Pi runtime failed";
     this.options.onDiagnostic?.(detail);
     await this.#event(
       command,
@@ -6014,6 +6037,7 @@ Usage:
   odla-ai context save <name> [--platform <url>] [--app <id>] [--env <name>] [--json]
   odla-ai context remove <name> --yes [--json]
   odla-ai o11y status [--app <id>] [--context <name>] [--platform https://odla.ai] [--env prod] [--minutes 60] [--json]
+  odla-ai platform status [--context <name>] [--platform https://odla.ai] [--email <odla-account>] [--json]
   odla-ai whoami [--context <name>] [--platform https://odla.ai] [--json]
   odla-ai runbook ask "<question>" [--app <id>] [--all] [--json]
   odla-ai runbook search "<question>" [--app <id>] [--all] [--limit <n>] [--json]
@@ -6138,6 +6162,8 @@ Commands:
                canary, collector ingest/scheduler trust, Cloudflare-owned
                runtime metrics, and a machine verdict.
                --json keeps auth progress on stderr for unattended agents.
+  platform     Read canonical fleet health, releases, provider load/freshness,
+               explicit unknowns, and next actions through a read-only grant.
   provision    Register services, compose integrations, persist credentials, optionally push secrets.
   smoke        Verify credentials, public-config, composed schema, db aggregate, and integration probes.
   skill        Same installer; --agent accepts all, claude, codex, cursor,
@@ -6238,17 +6264,17 @@ async function prepareCodeLocalSource(cwd, repository, readHead = readGitHead) {
   }
 }
 async function readGitHead(cwd) {
-  const value = await new Promise((accept, reject) => {
+  const value2 = await new Promise((accept, reject) => {
     execFile3("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", maxBuffer: 16384 }, (error, stdout) => {
       if (error) reject(new Error("code connect requires a Git checkout with an initial commit"));
       else accept(stdout.trim());
     });
   });
-  if (!/^[0-9a-f]{40}$/.test(value)) throw new Error("code connect could not resolve the checkout HEAD commit");
-  return value;
+  if (!/^[0-9a-f]{40}$/.test(value2)) throw new Error("code connect could not resolve the checkout HEAD commit");
+  return value2;
 }
-function digestText(value) {
-  return `sha256:${createHash4("sha256").update(value).digest("hex")}`;
+function digestText(value2) {
+  return `sha256:${createHash4("sha256").update(value2).digest("hex")}`;
 }
 
 // src/code-connect.ts
@@ -6412,8 +6438,8 @@ async function runCodeRuntime(input) {
     for (const [name, handler] of handlers) process.removeListener(name, handler);
   }
 }
-function parseConnection(value, appId, appEnv) {
-  const root = record4(value);
+function parseConnection(value2, appId, appEnv) {
+  const root = record4(value2);
   const host = record4(root?.host);
   const offer = record4(root?.offer);
   const binding = record4(root?.binding);
@@ -6422,16 +6448,16 @@ function parseConnection(value, appId, appEnv) {
   }
   return root;
 }
-function apiFailure(action, status, value) {
-  const message2 = record4(record4(value)?.error)?.message;
+function apiFailure(action, status, value2) {
+  const message2 = record4(record4(value2)?.error)?.message;
   return `${action} failed (${status})${typeof message2 === "string" ? `: ${message2}` : ""}`;
 }
-function record4(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+function record4(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
 
 // src/provision.ts
-import { createAppsClient, tenantIdFor as tenantIdFor4 } from "@odla-ai/apps";
+import { createAppsClient, orderAppServices, tenantIdFor as tenantIdFor4 } from "@odla-ai/apps";
 import { putSecret as putSecret2 } from "@odla-ai/ai";
 import process8 from "process";
 
@@ -6476,8 +6502,8 @@ async function postJson2(doFetch, url, bearer, body) {
   if (!res.ok) throw new Error(`${new URL(url).pathname} failed: ${res.status} ${await responseText(res)}`);
   return res.json().catch(() => ({}));
 }
-function isRecord7(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function isRecord7(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
 async function responseText(res) {
   try {
@@ -6585,11 +6611,6 @@ async function safeText4(res) {
 // src/provision-helpers.ts
 import { DEFAULT_SECRET_NAMES } from "@odla-ai/ai";
 import { tenantIdFor as tenantIdFor3 } from "@odla-ai/apps";
-function serviceRank(service) {
-  if (service === "db") return 0;
-  if (service === "calendar") return 2;
-  return 1;
-}
 function defaultSecretName(provider) {
   const names = DEFAULT_SECRET_NAMES;
   return names[provider] ?? `${provider}_api_key`;
@@ -6615,14 +6636,14 @@ async function postJson3(doFetch, url, bearer, body) {
   });
   if (!res.ok) throw new Error(`${new URL(url).pathname} failed: ${res.status} ${await safeText5(res)}`);
 }
-function normalizeClerkConfig(value) {
-  if (!value) return null;
-  if (typeof value === "string") {
-    const publishableKey2 = envValue(value);
+function normalizeClerkConfig(value2) {
+  if (!value2) return null;
+  if (typeof value2 === "string") {
+    const publishableKey2 = envValue(value2);
     return publishableKey2 ? { publishableKey: publishableKey2 } : null;
   }
-  if (typeof value !== "object") return null;
-  const cfg = value;
+  if (typeof value2 !== "object") return null;
+  const cfg = value2;
   const publishableKey = envValue(cfg.publishableKey);
   return publishableKey ? { publishableKey, ...cfg.audience ? { audience: cfg.audience } : {}, ...cfg.mode ? { mode: cfg.mode } : {} } : null;
 }
@@ -6715,7 +6736,7 @@ async function provision(options) {
   for (const env of cfg.envs) {
     await assertTenantAdminAccess(doFetch, cfg, env, token);
   }
-  const serviceOrder = [...cfg.services].sort((a, b) => serviceRank(a) - serviceRank(b));
+  const serviceOrder = orderAppServices(cfg.services);
   for (const env of cfg.envs) {
     for (const service of serviceOrder) {
       if (service === "ai") {
@@ -6895,6 +6916,7 @@ var COMMAND_SURFACE = {
   help: {},
   init: {},
   o11y: { status: {} },
+  platform: { status: {} },
   pm: {
     ...PM_ENTITIES,
     handoff: {}
@@ -7062,13 +7084,13 @@ function selectEnv(requested, declared, configPath, rootDir) {
   return env;
 }
 async function injectedToken(options, request2) {
-  const value = options.token ?? await options.getToken?.(Object.freeze({ ...request2 }));
-  if (typeof value !== "string" || value.length < 8 || value.length > 8192 || /\s|[\u0000-\u001f\u007f]/.test(value)) {
+  const value2 = options.token ?? await options.getToken?.(Object.freeze({ ...request2 }));
+  if (typeof value2 !== "string" || value2.length < 8 || value2.length > 8192 || /\s|[\u0000-\u001f\u007f]/.test(value2)) {
     throw new Error(
       request2.selfAudit ? "Self-audit requires an injected, scoped platform security token" : "Hosted security requires an injected app developer token or getToken callback"
     );
   }
-  return value;
+  return value2;
 }
 function profileFor(name, maxHuntTasks) {
   const profile = name === "odla" ? odlaProfile() : name === "cloudflare-app" ? cloudflareAppProfile() : name === "generic" ? genericProfile() : void 0;
@@ -7114,8 +7136,8 @@ async function getHostedSecurityIntent(options) {
   }
   return response2;
 }
-function isValidIntent(value, expected) {
-  return !!value && value.executionContract === "odla.hosted-security-execution-consent.v1" && /^sha256:[a-f0-9]{64}$/.test(value.executionDigest) && /^sha256:[a-f0-9]{64}$/.test(value.planDigest) && value.appId === expected.appId && value.env === expected.env && value.sourceId === expected.sourceId && typeof value.repository === "string" && value.repository.length > 2 && value.repository.length <= 201 && typeof value.defaultBranch === "string" && value.defaultBranch.length > 0 && value.defaultBranch.length <= 255 && typeof value.requestedRef === "string" && value.requestedRef.length > 0 && value.requestedRef.length <= 255 && !/[\u0000-\u001f\u007f]/.test(value.requestedRef) && ["odla", "cloudflare-app", "generic"].includes(value.profile) && value.sourceDisclosure === "redacted";
+function isValidIntent(value2, expected) {
+  return !!value2 && value2.executionContract === "odla.hosted-security-execution-consent.v1" && /^sha256:[a-f0-9]{64}$/.test(value2.executionDigest) && /^sha256:[a-f0-9]{64}$/.test(value2.planDigest) && value2.appId === expected.appId && value2.env === expected.env && value2.sourceId === expected.sourceId && typeof value2.repository === "string" && value2.repository.length > 2 && value2.repository.length <= 201 && typeof value2.defaultBranch === "string" && value2.defaultBranch.length > 0 && value2.defaultBranch.length <= 255 && typeof value2.requestedRef === "string" && value2.requestedRef.length > 0 && value2.requestedRef.length <= 255 && !/[\u0000-\u001f\u007f]/.test(value2.requestedRef) && ["odla", "cloudflare-app", "generic"].includes(value2.profile) && value2.sourceDisclosure === "redacted";
 }
 
 // src/security-hosted-jobs.ts
@@ -7241,17 +7263,17 @@ function hostedJobPath(appIdInput, jobIdInput) {
   const jobId = hostedIdentifier(jobIdInput, "jobId");
   return `/registry/apps/${encodeURIComponent(appId)}/security/jobs/${encodeURIComponent(jobId)}`;
 }
-function securityPlanDigest(value) {
-  if (!/^sha256:[a-f0-9]{64}$/.test(value)) {
+function securityPlanDigest(value2) {
+  if (!/^sha256:[a-f0-9]{64}$/.test(value2)) {
     throw new Error("expected plan digest must be a sha256 digest from security plan");
   }
-  return value;
+  return value2;
 }
-function securityExecutionDigest(value) {
-  if (!/^sha256:[a-f0-9]{64}$/.test(value)) {
+function securityExecutionDigest(value2) {
+  if (!/^sha256:[a-f0-9]{64}$/.test(value2)) {
     throw new Error("expected execution digest must be a sha256 digest from security intent");
   }
-  return value;
+  return value2;
 }
 
 // src/argv.ts
@@ -7275,10 +7297,10 @@ function parseArgv(argv) {
       addOption(options, rawName, arg.slice(eq + 1));
       continue;
     }
-    const value = argv[i + 1];
-    if (value !== void 0 && !value.startsWith("--")) {
+    const value2 = argv[i + 1];
+    if (value2 !== void 0 && !value2.startsWith("--")) {
       i++;
-      addOption(options, rawName, value);
+      addOption(options, rawName, value2);
     } else {
       addOption(options, rawName, true);
     }
@@ -7294,39 +7316,39 @@ function assertArgs(parsed, allowedOptions2, maxPositionals) {
     throw new Error(`unexpected argument "${parsed.positionals[maxPositionals]}"; run "odla-ai help"`);
   }
 }
-function requiredString(value, name) {
-  const result = stringOpt(value);
+function requiredString(value2, name) {
+  const result = stringOpt(value2);
   if (!result) throw new Error(`${name} is required`);
   return result;
 }
-function stringOpt(value) {
-  if (typeof value === "string") return value;
-  if (Array.isArray(value)) return value[value.length - 1];
+function stringOpt(value2) {
+  if (typeof value2 === "string") return value2;
+  if (Array.isArray(value2)) return value2[value2.length - 1];
   return void 0;
 }
-function listOpt(value) {
-  if (value === void 0 || typeof value === "boolean") return void 0;
-  const values = Array.isArray(value) ? value : [value];
+function listOpt(value2) {
+  if (value2 === void 0 || typeof value2 === "boolean") return void 0;
+  const values = Array.isArray(value2) ? value2 : [value2];
   return values.flatMap((item) => item.split(",")).map((item) => item.trim()).filter(Boolean);
 }
-function boolOpt(value) {
-  if (typeof value === "boolean") return value;
-  if (typeof value === "string" && (value === "true" || value === "false")) return value === "true";
-  if (value === void 0) return void 0;
+function boolOpt(value2) {
+  if (typeof value2 === "boolean") return value2;
+  if (typeof value2 === "string" && (value2 === "true" || value2 === "false")) return value2 === "true";
+  if (value2 === void 0) return void 0;
   throw new Error("boolean option must be true or false");
 }
-function numberOpt(value, flag) {
-  if (value === void 0) return void 0;
-  const raw = stringOpt(value);
+function numberOpt(value2, flag) {
+  if (value2 === void 0) return void 0;
+  const raw = stringOpt(value2);
   const parsed = raw === void 0 ? Number.NaN : Number(raw);
   if (!Number.isSafeInteger(parsed) || parsed < 1) throw new Error(`${flag} requires a positive integer`);
   return parsed;
 }
-function addOption(options, name, value) {
+function addOption(options, name, value2) {
   const current = options[name];
-  if (current === void 0) options[name] = value;
-  else if (Array.isArray(current)) current.push(String(value));
-  else options[name] = [String(current), String(value)];
+  if (current === void 0) options[name] = value2;
+  else if (Array.isArray(current)) current.push(String(value2));
+  else options[name] = [String(current), String(value2)];
 }
 
 // src/operator-context.ts
@@ -7354,8 +7376,8 @@ function resolveOperatorProfile(parsed) {
   }
   assertOperatorName(name, "context");
   const profiles = readOperatorProfiles(file);
-  const value = Object.hasOwn(profiles, name) ? profiles[name] : void 0;
-  if (!value) {
+  const value2 = Object.hasOwn(profiles, name) ? profiles[name] : void 0;
+  if (!value2) {
     throw new Error(
       `operator context "${name}" not found in ${file}; run "odla-ai context list" or save it first`
     );
@@ -7364,7 +7386,7 @@ function resolveOperatorProfile(parsed) {
     name,
     source: fromFlag ? "flag" : "environment",
     file,
-    value
+    value: value2
   };
 }
 function listOperatorProfiles(file = operatorProfileFile()) {
@@ -7392,8 +7414,8 @@ function operatorCredentialFiles(selection) {
     scoped: join9(base, "admin-token.local.json")
   };
 }
-function assertOperatorName(value, label) {
-  if (!/^[a-z0-9][a-z0-9-]*$/.test(value)) {
+function assertOperatorName(value2, label) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(value2)) {
     throw new Error(
       `${label} must contain lowercase letters, numbers, and hyphens`
     );
@@ -7419,22 +7441,22 @@ function readOperatorProfiles(file) {
     );
   }
   const profiles = emptyProfiles();
-  for (const [name, value] of Object.entries(
+  for (const [name, value2] of Object.entries(
     raw.profiles
   )) {
     assertOperatorName(name, "context");
-    profiles[name] = validateProfile(value, `operator context "${name}"`);
+    profiles[name] = validateProfile(value2, `operator context "${name}"`);
   }
   return profiles;
 }
 function emptyProfiles() {
   return /* @__PURE__ */ Object.create(null);
 }
-function validateProfile(value, label) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
+function validateProfile(value2, label) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) {
     throw new Error(`${label} has an invalid shape`);
   }
-  const unknown = Object.keys(value).filter(
+  const unknown = Object.keys(value2).filter(
     (key) => !["platform", "app", "environment"].includes(key)
   );
   if (unknown.length > 0) {
@@ -7442,7 +7464,7 @@ function validateProfile(value, label) {
       `${label} contains unsupported field(s): ${unknown.sort().join(", ")}; contexts store scope metadata only, never credentials`
     );
   }
-  const candidate = value;
+  const candidate = value2;
   if (typeof candidate.platform !== "string") {
     throw new Error(`${label} needs an absolute platform URL`);
   }
@@ -7457,8 +7479,8 @@ function validateProfile(value, label) {
     ...environment2 ? { environment: environment2 } : {}
   };
 }
-function clean(value) {
-  const normalized = value?.trim();
+function clean(value2) {
+  const normalized = value2?.trim();
   return normalized || void 0;
 }
 
@@ -7551,8 +7573,8 @@ async function resolveOperatorContext(parsed, options = {}) {
     }
   };
 }
-function clean2(value) {
-  const normalized = value?.trim();
+function clean2(value2) {
+  const normalized = value2?.trim();
   return normalized || void 0;
 }
 
@@ -8241,10 +8263,10 @@ function harnessList(parsed) {
   ];
   return selected.length ? selected : ["all"];
 }
-function harnessOption(value, flag) {
-  if (value === void 0) return [];
-  if (typeof value === "boolean") throw new Error(`${flag} requires a harness name`);
-  const raw = Array.isArray(value) ? value : [value];
+function harnessOption(value2, flag) {
+  if (value2 === void 0) return [];
+  if (typeof value2 === "boolean") throw new Error(`${flag} requires a harness name`);
+  const raw = Array.isArray(value2) ? value2 : [value2];
   const parts = raw.flatMap((item) => item.split(","));
   if (parts.some((item) => !item.trim())) {
     throw new Error(`${flag} requires a harness name`);
@@ -8413,8 +8435,8 @@ function developerTokenStatus(context, parsed, now = Date.now()) {
     cacheStatus
   };
 }
-function clean3(value) {
-  const normalized = value?.trim();
+function clean3(value2) {
+  const normalized = value2?.trim();
   return normalized || void 0;
 }
 
@@ -8563,8 +8585,8 @@ async function request(ctx, method, path, body) {
     throw new Error(`discuss ${method} ${path} failed: ${data.error ?? `registry returned ${res.status}`}`);
   return data;
 }
-function emit(ctx, value, human) {
-  if (ctx.json) ctx.out.log(JSON.stringify(value, null, 2));
+function emit(ctx, value2, human) {
+  if (ctx.json) ctx.out.log(JSON.stringify(value2, null, 2));
   else human();
 }
 var state = (topic) => topic.resolved ? "resolved" : "open";
@@ -8609,8 +8631,8 @@ async function discussList(ctx, parsed) {
     ["limit", "limit"],
     ["offset", "offset"]
   ]) {
-    const value = stringOpt(parsed.options[flag]);
-    if (value) query.set(param, value);
+    const value2 = stringOpt(parsed.options[flag]);
+    if (value2) query.set(param, value2);
   }
   const qs = query.toString();
   const page = await request(ctx, "GET", `/topics${qs ? `?${qs}` : ""}`);
@@ -8807,11 +8829,11 @@ var MAX_CONSECUTIVE_FAILURES = 5;
 var MAX_BACKOFF_MS = 3e4;
 function numberOpt2(parsed, flag, fallback) {
   const raw = stringOpt(parsed.options[flag]);
-  const value = raw == null ? NaN : Number(raw);
-  return Number.isFinite(value) && value > 0 ? value : fallback;
+  const value2 = raw == null ? NaN : Number(raw);
+  return Number.isFinite(value2) && value2 > 0 ? value2 : fallback;
 }
-function jsonl(ctx, parsed, value) {
-  if (parsed.options.jsonl === true) ctx.out.log(JSON.stringify({ v: 1, ...value }));
+function jsonl(ctx, parsed, value2) {
+  if (parsed.options.jsonl === true) ctx.out.log(JSON.stringify({ v: 1, ...value2 }));
 }
 async function discussWatch(ctx, topicId, parsed) {
   if (ctx.json && parsed.options.jsonl === true) throw new Error("--json and --jsonl cannot be combined");
@@ -9073,13 +9095,13 @@ async function pmRequest(ctx, method, path, body) {
 function collectFields(parsed, allowClear) {
   const out = {};
   for (const [flag, spec] of Object.entries(FIELD_MAP)) {
-    const value = parsed.options[flag];
-    if (value === void 0 || value === true) continue;
-    if (value === false) {
+    const value2 = parsed.options[flag];
+    if (value2 === void 0 || value2 === true) continue;
+    if (value2 === false) {
       if (allowClear) out[spec.key] = null;
       continue;
     }
-    const text = stringOpt(value);
+    const text = stringOpt(value2);
     out[spec.key] = spec.num ? Number(text) : text;
   }
   return out;
@@ -9100,8 +9122,8 @@ function statusCol(entity, r) {
 function printRecord(ctx, entity, r) {
   ctx.out.log(`${r.id}	[${statusCol(entity, r)}]	${r.appId}	${r.title ?? ""}`);
 }
-function emit2(ctx, value, human) {
-  if (ctx.json) ctx.out.log(JSON.stringify(value, null, 2));
+function emit2(ctx, value2, human) {
+  if (ctx.json) ctx.out.log(JSON.stringify(value2, null, 2));
   else human();
 }
 async function pmList(ctx, entity, parsed) {
@@ -9147,8 +9169,8 @@ async function pmAdd(ctx, entity, parsed) {
   emit2(ctx, res, () => ctx.out.log(`created ${entity} ${res.id}`));
 }
 async function pmGet(ctx, entity, id) {
-  const { record: record7 } = await pmRequest(ctx, "GET", `/${entity}/${encodeURIComponent(id)}`);
-  emit2(ctx, record7, () => printRecord(ctx, entity, record7));
+  const { record: record8 } = await pmRequest(ctx, "GET", `/${entity}/${encodeURIComponent(id)}`);
+  emit2(ctx, record8, () => printRecord(ctx, entity, record8));
 }
 async function pmSet(ctx, entity, id, parsed) {
   const patch2 = collectEntityFields(entity, parsed, true);
@@ -9193,9 +9215,9 @@ async function pmHandoff(ctx, parsed) {
   ]);
   const handoff = {
     appId,
-    unmetGoals: goals.filter((record7) => record7.status !== "met"),
-    activeTasks: tasks.filter((record7) => record7.column !== "done"),
-    openBugs: bugs.filter((record7) => record7.status !== "fixed" && record7.status !== "wontfix")
+    unmetGoals: goals.filter((record8) => record8.status !== "met"),
+    activeTasks: tasks.filter((record8) => record8.column !== "done"),
+    openBugs: bugs.filter((record8) => record8.status !== "fixed" && record8.status !== "wontfix")
   };
   const result = {
     ...handoff,
@@ -9214,10 +9236,10 @@ async function pmHandoff(ctx, parsed) {
     ]) {
       ctx.out.log(`${label}:`);
       if (!records.length) ctx.out.log("- (none)");
-      else for (const record7 of records) printRecord(
+      else for (const record8 of records) printRecord(
         ctx,
         label === "unmet goals" ? "goal" : label === "active tasks" ? "task" : "bug",
-        record7
+        record8
       );
     }
   });
@@ -9365,6 +9387,113 @@ async function pmCommand(parsed, deps = {}) {
   }
 }
 
+// src/platform-output.ts
+function printPlatformStatus(status, out) {
+  out.log(`platform	${status.verdict.status}	${status.observedAt}`);
+  out.log(
+    `fleet	${status.summary.healthy}/${status.summary.services} healthy	${status.summary.required} required	${status.summary.unreachable} unreachable	${status.summary.notConfigured} not configured`
+  );
+  out.log(`catalog	${status.catalog.revision}`);
+  out.log(
+    "service	required	health	probe ms	version	provider	age	requests	errors	cpu p99 us	wall p99 us"
+  );
+  for (const service of status.services) {
+    const metrics = service.provider.metrics;
+    out.log([
+      service.id,
+      service.required ? "yes" : "no",
+      service.health.status,
+      value(service.health.latencyMs),
+      service.release.observedVersionId ?? "unknown",
+      service.provider.status,
+      age(service.provider.ageMs),
+      value(metrics?.requests),
+      value(metrics?.errors),
+      value(metrics?.cpuTimeP99),
+      value(metrics?.wallTimeP99)
+    ].join("	"));
+  }
+  if (status.verdict.reasons.length) {
+    out.log(`reasons	${status.verdict.reasons.join(", ")}`);
+  }
+  for (const action of status.nextActions) {
+    out.log(`next	${action.service}	${action.code}	${action.message}`);
+  }
+}
+function value(input) {
+  return input === null || input === void 0 ? "unknown" : String(input);
+}
+function age(input) {
+  if (input === null) return "unknown";
+  if (input < 1e3) return `${input}ms`;
+  if (input < 6e4) return `${Math.round(input / 1e3)}s`;
+  return `${Math.round(input / 6e4)}m`;
+}
+
+// src/platform-command.ts
+async function platformCommand(parsed, deps = {}) {
+  assertArgs(
+    parsed,
+    ["config", "context", "platform", "token", "email", "open", "json"],
+    2
+  );
+  const action = parsed.positionals[1];
+  if (action !== "status") {
+    throw new Error(
+      `unknown platform action "${action ?? ""}". Try "odla-ai platform status --json".`
+    );
+  }
+  const context = await resolveOperatorContext(parsed, {
+    allowMissingConfig: true
+  });
+  const platform = context.platform.value;
+  const doFetch = deps.fetch ?? fetch;
+  const out = deps.stdout ?? console;
+  const token = await resolveAdminPlatformToken({
+    platform,
+    scope: "platform:status:read",
+    token: stringOpt(parsed.options.token),
+    tokenFile: context.credentials.scopedTokenFile,
+    email: stringOpt(parsed.options.email),
+    open: parsed.options.open === false ? false : parsed.options.open === true ? true : void 0,
+    fetch: doFetch,
+    stdout: out,
+    openApprovalUrl: deps.openUrl,
+    label: "odla CLI (platform fleet status)"
+  });
+  const response2 = await doFetch(`${platform}/registry/platform/status`, {
+    headers: { authorization: `Bearer ${token}` }
+  });
+  const body = await response2.json().catch(() => null);
+  if (!response2.ok) {
+    throw new Error(
+      `read platform status failed (HTTP ${response2.status}): ${apiMessage(body)}`
+    );
+  }
+  if (!isPlatformStatus(body)) {
+    throw new Error("platform returned an invalid odla.platform-status/v1 envelope");
+  }
+  if (parsed.options.json === true) {
+    out.log(JSON.stringify(body, null, 2));
+  } else {
+    printPlatformStatus(body, out);
+  }
+}
+function isPlatformStatus(value2) {
+  if (!record5(value2) || value2.schemaVersion !== "odla.platform-status/v1") return false;
+  if (!record5(value2.verdict) || !Array.isArray(value2.verdict.reasons)) return false;
+  if (!record5(value2.catalog) || !record5(value2.summary)) return false;
+  return Array.isArray(value2.services) && Array.isArray(value2.nextActions);
+}
+function apiMessage(value2) {
+  if (!record5(value2)) return "request failed";
+  const error = record5(value2.error) ? value2.error : value2;
+  return typeof error.message === "string" ? error.message : typeof error.code === "string" ? error.code : "request failed";
+}
+function record5(value2) {
+  return !!value2 && typeof value2 === "object" && !Array.isArray(value2);
+}
+
 // src/o11y-verdict.ts
 function statusVerdict(reads) {
   const reasons = [];
@@ -9402,7 +9531,7 @@ function statusVerdict(reads) {
       severity: "degraded"
     });
   }
-  const performance = record5(reads.liveSync.body.performance) ? reads.liveSync.body.performance : null;
+  const performance = record6(reads.liveSync.body.performance) ? reads.liveSync.body.performance : null;
   if (performance?.status === "unavailable") {
     reasons.push({
       source: "liveSync",
@@ -9483,11 +9612,11 @@ function statusVerdict(reads) {
     reasons
   };
 }
-function record5(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function record6(value2) {
+  return Boolean(value2) && typeof value2 === "object" && !Array.isArray(value2);
 }
-function numeric2(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+function numeric2(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? value2 : 0;
 }
 function collectorReason(read3, fallback) {
   const reasons = read3.body.reasons;
@@ -9511,7 +9640,7 @@ function printO11yStatus(status, out) {
   out.log(
     `o11y status ${status.scope.appId}/${status.scope.env} (${status.scope.minutes}m)`
   );
-  const routes = Array.isArray(status.application.body.routes) ? status.application.body.routes.filter(record6) : [];
+  const routes = Array.isArray(status.application.body.routes) ? status.application.body.routes.filter(record7) : [];
   const requests = routes.reduce(
     (total, row) => total + numeric3(row.requests),
     0
@@ -9523,39 +9652,39 @@ function printO11yStatus(status, out) {
   out.log(
     `application	${status.application.httpStatus}	${requests} requests	${errors} errors`
   );
-  const versions = Array.isArray(status.applicationVersions.body.rows) ? status.applicationVersions.body.rows.filter(record6) : [];
+  const versions = Array.isArray(status.applicationVersions.body.rows) ? status.applicationVersions.body.rows.filter(record7) : [];
   out.log(
     `application-versions	${status.applicationVersions.httpStatus}	${versions.length ? versions.slice(0, 5).map(
       (row) => `${String(row.value || "(unattributed)")}:${numeric3(row.requests)}`
     ).join(", ") : "none observed"}`
   );
   out.log(liveSyncLine(status.liveSync));
-  const canaryDurations = record6(status.canary.body.durationsMs) ? status.canary.body.durationsMs : {};
+  const canaryDurations = record7(status.canary.body.durationsMs) ? status.canary.body.durationsMs : {};
   out.log(
     `canary	${status.canary.httpStatus}	${String(status.canary.body.status ?? status.canary.body.error ?? "unavailable")}	${optionalNumeric(canaryDurations.publishToVisibleMs)} publish-to-visible`
   );
-  const collectorIngest = record6(status.collector.body.ingest) ? status.collector.body.ingest : {};
-  const collectorStorage = record6(collectorIngest.storage) ? collectorIngest.storage : {};
+  const collectorIngest = record7(status.collector.body.ingest) ? status.collector.body.ingest : {};
+  const collectorStorage = record7(collectorIngest.storage) ? collectorIngest.storage : {};
   out.log(
     `collector	${status.collector.httpStatus}	${String(status.collector.body.status ?? status.collector.body.error ?? "unavailable")}	${numeric3(collectorStorage.affectedPoints)} affected points`
   );
-  const providerMetrics = record6(status.provider.body.metrics) ? status.provider.body.metrics : {};
-  const providerCapacity = record6(status.provider.body.capacity) ? status.provider.body.capacity : {};
-  const workerMemory = record6(providerCapacity.memory) ? providerCapacity.memory : {};
+  const providerMetrics = record7(status.provider.body.metrics) ? status.provider.body.metrics : {};
+  const providerCapacity = record7(status.provider.body.capacity) ? status.provider.body.capacity : {};
+  const workerMemory = record7(providerCapacity.memory) ? providerCapacity.memory : {};
   out.log(
     `cloudflare	${status.provider.httpStatus}	${String(status.provider.body.status ?? status.provider.body.error ?? "unavailable")}	${numeric3(providerMetrics.requests)} invocations	${numeric3(providerMetrics.errors)} runtime errors	${optionalBytes(workerMemory.headroomBytes)} isolate memory headroom`
   );
   for (const line of providerCapacityLines(status.providerCapacity)) {
     out.log(line);
   }
-  const coverage = record6(status.providerReconciliation.body.comparison) ? status.providerReconciliation.body.comparison : {};
-  const coverageCounts = record6(status.providerReconciliation.body.counts) ? status.providerReconciliation.body.counts : {};
-  const coverageBudget = record6(status.providerReconciliation.body.budget) ? status.providerReconciliation.body.budget : {};
+  const coverage = record7(status.providerReconciliation.body.comparison) ? status.providerReconciliation.body.comparison : {};
+  const coverageCounts = record7(status.providerReconciliation.body.counts) ? status.providerReconciliation.body.counts : {};
+  const coverageBudget = record7(status.providerReconciliation.body.budget) ? status.providerReconciliation.body.budget : {};
   out.log(
     `request-coverage	${status.providerReconciliation.httpStatus}	${String(status.providerReconciliation.body.status ?? status.providerReconciliation.body.error ?? "unavailable")}	${optionalPercent(coverage.applicationCoverage)} application/provider	${numeric3(coverageCounts.applicationRequests)}/${numeric3(coverageCounts.providerRequests)} requests	\xB1${optionalPercent(coverageBudget.maxRelativeError)} budget`
   );
   const providerPoints = Array.isArray(status.providerHistory.body.points) ? status.providerHistory.body.points.length : 0;
-  const providerFreshness = record6(status.providerHistory.body.freshness) ? status.providerHistory.body.freshness : {};
+  const providerFreshness = record7(status.providerHistory.body.freshness) ? status.providerHistory.body.freshness : {};
   out.log(
     `cloudflare-history	${status.providerHistory.httpStatus}	${String(status.providerHistory.body.status ?? status.providerHistory.body.error ?? "unavailable")}	${providerPoints} snapshots	${optionalAge(providerFreshness.ageMs)} old`
   );
@@ -9564,17 +9693,17 @@ function printO11yStatus(status, out) {
   );
 }
 function providerCapacityLines(read3) {
-  const resources = record6(read3.body.resources) ? read3.body.resources : {};
-  const durableObjects = record6(resources.durableObjects) ? resources.durableObjects : {};
-  const periodic = record6(durableObjects.periodic) ? durableObjects.periodic : {};
-  const storage = record6(durableObjects.sqliteStorage) ? durableObjects.sqliteStorage : {};
-  const d1 = record6(resources.d1) ? resources.d1 : {};
-  const d1Activity = record6(d1.activity) ? d1.activity : {};
-  const d1Storage = record6(d1.storage) ? d1.storage : {};
-  const d1Latency = record6(d1Activity.latency) ? d1Activity.latency : {};
-  const r2 = record6(resources.r2) ? resources.r2 : {};
-  const r2Operations = record6(r2.operations) ? r2.operations : {};
-  const r2Storage = record6(r2.storage) ? r2.storage : {};
+  const resources = record7(read3.body.resources) ? read3.body.resources : {};
+  const durableObjects = record7(resources.durableObjects) ? resources.durableObjects : {};
+  const periodic = record7(durableObjects.periodic) ? durableObjects.periodic : {};
+  const storage = record7(durableObjects.sqliteStorage) ? durableObjects.sqliteStorage : {};
+  const d1 = record7(resources.d1) ? resources.d1 : {};
+  const d1Activity = record7(d1.activity) ? d1.activity : {};
+  const d1Storage = record7(d1.storage) ? d1.storage : {};
+  const d1Latency = record7(d1Activity.latency) ? d1Activity.latency : {};
+  const r2 = record7(resources.r2) ? resources.r2 : {};
+  const r2Operations = record7(r2.operations) ? r2.operations : {};
+  const r2Storage = record7(r2.storage) ? r2.storage : {};
   const status = String(
     read3.body.status ?? read3.body.error ?? "unavailable"
   );
@@ -9585,42 +9714,42 @@ function providerCapacityLines(read3) {
   ];
 }
 function liveSyncLine(read3) {
-  const performance = record6(read3.body.performance) ? read3.body.performance : {};
-  const commitToSend = record6(performance.commitToSend) ? performance.commitToSend : {};
+  const performance = record7(read3.body.performance) ? read3.body.performance : {};
+  const commitToSend = record7(performance.commitToSend) ? performance.commitToSend : {};
   return `live-sync	${read3.httpStatus}	${String(read3.body.status ?? read3.body.error ?? "unavailable")}	${numeric3(read3.body.activeConnections)} active	${optionalNumeric(commitToSend.p95)} commit-to-send p95	${numeric3(performance.sendFailures)} send failures`;
 }
-function record6(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function record7(value2) {
+  return Boolean(value2) && typeof value2 === "object" && !Array.isArray(value2);
 }
-function numeric3(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+function numeric3(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? value2 : 0;
 }
-function optionalNumeric(value) {
-  return typeof value === "number" && Number.isFinite(value) ? `${value} ms` : "\u2014";
+function optionalNumeric(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? `${value2} ms` : "\u2014";
 }
-function optionalAge(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return "unknown";
-  return `${Math.max(0, Math.round(value / 1e3))}s`;
+function optionalAge(value2) {
+  if (typeof value2 !== "number" || !Number.isFinite(value2)) return "unknown";
+  return `${Math.max(0, Math.round(value2 / 1e3))}s`;
 }
-function optionalPercent(value) {
-  return typeof value === "number" && Number.isFinite(value) ? `${Math.round(value * 100)}%` : "\u2014";
+function optionalPercent(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? `${Math.round(value2 * 100)}%` : "\u2014";
 }
-function optionalBytes(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) return "\u2014";
-  if (value >= 1024 * 1024 * 1024) {
-    return `${(value / (1024 * 1024 * 1024)).toFixed(2)} GiB`;
+function optionalBytes(value2) {
+  if (typeof value2 !== "number" || !Number.isFinite(value2)) return "\u2014";
+  if (value2 >= 1024 * 1024 * 1024) {
+    return `${(value2 / (1024 * 1024 * 1024)).toFixed(2)} GiB`;
   }
-  if (value >= 1024 * 1024) {
-    return `${(value / (1024 * 1024)).toFixed(1)} MiB`;
+  if (value2 >= 1024 * 1024) {
+    return `${(value2 / (1024 * 1024)).toFixed(1)} MiB`;
   }
-  if (value >= 1024) return `${(value / 1024).toFixed(1)} KiB`;
-  return `${Math.round(value)} B`;
+  if (value2 >= 1024) return `${(value2 / 1024).toFixed(1)} KiB`;
+  return `${Math.round(value2)} B`;
 }
-function optionalCount(value, unit) {
-  return typeof value === "number" && Number.isFinite(value) ? `${value} ${unit}` : `\u2014 ${unit}`;
+function optionalCount(value2, unit) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? `${value2} ${unit}` : `\u2014 ${unit}`;
 }
-function optionalAgeSeconds(value) {
-  return typeof value === "number" && Number.isFinite(value) ? `${Math.max(0, Math.round(value))}s` : "unknown";
+function optionalAgeSeconds(value2) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? `${Math.max(0, Math.round(value2))}s` : "unknown";
 }
 
 // src/o11y-command.ts
@@ -9750,11 +9879,11 @@ async function o11yCommand(parsed, deps = {}) {
   }
   printO11yStatus(status, out);
 }
-function statusMinutes(value) {
-  if (!Number.isSafeInteger(value) || value < 1 || value > 7 * 24 * 60) {
+function statusMinutes(value2) {
+  if (!Number.isSafeInteger(value2) || value2 < 1 || value2 > 7 * 24 * 60) {
     throw new Error("--minutes must be an integer from 1 to 10080");
   }
-  return value;
+  return value2;
 }
 async function read2(url, headers, doFetch) {
   const response2 = await doFetch(url, { headers });
@@ -9762,8 +9891,8 @@ async function read2(url, headers, doFetch) {
   let body = {};
   if (text) {
     try {
-      const value = JSON.parse(text);
-      body = value && typeof value === "object" && !Array.isArray(value) ? value : { value };
+      const value2 = JSON.parse(text);
+      body = value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : { value: value2 };
     } catch {
       body = { message: text.slice(0, 300) };
     }
@@ -9780,7 +9909,7 @@ function recordInvocation(parsed) {
   try {
     const entry = {
       path: invocationPath(parsed.positionals),
-      options: Object.entries(parsed.options).map(([name, value]) => value === false ? `no-${name}` : name).sort()
+      options: Object.entries(parsed.options).map(([name, value2]) => value2 === false ? `no-${name}` : name).sort()
     };
     if (!entry.path.length) return;
     appendFileSync(file, `${JSON.stringify(entry)}
@@ -9794,10 +9923,10 @@ import { readFileSync as readFileSync9 } from "fs";
 
 // src/runbook-requires.ts
 var SPEC = /^(@?[\w./-]+?)@(\d+\.\d+\.\d+(?:[\w.-]*)?)$/;
-function parseRequires(value) {
-  if (!value) return [];
+function parseRequires(value2) {
+  if (!value2) return [];
   const out = [];
-  for (const token of value.split(/[\s,]+/).filter(Boolean)) {
+  for (const token of value2.split(/[\s,]+/).filter(Boolean)) {
     const match = SPEC.exec(token);
     if (match?.[1] && match[2]) out.push({ name: match[1], min: match[2] });
   }
@@ -9973,9 +10102,9 @@ function parseRunbook(text, slug) {
     for (const line of fm[1].split(/\r?\n/)) {
       const pair = /^(\w+)\s*:\s*(.+)$/.exec(line.trim());
       if (!pair) continue;
-      const value = pair[2].trim().replace(/^["']|["']$/g, "");
-      if (pair[1] === "summary") meta.summary = value;
-      if (pair[1] === "tags") meta.tags = value.replace(/^\[|\]$/g, "").trim();
+      const value2 = pair[2].trim().replace(/^["']|["']$/g, "");
+      if (pair[1] === "summary") meta.summary = value2;
+      if (pair[1] === "tags") meta.tags = value2.replace(/^\[|\]$/g, "").trim();
     }
   }
   const lines = rest.split("\n");
@@ -10092,7 +10221,7 @@ var NOISE = /* @__PURE__ */ new Set([
   "and",
   "for"
 ]);
-var words = (value) => value.replace(/^@[\w-]+\//, "").split(/[^A-Za-z0-9]+/).filter((w) => w.length > 1 && !NOISE.has(w.toLowerCase()));
+var words = (value2) => value2.replace(/^@[\w-]+\//, "").split(/[^A-Za-z0-9]+/).filter((w) => w.length > 1 && !NOISE.has(w.toLowerCase()));
 function namedExports(clause) {
   return clause.split(",").map((part) => part.trim().split(/\s+as\s+/)[0]?.trim() ?? "").filter((name) => /^[A-Za-z_$][\w$]*$/.test(name) && name !== "type");
 }
@@ -10445,8 +10574,8 @@ import process13 from "process";
 var EDITOR_ENV = ["ODLA_EDITOR", "VISUAL", "EDITOR"];
 function resolveEditor(env = process13.env) {
   for (const name of EDITOR_ENV) {
-    const value = env[name];
-    if (value && value.trim()) return value.trim();
+    const value2 = env[name];
+    if (value2 && value2.trim()) return value2.trim();
   }
   return null;
 }
@@ -10711,9 +10840,9 @@ async function runbookCommand(parsed, deps = {}) {
       });
     }
     case "visibility": {
-      const value = parsed.positionals[3] ?? stringOpt(parsed.options.visibility);
-      if (!value) throw new Error('"runbook visibility" needs operator|admin, e.g. "runbook visibility release operator"');
-      return runbookVisibility(ctx, requireSlug(slug, "visibility"), value);
+      const value2 = parsed.positionals[3] ?? stringOpt(parsed.options.visibility);
+      if (!value2) throw new Error('"runbook visibility" needs operator|admin, e.g. "runbook visibility release operator"');
+      return runbookVisibility(ctx, requireSlug(slug, "visibility"), value2);
     }
     case "publish":
       return runbookStatus(ctx, requireSlug(slug, "publish"), "published");
@@ -10769,13 +10898,13 @@ async function interactiveConfirmation(message2, dependencies) {
   }
 }
 function requiredSecurityPositional(parsed, index, label) {
-  const value = parsed.positionals[index];
-  if (!value) throw new Error(`${label} is required`);
-  return value;
+  const value2 = parsed.positionals[index];
+  if (!value2) throw new Error(`${label} is required`);
+  return value2;
 }
-function securityProfile(value) {
-  if (value === void 0) return void 0;
-  if (value === "odla" || value === "cloudflare-app" || value === "generic") return value;
+function securityProfile(value2) {
+  if (value2 === void 0) return void 0;
+  if (value2 === "odla" || value2 === "cloudflare-app" || value2 === "generic") return value2;
   throw new Error("--profile must be odla, cloudflare-app, or generic");
 }
 
@@ -10876,9 +11005,9 @@ function routeLabel(route2) {
   return `${route2.provider}/${route2.model}${route2.policyVersion ? ` policy v${route2.policyVersion}` : ""}`;
 }
 var HOSTED_SEVERITIES = ["informational", "low", "medium", "high", "critical"];
-function hostedSeverity(value, flag) {
-  if (HOSTED_SEVERITIES.includes(value)) {
-    return value;
+function hostedSeverity(value2, flag) {
+  if (HOSTED_SEVERITIES.includes(value2)) {
+    return value2;
   }
   throw new Error(`${flag} must be informational, low, medium, high, or critical`);
 }
@@ -10945,7 +11074,7 @@ async function runSourceSecurityCommand(parsed, dependencies, sourceId) {
     ...context,
     jobId: job.jobId,
     wait: dependencies.pollWait,
-    onUpdate: parsed.options.json === true ? void 0 : (value) => printHostedJob(context.stdout, value, context.platform, context.appId)
+    onUpdate: parsed.options.json === true ? void 0 : (value2) => printHostedJob(context.stdout, value2, context.platform, context.appId)
   }) : job;
   if (!follow) {
     if (parsed.options.json === true) {
@@ -11045,9 +11174,9 @@ function enforceLocalGate(report4, parsed) {
     throw new Error(`hosted security gate failed: ${confirmed.length} confirmed >= ${failOn}; ${leads.length} leads >= ${failOnCandidates ?? "disabled"}${incomplete ? "; coverage incomplete" : ""}`);
   }
 }
-function severityOpt(value, flag) {
-  if (["informational", "low", "medium", "high", "critical"].includes(value)) {
-    return value;
+function severityOpt(value2, flag) {
+  if (["informational", "low", "medium", "high", "critical"].includes(value2)) {
+    return value2;
   }
   throw new Error(`${flag} must be informational, low, medium, high, or critical`);
 }
@@ -11155,7 +11284,7 @@ async function securityStatus(parsed, dependencies) {
     ...context,
     jobId,
     wait: dependencies.pollWait,
-    onUpdate: parsed.options.json === true ? void 0 : (value) => printHostedJob(context.stdout, value, context.platform, context.appId)
+    onUpdate: parsed.options.json === true ? void 0 : (value2) => printHostedJob(context.stdout, value2, context.platform, context.appId)
   }) : await getHostedSecurityJob({ ...context, jobId });
   if (parsed.options.json === true) context.stdout.log(JSON.stringify(job, null, 2));
   else if (parsed.options.follow !== true) {
@@ -11239,6 +11368,10 @@ async function runCli(argv = process.argv.slice(2), dependencies = {}) {
     await o11yCommand(parsed, runtime);
     return;
   }
+  if (command === "platform") {
+    await platformCommand(parsed, runtime);
+    return;
+  }
   if (command === "provision") {
     await provisionCommand(parsed, runtime);
     return;
@@ -11358,4 +11491,4 @@ export {
   exitCodeFor,
   runCli
 };
-//# sourceMappingURL=chunk-S3EJ66VG.js.map
+//# sourceMappingURL=chunk-L2NG4UR4.js.map