@sellable/install 0.1.794 → 0.1.795-wip.runs-api.20261004.1

package/container/Dockerfile

@@ -3,12 +3,12 @@ FROM ${HERMES_IMAGE}
 
 USER root
 
-ARG INSTALLER_PACKAGE=@sellable/install@0.1.794
+ARG INSTALLER_PACKAGE=@sellable/install@0.1.795-wip.runs-api.20261004.1
 ARG MCP_PACKAGE=@sellable/mcp@0.1.957
 ARG INSTALLER_INTEGRITY
 ARG MCP_INTEGRITY=sha512-tIZuO5IEanT/afamDIWdorUNMdqZA6xnjL9jGAmGqYIlIqkXdHB9slWiwfLfmM44iEp7OT98IBHJlvbpMThk6A==
 
-RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.794" \
+RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.795-wip.runs-api.20261004.1" \
     && test "${MCP_PACKAGE}" = "@sellable/mcp@0.1.957" \
     && test -n "${INSTALLER_INTEGRITY}" \
     && test "$(npm view "${INSTALLER_PACKAGE}" dist.integrity)" = "${INSTALLER_INTEGRITY}" \
@@ -23,9 +23,9 @@ RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.794" \
     && mkdir -p /opt/sellable-agent/install-root /opt/sellable-agent/mcp-root \
     && npm install --prefix /opt/sellable-agent/install-root --omit=dev --ignore-scripts --no-audit --no-fund "${INSTALLER_PACKAGE}" \
     && npm install --prefix /opt/sellable-agent/mcp-root --omit=dev --ignore-scripts --no-audit --no-fund "${MCP_PACKAGE}" \
-    && node --input-type=module -e "import { readFileSync } from 'node:fs'; const install = JSON.parse(readFileSync('/opt/sellable-agent/install-root/node_modules/@sellable/install/package.json')); const mcp = JSON.parse(readFileSync('/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp/package.json')); if (install.name !== '@sellable/install' || install.version !== '0.1.794' || mcp.name !== '@sellable/mcp' || mcp.version !== '0.1.957') throw new Error('package identity rejected');" \
+    && node --input-type=module -e "import { readFileSync } from 'node:fs'; const install = JSON.parse(readFileSync('/opt/sellable-agent/install-root/node_modules/@sellable/install/package.json')); const mcp = JSON.parse(readFileSync('/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp/package.json')); if (install.name !== '@sellable/install' || install.version !== '0.1.795-wip.runs-api.20261004.1' || mcp.name !== '@sellable/mcp' || mcp.version !== '0.1.957') throw new Error('package identity rejected');" \
     && node --input-type=module -e "import { buildExternalRuntimeClosure } from '/opt/sellable-agent/install-root/node_modules/@sellable/install/lib/sellable-agent/external-runtime-builder.mjs'; const built = buildExternalRuntimeClosure({ mcpPackageRoot: '/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp', mcpNodeModulesRoot: '/opt/sellable-agent/mcp-root/node_modules', hermesSourceRoot: '/opt/hermes', ownerUid: 0, ownerGid: 0 }); if (!built.closureDigest) throw new Error('runtime closure rejected');" \
-    && node --input-type=module -e "import { chmodSync, writeFileSync } from 'node:fs'; const release = { installerPackage: '@sellable/install@0.1.794', installerIntegrity: process.argv[1], mcpPackage: '@sellable/mcp@0.1.957', mcpIntegrity: process.argv[2] }; writeFileSync('/opt/sellable-agent/release.json', JSON.stringify(release) + '\\n', { mode: 0o444 }); chmodSync('/opt/sellable-agent/release.json', 0o444);" "${INSTALLER_INTEGRITY}" "${MCP_INTEGRITY}" \
+    && node --input-type=module -e "import { chmodSync, writeFileSync } from 'node:fs'; const release = { installerPackage: '@sellable/install@0.1.795-wip.runs-api.20261004.1', installerIntegrity: process.argv[1], mcpPackage: '@sellable/mcp@0.1.957', mcpIntegrity: process.argv[2] }; writeFileSync('/opt/sellable-agent/release.json', JSON.stringify(release) + '\\n', { mode: 0o444 }); chmodSync('/opt/sellable-agent/release.json', 0o444);" "${INSTALLER_INTEGRITY}" "${MCP_INTEGRITY}" \
     && npm cache clean --force
 
 COPY entrypoint.sh /usr/local/bin/sellable-agent-container-entrypoint

package/container/README.md

@@ -3,7 +3,7 @@
 This image is a dedicated Agent worker/runtime boundary beside an existing Hermes dashboard. It never replaces or reconfigures the dashboard container.
 
 Build from this directory after
-`@sellable/install@0.1.794` is
+`@sellable/install@0.1.795-wip.runs-api.20261004.1` is
 published:
 
 ```sh

package/lib/sellable-agent/fly-admin-image/Dockerfile

@@ -169,6 +169,7 @@ COPY fly-admin-image/start-admin-runtime /usr/local/lib/sellable-agent/admin-run
 COPY fly-customer-image/customer-runtime.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime.mjs
 COPY hermes-first-welcome.mjs /usr/local/lib/sellable-agent/hermes-first-welcome.mjs
 COPY fly-customer-image/hermes-runs-client.mjs /usr/local/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs
+COPY fly-customer-image/endpoint-model-selection.mjs fly-customer-image/runs-api-connections.mjs fly-customer-image/claude-code-runs-api.mjs /usr/local/lib/sellable-agent/fly-customer-image/
 COPY fly-customer-image/opener-stage-execution.mjs /usr/local/lib/sellable-agent/fly-customer-image/opener-stage-execution.mjs
 COPY fly-customer-image/endpoint-uat-completion-gate.mjs /usr/local/lib/sellable-agent/fly-customer-image/endpoint-uat-completion-gate.mjs
 COPY fly-customer-image/customer-runtime-phase-telemetry.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime-phase-telemetry.mjs
@@ -272,6 +273,9 @@ RUN set -eux; \
       /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime.mjs \
       /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime-phase-telemetry.mjs \
       /usr/local/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs \
+      /usr/local/lib/sellable-agent/fly-customer-image/endpoint-model-selection.mjs \
+      /usr/local/lib/sellable-agent/fly-customer-image/runs-api-connections.mjs \
+      /usr/local/lib/sellable-agent/fly-customer-image/claude-code-runs-api.mjs \
       /usr/local/lib/sellable-agent/fly-customer-image/opener-stage-execution.mjs \
       /usr/local/lib/sellable-agent/fly-customer-image/endpoint-uat-completion-gate.mjs \
       /usr/local/lib/sellable-agent/admin-native-gateway-supervisor.mjs \

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

@@ -63,6 +63,7 @@ import {
 } from "../fly-capabilities-bridge.mjs";
 import { createCustomerEndpointRelay } from "../fly-customer-image/customer-runtime.mjs";
 import { createHermesSessionRetention } from "../fly-customer-image/hermes-runs-client.mjs";
+import { startConfiguredClaudeRunsApis } from "../fly-customer-image/claude-code-runs-api.mjs";
 import {
   claimWithSoulObservation,
   createFlyCustomerControlClient,
@@ -3817,6 +3818,14 @@ async function runAdminProduction() {
   let activeLaunch = null;
   let activeModelHealthReporter = null;
   let shutdownMemorySnapshot = null;
+  let customRunsServices = null;
+  try {
+    customRunsServices = await startConfiguredClaudeRunsApis({
+      diagnostic: value => process.stderr.write(`${JSON.stringify(value)}\n`),
+    });
+  } catch {
+    process.stderr.write(`${JSON.stringify({ ok: false, code: "custom_runs_api_start_failed" })}\n`);
+  }
   const endpointRelay = createCustomerEndpointRelay({
     getControlClient: () => client,
     getActiveRuntime: () =>
@@ -4453,6 +4462,7 @@ async function runAdminProduction() {
     );
   }
   await endpointLoop;
+  await customRunsServices?.stop();
   await activeModelHealthReporter?.stop();
   await stopNativeGateway(activeGateway);
   await clearRuntimeSecrets();

package/lib/sellable-agent/fly-customer-image/Dockerfile

@@ -8,7 +8,7 @@ ENV PLAYWRIGHT_BROWSERS_PATH=/opt/hermes/.playwright
 
 ARG MCP_PACKAGE=@sellable/mcp@0.1.957
 ARG MCP_INTEGRITY=sha512-tIZuO5IEanT/afamDIWdorUNMdqZA6xnjL9jGAmGqYIlIqkXdHB9slWiwfLfmM44iEp7OT98IBHJlvbpMThk6A==
-ARG INSTALLER_PACKAGE=@sellable/install@0.1.794
+ARG INSTALLER_PACKAGE=@sellable/install@0.1.795-wip.runs-api.20261004.1
 ARG ADMIN_MCP_PACKAGE=@sellable/admin-mcp@0.1.202
 ARG ADMIN_MCP_INTEGRITY=sha512-ym3aye/0vQ8tfULJlKz9JFOxvIQsl1G+n3np+TTgK/tecwNblBo/j3AkTnRqH9iomKzPbZzP+n4tEQsvsU8ByA==
 ARG TUS_JS_CLIENT_VERSION=4.3.1
@@ -98,6 +98,7 @@ COPY hermes-memory-reconcile.sh /opt/sellable/share/hermes-memory-reconcile.sh
 COPY hermes-endpoint-cron.mjs /opt/sellable/bin/hermes-endpoint-cron
 COPY fly-customer-image/model-auth-store.mjs /usr/local/lib/sellable-agent/fly-customer-image/model-auth-store.mjs
 COPY fly-customer-image/hermes-runs-client.mjs /usr/local/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs
+COPY fly-customer-image/endpoint-model-selection.mjs fly-customer-image/runs-api-connections.mjs /usr/local/lib/sellable-agent/fly-customer-image/
 COPY fly-customer-image/opener-stage-execution.mjs /usr/local/lib/sellable-agent/fly-customer-image/opener-stage-execution.mjs
 COPY fly-customer-image/endpoint-uat-completion-gate.mjs /usr/local/lib/sellable-agent/fly-customer-image/endpoint-uat-completion-gate.mjs
 COPY fly-customer-image/customer-runtime-phase-telemetry.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime-phase-telemetry.mjs

package/lib/sellable-agent/fly-customer-image/claude-code-runs-api.d.mts

@@ -0,0 +1,48 @@
+import type { SpawnOptions } from "node:child_process";
+import type { Server } from "node:http";
+import type { RunsApiConnection } from "./runs-api-connections.mjs";
+
+export type ClaudeRunsRequest = {
+  input: string;
+  instructions: string;
+  schema: Record<string, unknown> | null;
+  model: string;
+  effort: string;
+};
+export type ClaudeRunsResult = {
+  output: string;
+  runtime: { provider: string; model: string };
+  usage: Record<string, number>;
+};
+export type ClaudeRunsServer = Server & { stopActiveRuns(): Promise<void> };
+export type ClaudeRunsApiOptions = {
+  token: string;
+  connection: RunsApiConnection;
+  execute?: (request: ClaudeRunsRequest) => {
+    promise: Promise<ClaudeRunsResult>;
+    stop(): void;
+  };
+  audit?: (entry: Record<string, unknown>) => void;
+  maxConcurrency?: number;
+};
+export function validateClaudeRunsRequest(
+  body: unknown,
+  models: RunsApiConnection["models"]
+): ClaudeRunsRequest;
+export function claudeInvocation(
+  request: ClaudeRunsRequest,
+  root: string
+): { command: string; args: string[]; options: SpawnOptions };
+export function parseClaudeResult(
+  stdout: string,
+  request: ClaudeRunsRequest
+): ClaudeRunsResult;
+export function createClaudeRunsApi(
+  options: ClaudeRunsApiOptions
+): ClaudeRunsServer;
+export function startConfiguredClaudeRunsApis(options?: {
+  env?: Record<string, string | undefined>;
+  diagnostic?: (entry: Record<string, unknown>) => void;
+  createApi?: typeof createClaudeRunsApi;
+  readToken?: (path: string) => string;
+}): Promise<{ stop(): Promise<void> }>;

package/lib/sellable-agent/fly-customer-image/claude-code-runs-api.mjs

@@ -0,0 +1,492 @@
+import { spawn } from "node:child_process";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { appendFileSync, readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { validateOpenerOutputContract } from "./hermes-runs-client.mjs";
+import {
+  parseRunsApiConnections,
+  RUNS_API_CONNECTIONS_ENV,
+} from "./runs-api-connections.mjs";
+
+const MAX_BODY = 320 * 1024;
+const MAX_OUTPUT = 48 * 1024;
+const MAX_CLI_OUTPUT = 512 * 1024;
+const hash = (s) => createHash("sha256").update(s).digest("hex");
+const record = (v) => v && typeof v === "object" && !Array.isArray(v);
+
+export function validateClaudeRunsRequest(body, models) {
+  const allowed = [
+    "input",
+    "instructions",
+    "conversation_history",
+    "session_id",
+    "provider",
+    "model",
+    "model_options",
+  ];
+  if (
+    !record(body) ||
+    Object.keys(body).some((k) => !allowed.includes(k)) ||
+    typeof body.input !== "string" ||
+    !body.input.length ||
+    Buffer.byteLength(body.input) > 128 * 1024 ||
+    typeof body.instructions !== "string" ||
+    !body.instructions.length ||
+    Buffer.byteLength(body.instructions) > 128 * 1024 ||
+    !Array.isArray(body.conversation_history) ||
+    body.conversation_history.length > 64 ||
+    Buffer.byteLength(JSON.stringify(body.conversation_history)) > 128 * 1024 ||
+    body.conversation_history.some(
+      (item) =>
+        !record(item) ||
+        Object.keys(item).sort().join(",") !== "content,role" ||
+        !["user", "assistant"].includes(item.role) ||
+        typeof item.content !== "string"
+    ) ||
+    !/^sellable_endpoint_[a-f0-9]{32}$/.test(body.session_id ?? "") ||
+    body.provider !== "claude-code" ||
+    !record(body.model_options) ||
+    Object.keys(body.model_options).some(
+      (key) =>
+        !["reasoning_effort", "sellable_opener_output_contract"].includes(key)
+    ) ||
+    !models.some(
+      (model) =>
+        model.provider === body.provider &&
+        model.model === body.model &&
+        model.reasoningEfforts.includes(body.model_options.reasoning_effort)
+    )
+  )
+    throw new Error("claude_runs_request_rejected");
+  const contract = body.model_options.sellable_opener_output_contract;
+  const schema =
+    contract === undefined
+      ? null
+      : validateOpenerOutputContract(contract).schema;
+  return {
+    input: body.conversation_history.length
+      ? JSON.stringify({
+          conversation_history: body.conversation_history,
+          input: body.input,
+        })
+      : body.input,
+    instructions: body.instructions,
+    schema,
+    model: body.model,
+    effort: body.model_options.reasoning_effort,
+  };
+}
+
+export function claudeInvocation(request, root) {
+  return {
+    command: `${root}/cli/node_modules/.bin/claude`,
+    args: [
+      "-p",
+      "--model",
+      request.model,
+      "--effort",
+      request.effort,
+      "--output-format",
+      "json",
+      ...(request.schema
+        ? ["--json-schema", JSON.stringify(request.schema)]
+        : []),
+      "--tools",
+      "",
+      "--permission-mode",
+      "dontAsk",
+      "--strict-mcp-config",
+      "--mcp-config",
+      '{"mcpServers":{}}',
+      "--setting-sources",
+      "",
+      "--settings",
+      '{"disableAllHooks":true,"autoMemoryEnabled":false}',
+      "--disable-slash-commands",
+      "--no-session-persistence",
+      "--max-turns",
+      "3",
+      "--system-prompt",
+      request.instructions,
+    ],
+    // Whitelist instead of inheriting the runtime's provider keys, URLs, hooks,
+    // plugin paths, NODE_OPTIONS, or workspace access credentials.
+    options: {
+      cwd: `${root}/work`,
+      detached: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        PATH: "/usr/local/bin:/usr/bin:/bin",
+        HOME: `${root}/claude`,
+        CLAUDE_CONFIG_DIR: `${root}/claude`,
+        LANG: "C.UTF-8",
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+      },
+    },
+  };
+}
+
+export function parseClaudeResult(stdout, request) {
+  const result = JSON.parse(stdout);
+  const models = Object.keys(result.modelUsage ?? {});
+  if (
+    result.type !== "result" ||
+    result.is_error !== false ||
+    result.subtype !== "success" ||
+    (request.schema
+      ? !record(result.structured_output)
+      : typeof result.result !== "string") ||
+    (result.permission_denials ?? []).length ||
+    !models.length ||
+    models.some(
+      (model) =>
+        model !== request.model && !model.startsWith(`${request.model}-`)
+    )
+  )
+    throw new Error("claude_runs_output_rejected");
+  const output = request.schema
+    ? JSON.stringify(result.structured_output)
+    : result.result;
+  if (!output.trim()) throw new Error("claude_runs_output_empty");
+  if (Buffer.byteLength(output) > MAX_OUTPUT)
+    throw new Error("claude_runs_output_too_large");
+  return {
+    output,
+    runtime: { provider: "claude-code", model: models[0] },
+    usage: {
+      input_tokens: result.usage?.input_tokens ?? 0,
+      output_tokens: result.usage?.output_tokens ?? 0,
+      cache_read_tokens: result.usage?.cache_read_input_tokens ?? 0,
+      cache_write_tokens: result.usage?.cache_creation_input_tokens ?? 0,
+    },
+  };
+}
+
+export function startClaudeRun(
+  request,
+  { root, spawnImpl = spawn, timeoutMs = 750_000 } = {}
+) {
+  const invocation = claudeInvocation(request, root);
+  const child = spawnImpl(
+    invocation.command,
+    invocation.args,
+    invocation.options
+  );
+  let reason = null;
+  let killTimer;
+  const stop = (code = "claude_runs_cancelled") => {
+    reason ??= code;
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      child.kill("SIGTERM");
+    }
+    killTimer ??= setTimeout(() => {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+        child.kill("SIGKILL");
+      }
+    }, 5_000);
+    killTimer.unref();
+  };
+  const promise = new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    const timer = setTimeout(() => stop("claude_runs_timeout"), timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > MAX_CLI_OUTPUT) stop("claude_runs_output_too_large");
+      else chunks.push(chunk);
+    });
+    // Drain diagnostics without logging prompts, credentials, or message bodies.
+    child.stderr.on("data", () => {});
+    child.once("error", () => {
+      clearTimeout(timer);
+      reject(new Error("claude_runs_cli_unavailable"));
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      clearTimeout(killTimer);
+      if (reason || code !== 0)
+        return reject(new Error(reason ?? "claude_runs_cli_failed"));
+      try {
+        resolve(
+          parseClaudeResult(Buffer.concat(chunks).toString("utf8"), request)
+        );
+      } catch {
+        reject(new Error("claude_runs_output_rejected"));
+      }
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(request.input);
+  });
+  return { promise, stop };
+}
+
+export function createClaudeRunsApi({
+  token,
+  connection,
+  execute = (request) =>
+    startClaudeRun(request, { root: connection.localRoot }),
+  audit = () => {},
+  maxConcurrency = 2,
+} = {}) {
+  if (!/^[a-f0-9]{64}$/.test(token ?? ""))
+    throw new Error("claude_runs_key_rejected");
+  const recordAudit = (entry) => {
+    try {
+      audit(entry);
+    } catch {
+      /* Logging cannot crash the Admin runtime. */
+    }
+  };
+  const runs = new Map();
+  let active = 0;
+  const json = (res, status, body) => {
+    res.writeHead(status, {
+      "content-type": "application/json",
+      "cache-control": "no-store",
+      "retry-after": "2",
+    });
+    res.end(JSON.stringify(body));
+  };
+  const terminal = (run, event, fields) => {
+    Object.assign(run, fields);
+    run.event = {
+      event,
+      run_id: run.run_id,
+      timestamp: new Date().toISOString(),
+      ...(run.status === "completed"
+        ? { output: run.output, runtime: run.runtime, usage: run.usage }
+        : run.status === "failed"
+          ? { error: run.error }
+          : {}),
+    };
+    for (const res of run.listeners)
+      res.end(`data: ${JSON.stringify(run.event)}\n\n`);
+    run.listeners.clear();
+    recordAudit({
+      runId: run.run_id,
+      status: run.status,
+      servedRuntime: run.runtime ?? null,
+      usage: run.usage ?? null,
+      durationMs: Date.now() - run.startedAt,
+      outputDigest: run.output ? hash(run.output) : null,
+    });
+    setTimeout(() => runs.delete(run.run_id), 3_600_000).unref();
+  };
+  const server = createServer(async (req, res) => {
+    const provided = Buffer.from(req.headers.authorization ?? "");
+    const expected = Buffer.from(`Bearer ${token}`);
+    if (
+      provided.length !== expected.length ||
+      !timingSafeEqual(provided, expected)
+    )
+      return json(res, 401, { error: "claude_runs_auth_required" });
+    if (
+      req.headers["x-sellable-workspace-id"] !== connection.workspaceId ||
+      req.headers["x-sellable-agent-id"] !== connection.agentId
+    )
+      return json(res, 403, { error: "claude_runs_scope_rejected" });
+    if (req.method === "GET" && req.url === "/health")
+      return json(res, 200, {
+        ok: true,
+        provider: "claude-code",
+        active,
+        scope: {
+          workspaceId: connection.workspaceId,
+          agentId: connection.agentId,
+        },
+      });
+    if (req.method === "POST" && req.url === "/v1/runs") {
+      if (active >= maxConcurrency || runs.size >= 200)
+        return json(res, 429, { error: "claude_runs_busy" });
+      let request;
+      try {
+        let size = 0;
+        const chunks = [];
+        for await (const chunk of req) {
+          size += chunk.length;
+          if (size > MAX_BODY) {
+            json(res, 413, { error: "claude_runs_input_too_large" });
+            return;
+          }
+          chunks.push(chunk);
+        }
+        const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        request = validateClaudeRunsRequest(body, connection.models);
+      } catch (error) {
+        recordAudit({
+          status: "request-rejected",
+          reason: /^claude_runs_[a-z_]+$/.test(error.message ?? "")
+            ? error.message
+            : "claude_runs_invalid_request",
+        });
+        return json(res, 400, { error: "claude_runs_request_rejected" });
+      }
+      // Check again after reading: concurrent uploads cannot over-admit.
+      if (active >= maxConcurrency || runs.size >= 200)
+        return json(res, 429, { error: "claude_runs_busy" });
+      const run = {
+        run_id: `run_${randomBytes(16).toString("hex")}`,
+        status: "running",
+        startedAt: Date.now(),
+        listeners: new Set(),
+        consumed: false,
+      };
+      active++;
+      runs.set(run.run_id, run);
+      try {
+        run.execution = execute(request);
+        run.execution.promise
+          .then(
+            (result) =>
+              terminal(run, "run.completed", {
+                status: "completed",
+                ...result,
+              }),
+            (error) =>
+              terminal(
+                run,
+                run.stopping && error.message === "claude_runs_cancelled"
+                  ? "run.cancelled"
+                  : "run.failed",
+                run.stopping && error.message === "claude_runs_cancelled"
+                  ? { status: "cancelled" }
+                  : { status: "failed", error: "claude_runs_generation_failed" }
+              )
+          )
+          .finally(() => active--);
+      } catch {
+        active--;
+        terminal(run, "run.failed", {
+          status: "failed",
+          error: "claude_runs_cli_unavailable",
+        });
+      }
+      return json(res, 202, { run_id: run.run_id, status: "started" });
+    }
+    const match =
+      /^\/v1\/runs\/(run_[a-f0-9]{32})(?:\/(events|stop|approval))?$/.exec(
+        req.url ?? ""
+      );
+    const run = match && runs.get(match[1]);
+    if (!run) return json(res, 404, { error: "claude_runs_run_missing" });
+    if (req.method === "GET" && !match[2])
+      return json(res, 200, {
+        run_id: run.run_id,
+        status: run.status,
+        ...(run.output
+          ? { output: run.output, runtime: run.runtime, usage: run.usage }
+          : {}),
+        ...(run.error ? { error: run.error } : {}),
+      });
+    if (req.method === "GET" && match[2] === "events") {
+      if (run.consumed)
+        return json(res, 404, { error: "claude_runs_events_consumed" });
+      run.consumed = true;
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-store",
+      });
+      res.flushHeaders();
+      if (run.event) return res.end(`data: ${JSON.stringify(run.event)}\n\n`);
+      run.listeners.add(res);
+      const heartbeat = setInterval(
+        () => res.write(": keep-alive\n\n"),
+        15_000
+      );
+      res.once("close", () => {
+        clearInterval(heartbeat);
+        run.listeners.delete(res);
+      });
+      return;
+    }
+    if (req.method === "POST" && match[2] === "stop") {
+      if (run.event)
+        return json(res, 200, {
+          run_id: run.run_id,
+          status: run.status,
+          ...(run.output
+            ? { output: run.output, runtime: run.runtime, usage: run.usage }
+            : {}),
+        });
+      run.stopping = true;
+      run.execution.stop();
+      return json(res, 200, { run_id: run.run_id, status: "stopping" });
+    }
+    return json(res, 405, { error: "claude_runs_method_rejected" });
+  });
+  server.stopActiveRuns = async () => {
+    const activeRuns = [...runs.values()].filter(
+      (run) => !run.event && run.execution
+    );
+    for (const run of activeRuns) {
+      run.stopping = true;
+      run.execution.stop();
+    }
+    await Promise.allSettled(activeRuns.map((run) => run.execution.promise));
+  };
+  return server;
+}
+
+// The Admin runtime owns these listeners for its lifetime. Image-owned startup
+// plus the persistent CLI/auth directory makes normal restarts repeatable.
+export async function startConfiguredClaudeRunsApis({
+  env = process.env,
+  diagnostic = () => {},
+  createApi = createClaudeRunsApi,
+  readToken = (path) => readFileSync(path, "utf8").trim(),
+} = {}) {
+  const services = [];
+  for (const connection of parseRunsApiConnections(
+    env[RUNS_API_CONNECTIONS_ENV]
+  )) {
+    if (
+      !connection.localRoot ||
+      connection.runtimeId !== env.SELLABLE_RUNTIME_ID
+    )
+      continue;
+    try {
+      const token = readToken(connection.apiKeyFile);
+      const server = createApi({
+        token,
+        connection,
+        audit: (entry) =>
+          appendFileSync(
+            `${connection.localRoot}/audit.jsonl`,
+            `${JSON.stringify({ at: new Date().toISOString(), ...entry })}\n`,
+            { mode: 0o600 }
+          ),
+      });
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(
+          Number(new URL(connection.baseUrl).port),
+          "127.0.0.1",
+          resolve
+        );
+      });
+      services.push(server);
+      diagnostic({
+        ok: true,
+        code: "claude_runs_api_ready",
+        baseUrl: connection.baseUrl,
+      });
+    } catch {
+      diagnostic({ ok: false, code: "claude_runs_api_unavailable" });
+    }
+  }
+  return {
+    async stop() {
+      for (const server of services) {
+        await server.stopActiveRuns();
+        await new Promise((resolve) => {
+          server.close(resolve);
+          server.closeAllConnections();
+        });
+      }
+    },
+  };
+}

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

@@ -93,12 +93,12 @@ import {
   validateEndpointUatCompletionControl,
 } from "./endpoint-uat-completion-gate.mjs";
 import {
-  createHermesRunsClient,
   createHermesSessionRetention,
   HERMES_RUNS_FIXTURE_IDENTITY,
   validateEndpointModelSelection,
   validateOpenerOutputContract,
 } from "./hermes-runs-client.mjs";
+import { createConfiguredRunsClient } from "./runs-api-connections.mjs";
 import {
   createOpenerStageExecution,
   usesOpenerDraftStrategy,
@@ -126,7 +126,7 @@ const RUNTIME_GENERATION = Number(
 const BOOT_SESSION_ID = randomUUID();
 const HERMES_VERSION = process.env.SELLABLE_AGENT_HERMES_VERSION ?? "0.21.5";
 const INSTALLER_PACKAGE =
-  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.794";
+  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.795-wip.runs-api.20261004.1";
 const MCP_PACKAGE =
   process.env.SELLABLE_AGENT_MCP_PACKAGE ?? "@sellable/mcp@0.1.957";
 export const ENDPOINT_MAX_CONCURRENT_RUNS = 10;
@@ -1605,8 +1605,7 @@ export function createCustomerEndpointRelay(options = {}) {
     runtimeGeneration,
     getApiKeyFile = ({ claim }) =>
       join(SECRET_ROOT, claim.runtime.profileId, "api-server-key"),
-    createRunsClient = ({ apiKeyFile }) =>
-      createHermesRunsClient({ apiKeyFile }),
+    createRunsClient = createConfiguredRunsClient,
     now = () => new Date(),
     sleepImpl = sleep,
     diagnostic = () => {},

package/lib/sellable-agent/fly-customer-image/endpoint-model-selection.d.mts

@@ -0,0 +1,22 @@
+export const ENDPOINT_MODEL_SELECTION_ALLOWLIST: Readonly<{
+  openrouter: readonly [
+    "anthropic/claude-opus-5.5",
+    "anthropic/claude-sonnet-5.5",
+  ];
+}>;
+export const ENDPOINT_MODEL_REASONING_EFFORTS: readonly [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+];
+export type EndpointModelSelection = Readonly<{
+  provider: string;
+  model: string;
+  reasoningEffort: (typeof ENDPOINT_MODEL_REASONING_EFFORTS)[number];
+  runsApiBaseUrl?: string;
+}>;
+export function normalizeRunsApiBaseUrl(value: unknown): string | null;
+export function compileEndpointModelSelection(
+  value: unknown
+): EndpointModelSelection | null | "invalid";

package/lib/sellable-agent/fly-customer-image/endpoint-model-selection.mjs

@@ -0,0 +1,84 @@
+// Shared by the control plane and the runtime. A custom Runs API is only a
+// requested destination here; the runtime must also match a trusted connection.
+export const ENDPOINT_MODEL_SELECTION_ALLOWLIST = Object.freeze({
+  openrouter: Object.freeze([
+    "anthropic/claude-opus-5.5",
+    "anthropic/claude-sonnet-5.5",
+  ]),
+});
+export const ENDPOINT_MODEL_REASONING_EFFORTS = Object.freeze([
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+]);
+
+export function normalizeRunsApiBaseUrl(value) {
+  if (
+    typeof value !== "string" ||
+    value.length > 1_024 ||
+    value !== value.trim()
+  )
+    return null;
+  try {
+    const url = new URL(value);
+    if (
+      url.username ||
+      url.password ||
+      url.search ||
+      url.hash ||
+      /[\\\s]/.test(value) ||
+      (url.protocol !== "https:" &&
+        !(
+          url.protocol === "http:" &&
+          ["127.0.0.1", "[::1]"].includes(url.hostname)
+        ))
+    )
+      return null;
+    return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
+  } catch {
+    return null;
+  }
+}
+
+export function compileEndpointModelSelection(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== "object" || Array.isArray(value)) return "invalid";
+  const custom = Object.hasOwn(value, "runsApiBaseUrl");
+  if (
+    Object.keys(value).sort().join(",") !==
+    (custom
+      ? "model,provider,reasoningEffort,runsApiBaseUrl"
+      : "model,provider,reasoningEffort")
+  )
+    return "invalid";
+  const { provider, model, reasoningEffort } = value;
+  if (
+    typeof provider !== "string" ||
+    typeof model !== "string" ||
+    !ENDPOINT_MODEL_REASONING_EFFORTS.includes(reasoningEffort)
+  )
+    return "invalid";
+  if (
+    !custom &&
+    (!Object.hasOwn(ENDPOINT_MODEL_SELECTION_ALLOWLIST, provider) ||
+      !ENDPOINT_MODEL_SELECTION_ALLOWLIST[provider].includes(model))
+  )
+    return "invalid";
+  const runsApiBaseUrl = custom
+    ? normalizeRunsApiBaseUrl(value.runsApiBaseUrl)
+    : null;
+  if (
+    custom &&
+    (!runsApiBaseUrl ||
+      !/^[a-z][a-z0-9_-]{0,63}$/.test(provider) ||
+      !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/.test(model))
+  )
+    return "invalid";
+  return Object.freeze({
+    provider,
+    model,
+    reasoningEffort,
+    ...(custom ? { runsApiBaseUrl } : {}),
+  });
+}

package/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs

@@ -7,6 +7,11 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, isAbsolute } from "node:path";
+import {
+  compileEndpointModelSelection,
+  normalizeRunsApiBaseUrl,
+} from "./endpoint-model-selection.mjs";
+export { ENDPOINT_MODEL_SELECTION_ALLOWLIST } from "./endpoint-model-selection.mjs";
 
 const LOOPBACK_ORIGIN = "http://127.0.0.1:8642";
 const RUN_ID = /^run_[a-f0-9]{32}$/;
@@ -206,37 +211,12 @@ function canonicalHistory(value) {
   return result;
 }
 
-// The models a caller may name for one endpoint run. The server checks the
-// same list before it hands the run over; the runtime checks it again here so
-// a run can never reach Hermes with a model that was not reviewed.
-export const ENDPOINT_MODEL_SELECTION_ALLOWLIST = Object.freeze({
-  openrouter: Object.freeze([
-    "anthropic/claude-opus-5.5",
-    "anthropic/claude-sonnet-5.5",
-  ]),
-});
-const ENDPOINT_MODEL_REASONING_EFFORTS = Object.freeze([
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-]);
-
 export function validateEndpointModelSelection(value) {
-  if (
-    !exactObject(value) ||
-    Object.keys(value).sort().join(",") !== "model,provider,reasoningEffort" ||
-    !Object.hasOwn(ENDPOINT_MODEL_SELECTION_ALLOWLIST, value.provider) ||
-    !ENDPOINT_MODEL_SELECTION_ALLOWLIST[value.provider].includes(value.model) ||
-    !ENDPOINT_MODEL_REASONING_EFFORTS.includes(value.reasoningEffort)
-  ) {
+  const compiled = compileEndpointModelSelection(value);
+  if (!compiled || compiled === "invalid") {
     throw new Error("hermes_runs_model_selection_rejected");
   }
-  return Object.freeze({
-    provider: value.provider,
-    model: value.model,
-    reasoningEffort: value.reasoningEffort,
-  });
+  return compiled;
 }
 
 export function validateOpenerOutputContract(value) {
@@ -606,12 +586,19 @@ function submitNotAdmitted(response, value) {
 export function createHermesRunsClient(options = {}) {
   const {
     apiKeyFile,
+    baseUrl = LOOPBACK_ORIGIN,
+    scopeHeaders = {},
     fixture,
     fetchImpl = fetch,
     timeoutMs = 20_000,
   } = options;
   assertFixture(fixture);
+  const origin = normalizeRunsApiBaseUrl(baseUrl);
   if (
+    !origin ||
+    !exactObject(scopeHeaders) ||
+    Object.keys(scopeHeaders).some(key => !["x-sellable-workspace-id", "x-sellable-agent-id"].includes(key)) ||
+    Object.values(scopeHeaders).some(value => typeof value !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(value)) ||
     typeof fetchImpl !== "function" ||
     !Number.isSafeInteger(timeoutMs) ||
     timeoutMs < 100 ||
@@ -624,9 +611,11 @@ export function createHermesRunsClient(options = {}) {
     if (!path.startsWith("/v1/runs")) {
       throw new Error("hermes_runs_path_rejected");
     }
-    return fetchImpl(`${LOOPBACK_ORIGIN}${path}`, {
+    return fetchImpl(`${origin}${path}`, {
       ...init,
+      redirect: "error",
       headers: {
+        ...scopeHeaders,
         authorization: `Bearer ${apiKey}`,
         ...(init.body === undefined
           ? {}

package/lib/sellable-agent/fly-customer-image/runs-api-connections.d.mts

@@ -0,0 +1,26 @@
+export const RUNS_API_CONNECTIONS_ENV: "SELLABLE_AGENT_RUNS_API_CONNECTIONS_JSON";
+export type RunsApiConnection = Readonly<{
+  runtimeId: string;
+  workspaceId: string;
+  agentId: string;
+  baseUrl: string;
+  apiKeyFile: string;
+  endpointIds: string[];
+  workKinds: Array<"STANDARD" | "OPENER" | "REPLY" | "FOLLOW_UP">;
+  models: Array<{
+    provider: string;
+    model: string;
+    reasoningEfforts: string[];
+  }>;
+  localRoot?: string;
+}>;
+export function parseRunsApiConnections(raw: unknown): RunsApiConnection[];
+export function runsApiConnectionsForRuntime(
+  raw: unknown,
+  runtime: {
+    runtimeId: string;
+    workspaceId: string;
+    agentId: string;
+  }
+): RunsApiConnection[];
+export function createConfiguredRunsClient(options: any): any;

package/lib/sellable-agent/fly-customer-image/runs-api-connections.mjs

@@ -0,0 +1,211 @@
+import { createHash } from "node:crypto";
+import {
+  compileEndpointModelSelection,
+  normalizeRunsApiBaseUrl,
+} from "./endpoint-model-selection.mjs";
+import { createHermesRunsClient } from "./hermes-runs-client.mjs";
+
+export const RUNS_API_CONNECTIONS_ENV =
+  "SELLABLE_AGENT_RUNS_API_CONNECTIONS_JSON";
+const id = (value) =>
+  typeof value === "string" && /^[A-Za-z0-9_.:-]{1,128}$/.test(value);
+const record = (value) =>
+  value && typeof value === "object" && !Array.isArray(value);
+const stable = (value) =>
+  Array.isArray(value)
+    ? `[${value.map(stable).join(",")}]`
+    : record(value)
+      ? `{${Object.keys(value)
+          .sort()
+          .map((key) => `${JSON.stringify(key)}:${stable(value[key])}`)
+          .join(",")}}`
+      : JSON.stringify(value);
+const fail = () => {
+  throw new Error("runs_api_connection_configuration_rejected");
+};
+
+// Only the control plane's machine configuration supplies this registry. It
+// contains credential file references, never credentials or request input.
+export function parseRunsApiConnections(raw) {
+  if (raw === undefined || raw === "") return [];
+  if (typeof raw !== "string" || Buffer.byteLength(raw) > 64 * 1024) fail();
+  let entries;
+  try {
+    entries = JSON.parse(raw);
+  } catch {
+    fail();
+  }
+  if (!Array.isArray(entries) || entries.length > 32) fail();
+  const seen = new Set();
+  return entries.map((entry) => {
+    if (
+      !record(entry) ||
+      Object.keys(entry).some(
+        (key) =>
+          ![
+            "runtimeId",
+            "workspaceId",
+            "agentId",
+            "baseUrl",
+            "apiKeyFile",
+            "endpointIds",
+            "workKinds",
+            "models",
+            "localRoot",
+          ].includes(key)
+      ) ||
+      ![entry.runtimeId, entry.workspaceId, entry.agentId].every(id) ||
+      typeof entry.apiKeyFile !== "string" ||
+      !/^\/(?:opt\/data|run\/secrets)\/[A-Za-z0-9_./-]{1,250}$/.test(
+        entry.apiKeyFile
+      ) ||
+      entry.apiKeyFile
+        .split("/")
+        .some((part) => part === "." || part === "..") ||
+      !Array.isArray(entry.endpointIds) ||
+      !entry.endpointIds.length ||
+      entry.endpointIds.length > 64 ||
+      !entry.endpointIds.every(id) ||
+      !Array.isArray(entry.workKinds) ||
+      !entry.workKinds.length ||
+      !entry.workKinds.every((kind) =>
+        ["STANDARD", "OPENER", "REPLY", "FOLLOW_UP"].includes(kind)
+      ) ||
+      !Array.isArray(entry.models) ||
+      !entry.models.length ||
+      entry.models.length > 16
+    )
+      fail();
+    const baseUrl = normalizeRunsApiBaseUrl(entry.baseUrl);
+    if (!baseUrl) fail();
+    const identity = `${entry.runtimeId}:${baseUrl}`;
+    if (seen.has(identity)) fail();
+    seen.add(identity);
+    const models = entry.models.map((model) => {
+      if (
+        !record(model) ||
+        Object.keys(model).sort().join(",") !==
+          "model,provider,reasoningEfforts" ||
+        !Array.isArray(model.reasoningEfforts) ||
+        !model.reasoningEfforts.length ||
+        model.reasoningEfforts.some(
+          (reasoningEffort) =>
+            compileEndpointModelSelection({
+              provider: model.provider,
+              model: model.model,
+              reasoningEffort,
+              runsApiBaseUrl: baseUrl,
+            }) === "invalid"
+        )
+      )
+        fail();
+      return { ...model, reasoningEfforts: [...model.reasoningEfforts] };
+    });
+    if (entry.localRoot !== undefined) {
+      const url = new URL(baseUrl);
+      if (
+        typeof entry.localRoot !== "string" ||
+        !/^\/opt\/data\/[A-Za-z0-9_-]{1,80}$/.test(entry.localRoot) ||
+        entry.apiKeyFile !== `${entry.localRoot}/api-key` ||
+        url.hostname !== "127.0.0.1" ||
+        url.protocol !== "http:" ||
+        url.pathname !== "/" ||
+        !url.port ||
+        Number(url.port) < 1024 ||
+        models.some(
+          (model) =>
+            model.provider !== "claude-code" ||
+            !/^claude-[a-z0-9-]{1,100}$/.test(model.model) ||
+            model.reasoningEfforts.some(
+              (effort) => !["low", "medium", "high"].includes(effort)
+            )
+        )
+      )
+        fail();
+    }
+    return Object.freeze({
+      ...entry,
+      baseUrl,
+      models,
+      endpointIds: [...entry.endpointIds],
+      workKinds: [...entry.workKinds],
+    });
+  });
+}
+
+export function runsApiConnectionsForRuntime(raw, runtime) {
+  return parseRunsApiConnections(raw).filter(
+    (connection) =>
+      connection.runtimeId === runtime.runtimeId &&
+      connection.workspaceId === runtime.workspaceId &&
+      connection.agentId === runtime.agentId
+  );
+}
+
+/** @param {any} options */
+export function createConfiguredRunsClient({
+  apiKeyFile,
+  claim,
+  env = process.env,
+  clientFactory = createHermesRunsClient,
+}) {
+  const selection = claim?.run?.modelSelection;
+  if (!selection?.runsApiBaseUrl) return clientFactory({ apiKeyFile });
+  const model = compileEndpointModelSelection(selection);
+  if (!model || model === "invalid") throw new Error("runs_api_model_rejected");
+  const connection = runsApiConnectionsForRuntime(
+    env[RUNS_API_CONNECTIONS_ENV],
+    {
+      runtimeId: claim.runtime?.runtimeId,
+      workspaceId: claim.attempt?.workspaceId,
+      agentId: claim.attempt?.agentId,
+    }
+  ).find((value) => value.baseUrl === model.runsApiBaseUrl);
+  const workKind = claim.run.productExecution?.workKind ?? "STANDARD";
+  if (
+    !connection ||
+    env.SELLABLE_RUNTIME_ID !== connection.runtimeId ||
+    !connection.endpointIds.includes(claim.attempt.endpointId) ||
+    !connection.workKinds.includes(workKind) ||
+    !connection.models.some(
+      (allowed) =>
+        allowed.provider === model.provider &&
+        allowed.model === model.model &&
+        allowed.reasoningEfforts.includes(model.reasoningEffort)
+    )
+  )
+    throw new Error("runs_api_connection_not_authorized");
+  // This client instance retains one destination and one credential for the
+  // entire attempt, including stream/status/stop, even if settings later change.
+  const client = clientFactory({
+    baseUrl: connection.baseUrl,
+    apiKeyFile: connection.apiKeyFile,
+    scopeHeaders: {
+      "x-sellable-workspace-id": connection.workspaceId,
+      "x-sellable-agent-id": connection.agentId,
+    },
+  });
+  return Object.freeze({
+    ...client,
+    submit(compiled, options) {
+      // Public semantic endpoints have a published schema but no product tuple.
+      // Preserve that existing contract when calling a custom Runs service.
+      const schema = claim.revision?.outputSchema;
+      if (compiled.outputContract || !schema?.properties?.proposal)
+        return client.submit(compiled, options);
+      return client.submit(
+        {
+          ...compiled,
+          outputContract: {
+            schemaVersion: "sellable-opener-output-contract/v1",
+            schema,
+            nativeProposalSchemaDigest: createHash("sha256")
+              .update(stable(schema.properties.proposal))
+              .digest("hex"),
+          },
+        },
+        options
+      );
+    },
+  });
+}

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.794";
+const INSTALLER_PACKAGE = "@sellable/install@0.1.795-wip.runs-api.20261004.1";
 const MCP_PACKAGE = "@sellable/mcp@0.1.957";
 const HERMES_VERSION = "0.18.0";
 const SHA256 = /^[a-f0-9]{64}$/;

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

@@ -1546,7 +1546,7 @@ export function compileClaimToProfileDesired(activeClaim, config) {
       ]) ||
       pinned.hermesCli !== "hermes" ||
       pinned.hermesVersion !== "0.18.0" ||
-      pinned.installerPackage !== "@sellable/install@0.1.794" ||
+      pinned.installerPackage !== "@sellable/install@0.1.795-wip.runs-api.20261004.1" ||
       pinned.mcpPackage !== "@sellable/mcp@0.1.957" ||
       !Array.isArray(policy.toolInclude) ||
       policy.toolInclude.length === 0 ||

package/lib/sellable-agent/profile-materializer.mjs

@@ -312,7 +312,7 @@ function validateDesired(desired) {
     desired.serviceCredentialGeneration < 1 ||
     desired.hermesCli !== "hermes" ||
     desired.hermesVersion !== "0.18.0" ||
-    desired.installerPackage !== "@sellable/install@0.1.794" ||
+    desired.installerPackage !== "@sellable/install@0.1.795-wip.runs-api.20261004.1" ||
     desired.mcpPackage !== "@sellable/mcp@0.1.957" ||
     !Array.isArray(desired.toolInclude) ||
     desired.toolInclude.length === 0 ||

package/lib/sellable-agent/provisioning-adapter.mjs

@@ -25,7 +25,7 @@ import { fileURLToPath } from "node:url";
 import { deriveContainedProfileId } from "./profile-materializer.mjs";
 
 export const PROVISIONING_ACTION = "PROVISION_HERMES_PROFILE";
-export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.794";
+export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.795-wip.runs-api.20261004.1";
 export const PINNED_MCP_PACKAGE = "@sellable/mcp@0.1.957";
 const PINNED_INSTALL_VERSION = PINNED_INSTALL_PACKAGE.slice(
   PINNED_INSTALL_PACKAGE.lastIndexOf("@") + 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.794",
+  "version": "0.1.795-wip.runs-api.20261004.1",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {