threadwire 0.1.11 → 0.1.13

package/src/telegram-ingress/core.js

@@ -10,7 +10,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,8 +26,9 @@ import {parseCodeCommand, parseEvidenceCommand} from "./command.js"
  *   Relay?: typeof Relay,
  *   processNumber?: number,
  *   providerEnvironment?: NodeJS.ProcessEnv,
- *   workspaceProfileOperations?: import("../workspace-profile.js").WorkspaceProfileOperations,
- *   activity?: Pick<import("../activity-log.js").ActivityLog, "recordWorkspace" | "recordStarted" | "recordSession" | "close">,
+ *   cwd?: string,
+ *   kimiBinding?: unknown,
+ *   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">,
@@ -96,9 +96,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")
@@ -111,32 +108,26 @@ 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 workspace = await resolveWorkspaceProfile(
-    {provider: job.provider},
-    dependencies.workspaceProfileOperations
-  )
+  const cwd = dependencies.cwd ?? process.cwd()
+  const kimiBinding = job.provider === "kimi" ? dependencies.kimiBinding : undefined
   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,
-      repositoryRoot: workspace.repositoryRoot,
-      cwd: workspace.cwd,
+      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({
@@ -163,9 +154,10 @@ export async function dispatchWorker(job, config, dependencies = {}) {
       try {
         const preflight = earlyKimiPreflight ?? await isolatedRuntimeClient.preflight({
           provider: job.provider,
-          profile: workspace.profile,
-          repositoryRoot: workspace.repositoryRoot,
-          cwd: workspace.cwd,
+          profile: "explicit-isolation",
+          ...(job.provider === "kimi"
+            ? {binding: kimiBinding}
+            : {repositoryRoot: cwd, cwd}),
           providerArguments: []
         })
         const exitCode = await isolatedRuntimeClient.run({
@@ -239,8 +231,9 @@ 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,
       onEvent: async (event) => control.accept(event),
       onSpawn: (pid) => {
@@ -260,11 +253,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 {

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

@@ -6,6 +6,7 @@ import {EvidenceStore} from "./evidence-store.js"
 import {buildProviderEnvironment, parseIngressConfig, resolveIngressEnvironment} from "./telegram-ingress/config.js"
 import {createWebhookHandler} from "./telegram-ingress/http.js"
 import {isolatedRuntimeClientFromEnvironment, kimiIsolatedRuntimeClientFromEnvironment} from "./isolated-runtime-client.js"
+import {parseTrustedThreadwireBinding} from "./threadwire-binding.js"
 
 /**
  * Start the standalone Threadwire Telegram webhook service.
@@ -16,7 +17,7 @@ import {isolatedRuntimeClientFromEnvironment, kimiIsolatedRuntimeClientFromEnvir
  *   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]
@@ -33,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
@@ -43,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"
@@ -55,6 +65,7 @@ export async function startTelegramWebhook(options = {}) {
     providerEnvironment,
     ...(isolatedRuntimeClient === undefined ? {} : {isolatedRuntimeClient}),
     ...(kimiIsolatedRuntimeClient === undefined ? {} : {kimiIsolatedRuntimeClient}),
+    ...(kimiBinding === undefined ? {} : {kimiBinding}),
     onOperationalError,
     onWorkerFailure
   })

package/src/threadwire-binding.js

@@ -0,0 +1,192 @@
+// @ts-nocheck
+
+import {createHash} from "node:crypto"
+import {isAbsolute, normalize, relative} from "node:path"
+
+const UUID = /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/u
+const VOLUME = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/u
+const REVISION = /^[0-9a-f]{40}$/u
+const DIGEST = /^sha256:[0-9a-f]{64}$/u
+const CONTAINER_ID = /^[0-9a-f]{64}$/u
+const POSITIVE_ID = /^[1-9]\d{0,9}$/u
+const MAX_ID = 2_147_483_647
+const MAX_MANIFEST_BYTES = 1_048_576
+const MAX_CONTEXT_ENTRIES = 4_096
+const MAX_CONTEXT_BYTES = 67_108_864
+
+/**
+ * Parse the closed Threadwire binding transport schema. This function is the
+ * single authority for a binding: callers must not re-parse loose fields.
+ * @param {unknown} value
+ */
+export function parseThreadwireBinding(value) {
+  if (!record(value) || !exactKeys(value, ["version", "taskId", "source", "context", "runtime", "leaseContainerId"])
+    || value.version !== 1 || !canonicalUuid(value.taskId) || !CONTAINER_ID.test(value.leaseContainerId)) failBinding()
+  const source = parseSource(value.source)
+  const context = parseContext(value.context)
+  const runtime = parseRuntime(value.runtime)
+  if (source.volume === context.volume || runtime.workdir !== "/workspace" && !within("/workspace", runtime.workdir)) failBinding()
+  return {
+    version: 1,
+    taskId: value.taskId,
+    source,
+    context,
+    runtime,
+    leaseContainerId: value.leaseContainerId
+  }
+}
+
+/**
+ * Parse the trusted launcher transport without retaining or reporting its raw
+ * text. A binding is control metadata, but still never belongs in a provider
+ * or worker environment.
+ * @param {unknown} value
+ */
+export function parseTrustedThreadwireBinding(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 32_768) failBinding()
+  try { return parseThreadwireBinding(JSON.parse(value)) } catch { failBinding() }
+}
+
+/** @param {ReturnType<typeof parseThreadwireBinding>} binding */
+export function canonicalThreadwireBinding(binding) {
+  const parsed = parseThreadwireBinding(binding)
+  return JSON.stringify({
+    version: parsed.version,
+    taskId: parsed.taskId,
+    source: {
+      volume: parsed.source.volume, target: parsed.source.target,
+      readOnly: parsed.source.readOnly, revision: parsed.source.revision
+    },
+    context: {
+      volume: parsed.context.volume, target: parsed.context.target,
+      readOnly: parsed.context.readOnly,
+      digests: {manifest: parsed.context.digests.manifest, content: parsed.context.digests.content},
+      imageId: parsed.context.imageId
+    },
+    runtime: {uid: parsed.runtime.uid, gid: parsed.runtime.gid, workdir: parsed.runtime.workdir},
+    leaseContainerId: parsed.leaseContainerId
+  })
+}
+
+/** @param {ReturnType<typeof parseThreadwireBinding>} binding */
+export function threadwireBindingDigest(binding) {
+  return `sha256:${createHash("sha256").update(canonicalThreadwireBinding(binding)).digest("hex")}`
+}
+
+/**
+ * A stable identity for state adoption. It intentionally excludes only the
+ * mutable source commit and recreatable lease identifier.
+ * @param {ReturnType<typeof parseThreadwireBinding>} binding
+ */
+export function resumeTaskIdentity(binding) {
+  const parsed = parseThreadwireBinding(binding)
+  return JSON.stringify({
+    version: parsed.version,
+    taskId: parsed.taskId,
+    source: {volume: parsed.source.volume, target: parsed.source.target, readOnly: parsed.source.readOnly},
+    context: {
+      volume: parsed.context.volume, target: parsed.context.target,
+      digests: {manifest: parsed.context.digests.manifest, content: parsed.context.digests.content},
+      imageId: parsed.context.imageId
+    },
+    runtime: parsed.runtime
+  })
+}
+
+/** @param {Buffer | string} bytes */
+export function parseContextManifest(bytes) {
+  const buffer = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)
+  if (buffer.length === 0 || buffer.length > MAX_MANIFEST_BYTES) failManifest()
+  let value
+  try { value = JSON.parse(buffer.toString("utf8")) } catch { failManifest() }
+  if (!record(value) || !exactKeys(value, ["version", "taskId", "imageId", "content", "entries"])
+    || value.version !== 1 || !canonicalUuid(value.taskId) || !DIGEST.test(value.imageId) || !DIGEST.test(value.content)
+    || !Array.isArray(value.entries) || value.entries.length > MAX_CONTEXT_ENTRIES) failManifest()
+  let previous
+  let total = 0
+  const entries = value.entries.map((entry) => {
+    if (!record(entry) || !exactKeys(entry, ["path", "type", "mode", "bytes", "sha256"])
+      || !contextPath(entry.path) || entry.type !== "file" || !Number.isSafeInteger(entry.mode) || entry.mode < 0 || entry.mode > 0o777 || (entry.mode & 0o222) !== 0
+      || !Number.isSafeInteger(entry.bytes) || entry.bytes < 0 || entry.bytes > MAX_CONTEXT_BYTES || !DIGEST.test(entry.sha256)) failManifest()
+    if (previous !== undefined && Buffer.compare(Buffer.from(previous), Buffer.from(entry.path)) >= 0) failManifest()
+    previous = entry.path
+    total += entry.bytes
+    if (total > MAX_CONTEXT_BYTES) failManifest()
+    return {path: entry.path, type: "file", mode: entry.mode, bytes: entry.bytes, sha256: entry.sha256}
+  })
+  return {version: 1, taskId: value.taskId, imageId: value.imageId, content: value.content, entries}
+}
+
+/** @param {ReturnType<typeof parseContextManifest>} manifest */
+export function canonicalContextInventory(manifest) {
+  const parsed = parseContextManifest(Buffer.from(JSON.stringify(manifest)))
+  return JSON.stringify(parsed.entries.map((entry) => ({
+    path: entry.path, type: entry.type, mode: entry.mode, bytes: entry.bytes, sha256: entry.sha256
+  })))
+}
+
+/** @param {ReturnType<typeof parseContextManifest>} manifest */
+export function contextInventoryDigest(manifest) {
+  return `sha256:${createHash("sha256").update(canonicalContextInventory(manifest)).digest("hex")}`
+}
+
+/**
+ * Bind a parsed manifest to the exact task and immutable image of the active
+ * binding before any inventory is accepted.
+ * @param {ReturnType<typeof parseContextManifest>} manifest
+ * @param {unknown} taskId
+ * @param {unknown} imageId
+ */
+export function assertContextManifestIdentity(manifest, taskId, imageId) {
+  if (!canonicalUuid(taskId) || typeof imageId !== "string" || !DIGEST.test(imageId)
+    || manifest.taskId !== taskId || manifest.imageId !== imageId) failManifest()
+}
+
+/** @param {unknown} value */
+function parseSource(value) {
+  // readOnly selects the exact admitted mount mode: false is a writable
+  // implementation source, true an explicitly read-only review source.
+  if (!record(value) || !exactKeys(value, ["volume", "target", "readOnly", "revision"])
+    || !VOLUME.test(value.volume) || value.target !== "/workspace" || typeof value.readOnly !== "boolean" || !REVISION.test(value.revision)) failBinding()
+  return {volume: value.volume, target: value.target, readOnly: value.readOnly, revision: value.revision}
+}
+
+/** @param {unknown} value */
+function parseContext(value) {
+  if (!record(value) || !exactKeys(value, ["volume", "target", "readOnly", "digests", "imageId"])
+    || !VOLUME.test(value.volume) || value.target !== "/context" || value.readOnly !== true || !DIGEST.test(value.imageId)
+    || !record(value.digests) || !exactKeys(value.digests, ["manifest", "content"])
+    || !DIGEST.test(value.digests.manifest) || !DIGEST.test(value.digests.content)) failBinding()
+  return {
+    volume: value.volume, target: value.target, readOnly: value.readOnly,
+    digests: {manifest: value.digests.manifest, content: value.digests.content}, imageId: value.imageId
+  }
+}
+
+/** @param {unknown} value */
+function parseRuntime(value) {
+  if (!record(value) || !exactKeys(value, ["uid", "gid", "workdir"])
+    || !safeContainerId(value.uid) || !safeContainerId(value.gid) || typeof value.workdir !== "string"
+    || !isAbsolute(value.workdir) || normalize(value.workdir) !== value.workdir) failBinding()
+  return {uid: value.uid, gid: value.gid, workdir: value.workdir}
+}
+
+/** @param {unknown} value */
+function safeContainerId(value) { return typeof value === "number" && Number.isSafeInteger(value) && POSITIVE_ID.test(String(value)) && value <= MAX_ID }
+/** @param {unknown} value */
+function canonicalUuid(value) { return typeof value === "string" && UUID.test(value) }
+/** @param {string} root @param {string} path */
+function within(root, path) { const path_ = relative(root, path); return path_ === "" || (!path_.startsWith("..") && !isAbsolute(path_)) }
+/** @param {unknown} value */
+function contextPath(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 1024 && !value.startsWith("/")
+    && !value.includes("\\") && value.split("/").every((part) => part !== "" && part !== "." && part !== "..")
+}
+/** @param {unknown} value @param {string[]} keys */
+function exactKeys(value, keys) { return record(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key)) }
+/** @param {unknown} value */
+function record(value) { return typeof value === "object" && value !== null && !Array.isArray(value) }
+/** Fail without reflecting untrusted binding input. */
+function failBinding() { throw new Error("Threadwire binding is invalid") }
+/** Fail without reflecting untrusted manifest input. */
+function failManifest() { throw new Error("Threadwire context manifest is invalid") }

package/src/workspace-profile.js

@@ -1,189 +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"
-
-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")[]}} WorkspaceProfile
- * @typedef {{version: 1, defaultProfile: string, profiles: Record<string, WorkspaceProfile>}} WorkspaceProfilesConfig
- * @typedef {{profile: string, repositoryRoot: string, cwd: string, revision: string, sourceIdentity: string}} 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 || 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, ["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)
-    profiles[name] = {repositoryRoot, cwd: resolve(cwd), providers}
-  }
-  if (!Object.hasOwn(profiles, value.defaultProfile)) {
-    throw new Error("Workspace profile configuration is invalid")
-  }
-  return {version: 1, defaultProfile: value.defaultProfile, profiles}
-}
-
-/**
- * Resolve a reviewed workspace profile to a validated in-container workspace.
- * @param {{provider: "codex" | "claude" | "kimi" | "opencode", profile?: string}} 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)
-  }
-  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,11 +0,0 @@
-{
-  "version": 1,
-  "defaultProfile": "container-runtime",
-  "profiles": {
-    "container-runtime": {
-      "repositoryRoot": "/workspace/threadwire",
-      "cwd": "/workspace/threadwire",
-      "providers": ["codex", "kimi"]
-    }
-  }
-}