threadwire 0.1.12 → 0.1.14

package/src/telegram-ingress/core.js

@@ -1,6 +1,7 @@
 // @ts-check
 
 import {createHash, randomUUID, timingSafeEqual} from "node:crypto"
+import {abortable} from "../absolute-deadline.js"
 import {evidenceTelegramDestination} from "../evidence-store.js"
 import {NoticeQueue} from "../notice-queue.js"
 import {createFetchTransport} from "../notifiers/fetch-transport.js"
@@ -10,7 +11,6 @@ import {kimiSessionEnvelopeId} from "../providers/kimi.js"
 import {Relay} from "../relay.js"
 import {runWorker} from "../run-worker.js"
 import {WorkerControl} from "../worker-control.js"
-import {resolveWorkspaceProfile} from "../workspace-profile.js"
 import {buildProviderEnvironment, collectEvidenceRedactions} from "./config.js"
 import {parseCodeCommand, parseEvidenceCommand} from "./command.js"
 
@@ -27,12 +27,12 @@ import {parseCodeCommand, parseEvidenceCommand} from "./command.js"
  *   Relay?: typeof Relay,
  *   processNumber?: number,
  *   providerEnvironment?: NodeJS.ProcessEnv,
+ *   cwd?: string,
  *   kimiBinding?: unknown,
- *   workspaceProfileOperations?: import("../workspace-profile.js").WorkspaceProfileOperations,
- *   activity?: Pick<import("../activity-log.js").ActivityLog, "recordWorkspace" | "recordStarted" | "recordSession" | "close">,
+ *   activity?: Pick<import("../activity-log.js").ActivityLog, "recordStarted" | "recordSession" | "close">,
  *   evidenceStore?: import("../evidence-store.js").EvidenceStore,
- *   isolatedRuntimeClient?: Pick<import("../isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "run">,
- *   kimiIsolatedRuntimeClient?: Pick<import("../isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "run">,
+ *   isolatedRuntimeClient?: Pick<import("../isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "startRun">,
+ *   kimiIsolatedRuntimeClient?: Pick<import("../isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "startRun">,
  *   onWorkerFailure?: (message: string) => void,
  *   onWorkerSettled?: () => void
  * }} IngressDependencies
@@ -97,9 +97,6 @@ export function interpretUpdate(update, config) {
  */
 export async function dispatchWorker(job, config, dependencies = {}) {
   if ("type" in job) throw new Error("Worker dispatch requires a worker job")
-  if (job.provider === "kimi" && dependencies.kimiIsolatedRuntimeClient === undefined) {
-    throw new Error("Kimi isolated runtime is required")
-  }
   if (job.provider === "codex" && config.requireCodexIsolation === true
     && dependencies.isolatedRuntimeClient === undefined) {
     throw new Error("Codex isolated runtime is required")
@@ -112,65 +109,74 @@ export async function dispatchWorker(job, config, dependencies = {}) {
   const NoticeQueueImpl = dependencies.NoticeQueue ?? NoticeQueue
   const RelayImpl = dependencies.Relay ?? Relay
   const processNumber = dependencies.processNumber ?? process.pid
-  // Explicit only: never fall back to ambient process.env (avoids secret leakage).
-  const providerEnvironment = buildProviderEnvironment(dependencies.providerEnvironment ?? {})
+  const cwd = dependencies.cwd ?? process.cwd()
   const kimiBinding = job.provider === "kimi" ? dependencies.kimiBinding : undefined
-  const workspace = await resolveWorkspaceProfile(
-    {provider: job.provider, ...(kimiBinding === undefined ? {} : {binding: kimiBinding})},
-    dependencies.workspaceProfileOperations
-  )
   const isolatedRuntimeClient = job.provider === "kimi"
     ? dependencies.kimiIsolatedRuntimeClient
     : job.provider === "codex" ? dependencies.isolatedRuntimeClient : undefined
-  const earlyKimiPreflight = job.provider === "kimi"
+  // Explicit only: never fall back to ambient process.env (avoids secret leakage).
+  const providerEnvironment = buildProviderEnvironment(dependencies.providerEnvironment ?? {}, {
+    provider: job.provider,
+    isolated: isolatedRuntimeClient !== undefined
+  })
+  const earlyKimiPreflight = job.provider === "kimi" && isolatedRuntimeClient !== undefined
     ? await /** @type {NonNullable<typeof isolatedRuntimeClient>} */ (isolatedRuntimeClient).preflight({
       provider: "kimi",
-      profile: workspace.profile,
+      profile: "explicit-isolation",
       binding: kimiBinding,
       providerArguments: []
     })
     : undefined
 
-  const provider = createProviderImpl(job.provider, [], job.prompt, undefined, providerEnvironment)
-  dependencies.activity?.recordWorkspace(
-    workspace.profile,
-    workspace.repositoryRoot,
-    workspace.revision,
-    workspace.sourceIdentity
-  )
-  const transport = createFetchTransportImpl(config.botToken, undefined, config.telegramRequestTimeoutMs)
-  const sender = createTelegramSenderImpl(job.target, transport)
-  const control = new WorkerControlImpl({
-    sender,
-    processNumber,
-    toolMessages: config.toolMessages ?? false,
-    NoticeQueueClass: NoticeQueueImpl,
-    RelayClass: RelayImpl
-  })
-  const evidenceOwner = dependencies.evidenceStore?.createOwnerScope({
-    destinationId: evidenceTelegramDestination(job.target, job.senderId),
-    runId: randomUUID()
-  })
-  const evidence = evidenceOwner === undefined ? undefined : await dependencies.evidenceStore?.createArtifact(evidenceOwner, {
-    contentType: "text/plain; charset=utf-8",
-    redactions: await collectEvidenceRedactions(dependencies.providerEnvironment ?? {})
-  })
+  /** @type {ReturnType<typeof createProvider>} */
+  let provider
+  /** @type {ReturnType<typeof createTelegramSender>} */
+  let sender
+  /** @type {WorkerControl} */
+  let control
+  /** @type {Awaited<ReturnType<import("../evidence-store.js").EvidenceStore["createArtifact"]>> | undefined} */
+  let evidence
+  try {
+    provider = createProviderImpl(job.provider, [], job.prompt, undefined, providerEnvironment)
+    const transport = createFetchTransportImpl(config.botToken, undefined, config.telegramRequestTimeoutMs)
+    sender = createTelegramSenderImpl(job.target, transport)
+    control = new WorkerControlImpl({
+      sender,
+      processNumber,
+      toolMessages: config.toolMessages ?? false,
+      NoticeQueueClass: NoticeQueueImpl,
+      RelayClass: RelayImpl
+    })
+    const evidenceOwner = dependencies.evidenceStore?.createOwnerScope({
+      destinationId: evidenceTelegramDestination(job.target, job.senderId),
+      runId: randomUUID()
+    })
+    evidence = evidenceOwner === undefined ? undefined : await dependencies.evidenceStore?.createArtifact(evidenceOwner, {
+      contentType: "text/plain; charset=utf-8",
+      redactions: await collectEvidenceRedactions(dependencies.providerEnvironment ?? {})
+    })
+  } catch (error) {
+    earlyKimiPreflight?.deadline?.close()
+    throw error
+  }
   let evidenceTransferred = false
   try {
     await evidence?.append("prompt", `prompt\n${job.prompt}\nprovider-stream\n`)
 
     if (isolatedRuntimeClient !== undefined) {
       evidenceTransferred = true
+      let isolatedDeadline = earlyKimiPreflight?.deadline
       try {
         const preflight = earlyKimiPreflight ?? await isolatedRuntimeClient.preflight({
           provider: job.provider,
-          profile: workspace.profile,
+          profile: "explicit-isolation",
           ...(job.provider === "kimi"
             ? {binding: kimiBinding}
-            : {repositoryRoot: workspace.repositoryRoot, cwd: workspace.cwd}),
+            : {repositoryRoot: cwd, cwd}),
           providerArguments: []
         })
-        const exitCode = await isolatedRuntimeClient.run({
+        isolatedDeadline = preflight.deadline
+        const isolatedRun = isolatedRuntimeClient.startRun({
           preflightId: preflight.preflightId,
           prompt: job.prompt,
           providerArguments: [],
@@ -185,6 +191,13 @@ export async function dispatchWorker(job, config, dependencies = {}) {
             onStderrChunk: (chunk) => evidence?.append("provider-stderr", chunk)
           })
         })
+        let exitCode
+        try {
+          exitCode = await abortable(isolatedRun.completion, preflight.deadline?.signal)
+        } catch (error) {
+          await isolatedRun.cancel(error instanceof Error ? error : new Error("Isolated runtime run failed"))
+          throw error
+        }
         if (exitCode !== 0) throw new Error(`Isolated ${job.provider === "kimi" ? "Kimi" : "Codex"} worker exited with status ${exitCode}`)
         await control.close()
         if (evidence !== undefined) {
@@ -197,6 +210,7 @@ export async function dispatchWorker(job, config, dependencies = {}) {
         await evidence?.abort()
         throw error
       } finally {
+        isolatedDeadline?.close()
         dependencies.onWorkerSettled?.()
       }
     }
@@ -241,9 +255,11 @@ export async function dispatchWorker(job, config, dependencies = {}) {
     const running = runWorkerImpl({
       executable: provider.executable,
       arguments: provider.arguments,
-      cwd: workspace.cwd,
+      cwd,
       environment: providerEnvironment,
+      provider: provider.name,
       parse: provider.parse,
+      ...(provider.completion === undefined ? {} : {completion: provider.completion}),
       onEvent: async (event) => control.accept(event),
       onSpawn: (pid) => {
         if (pid !== undefined) dependencies.activity?.recordStarted(provider.name, pid)
@@ -262,11 +278,22 @@ export async function dispatchWorker(job, config, dependencies = {}) {
     // reported. Always notify settlement so concurrency slots are released.
     evidenceTransferred = true
     void (async () => {
+      /** @type {Error | undefined} */
+      let nativeKimiExitFailure
       try {
         try {
-          await running
+          const exitCode = await running
+          if (job.provider === "kimi" && spawnGate.settled) {
+            nativeKimiExitFailure = exitCode === 0 ? undefined : new Error(`Kimi worker exited with status ${exitCode}`)
+            await control.accept({
+              type: "lifecycle",
+              phase: exitCode === 0 ? "completed" : "failed",
+              summary: exitCode === 0 ? "Kimi worker completed" : "Kimi worker failed"
+            })
+            if (nativeKimiExitFailure !== undefined) throw nativeKimiExitFailure
+          }
         } catch (error) {
-          const failure = error instanceof Error ? error : new Error(safeFailureMessage(error))
+          const failure = nativeKimiExitFailure ?? (error instanceof Error ? error : new Error(safeFailureMessage(error)))
           if (spawnGate.settled) {
             reportBackgroundFailure(failure)
           } else {
@@ -316,7 +343,11 @@ export async function dispatchWorker(job, config, dependencies = {}) {
 
     await spawned
   } finally {
-    if (!evidenceTransferred) await evidence?.abort()
+    try {
+      if (!evidenceTransferred) await evidence?.abort()
+    } finally {
+      earlyKimiPreflight?.deadline?.close()
+    }
   }
 }
 

package/src/telegram-ingress/http.js

@@ -3,7 +3,6 @@
 import {createConcurrencyLimiter} from "./concurrency.js"
 import {dispatchEvidenceRead, dispatchWorker, interpretUpdate, secretsEqual} from "./core.js"
 import {createUpdateGuard, parseUpdateId} from "./update-guard.js"
-import {WorkspaceProviderMismatchError} from "../workspace-profile.js"
 
 export const MAX_WEBHOOK_BODY_BYTES = 65_536
 export const WEBHOOK_PATH = "/webhook"
@@ -159,11 +158,6 @@ async function handleRequest(request, response, config, dependencies) {
       // Safety release for failures before the observer is installed (e.g. provider setup).
       // Idempotent with onWorkerSettled via slotHeld.
       releaseSlot()
-      if (error instanceof WorkspaceProviderMismatchError) {
-        dependencies.updateGuard.complete(updateId)
-        send(response, 200)
-        return
-      }
       dependencies.updateGuard.release(updateId)
       const message = error instanceof Error ? error.message : "Worker launch failed"
       dependencies.onOperationalError?.(message)

package/src/telegram-webhook.js

@@ -17,7 +17,7 @@ import {parseTrustedThreadwireBinding} from "./threadwire-binding.js"
  *   onOperationalError?: (message: string) => void,
  *   onWorkerFailure?: (message: string) => void,
  *   providerEnvironment?: NodeJS.ProcessEnv,
- *   activity?: Pick<ActivityLog, "recordWorkspace" | "recordStarted" | "recordSession" | "close">,
+ *   activity?: Pick<ActivityLog, "recordStarted" | "recordSession" | "close">,
  *   evidenceStore?: EvidenceStore,
  *   handlerDependencies?: import("./telegram-ingress/http.js").WebhookDependencies
  * }} [options]
@@ -25,14 +25,6 @@ import {parseTrustedThreadwireBinding} from "./threadwire-binding.js"
  */
 export async function startTelegramWebhook(options = {}) {
   const environment = await resolveIngressEnvironment(options.env ?? process.env)
-  // Capture this trusted topology attestation before anything derives a
-  // provider environment. The parsed object is passed only to Kimi preflight.
-  // Codex-only Compose renders the variable as an empty string; a blank value
-  // means "absent", while a malformed non-blank value still fails closed.
-  const rawKimiBinding = environment.THREADWIRE_KIMI_TASK_BINDING
-  const kimiBinding = rawKimiBinding === undefined || rawKimiBinding.trim().length === 0
-    ? undefined
-    : parseTrustedThreadwireBinding(rawKimiBinding)
   const config = parseIngressConfig(environment)
   const createServerImpl = options.createServerImpl ?? createServer
   const onOperationalError = options.onOperationalError ?? defaultOperationalError
@@ -42,7 +34,10 @@ export async function startTelegramWebhook(options = {}) {
   // Strip ingress/Telegram secrets before they enter the worker dependency chain.
   // Never pass ambient process.env through unfiltered.
   const providerEnvironment = buildProviderEnvironment(
-    options.providerEnvironment ?? environment
+    options.providerEnvironment ?? environment,
+    // dispatchWorker applies the final provider/path-aware filter. Retain only
+    // the narrow native Kimi candidate configuration until it can do so.
+    {provider: "kimi"}
   )
   const isolatedConfigured = typeof environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN === "string"
     && environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN.trim().length > 0
@@ -52,6 +47,12 @@ export async function startTelegramWebhook(options = {}) {
     && environment.THREADWIRE_KIMI_ISOLATED_RUNTIME_CONTROL_TOKEN.trim().length > 0
   const kimiIsolatedRuntimeClient = options.handlerDependencies?.kimiIsolatedRuntimeClient
     ?? (kimiIsolatedConfigured ? kimiIsolatedRuntimeClientFromEnvironment(environment) : undefined)
+  // A task binding belongs solely to an explicitly selected isolated Kimi
+  // supervisor. Native Kimi neither reads nor validates this topology input.
+  const rawKimiBinding = environment.THREADWIRE_KIMI_TASK_BINDING
+  const kimiBinding = kimiIsolatedRuntimeClient === undefined || rawKimiBinding === undefined || rawKimiBinding.trim().length === 0
+    ? undefined
+    : parseTrustedThreadwireBinding(rawKimiBinding)
   const activity = options.activity ?? options.handlerDependencies?.activity ?? new ActivityLog("/var/lib/threadwire/activity/threadwire.jsonl")
   const evidenceStore = options.evidenceStore ?? options.handlerDependencies?.evidenceStore ?? await EvidenceStore.open({
     root: config.evidenceRoot ?? "/var/lib/threadwire/evidence"

package/src/workspace-profile.js

@@ -1,212 +0,0 @@
-// @ts-check
-
-import {execFile as nodeExecFile} from "node:child_process"
-import {readFile} from "node:fs/promises"
-import {dirname, join, resolve, sep} from "node:path"
-import {fileURLToPath} from "node:url"
-import {promisify} from "node:util"
-import {PROVIDERS} from "./providers/index.js"
-import {parseThreadwireBinding} from "./threadwire-binding.js"
-
-const execFile = promisify(nodeExecFile)
-const DEFAULT_PROFILES_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "threadwire.workspace-profiles.json")
-const REVISION_PATTERN = /^[0-9a-f]{40}$/u
-const SOURCE_IDENTITY_PATTERN = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/u
-const PROFILE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u
-
-/**
- * @typedef {{repositoryRoot: string, cwd: string, providers: ("codex" | "claude" | "kimi" | "opencode")[], bindings?: {kimi: "threadwire-v1"}}} WorkspaceProfile
- * @typedef {{version: 1 | 2, defaultProfile: string, profiles: Record<string, WorkspaceProfile>}} WorkspaceProfilesConfig
- * @typedef {{profile: string, repositoryRoot: string, cwd: string, revision: string, sourceIdentity: string, binding?: unknown}} ResolvedWorkspaceProfile
- * @typedef {{repositoryRoot: string, revision: string, sourceIdentity: string}} GitProvenance
- * @typedef {{
- *   readProfiles?: () => Promise<unknown>,
- *   directoryExists?: (path: string) => Promise<boolean>,
- *   resolveGitProvenance?: (cwd: string) => Promise<GitProvenance>
- * }} WorkspaceProfileOperations
- */
-
-/** @param {unknown} value @returns {WorkspaceProfilesConfig} */
-export function parseWorkspaceProfiles(value) {
-  if (!isRecord(value) || (value.version !== 1 && value.version !== 2) || typeof value.defaultProfile !== "string" || !isRecord(value.profiles)) {
-    throw new Error("Workspace profile configuration is invalid")
-  }
-  assertExactKeys(value, ["version", "defaultProfile", "profiles"])
-  /** @type {Record<string, WorkspaceProfile>} */
-  const profiles = {}
-  for (const [name, profile] of Object.entries(value.profiles)) {
-    if (!PROFILE_NAME_PATTERN.test(name) || !isRecord(profile)) throw new Error("Workspace profile configuration is invalid")
-    assertExactKeys(profile, value.version === 2 ? ["repositoryRoot", "cwd", "providers", "bindings"] : ["repositoryRoot", "cwd", "providers"])
-    const repositoryRoot = absoluteNormalizedPath(profile.repositoryRoot)
-    const cwd = absoluteAbsolutePath(profile.cwd)
-    if (cwd !== resolve(cwd) || !pathWithin(repositoryRoot, resolve(cwd))) {
-      throw new Error(`Workspace profile ${name} cwd must stay within its repository root`)
-    }
-    const providers = parseProviders(profile.providers)
-    let bindings
-    if (value.version === 2 && Object.hasOwn(profile, "bindings")) {
-      if (!isRecord(profile.bindings)) throw new Error("Workspace profile configuration is invalid")
-      assertExactKeys(profile.bindings, ["kimi"])
-      if (profile.bindings.kimi !== "threadwire-v1") throw new Error("Workspace profile configuration is invalid")
-      bindings = /** @type {{kimi: "threadwire-v1"}} */ ({kimi: "threadwire-v1"})
-    }
-    profiles[name] = {repositoryRoot, cwd: resolve(cwd), providers, ...(bindings === undefined ? {} : {bindings})}
-  }
-  if (!Object.hasOwn(profiles, value.defaultProfile)) {
-    throw new Error("Workspace profile configuration is invalid")
-  }
-  return {version: value.version, defaultProfile: value.defaultProfile, profiles}
-}
-
-/**
- * Resolve a reviewed workspace profile to a validated in-container workspace.
- * @param {{provider: "codex" | "claude" | "kimi" | "opencode", profile?: string, binding?: unknown}} selection
- * @param {WorkspaceProfileOperations} [operations]
- * @returns {Promise<ResolvedWorkspaceProfile>}
- */
-export async function resolveWorkspaceProfile(selection, operations = {}) {
-  const raw = await (operations.readProfiles ?? readProfiles)()
-  const config = parseWorkspaceProfiles(raw)
-  const profileName = selection.profile ?? config.defaultProfile
-  const profile = config.profiles[profileName]
-  if (!profile) throw new Error("--workspace-profile must name a configured workspace profile")
-  if (!profile.providers.includes(selection.provider)) {
-    throw new WorkspaceProviderMismatchError(profileName, selection.provider)
-  }
-  if (selection.provider === "kimi") {
-    if (config.version !== 2 || profile.bindings?.kimi !== "threadwire-v1" || selection.binding === undefined) {
-      throw new Error("Kimi requires Threadwire binding schema v1")
-    }
-    let binding
-    try { binding = parseThreadwireBinding(selection.binding) } catch { throw new Error("Kimi requires Threadwire binding schema v1") }
-    return {
-      profile: profileName,
-      repositoryRoot: binding.source.target,
-      cwd: binding.runtime.workdir,
-      revision: binding.source.revision,
-      sourceIdentity: binding.context.digests.content.slice("sha256:".length),
-      binding
-    }
-  }
-  const directoryExists = operations.directoryExists ?? defaultDirectoryExists
-  if (!await directoryExists(profile.repositoryRoot) || !await directoryExists(profile.cwd)) {
-    throw new Error(`Workspace profile ${profileName} workspace is unavailable`)
-  }
-  let provenance
-  try {
-    provenance = await (operations.resolveGitProvenance ?? defaultResolveGitProvenance)(profile.cwd)
-  } catch {
-    throw new Error(`Workspace profile ${profileName} workspace is unavailable`)
-  }
-  if (provenance.repositoryRoot !== profile.repositoryRoot) {
-    throw new Error(`Workspace profile ${profileName} workspace is unavailable`)
-  }
-  return {
-    profile: profileName,
-    repositoryRoot: profile.repositoryRoot,
-    cwd: profile.cwd,
-    revision: provenance.revision,
-    sourceIdentity: provenance.sourceIdentity
-  }
-}
-
-export class WorkspaceProviderMismatchError extends Error {
-  /** @param {string} profileName @param {string} provider */
-  constructor(profileName, provider) {
-    super(`Workspace profile ${profileName} does not allow provider ${provider}`)
-    this.name = "WorkspaceProviderMismatchError"
-  }
-}
-
-/** @returns {Promise<unknown>} */
-async function readProfiles() {
-  return JSON.parse(await readFile(DEFAULT_PROFILES_PATH, "utf8"))
-}
-
-/** @param {string} path @returns {Promise<boolean>} */
-async function defaultDirectoryExists(path) {
-  try {
-    const metadata = await import("node:fs/promises").then(({stat}) => stat(path))
-    return metadata.isDirectory()
-  } catch {
-    return false
-  }
-}
-
-/** @param {string} cwd @returns {Promise<GitProvenance>} */
-async function defaultResolveGitProvenance(cwd) {
-  const repositoryRoot = await gitText(cwd, ["rev-parse", "--show-toplevel"])
-  const revision = await gitText(cwd, ["rev-parse", "HEAD"])
-  const sourceIdentity = await readSourceIdentity(repositoryRoot, cwd)
-  if (!REVISION_PATTERN.test(revision) || !SOURCE_IDENTITY_PATTERN.test(sourceIdentity)) throw new Error("invalid workspace provenance")
-  return {repositoryRoot, revision, sourceIdentity}
-}
-
-/** @param {string} cwd @param {string[]} arguments_ */
-async function gitText(cwd, arguments_) {
-  const {stdout} = await execFile("git", ["-C", cwd, ...arguments_], {encoding: "utf8"})
-  return stdout.trim()
-}
-
-/** @param {string} repositoryRoot @param {string} cwd */
-async function readSourceIdentity(repositoryRoot, cwd) {
-  try {
-    return (await readFile(join(repositoryRoot, ".threadwire-source-identity"), "utf8")).trim()
-  } catch {
-    return gitText(cwd, ["rev-parse", "HEAD^{tree}"])
-  }
-}
-
-/** @param {unknown} value */
-function parseProviders(value) {
-  if (!Array.isArray(value) || value.length === 0) throw new Error("Workspace profile configuration is invalid")
-  /** @type {("codex" | "claude" | "kimi" | "opencode")[]} */
-  const providers = []
-  for (const entry of value) {
-    if (typeof entry !== "string") {
-      throw new Error("Workspace profile configuration is invalid")
-    }
-    const provider = /** @type {(typeof PROVIDERS)[number]} */ (entry)
-    if (!PROVIDERS.includes(provider) || providers.includes(provider)) {
-      throw new Error(typeof entry === "string" ? `Workspace profile configuration contains unknown provider ${entry}` : "Workspace profile configuration is invalid")
-    }
-    providers.push(provider)
-  }
-  return providers
-}
-
-/** @param {unknown} value */
-function absoluteNormalizedPath(value) {
-  if (typeof value !== "string") throw new Error("Workspace profile configuration is invalid")
-  const normalized = resolve(value)
-  if (!normalized.startsWith(sep) || value !== normalized) {
-    throw new Error("Workspace profile configuration is invalid")
-  }
-  return normalized
-}
-
-/** @param {unknown} value */
-function absoluteAbsolutePath(value) {
-  if (typeof value !== "string") throw new Error("Workspace profile configuration is invalid")
-  const normalized = resolve(value)
-  if (!normalized.startsWith(sep)) throw new Error("Workspace profile configuration is invalid")
-  return value
-}
-
-/** @param {string} root @param {string} child */
-function pathWithin(root, child) {
-  return child === root || child.startsWith(`${root}${sep}`)
-}
-
-/** @param {unknown} value @returns {value is Record<string, unknown>} */
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-/** @param {Record<string, unknown>} value @param {string[]} allowedKeys */
-function assertExactKeys(value, allowedKeys) {
-  const allowed = new Set(allowedKeys)
-  for (const key of Object.keys(value)) {
-    if (!allowed.has(key)) throw new Error("Workspace profile configuration is invalid")
-  }
-}

package/threadwire.workspace-profiles.json

@@ -1,12 +0,0 @@
-{
-  "version": 2,
-  "defaultProfile": "container-runtime",
-  "profiles": {
-    "container-runtime": {
-      "repositoryRoot": "/workspace/threadwire",
-      "cwd": "/workspace/threadwire",
-      "providers": ["codex", "kimi"],
-      "bindings": {"kimi": "threadwire-v1"}
-    }
-  }
-}