threadwire 0.1.8 → 0.1.9

package/src/isolated-runtime.js

@@ -9,6 +9,8 @@ import {DockerApi} from "./docker-api.js"
 import {buildWorkerContainerSpec, isDigestImage} from "./isolated-worker.js"
 import {validateRelayWriteProviderArguments} from "./relay-write.js"
 import {codexSessionId, parseCodexEvent} from "./providers/codex.js"
+import {kimiSessionEnvelopeId, validateKimiProviderArguments} from "./providers/kimi.js"
+import {parseApprovedKimiModels} from "./kimi-model-broker-policy.js"
 import {openStateRegistry, validateStateVolume} from "./isolated-state.js"
 import {assertNoNestedMounts} from "./mount-policy.js"
 import {AbsoluteDeadline, deadlineAfter} from "./absolute-deadline.js"
@@ -30,12 +32,21 @@ export async function startIsolatedRuntime(options = {}) {
   const environment = options.environment ?? process.env
   const host = environment.THREADWIRE_ISOLATED_RUNTIME_HOST ?? "0.0.0.0"
   const port = portValue(environment.THREADWIRE_ISOLATED_RUNTIME_PORT, 8790)
-  const controlToken = safeSetting(environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN, "THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN")
-  const workerImage = safeSetting(environment.THREADWIRE_RELAY_WORKER_IMAGE, "THREADWIRE_RELAY_WORKER_IMAGE")
-  if (!isDigestImage(workerImage)) throw new Error("THREADWIRE_RELAY_WORKER_IMAGE must use an immutable digest")
-  const brokerUrl = normalizedHttpUrl(environment.THREADWIRE_MODEL_BROKER_URL, "THREADWIRE_MODEL_BROKER_URL")
-  const brokerAdminToken = safeSetting(environment.THREADWIRE_MODEL_BROKER_ADMIN_TOKEN, "THREADWIRE_MODEL_BROKER_ADMIN_TOKEN")
-  const brokerContainer = safeSetting(environment.THREADWIRE_MODEL_BROKER_CONTAINER, "THREADWIRE_MODEL_BROKER_CONTAINER")
+  const provider = isolatedProvider(environment.THREADWIRE_ISOLATED_PROVIDER)
+  const controlToken = provider === "kimi"
+    ? authoritySetting(environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN, "THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN")
+    : safeSetting(environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN, "THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN")
+  const workerImageName = provider === "kimi" ? "THREADWIRE_KIMI_RELAY_WORKER_IMAGE" : "THREADWIRE_RELAY_WORKER_IMAGE"
+  const workerImage = safeSetting(environment[workerImageName], workerImageName)
+  if (!isDigestImage(workerImage)) throw new Error(`${workerImageName} must use an immutable digest`)
+  const brokerUrlName = provider === "kimi" ? "THREADWIRE_KIMI_MODEL_BROKER_URL" : "THREADWIRE_MODEL_BROKER_URL"
+  const brokerAdminName = provider === "kimi" ? "THREADWIRE_KIMI_MODEL_BROKER_ADMIN_TOKEN" : "THREADWIRE_MODEL_BROKER_ADMIN_TOKEN"
+  const brokerContainerName = provider === "kimi" ? "THREADWIRE_KIMI_MODEL_BROKER_CONTAINER" : "THREADWIRE_MODEL_BROKER_CONTAINER"
+  const brokerUrl = normalizedHttpUrl(environment[brokerUrlName], brokerUrlName)
+  const brokerAdminToken = provider === "kimi"
+    ? authoritySetting(environment[brokerAdminName], brokerAdminName)
+    : safeSetting(environment[brokerAdminName], brokerAdminName)
+  const brokerContainer = safeSetting(environment[brokerContainerName], brokerContainerName)
   const allowedRoots = parseAllowedRoots(environment.THREADWIRE_ALLOWED_WORKTREE_ROOTS)
   const worktreeVolume = environment.THREADWIRE_WORKTREE_VOLUME
   const sessionTtlMs = positiveDuration(environment.THREADWIRE_SESSION_TTL_MS, 86_400_000)
@@ -44,11 +55,14 @@ export async function startIsolatedRuntime(options = {}) {
   const docker = options.docker ?? new DockerApi()
   const fetchImplementation = options.fetchImplementation ?? fetch
   const now = options.now ?? Date.now
-  const allowedModels = parseAllowedModels(environment.THREADWIRE_ALLOWED_CODEX_MODELS)
+  const allowedModels = provider === "kimi"
+    ? parseApprovedKimiModels(environment.THREADWIRE_ALLOWED_KIMI_MODELS)
+    : parseAllowedModels(environment.THREADWIRE_ALLOWED_CODEX_MODELS)
   const stateRegistry = await openStateRegistry({
     file: safeSetting(environment.THREADWIRE_STATE_REGISTRY_FILE, "THREADWIRE_STATE_REGISTRY_FILE"),
     key: safeSetting(environment.THREADWIRE_STATE_AUTH_KEY, "THREADWIRE_STATE_AUTH_KEY"),
     namespace: safeSetting(environment.THREADWIRE_STATE_NAMESPACE, "THREADWIRE_STATE_NAMESPACE"),
+    provider,
     now
   })
   const preflights = new PreflightStore({
@@ -108,28 +122,22 @@ export async function startIsolatedRuntime(options = {}) {
         })
         try {
           const body = await readJson(request, MAX_PREFLIGHT_BYTES, operation.signal)
-          const selection = parsePreflight(body)
+          const selection = parsePreflight(body, provider)
           const task = taskIdentity(selection)
           preflights.assertCapacity(task)
-          let codexArguments
-          try {
-            codexArguments = validateRelayWriteProviderArguments(selection.providerArguments)
-          } catch (error) {
-            throw new ClientError(error instanceof Error ? error.message : "Provider argument is unavailable in relay write mode")
-          }
-          if (!allowedModels.has(codexArguments.model)) throw new ClientError("Codex model is not allowed")
+          const providerSelection = runtimeProviderSelection(provider, selection.providerArguments, allowedModels)
           const {fingerprint, root: worktreeRoot} = await verifyPrerequisites({
             docker, workerImage, selection, allowedRoots, brokerUrl, brokerAdminToken, fetchImplementation, operation
           })
           let state
           if (selection.resumeSession !== undefined) {
-            state = stateRegistry.lookup(selection.resumeSession)
-            if (!state || state.task !== task) throw new ClientError("Codex resume state is unavailable")
+            state = stateRegistry.lookup(selection.resumeSession, provider)
+            if (!state || state.provider !== provider || state.task !== task) throw new ClientError(`${providerName(provider)} resume state is unavailable`)
             const volume = await docker.inspectVolume(state.volume, operation.options()).catch(() => undefined)
-            try { validateStateVolume(volume, state.volume, state.labels) } catch { throw new ClientError("Codex resume state is unavailable") }
+            try { validateStateVolume(volume, state.volume, state.labels) } catch { throw new ClientError(`${providerName(provider)} resume state is unavailable`) }
           } else state = stateRegistry.allocate(task)
           const preflightId = randomBytes(24).toString("base64url")
-          preflights.add(preflightId, task, {...selection, codexArguments, state, fingerprint, worktreeRoot, launchDeadlineAt})
+          preflights.add(preflightId, task, {...selection, providerSelection, state, fingerprint, worktreeRoot, launchDeadlineAt})
           sendJson(response, 200, {ok: true, preflightId, launchDeadlineAt})
         } finally {
           operation.close()
@@ -159,9 +167,9 @@ export async function startIsolatedRuntime(options = {}) {
         try {
           releaseRun = activeRuns.acquire(task)
           releaseLineage = activeLineages.acquire(preflight.state.lineage)
-          if (body.resumeSession !== preflight.resumeSession) throw new ClientError("Codex resume state does not match preflight")
-          if (JSON.stringify(validateRelayWriteProviderArguments(body.providerArguments)) !== JSON.stringify(preflight.codexArguments)) {
-            throw new ClientError("Codex arguments do not match preflight")
+          if (body.resumeSession !== preflight.resumeSession) throw new ClientError(`${providerName(provider)} resume state does not match preflight`)
+          if (JSON.stringify(runtimeProviderSelection(provider, body.providerArguments, allowedModels)) !== JSON.stringify(preflight.providerSelection)) {
+            throw new ClientError(`${providerName(provider)} arguments do not match preflight`)
           }
           await revalidateFingerprint(preflight.fingerprint)
           operation.throwIfAborted()
@@ -274,6 +282,9 @@ export async function runIsolatedWorker(options) {
   const runId = `tw-${randomBytes(12).toString("hex")}`
   const networkName = `${runId}-net`
   const state = options.preflight.state
+  const provider = options.preflight.provider ?? "codex"
+  const providerSelection = options.preflight.providerSelection ?? options.preflight.codexArguments
+  if (providerSelection === undefined) throw new Error("Provider selection unavailable")
   const freshState = options.resumeSession === undefined
   let keepFreshState = false
   let networkId
@@ -294,6 +305,7 @@ export async function runIsolatedWorker(options) {
     runTracked = true
     const resourceLabels = {
       "org.threadwire.namespace": options.stateRegistry.namespace,
+      "org.threadwire.provider": provider,
       "org.threadwire.run": runId,
       "org.threadwire.lineage": state.lineage,
       "org.threadwire.task": state.labels["org.threadwire.task"],
@@ -311,7 +323,14 @@ export async function runIsolatedWorker(options) {
       redirect: "error",
       signal: operation.signal,
       headers: {authorization: `Bearer ${options.brokerAdminToken}`, "content-type": "application/json"},
-      body: JSON.stringify({runId, provider: "codex", networkId, model: options.preflight.codexArguments.model, brokerAddress, ttlMs: Math.min(operation.remaining(), 3_600_000)})
+      body: JSON.stringify(provider === "kimi"
+        ? {
+          runId, provider, networkId, modelAlias: providerSelection.modelAlias, brokerAddress,
+          taskId: state.labels["org.threadwire.task"],
+          sessionId: options.resumeSession ?? `pending:${state.lineage}`,
+          ttlMs: Math.min(operation.remaining(), 3_600_000)
+        }
+        : {runId, provider, networkId, model: providerSelection.model, brokerAddress, ttlMs: Math.min(operation.remaining(), 3_600_000)})
     }), operation.signal)
     if (!grantResponse.ok) throw new Error("Model broker grant failed")
     const grant = await grantResponse.json()
@@ -322,13 +341,15 @@ export async function runIsolatedWorker(options) {
     const cwdMetadata = repository.find((entry) => entry.path === options.preflight.cwd)
     if (worktreeMetadata === undefined || cwdMetadata === undefined) throw new Error("Worktree fingerprint unavailable")
     const spec = buildWorkerContainerSpec({
+      provider,
       image: options.workerImage,
       worktree: options.preflight.repositoryRoot,
       networkName,
       brokerToken: grantToken,
       brokerUrl: `http://${brokerAddress}:${grant.port}/v1`,
       prompt: options.prompt,
-      providerArguments: options.preflight.codexArguments.arguments,
+      providerArguments: providerSelection.arguments,
+      ...(provider === "kimi" ? {model: providerSelection.model} : {}),
       stateVolume: state.volume,
       workingDirectory: `/worktree${relative(options.preflight.repositoryRoot, options.preflight.cwd) === "" ? "" : `/${relative(options.preflight.repositoryRoot, options.preflight.cwd)}`}`,
       worktreeInode: worktreeMetadata.ino,
@@ -367,12 +388,27 @@ export async function runIsolatedWorker(options) {
     const rawChunks = demultiplexDockerLogChunks(logs)
     const result = {
       exitCode: typeof wait.StatusCode === "number" ? wait.StatusCode : 1,
-      records: parseWorkerRecords(Buffer.concat(rawChunks.filter((chunk) => chunk.channel === "stdout").map((chunk) => chunk.data)).toString("utf8")),
-      rawChunks: rawChunks.map((chunk) => ({channel: chunk.channel, data: chunk.data.toString("base64")}))
+      records: parseWorkerRecords(
+        Buffer.concat(rawChunks.filter((chunk) => chunk.channel === "stdout").map((chunk) => chunk.data)).toString("utf8"),
+        provider
+      ),
+      rawChunks: provider === "kimi"
+        ? []
+        : rawChunks.map((chunk) => ({channel: chunk.channel, data: chunk.data.toString("base64")}))
+    }
+    let sessionIds = [...new Set(result.records.filter((record) => record.type === "session").map((record) => record.sessionId))]
+    if (provider === "kimi" && result.exitCode !== 0) {
+      result.records = result.records.filter((record) => record.type !== "session")
+      sessionIds = []
+    }
+    if (provider === "kimi" && result.exitCode === 0) {
+      if (sessionIds.length !== 1) throw new Error("Kimi worker did not establish exactly one native session")
+      if (options.resumeSession !== undefined && sessionIds[0] !== options.resumeSession) {
+        throw new Error("Kimi worker did not preserve the exact resume session")
+      }
     }
     if (freshState && result.exitCode === 0) {
-      const sessionIds = [...new Set(result.records.filter((record) => record.type === "session").map((record) => record.sessionId))]
-      if (sessionIds.length === 0) throw new Error("Codex session state was not established")
+      if (sessionIds.length === 0) throw new Error(`${providerName(provider)} session state was not established`)
       await options.stateRegistry.register(sessionIds, state, options.sessionTtlMs, operation.signal)
       keepFreshState = true
     }
@@ -421,7 +457,8 @@ export async function prepareStateVolume(docker, state, fresh, requestOptions) {
   try {
     validateStateVolume(volume, state.volume, state.labels)
   } catch {
-    throw new ClientError(fresh ? "Codex state volume collision" : "Codex resume state is unavailable")
+    const provider = state.provider ?? "codex"
+    throw new ClientError(fresh ? `${providerName(provider)} state volume collision` : `${providerName(provider)} resume state is unavailable`)
   }
 }
 
@@ -438,27 +475,70 @@ export function validateWorkerMountInventory(container, expected) {
   }
 }
 
-function parseWorkerRecords(text) {
+function parseWorkerRecords(text, provider = "codex") {
   const records = []
+  let kimiSessionId
+  let conflictingKimiSession = false
   for (const line of text.split("\n")) {
     if (line.trim().length === 0) continue
     try {
       const record = JSON.parse(line)
-      if (isRecord(record)) {
-        records.push(record)
-        if (record.type !== "worker-event") {
-          const sessionId = codexSessionId(record)
-          if (sessionId !== undefined) records.push({type: "session", sessionId})
-          for (const event of parseCodexEvent(record)) records.push({type: "worker-event", event})
-        }
+      if (!isRecord(record)) continue
+      if (provider === "kimi") {
+        const envelope = validatedKimiWorkerEnvelope(record)
+        if (envelope?.type === "session") {
+          if (kimiSessionId === undefined) {
+            kimiSessionId = envelope.sessionId
+            records.push(envelope)
+          } else if (kimiSessionId !== envelope.sessionId) conflictingKimiSession = true
+        } else if (envelope !== undefined) records.push(envelope)
+        continue
+      }
+      records.push(record)
+      if (record.type !== "worker-event") {
+        const sessionId = codexSessionId(record)
+        if (sessionId !== undefined) records.push({type: "session", sessionId})
+        for (const event of parseCodexEvent(record)) records.push({type: "worker-event", event})
       }
     } catch {
-      records.push({type: "worker-event", event: {type: "diagnostic", level: "warning", summary: "Worker emitted an unreadable event"}})
+      if (provider === "codex") {
+        records.push({type: "worker-event", event: {type: "diagnostic", level: "warning", summary: "Worker emitted an unreadable event"}})
+      }
     }
   }
+  if (conflictingKimiSession) throw new Error("Kimi worker emitted conflicting native sessions")
   return records
 }
 
+function validatedKimiWorkerEnvelope(record) {
+  const sessionId = kimiSessionEnvelopeId(record)
+  if (sessionId !== undefined) return {type: "session", sessionId}
+  if (!exactKeys(record, ["type", "event"]) || record.type !== "worker-event" || !isRecord(record.event)) return undefined
+  const event = record.event
+  if (exactKeys(event, ["type", "text", "streamId"]) && event.type === "text-delta"
+    && typeof event.text === "string" && event.text.length <= 1_048_576 && event.streamId === "kimi:assistant") {
+    return {type: "worker-event", event: {type: "text-delta", text: event.text, streamId: "kimi:assistant"}}
+  }
+  if (exactKeys(event, ["type", "phase", "name", "key"]) && event.type === "tool"
+    && (event.phase === "started" || event.phase === "finished")
+    && typeof event.name === "string" && /^[A-Za-z_][A-Za-z0-9_.:-]{0,127}$/u.test(event.name)
+    && typeof event.key === "string" && /^tool:[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u.test(event.key)) {
+    return {type: "worker-event", event: {type: "tool", phase: event.phase, name: event.name, key: event.key}}
+  }
+  if (exactKeys(event, ["type", "phase", "summary"]) && event.type === "lifecycle") {
+    const summaries = {
+      started: "Kimi worker started",
+      completed: "Kimi worker completed",
+      failed: "Kimi worker failed",
+      cancelled: "Kimi worker cancelled"
+    }
+    if (summaries[event.phase] === event.summary) {
+      return {type: "worker-event", event: {type: "lifecycle", phase: event.phase, summary: event.summary}}
+    }
+  }
+  return undefined
+}
+
 export function demultiplexDockerLogs(buffer) {
   return Buffer.concat(demultiplexDockerLogChunks(buffer).map((chunk) => chunk.data)).toString("utf8")
 }
@@ -481,17 +561,20 @@ export function demultiplexDockerLogChunks(buffer) {
   return [{channel: "stdout", data: buffer}]
 }
 
-export function parsePreflight(value) {
-  if (!isRecord(value) || value.provider !== "codex" || typeof value.profile !== "string" || typeof value.repositoryRoot !== "string" || typeof value.cwd !== "string" || !Array.isArray(value.providerArguments) || !value.providerArguments.every((item) => typeof item === "string")) {
+export function parsePreflight(value, expectedProvider = "codex") {
+  if (!isRecord(value) || value.provider !== expectedProvider || (expectedProvider !== "codex" && expectedProvider !== "kimi")
+    || typeof value.profile !== "string" || typeof value.repositoryRoot !== "string" || typeof value.cwd !== "string"
+    || !Array.isArray(value.providerArguments) || !value.providerArguments.every((item) => typeof item === "string")) {
     throw new ClientError("Invalid isolated runtime preflight")
   }
   if (!bounded(value.profile, 128) || !bounded(value.repositoryRoot, 4096) || !bounded(value.cwd, 4096)
     || value.providerArguments.length > 16 || value.providerArguments.some((item) => !bounded(item, 512))
-    || (value.resumeSession !== undefined && !bounded(value.resumeSession, 256))) {
+    || (value.resumeSession !== undefined && !bounded(value.resumeSession, 512))) {
     throw new ClientError("Invalid isolated runtime preflight")
   }
   if (value.resumeSession !== undefined && (typeof value.resumeSession !== "string" || /[\r\n]/u.test(value.resumeSession))) throw new ClientError("Invalid isolated runtime preflight")
   return {
+    provider: expectedProvider,
     profile: value.profile,
     repositoryRoot: value.repositoryRoot,
     cwd: value.cwd,
@@ -506,14 +589,9 @@ export function parseRun(value) {
   }
   if (!bounded(value.preflightId, 64) || !bounded(value.prompt, 524_288)
     || value.providerArguments.length > 16 || value.providerArguments.some((item) => !bounded(item, 512))
-    || (value.resumeSession !== undefined && !bounded(value.resumeSession, 256))) {
+    || (value.resumeSession !== undefined && !bounded(value.resumeSession, 512))) {
     throw new ClientError("Invalid isolated runtime run")
   }
-  try {
-    validateRelayWriteProviderArguments(value.providerArguments)
-  } catch (error) {
-    throw new ClientError(error instanceof Error ? error.message : "Provider argument is unavailable in relay write mode")
-  }
   if (value.resumeSession !== undefined && (typeof value.resumeSession !== "string" || /[\r\n]/u.test(value.resumeSession))) throw new ClientError("Invalid isolated runtime run")
   return {
     preflightId: value.preflightId,
@@ -523,6 +601,32 @@ export function parseRun(value) {
   }
 }
 
+function runtimeProviderSelection(provider, providerArguments, allowedModels) {
+  if (provider === "kimi") {
+    let selection
+    try { selection = validateKimiProviderArguments(providerArguments) } catch (error) {
+      throw new ClientError(error instanceof Error ? error.message : "Kimi provider arguments are unavailable")
+    }
+    const approved = allowedModels.get(selection.modelAlias)
+    if (approved === undefined) throw new ClientError("Kimi model is not allowed")
+    return {modelAlias: approved.alias, model: approved.model, arguments: selection.arguments}
+  }
+  let selection
+  try { selection = validateRelayWriteProviderArguments(providerArguments) } catch (error) {
+    throw new ClientError(error instanceof Error ? error.message : "Provider argument is unavailable in relay write mode")
+  }
+  if (!allowedModels.has(selection.model)) throw new ClientError("Codex model is not allowed")
+  return selection
+}
+
+function isolatedProvider(value) {
+  if (value === undefined || value === "codex") return "codex"
+  if (value === "kimi") return "kimi"
+  throw new Error("THREADWIRE_ISOLATED_PROVIDER must be codex or kimi")
+}
+
+function providerName(provider) { return provider === "kimi" ? "Kimi" : "Codex" }
+
 function requestedDeadline(value, maximumMs) {
   const parsed = Number(value)
   const maximum = Date.now() + maximumMs
@@ -560,7 +664,7 @@ function ancestry(root, child) {
 }
 
 function taskIdentity(preflight) {
-  return `${preflight.profile}\0${preflight.repositoryRoot}`
+  return `${preflight.provider ?? "codex"}\0${preflight.profile}\0${preflight.repositoryRoot}`
 }
 
 function brokerNetworkAddress(value, containerName) {
@@ -609,6 +713,12 @@ function safeSetting(value, name) {
   return value
 }
 
+function authoritySetting(value, name) {
+  const authority = safeSetting(value, name)
+  if (authority.length < 32 || authority.length > 512) throw new Error(`${name} must be at least 32 characters`)
+  return authority
+}
+
 function portValue(value, fallback) {
   if (value === undefined) return fallback
   const number = Number(value)
@@ -652,6 +762,12 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value)
 }
 
+function exactKeys(value, expected) {
+  const actual = Object.keys(value).sort()
+  const wanted = [...expected].sort()
+  return actual.length === wanted.length && actual.every((key, index) => key === wanted[index])
+}
+
 function abortable(promise, signal) {
   if (signal.aborted) return Promise.reject(signal.reason)
   return new Promise((resolve, reject) => {
@@ -786,13 +902,13 @@ export async function reconcileDockerResources(docker, brokerContainer, stateReg
   const cleanupFailed = new Set()
   const containers = await docker.listContainers({"org.threadwire.owner": "isolated-runtime"}, true, requestOptions)
   for (const container of Array.isArray(containers) ? containers : []) {
-    const labels = validResourceLabels(container?.Labels, namespace, true)
+    const labels = validResourceLabels(container?.Labels, namespace, true, stateRegistry.provider ?? "codex")
     if (!labels) continue
     const persisted = ownedIdentities.get(labels.run)
-    if (!persisted || stateRegistry.sealRun(persisted) !== labels.seal) continue
+    if (!persisted || !stateRegistry.ownsRunSeal(persisted, labels.seal, labels.legacy)) continue
     const inspection = await docker.inspectContainer(container.Id, requestOptions).catch(() => undefined)
     const identity = ownedContainerIdentity(inspection, labels)
-    if (!identity || !stateRegistry.ownsRun(identity, labels.seal)) {
+    if (!identity || !stateRegistry.ownsRun(identity, labels.seal, labels.legacy)) {
       cleanupFailed.add(labels.run)
       continue
     }
@@ -810,13 +926,13 @@ export async function reconcileDockerResources(docker, brokerContainer, stateReg
   }
   const networks = await docker.listNetworks({"org.threadwire.owner": "isolated-runtime"}, requestOptions)
   for (const network of Array.isArray(networks) ? networks : []) {
-    const labels = validResourceLabels(network?.Labels, namespace, false)
+    const labels = validResourceLabels(network?.Labels, namespace, false, stateRegistry.provider ?? "codex")
     if (!labels || activeRuns.has(labels.run) || cleanupFailed.has(labels.run)) continue
     const identity = ownedIdentities.get(labels.run)
-    if (!identity || stateRegistry.sealRun(identity) !== labels.seal) continue
+    if (!identity || !stateRegistry.ownsRunSeal(identity, labels.seal, labels.legacy)) continue
     const inspection = await docker.inspectNetwork(network.Id, requestOptions).catch(() => undefined)
     if (!identity || !ownedNetworkIdentity(inspection, labels, identity, brokerContainer)
-      || !stateRegistry.ownsRun(identity, labels.seal)) {
+      || !stateRegistry.ownsRun(identity, labels.seal, labels.legacy)) {
       cleanupFailed.add(labels.run)
       continue
     }
@@ -843,15 +959,19 @@ export async function reconcileDockerResources(docker, brokerContainer, stateReg
   return [...activeLineages]
 }
 
-function validResourceLabels(value, namespace, container) {
+function validResourceLabels(value, namespace, container, expectedProvider = "codex") {
   if (!isRecord(value)) return undefined
+  const provider = value["org.threadwire.provider"] ?? "codex"
+  const legacy = value["org.threadwire.provider"] === undefined
   const expectedKeys = [
     "org.threadwire.owner", "org.threadwire.namespace", "org.threadwire.run",
     "org.threadwire.lineage", "org.threadwire.task", "org.threadwire.state-volume",
     "org.threadwire.run-seal",
+    ...(legacy ? [] : ["org.threadwire.provider"]),
     ...(container ? ["org.threadwire.network"] : [])
   ]
-  if (Object.keys(value).length !== expectedKeys.length || expectedKeys.some((key) => typeof value[key] !== "string")) return undefined
+  if (provider !== expectedProvider || (legacy && provider !== "codex")
+    || Object.keys(value).length !== expectedKeys.length || expectedKeys.some((key) => typeof value[key] !== "string")) return undefined
   const run = value["org.threadwire.run"]
   const lineage = value["org.threadwire.lineage"]
   const volume = value["org.threadwire.state-volume"]
@@ -862,20 +982,22 @@ function validResourceLabels(value, namespace, container) {
     || !/^[0-9a-f]{64}$/u.test(seal)
     || volume !== `threadwire-state-${namespace}-${lineage}`
     || (container && value["org.threadwire.network"] !== `${run}-net`)) return undefined
-  return {run, lineage, volume, seal, task: value["org.threadwire.task"], namespace}
+  return {provider, legacy, run, lineage, volume, seal, task: value["org.threadwire.task"], namespace}
 }
 
 function ownedContainerIdentity(container, labels) {
   if (!isRecord(container) || container.Name !== `/${labels.run}-worker`
     || !isRecord(container.Config) || !isRecord(container.HostConfig)
     || container.Config.Image !== container.Image || !isDigestImage(container.Config.Image)
-    || JSON.stringify(container.Config.Entrypoint) !== JSON.stringify(["/usr/local/libexec/threadwire/worker-entrypoint"])
+    || JSON.stringify(container.Config.Entrypoint) !== JSON.stringify(labels.provider === "kimi"
+      ? ["node", "/opt/threadwire/docker/kimi-worker-entrypoint.mjs"]
+      : ["/usr/local/libexec/threadwire/worker-entrypoint"])
     || ![null, undefined].includes(container.Config.Cmd) || container.Config.User !== "10002:10002"
     || typeof container.Config.WorkingDir !== "string" || !within("/worktree", container.Config.WorkingDir)
     || container.HostConfig.NetworkMode !== `${labels.run}-net`
-    || !validWorkerSecurity(container.Config, container.HostConfig)
+    || !validWorkerSecurity(container.Config, container.HostConfig, labels.provider)
     || !Array.isArray(container.HostConfig.Mounts) || container.HostConfig.Mounts.length !== 2) return undefined
-  const inspectedLabels = validResourceLabels(container.Config.Labels, labels.namespace, true)
+  const inspectedLabels = validResourceLabels(container.Config.Labels, labels.namespace, true, labels.provider)
   if (!inspectedLabels || JSON.stringify(inspectedLabels) !== JSON.stringify(labels)) return undefined
   const state = container.HostConfig.Mounts.find((mount) => mount?.Target === "/home/worker")
   const worktree = container.HostConfig.Mounts.find((mount) => mount?.Target === "/worktree")
@@ -885,7 +1007,7 @@ function ownedContainerIdentity(container, labels) {
   return runIdentityFrom(labels, container.Config.Image, worktree)
 }
 
-function validWorkerSecurity(config, host) {
+function validWorkerSecurity(config, host, provider = "codex") {
   if (host.AutoRemove !== false || host.ReadonlyRootfs !== true
     || host.Privileged === true || JSON.stringify(host.CapDrop) !== JSON.stringify(["ALL"])
     || JSON.stringify(host.CapAdd ?? null) !== "null"
@@ -910,8 +1032,20 @@ function validWorkerSecurity(config, host) {
   if (![undefined, "", "private"].includes(host.PidMode) || ![undefined, "", "private"].includes(host.IpcMode)
     || ![undefined, ""].includes(host.UTSMode) || ![undefined, ""].includes(host.UsernsMode)
     || ![undefined, "", "private"].includes(host.CgroupnsMode) || host.PublishAllPorts === true) return false
-  if (!Array.isArray(config.Env) || config.Env.length !== 13 + (config.Env.some((entry) => entry.startsWith("THREADWIRE_RESUME_SESSION=")) ? 1 : 0)) return false
+  if (!Array.isArray(config.Env)) return false
   const names = config.Env.map((entry) => entry.split("=", 1)[0])
+  const resumeCount = names.filter((name) => name === "THREADWIRE_RESUME_SESSION").length
+  if (resumeCount > 1) return false
+  if (provider === "kimi") {
+    const expected = [
+      "HOME", "TMPDIR", "THREADWIRE_PROMPT", "THREADWIRE_WORKTREE_INODE", "THREADWIRE_CWD_INODE",
+      "KIMI_CODE_HOME", "THREADWIRE_KIMI_MODEL", "THREADWIRE_KIMI_BROKER_URL", "THREADWIRE_KIMI_BROKER_TOKEN"
+    ]
+    return names.length === expected.length + resumeCount
+      && expected.every((name) => names.filter((entry) => entry === name).length === 1)
+      && !names.some((name) => /^(?:CODEX|OPENAI|TELEGRAM|THREADWIRE_KIMI_(?:OAUTH|CONTROL))/u.test(name))
+  }
+  if (config.Env.length !== 13 + resumeCount) return false
   const expected = [
     "HOME", "CODEX_HOME", "TMPDIR", "OPENAI_BASE_URL", "OPENAI_API_KEY", "CODEX_API_KEY",
     "THREADWIRE_PROMPT", "THREADWIRE_CODEX_ARGUMENTS", "THREADWIRE_WORKTREE_INODE", "THREADWIRE_CWD_INODE"
@@ -927,7 +1061,7 @@ function ownedNetworkIdentity(network, labels, identity, brokerContainer) {
     || network.EnableIPv6 !== false || network.Attachable !== false || network.Ingress !== false
     || network.ConfigOnly !== false || !isRecord(network.Options) || Object.keys(network.Options).length !== 0
     || !isRecord(network.Containers)) return undefined
-  const inspectedLabels = validResourceLabels(network.Labels, labels.namespace, false)
+  const inspectedLabels = validResourceLabels(network.Labels, labels.namespace, false, labels.provider)
   if (!inspectedLabels || JSON.stringify(inspectedLabels) !== JSON.stringify(labels)) return undefined
   const endpoints = Object.values(network.Containers)
   if (endpoints.some((endpoint) => !isRecord(endpoint)
@@ -951,7 +1085,7 @@ function validWorktreeMount(mount) {
 
 function runIdentityFrom(labels, image, worktree) {
   return {
-    namespace: labels.namespace, run: labels.run, lineage: labels.lineage, task: labels.task,
+    provider: labels.provider, namespace: labels.namespace, run: labels.run, lineage: labels.lineage, task: labels.task,
     volume: labels.volume, network: `${labels.run}-net`, container: `${labels.run}-worker`,
     image, worktreeType: worktree.Type, worktreeSource: worktree.Source,
     worktreeSubpath: worktree.Type === "volume" ? worktree.VolumeOptions.Subpath : ""
@@ -961,6 +1095,7 @@ function runIdentityFrom(labels, image, worktree) {
 function expectedRunIdentity(options, run, network, state, worktreeSubpath) {
   const volumeMode = options.worktreeVolume !== undefined
   return {
+    provider: options.preflight.provider ?? "codex",
     namespace: options.stateRegistry.namespace, run, lineage: state.lineage,
     task: state.labels["org.threadwire.task"], volume: state.volume, network,
     container: `${run}-worker`, image: options.workerImage,