@sellable/install 0.1.483 → 0.1.486-wip.phase169.20260804.2

package/lib/sellable-agent/fly-customer-image/customer-runtime.mjs

@@ -16,12 +16,13 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 import {
-  FLY_CUSTOMER_MODEL_ID,
-  FLY_CUSTOMER_MODEL_PROVIDER,
-  FLY_CUSTOMER_MODEL_REASONING_EFFORT,
   evaluateModelAuthReadback,
-  parseFlyCustomerModelCredential,
-} from "../fly-customer-model.mjs";
+  modelAuthConfigOverlay,
+  parseModelAuthRuntimeCredential,
+  readModelAuthMaterialization,
+  reconcileHermesModelAuth,
+} from "../model-auth-reconciler.mjs";
+import { createModelHealthReporter } from "../model-health-reporter.mjs";
 import {
   buildNativeHermesLaunch,
   clearCustomerRuntimeSecrets,
@@ -37,6 +38,7 @@ import {
   loadOrCreateFlyRuntimeIdentity,
   obtainFlyOidcToken,
   renewFlyCustomerControlSession,
+  signedWorkerAuthorization,
 } from "../fly-runtime-identity.mjs";
 import {
   ensureHermesSnapshotCron,
@@ -69,7 +71,7 @@ const RUNTIME_GENERATION = Number(
 const BOOT_SESSION_ID = randomUUID();
 const HERMES_VERSION = process.env.SELLABLE_AGENT_HERMES_VERSION ?? "0.20.0";
 const INSTALLER_PACKAGE =
-  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.483";
+  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.486-wip.phase169.20260804.2";
 const MCP_PACKAGE =
   process.env.SELLABLE_AGENT_MCP_PACKAGE ??
   "@sellable/mcp@0.1.805";
@@ -181,6 +183,22 @@ function compileDesired(claim, trustRootPem) {
   ) {
     throw new Error("customer_claim_contract_rejected");
   }
+  const modelEnvelope = claim.secretEnvelopes.modelCodex;
+  if (
+    model.provider !== "codex" ||
+    !/^[A-Za-z0-9_.:-]{1,256}$/.test(model.activationId ?? "") ||
+    !Number.isSafeInteger(model.bundleGeneration) ||
+    model.bundleGeneration < 1 ||
+    !/^[a-f0-9]{64}$/.test(model.policyHash ?? "") ||
+    !/^[a-f0-9]{16}$/.test(model.credentialFingerprint ?? "") ||
+    modelEnvelope.generation !== model.bundleGeneration ||
+    modelEnvelope.fingerprint !== model.credentialFingerprint ||
+    modelEnvelope.activationId !== model.activationId ||
+    modelEnvelope.bundleGeneration !== model.bundleGeneration ||
+    modelEnvelope.policyHash !== model.policyHash
+  ) {
+    throw new Error("customer_model_auth_identity_rejected");
+  }
   const routeGenerations = [
     ...new Set(selectedBindings.map((binding) => binding.routeGeneration)),
   ];
@@ -244,7 +262,10 @@ function compileDesired(claim, trustRootPem) {
       routeGeneration: routeGenerations[0],
       membershipGeneration: membershipGenerations[0],
       serviceCredentialGeneration: service.credentialGeneration,
-      modelCredentialGeneration: model.credentialGeneration,
+      modelCredentialGeneration: model.bundleGeneration,
+      modelActivationId: model.activationId,
+      modelBundleGeneration: model.bundleGeneration,
+      modelPolicyHash: model.policyHash,
       runtimeGeneration: RUNTIME_GENERATION,
       selectedChannelIds,
       defaultChannelId: defaultBinding.channelId,
@@ -400,24 +421,13 @@ function writeRuntimeHermesConfig({
   const runtimeConfigRoot = profileRoot;
   mkdirSync(runtimeConfigRoot, { recursive: true, mode: 0o700 });
   chmodSync(runtimeConfigRoot, 0o700);
-  const priorIdentityPath = join(runtimeConfigRoot, "runtime-identity.json");
-  let priorModelCredentialGeneration = null;
-  if (existsSync(priorIdentityPath)) {
-    try {
-      const priorIdentity = JSON.parse(readFileSync(priorIdentityPath, "utf8"));
-      if (
-        Number.isSafeInteger(priorIdentity.modelCredentialGeneration) &&
-        priorIdentity.modelCredentialGeneration > 0
-      ) {
-        priorModelCredentialGeneration =
-          priorIdentity.modelCredentialGeneration;
-      }
-    } catch {
-      priorModelCredentialGeneration = null;
-    }
-  }
   const localHermesAuthStorePath = join(runtimeConfigRoot, "auth.json");
   const hermesRootAuthStorePath = join(DATA_ROOT, "auth.json");
+  const hermesRootAuthMarkerPath = join(
+    DATA_ROOT,
+    ".sellable-agent",
+    "model-auth-source.json"
+  );
   if (existsSync(localHermesAuthStorePath)) {
     const localAuthStore = lstatSync(localHermesAuthStorePath);
     if (localAuthStore.isSymbolicLink() || !localAuthStore.isFile()) {
@@ -425,17 +435,6 @@ function writeRuntimeHermesConfig({
     }
     unlinkSync(localHermesAuthStorePath);
   }
-  if (
-    priorModelCredentialGeneration !== null &&
-    priorModelCredentialGeneration !== desired.modelCredentialGeneration &&
-    existsSync(hermesRootAuthStorePath)
-  ) {
-    const authStore = lstatSync(hermesRootAuthStorePath);
-    if (authStore.isSymbolicLink() || !authStore.isFile()) {
-      throw new Error("customer_model_auth_store_rejected");
-    }
-    unlinkSync(hermesRootAuthStorePath);
-  }
   const mcpConfig = JSON.parse(
     readFileSync(join(profileRoot, "sellable", "mcp.json"), "utf8")
   );
@@ -477,22 +476,25 @@ function writeRuntimeHermesConfig({
   const testModelOrigin = allowTestProviders()
     ? process.env.SELLABLE_AGENT_TEST_MODEL_ORIGIN
     : null;
-  const modelCredential = parseFlyCustomerModelCredential(secrets.modelCodex);
-  const modelAuthPath = join(secretRoot, "auth.json");
-  atomicFile(modelAuthPath, modelCredential.authJson, 0o600);
-  if (!existsSync(hermesRootAuthStorePath)) {
-    atomicFile(
-      hermesRootAuthStorePath,
-      modelCredential.hermesRootAuthJson,
-      0o600
-    );
-  } else {
-    const authStore = lstatSync(hermesRootAuthStorePath);
-    if (authStore.isSymbolicLink() || !authStore.isFile()) {
-      throw new Error("customer_model_auth_store_rejected");
-    }
-    chmodSync(hermesRootAuthStorePath, 0o600);
+  const modelCredential = parseModelAuthRuntimeCredential(secrets.modelCodex);
+  if (
+    modelCredential.activationId !== desired.modelActivationId ||
+    modelCredential.bundleGeneration !== desired.modelBundleGeneration ||
+    modelCredential.policyHash !== desired.modelPolicyHash
+  ) {
+    throw new Error("customer_model_auth_identity_rejected");
   }
+  const modelBundlePath = join(secretRoot, "model-auth-runtime-v2.json");
+  atomicFile(modelBundlePath, modelCredential.authJson, 0o600);
+  const modelLifecycle =
+    claim.operation.action === "INSTANTIATE" ? "OFF" : "ON";
+  const modelAuthState = reconcileHermesModelAuth({
+    authStorePath: hermesRootAuthStorePath,
+    markerPath: hermesRootAuthMarkerPath,
+    credential: modelCredential,
+    lifecycle: modelLifecycle,
+  });
+  const modelConfig = modelAuthConfigOverlay(modelCredential);
   atomicJson(runtimeConfigPath, {
     ...baseConfig,
     ...(testModelOrigin
@@ -515,12 +517,7 @@ function writeRuntimeHermesConfig({
           ],
         }
       : {
-          model: {
-            default: FLY_CUSTOMER_MODEL_ID,
-            provider: FLY_CUSTOMER_MODEL_PROVIDER,
-            reasoning_effort: FLY_CUSTOMER_MODEL_REASONING_EFFORT,
-            generation: desired.modelCredentialGeneration,
-          },
+          ...modelConfig,
         }),
     mcp_servers: {
       ...baseConfig.mcp_servers,
@@ -548,10 +545,10 @@ function writeRuntimeHermesConfig({
   });
   const gatesPath = join(secretRoot, "gates.json");
   atomicJson(gatesPath, {
-    lifecycle: "ON",
-    dispatch: "ENABLED",
-    route: "OPEN",
-    output: "OPEN",
+    lifecycle: modelLifecycle,
+    dispatch: modelLifecycle === "ON" ? "ENABLED" : "DISABLED",
+    route: modelLifecycle === "ON" ? "OPEN" : "CLOSED",
+    output: modelLifecycle === "ON" ? "OPEN" : "CLOSED",
   });
   atomicJson(join(runtimeConfigRoot, "runtime-identity.json"), {
     runtimeId: RUNTIME_ID,
@@ -564,14 +561,20 @@ function writeRuntimeHermesConfig({
     membershipGeneration: desired.membershipGeneration,
     serviceCredentialGeneration: desired.serviceCredentialGeneration,
     modelCredentialGeneration: desired.modelCredentialGeneration,
+    modelActivationId: desired.modelActivationId,
+    modelBundleGeneration: desired.modelBundleGeneration,
+    modelPolicyHash: desired.modelPolicyHash,
   });
   return {
     runtimeHome: runtimeConfigRoot,
     runtimeConfigPath,
     runtimeMcpPath,
     gatesPath,
-    modelAuthPath,
+    modelBundlePath,
     hermesRootAuthStorePath,
+    hermesRootAuthMarkerPath,
+    modelAuthSourceFingerprint: modelAuthState.sourceFingerprint,
+    modelAuthState,
     modelCredential,
   };
 }
@@ -611,7 +614,7 @@ function applicationRuntimeEnv({ desired, runtimeConfig, secrets }) {
     HERMES_HOME: DATA_ROOT,
     SELLABLE_HERMES_PROFILE_ID: desired.profileId,
     HERMES_CONFIG_PATH: runtimeConfig.runtimeConfigPath,
-    CODEX_HOME: dirname(runtimeConfig.modelAuthPath),
+    CODEX_HOME: dirname(runtimeConfig.modelBundlePath),
     SELLABLE_AGENT_RUNTIME: "1",
     SELLABLE_AGENT_RUNTIME_GATE_FILE: runtimeConfig.gatesPath,
     SLACK_HOME_CHANNEL: desired.defaultChannelId,
@@ -771,54 +774,100 @@ async function proveProvisionedApplication({
   profileDigest,
 }) {
   const runtimeEnv = applicationRuntimeEnv({ desired, runtimeConfig, secrets });
-  const [hermesVersion, mcpVersion, modelAuth] = await Promise.all([
+  const materializedModelAuth = runtimeConfig.modelAuthState.materialized;
+  const [hermesVersion, mcpVersion, hermesModelAuth] = await Promise.all([
     run(HERMES, ["--version"], { env: runtimeEnv, timeoutMs: 180_000 }),
     run(MCP, ["--version"], { env: runtimeEnv, timeoutMs: 180_000 }),
-    run(
-      HERMES_PYTHON,
-      [
-        "-c",
-        [
-          "import json",
-          "from pathlib import Path",
-          "from hermes_constants import get_default_hermes_root, get_hermes_home",
-          "from hermes_cli.auth import resolve_codex_runtime_credentials",
-          "value = resolve_codex_runtime_credentials(refresh_if_expiring=False)",
-          'root_auth = get_default_hermes_root() / "auth.json"',
-          'local_auth = get_hermes_home() / "auth.json"',
-          'print(json.dumps({"provider": value.get("provider"), "source": value.get("source"), "source_class": "root_fallback" if root_auth.is_file() and not local_auth.exists() else "unexpected", "auth_mode": value.get("auth_mode"), "credential_present": bool(value.get("api_key")), "local_auth_entry_count": 0 if not local_auth.exists() else 1}))',
-        ].join(";"),
-      ],
-      {
-        env: { ...runtimeEnv, HERMES_HOME: runtimeConfig.runtimeHome },
-        timeoutMs: 180_000,
-      }
-    ),
+    materializedModelAuth
+      ? run(
+          HERMES_PYTHON,
+          [
+            "-c",
+            [
+              "import json",
+              "from agent.credential_pool import load_pool",
+              'pool = load_pool("openai-codex")',
+              "entry = pool.select() if pool else None",
+              'print(json.dumps({"provider": "openai-codex", "source": "credential_pool", "credential_present": bool(entry and entry.runtime_api_key), "credential_id": getattr(entry, "id", None), "runtime_refresh_owned": bool(getattr(entry, "refresh_token", None))}))',
+            ].join(";"),
+          ],
+          {
+            env: { ...runtimeEnv, HERMES_HOME: runtimeConfig.runtimeHome },
+            timeoutMs: 180_000,
+          }
+        )
+      : Promise.resolve({
+          status: 0,
+          stdout: JSON.stringify({ materialization_pending_start: true }),
+          stderr: "",
+        }),
   ]);
-  let modelAuthReadback = null;
+  let hermesModelAuthReadback = null;
   try {
-    modelAuthReadback = JSON.parse(modelAuth.stdout);
+    hermesModelAuthReadback = JSON.parse(hermesModelAuth.stdout);
   } catch {
-    modelAuthReadback = null;
+    hermesModelAuthReadback = null;
+  }
+  const modelAuthReadback = materializedModelAuth
+    ? readModelAuthMaterialization({
+        authStorePath: runtimeConfig.hermesRootAuthStorePath,
+        markerPath: runtimeConfig.hermesRootAuthMarkerPath,
+      })
+    : {
+        schemaVersion: "sellable-agent-model-auth-readback/v2",
+        activationId: desired.modelActivationId,
+        bundleGeneration: desired.modelBundleGeneration,
+        policyHash: desired.modelPolicyHash,
+        provider: "openai-codex",
+        model: runtimeConfig.modelCredential.model,
+        fallbackDepth:
+          runtimeConfig.modelCredential.value.openrouter.models.length,
+        desiredStatus: "converged",
+        materializedStatus: "pending_start",
+        slots: runtimeConfig.modelCredential.identity.slots.map((slot) => ({
+          slotId: slot.slotId,
+          grantFingerprint: slot.grantFingerprint,
+          expiresAt: new Date(slot.expiresAt).toISOString(),
+          state: "ok",
+          lastErrorReason: null,
+          lastErrorResetAt: null,
+        })),
+        openrouter: {
+          keyFingerprint:
+            runtimeConfig.modelCredential.identity.openrouterKeyFingerprint,
+          state: "ok",
+        },
+      };
+  const modelAuthVerdict = materializedModelAuth
+    ? evaluateModelAuthReadback(modelAuthReadback, {
+        activationId: desired.modelActivationId,
+        bundleGeneration: desired.modelBundleGeneration,
+        policyHash: desired.modelPolicyHash,
+      })
+    : { accepted: true, rejection: null };
+  if (
+    materializedModelAuth &&
+    (hermesModelAuth.status !== 0 ||
+      hermesModelAuthReadback?.provider !== "openai-codex" ||
+      hermesModelAuthReadback?.source !== "credential_pool" ||
+      hermesModelAuthReadback?.credential_present !== true ||
+      hermesModelAuthReadback?.runtime_refresh_owned !== false ||
+      !["dittto-primary", "kaigo-secondary"].includes(
+        hermesModelAuthReadback?.credential_id
+      ))
+  ) {
+    throw new Error("access_only_snapshot_infeasible");
   }
-  const modelAuthVerdict = evaluateModelAuthReadback(modelAuthReadback);
-  if (modelAuth.status !== 0 || !modelAuthVerdict.accepted) {
-    // Name the failed invariant: a bare rejection sent the 2026-07-28 outage
-    // hunting the credential itself when the credential was valid and only its
-    // storage shape in the root auth store had changed.
+  if (!modelAuthVerdict.accepted) {
     throw new Error(
-      `customer_model_auth_readback_rejected:${
-        modelAuth.status !== 0
-          ? "probe_failed"
-          : (modelAuthVerdict.rejection ?? "unknown")
-      }`
+      `customer_model_auth_readback_rejected:${modelAuthVerdict.rejection ?? "unknown"}`
     );
   }
   if (
     hermesVersion.status !== 0 ||
     mcpVersion.status !== 0 ||
     /Lazy-installing|pip install|npm install/i.test(
-      `${hermesVersion.stdout}\n${hermesVersion.stderr}\n${mcpVersion.stdout}\n${mcpVersion.stderr}\n${modelAuth.stdout}\n${modelAuth.stderr}`
+      `${hermesVersion.stdout}\n${hermesVersion.stderr}\n${mcpVersion.stdout}\n${mcpVersion.stderr}\n${hermesModelAuth.stdout}\n${hermesModelAuth.stderr}`
     )
   ) {
     throw new Error("customer_runtime_binary_rejected");
@@ -827,7 +876,10 @@ async function proveProvisionedApplication({
     profileDigest,
     hermesOutput: hermesVersion.stdout,
     mcpOutput: mcpVersion.stdout,
-    modelAuthOutput: modelAuth.stdout,
+    modelAuthOutput: `${hermesModelAuth.stdout}\n${JSON.stringify(
+      modelAuthReadback
+    )}`,
+    modelAuthReadback,
   };
 }
 
@@ -956,7 +1008,13 @@ function completionReceipt({
             { code: "NATIVE_SLACK_GATEWAY", status: "TRUE" },
           ]),
       { code: "MCP_PREBAKED", status: "TRUE" },
-      { code: "CODEX_OAUTH_READBACK", status: "TRUE" },
+      {
+        code:
+          claim.operation.action === "INSTANTIATE"
+            ? "MODEL_AUTH_DESIRED_PENDING_START"
+            : "CODEX_OAUTH_READBACK",
+        status: "TRUE",
+      },
       { code: "NO_BOOT_INSTALL", status: "TRUE" },
       { code: "DEDICATED_SLACK_APP", status: "TRUE" },
     ],
@@ -999,7 +1057,52 @@ async function flushHermesSnapshot({ client, profileId, profileRoot }) {
   }
 }
 
-async function processOperation({ claim, exchange, client }) {
+function runtimeModelHealthReporter({ identity, exchange, runtimeConfig }) {
+  return createModelHealthReporter({
+    origin: ORIGIN,
+    identity: {
+      kind: "CUSTOMER",
+      runtimeGeneration: RUNTIME_GENERATION,
+      workloadKeyHash: exchange.publicKeyHash,
+      machineId: exchange.workerId,
+      adminRuntimeGenerationId: null,
+      adminRuntimeGenerationFence: null,
+    },
+    observe: () =>
+      readModelAuthMaterialization({
+        authStorePath: runtimeConfig.hermesRootAuthStorePath,
+        markerPath: runtimeConfig.hermesRootAuthMarkerPath,
+      }),
+    authorize: (body) =>
+      signedWorkerAuthorization({
+        identity,
+        exchange,
+        verb: "model-health",
+        body,
+        now: new Date(),
+        unbound: true,
+      }),
+    onError: (error) => {
+      process.stderr.write(
+        `${JSON.stringify({
+          ok: false,
+          code:
+            error instanceof Error
+              ? error.message
+              : "model_health_report_failed",
+        })}\n`
+      );
+    },
+    allowHttpLoopback: allowTestProviders(),
+    sequencePath: join(
+      DATA_ROOT,
+      ".sellable-agent",
+      "model-health-sequence.json"
+    ),
+  });
+}
+
+async function processOperation({ claim, exchange, client, identity }) {
   const trustRootPem = readFileSync(TRUST_ROOT, "utf8");
   const { desired, toolInclude } = compileDesired(claim, trustRootPem);
   mkdirSync(PROFILES_ROOT, { recursive: true, mode: 0o700 });
@@ -1063,6 +1166,27 @@ async function processOperation({ claim, exchange, client }) {
   const completed = await client.complete(receipt);
   if (completed?.accepted !== true)
     throw new Error("customer_completion_rejected");
+  let modelHealthReporter = null;
+  if (claim.operation.action !== "INSTANTIATE") {
+    modelHealthReporter = runtimeModelHealthReporter({
+      identity,
+      exchange,
+      runtimeConfig,
+    });
+    try {
+      await modelHealthReporter.start("materialized");
+    } catch (error) {
+      process.stderr.write(
+        `${JSON.stringify({
+          ok: false,
+          code:
+            error instanceof Error
+              ? error.message
+              : "model_health_report_failed",
+        })}\n`
+      );
+    }
+  }
   atomicJson(join(DATA_ROOT, "sellable-agent-runtime-proof.json"), {
     ok: true,
     runtimeId: RUNTIME_ID,
@@ -1073,6 +1197,7 @@ async function processOperation({ claim, exchange, client }) {
     revisionId: desired.revisionId,
     observedLifecycle: receipt.observedLifecycle,
     profileDigest: proof.profileDigest,
+    modelAuth: proof.modelAuthReadback,
     runtimeUid: process.getuid?.() ?? null,
     runtimeGid: process.getgid?.() ?? null,
     profileMode: (lstatSync(profileRoot).mode & 0o777)
@@ -1099,6 +1224,7 @@ async function processOperation({ claim, exchange, client }) {
     trustRootPem,
     action: claim.operation.action,
     gateway: proof.gateway ?? null,
+    modelHealthReporter,
   };
 }
 
@@ -1241,8 +1367,14 @@ async function main() {
         exchange,
         client,
       });
+      await activeRuntime?.modelHealthReporter?.stop();
       await stopNativeGateway(activeRuntime?.gateway);
-      activeRuntime = await processOperation({ claim, exchange, client });
+      activeRuntime = await processOperation({
+        claim,
+        exchange,
+        client,
+        identity,
+      });
       operationHeartbeat.assertHealthy();
       await operationHeartbeat.stop();
       operationHeartbeat = null;
@@ -1277,6 +1409,7 @@ async function main() {
     );
   }
   await stopNativeGateway(activeRuntime?.gateway);
+  await activeRuntime?.modelHealthReporter?.stop();
   if (activeRuntime?.desired.profileId) {
     clearCustomerRuntimeSecrets({
       secretsRoot: SECRET_ROOT,

package/lib/sellable-agent/fly-customer-image/model-auth-store.mjs

@@ -0,0 +1,6 @@
+// Compatibility-only export. Runtime behavior lives in the neutral module
+// copied byte-for-byte into both CUSTOMER and ADMIN image contexts.
+export {
+  reconcileHermesModelAuth,
+  reconcileHermesModelAuth as reconcileHermesRootModelAuth,
+} from "../model-auth-reconciler.mjs";

package/lib/sellable-agent/fly-customer-model.mjs

@@ -1,152 +1,20 @@
-export const FLY_CUSTOMER_MODEL_PROVIDER = "openai-codex";
-export const FLY_CUSTOMER_MODEL_ID = "gpt-5.6-sol";
-export const FLY_CUSTOMER_MODEL_REASONING_EFFORT = "high";
+import {
+  MODEL_AUTH_DEFAULT_MODEL,
+  MODEL_AUTH_PROVIDER,
+  MODEL_AUTH_REASONING_EFFORT,
+  evaluateModelAuthReadback,
+  parseModelAuthRuntimeCredential,
+} from "./model-auth-reconciler.mjs";
 
-const MODEL_CREDENTIAL_KEYS = [
-  "OPENAI_API_KEY",
-  "auth_mode",
-  "last_refresh",
-  "tokens",
-];
-const MODEL_TOKEN_KEYS = [
-  "access_token",
-  "account_id",
-  "id_token",
-  "refresh_token",
-];
-/**
- * Credential sources that count as "resolved from this runtime's own root auth
- * store". `hermes-auth-store` is the seeded singleton under `providers`;
- * `credential_pool` is the pooled entry — which this module seeds itself (see
- * `hermesRootAuthJson` below) and which `hermes auth add` also writes when an
- * operator re-authenticates an expired Codex token. Both live in the same root
- * auth.json, so neither weakens isolation: that guarantee is carried by
- * `source_class === "root_fallback"` and `local_auth_entry_count === 0`, which
- * together prove no profile-local auth.json is shadowing the root store.
- */
-const TRUSTED_MODEL_AUTH_SOURCES = ["hermes-auth-store", "credential_pool"];
+export const FLY_CUSTOMER_MODEL_PROVIDER = MODEL_AUTH_PROVIDER;
+export const FLY_CUSTOMER_MODEL_ID = MODEL_AUTH_DEFAULT_MODEL;
+export const FLY_CUSTOMER_MODEL_REASONING_EFFORT =
+  MODEL_AUTH_REASONING_EFFORT;
 
-/**
- * Decide whether the runtime's model-auth readback proves a usable, isolated
- * Codex credential. Returns the first failed invariant so boot failures name
- * the actual cause instead of a generic rejection.
- */
-export function evaluateModelAuthReadback(readback) {
-  const reject = (rejection) => ({ accepted: false, rejection });
-  if (!readback || typeof readback !== "object" || Array.isArray(readback)) {
-    return reject("readback_unparsable");
-  }
-  if (readback.provider !== FLY_CUSTOMER_MODEL_PROVIDER) {
-    return reject("provider_mismatch");
-  }
-  if (readback.source_class !== "root_fallback") {
-    return reject("source_class_not_root_fallback");
-  }
-  if (readback.local_auth_entry_count !== 0) {
-    return reject("local_auth_entry_present");
-  }
-  if (!TRUSTED_MODEL_AUTH_SOURCES.includes(readback.source)) {
-    return reject("source_not_trusted");
-  }
-  if (readback.auth_mode !== "chatgpt") {
-    return reject("auth_mode_not_chatgpt");
-  }
-  if (readback.credential_present !== true) {
-    return reject("credential_absent");
-  }
-  return { accepted: true, rejection: null };
+// Kept as the package's stable import name while the on-wire credential is
+// upgraded from a singleton full grant to the v2 access-only runtime bundle.
+export function parseFlyCustomerModelCredential(secret, options) {
+  return parseModelAuthRuntimeCredential(secret, options);
 }
 
-const exactKeys = (value, expected) =>
-  value &&
-  typeof value === "object" &&
-  !Array.isArray(value) &&
-  Object.keys(value).length === expected.length &&
-  Object.keys(value).every((key) => expected.includes(key));
-const bounded = (value, minimum, maximum) =>
-  typeof value === "string" &&
-  value.length >= minimum &&
-  value.length <= maximum &&
-  !value.includes("\0");
-
-export function parseFlyCustomerModelCredential(secret) {
-  if (
-    typeof secret !== "string" ||
-    !secret ||
-    Buffer.byteLength(secret, "utf8") > 64 * 1024
-  ) {
-    throw new Error("customer_model_credential_rejected");
-  }
-  let value;
-  try {
-    value = JSON.parse(secret);
-  } catch {
-    throw new Error("customer_model_credential_rejected");
-  }
-  if (
-    !exactKeys(value, MODEL_CREDENTIAL_KEYS) ||
-    value.auth_mode !== "chatgpt" ||
-    value.OPENAI_API_KEY !== null ||
-    !bounded(value.last_refresh, 10, 128) ||
-    Number.isNaN(Date.parse(value.last_refresh)) ||
-    !exactKeys(value.tokens, MODEL_TOKEN_KEYS) ||
-    !bounded(value.tokens.id_token, 32, 32 * 1024) ||
-    !bounded(value.tokens.access_token, 32, 32 * 1024) ||
-    !bounded(value.tokens.refresh_token, 32, 16 * 1024) ||
-    !bounded(value.tokens.account_id, 1, 512)
-  ) {
-    throw new Error("customer_model_credential_rejected");
-  }
-  const authJson = JSON.stringify({
-    auth_mode: "chatgpt",
-    OPENAI_API_KEY: null,
-    tokens: {
-      id_token: value.tokens.id_token,
-      access_token: value.tokens.access_token,
-      refresh_token: value.tokens.refresh_token,
-      account_id: value.tokens.account_id,
-    },
-    last_refresh: value.last_refresh,
-  });
-  const hermesRootAuthJson = JSON.stringify({
-    version: 1,
-    providers: {
-      "openai-codex": {
-        tokens: {
-          id_token: value.tokens.id_token,
-          access_token: value.tokens.access_token,
-          refresh_token: value.tokens.refresh_token,
-          account_id: value.tokens.account_id,
-        },
-        last_refresh: value.last_refresh,
-        auth_mode: "chatgpt",
-      },
-    },
-    credential_pool: {
-      "openai-codex": [
-        {
-          id: "sellable-control-plane",
-          label: "Sellable Codex OAuth",
-          auth_type: "oauth",
-          source: "device_code",
-          access_token: value.tokens.access_token,
-          refresh_token: value.tokens.refresh_token,
-          id_token: value.tokens.id_token,
-          account_id: value.tokens.account_id,
-          last_refresh: value.last_refresh,
-          priority: 0,
-          request_count: 0,
-        },
-      ],
-    },
-    active_provider: "openai-codex",
-  });
-  return Object.freeze({
-    provider: FLY_CUSTOMER_MODEL_PROVIDER,
-    model: FLY_CUSTOMER_MODEL_ID,
-    reasoningEffort: FLY_CUSTOMER_MODEL_REASONING_EFFORT,
-    authJson,
-    hermesRootAuthJson,
-    testAccessToken: value.tokens.access_token,
-  });
-}
+export { evaluateModelAuthReadback };

package/lib/sellable-agent/host-bootstrap.mjs

@@ -38,7 +38,7 @@ import { installAgentHostServices } from "./service-installer.mjs";
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 const VERSION = "sellable-agent-host-bootstrap/v1";
 const RECEIPT_VERSION = "sellable-agent-host-registration/v1";
-const INSTALLER_PACKAGE = "@sellable/install@0.1.483";
+const INSTALLER_PACKAGE = "@sellable/install@0.1.486-wip.phase169.20260804.2";
 const MCP_PACKAGE = "@sellable/mcp@0.1.760-wip.phase143.20260727100513";
 const HERMES_VERSION = "0.18.0";
 const SHA256 = /^[a-f0-9]{64}$/;