@iowarp/clio-coder 0.3.0

package/dist/chunk-BBUH4VAA.js

@@ -0,0 +1,1224 @@
+import {
+  shellQuote
+} from "./chunk-GOTUR54M.js";
+import {
+  atomicWrite
+} from "./chunk-UGYAX5YI.js";
+import {
+  clioStateDir
+} from "./chunk-X3NE4WVW.js";
+import {
+  readClioVersion,
+  resolvePackageRoot
+} from "./chunk-DXQNI4PC.js";
+
+// src/domains/dispatch/fleet-preflight.ts
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/domains/dispatch/route-facts.ts
+var ROUTE_FACT_FRESHNESS_MS = 15 * 60 * 1e3;
+function isFresh(probedAt, now, freshnessMs) {
+  const at = Date.parse(probedAt);
+  if (!Number.isFinite(at)) return false;
+  return at <= now && now - at <= freshnessMs;
+}
+function evaluateRouteFacts(facts, resources, requirement, options) {
+  const now = options?.now ?? Date.now();
+  const freshnessMs = options?.freshnessMs ?? ROUTE_FACT_FRESHNESS_MS;
+  const unknowns = [];
+  const fact = facts.find((entry) => entry.nodeId === requirement.nodeId && entry.targetId === requirement.targetId);
+  if (!fact) {
+    const unknowns2 = ["reachable", "runtimeCompatible", "modelAvailable"];
+    if (requirement.mode === "shadow") return { ok: true, unknowns: unknowns2 };
+    return {
+      ok: false,
+      reason: `no probe fact for target '${requirement.targetId}' on node '${requirement.nodeId}'; run 'clio-coder doctor'`,
+      unknowns: unknowns2
+    };
+  }
+  const fresh = isFresh(fact.probedAt, now, freshnessMs);
+  if (fact.endpointIdentityHash !== requirement.endpointIdentityHash) {
+    return {
+      ok: false,
+      reason: `node '${requirement.nodeId}' endpoint identity for target '${requirement.targetId}' does not match settings`,
+      unknowns
+    };
+  }
+  const checks = [
+    ["reachable", requirement.requireReachable, fact.reachable],
+    ["runtimeCompatible", requirement.requireRuntimeCompatible, fact.runtimeCompatible],
+    ["modelAvailable", requirement.requireModelAvailable, fact.modelAvailable]
+  ];
+  for (const [name, required, state] of checks) {
+    if (state === "unknown") unknowns.push(name);
+    if (!required) continue;
+    if (state === "false") {
+      return {
+        ok: false,
+        reason: `node '${requirement.nodeId}' proved ${name}=false for target '${requirement.targetId}'`,
+        unknowns
+      };
+    }
+    if (state === "unknown" && requirement.mode === "active") {
+      return {
+        ok: false,
+        reason: `node '${requirement.nodeId}' has no ${name} evidence for target '${requirement.targetId}'`,
+        unknowns
+      };
+    }
+    if (!fresh && requirement.mode === "active") {
+      return {
+        ok: false,
+        reason: `node '${requirement.nodeId}' ${name} evidence for target '${requirement.targetId}' is stale (probed ${fact.probedAt})`,
+        unknowns
+      };
+    }
+  }
+  if (requirement.requireModelAvailable && requirement.wireModelId !== null && fact.wireModelId !== null && fact.wireModelId !== requirement.wireModelId) {
+    return {
+      ok: false,
+      reason: `node '${requirement.nodeId}' model evidence names '${fact.wireModelId}', not '${requirement.wireModelId}'`,
+      unknowns
+    };
+  }
+  const resource = resources.find((entry) => entry.nodeId === requirement.nodeId);
+  const resourceChecks = [
+    ["gpuCount", requirement.requireGpuCount, resource?.gpuCount],
+    ["vramBytes", requirement.requireVramBytes, resource?.vramBytes]
+  ];
+  for (const [name, required, observed] of resourceChecks) {
+    if (observed === null || observed === void 0) {
+      if (required !== null) unknowns.push(name);
+      if (required !== null && requirement.mode === "active") {
+        return {
+          ok: false,
+          reason: `node '${requirement.nodeId}' reports unknown ${name}; a declared fit requirement cannot be satisfied by unknown`,
+          unknowns
+        };
+      }
+      continue;
+    }
+    if (required !== null && observed < required) {
+      return {
+        ok: false,
+        reason: `node '${requirement.nodeId}' ${name} ${observed} is below the declared requirement ${required}`,
+        unknowns
+      };
+    }
+  }
+  return { ok: true, unknowns };
+}
+
+// src/domains/dispatch/transport.ts
+import { spawn as spawn2 } from "node:child_process";
+
+// src/domains/dispatch/worker-spawn.ts
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+
+// src/domains/dispatch/worker-protocol.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// src/worker/protocol.ts
+import { createHash } from "node:crypto";
+var WORKER_PROTOCOL_VERSION = 1;
+var CONTROL_FRAME_PREFIX = "@clio-control/1 ";
+var WORKER_CONTROL_FRAME_MAX_BYTES = 16 * 1024;
+var WORKER_BULK_FRAME_MAX_BYTES = 4 * 1024 * 1024;
+var WORKER_STDIN_FRAME_MAX_BYTES = 1024 * 1024;
+var WORKER_STDIN_QUEUE_MAX_BYTES = 4 * 1024 * 1024;
+var WORKER_EVENT_QUEUE_MAX_FRAMES = 4096;
+function knownResource(value) {
+  return { known: true, value };
+}
+var UNKNOWN_RESOURCE = { known: false };
+var WORKER_RESOURCE_LABEL_MAX = 32;
+var WORKER_RESIDENT_MODEL_MAX = 64;
+var AGENT_LEDGER_SCOPE_MAX_ENTRIES = 8;
+var AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS = 200;
+var AGENT_LEDGER_INTENT_MAX_CHARS = 200;
+var AGENT_LEDGER_CLAIM_MAX_CHARS = 400;
+var AGENT_LEDGER_EVIDENCE_MAX_CHARS = 400;
+var AGENT_LEDGER_PATH_MAX_CHARS = 400;
+var AGENT_LEDGER_ENTRY_ID = /^e[1-9][0-9]*$/;
+function isAgentLedgerEntryId(value) {
+  return typeof value === "string" && AGENT_LEDGER_ENTRY_ID.test(value);
+}
+function boundedString(value, max) {
+  return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+function parseAgentLedgerBody(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "ledger body is not an object" };
+  }
+  const record = value;
+  switch (record.kind) {
+    case "claim": {
+      const scope = record.scope;
+      if (!Array.isArray(scope) || scope.length === 0) {
+        return { ok: false, reason: "claim scope must be a non-empty array of path prefixes" };
+      }
+      if (scope.length > AGENT_LEDGER_SCOPE_MAX_ENTRIES) {
+        return { ok: false, reason: `claim scope exceeds ${AGENT_LEDGER_SCOPE_MAX_ENTRIES} entries` };
+      }
+      for (const entry of scope) {
+        if (!boundedString(entry, AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS)) {
+          return {
+            ok: false,
+            reason: `claim scope entries must be 1..${AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS} characters`
+          };
+        }
+      }
+      if (!boundedString(record.intent, AGENT_LEDGER_INTENT_MAX_CHARS)) {
+        return { ok: false, reason: `claim intent must be 1..${AGENT_LEDGER_INTENT_MAX_CHARS} characters` };
+      }
+      return { ok: true, body: { kind: "claim", scope: scope.map(String), intent: record.intent } };
+    }
+    case "finding": {
+      if (!boundedString(record.claim, AGENT_LEDGER_CLAIM_MAX_CHARS)) {
+        return { ok: false, reason: `finding claim must be 1..${AGENT_LEDGER_CLAIM_MAX_CHARS} characters` };
+      }
+      const body = {
+        kind: "finding",
+        claim: record.claim
+      };
+      if (record.path !== void 0) {
+        if (!boundedString(record.path, AGENT_LEDGER_PATH_MAX_CHARS)) {
+          return { ok: false, reason: `finding path must be 1..${AGENT_LEDGER_PATH_MAX_CHARS} characters` };
+        }
+        body.path = record.path;
+      }
+      if (record.line !== void 0) {
+        const line = record.line;
+        if (typeof line !== "number" || !Number.isSafeInteger(line) || line <= 0) {
+          return { ok: false, reason: "finding line must be a positive safe integer" };
+        }
+        body.line = line;
+      }
+      return { ok: true, body };
+    }
+    case "review": {
+      if (!isAgentLedgerEntryId(record.target)) {
+        return { ok: false, reason: "review target must be a ledger entry id such as e3" };
+      }
+      if (typeof record.passed !== "boolean") {
+        return { ok: false, reason: "review passed must be a boolean" };
+      }
+      if (!boundedString(record.evidence, AGENT_LEDGER_EVIDENCE_MAX_CHARS)) {
+        return { ok: false, reason: `review evidence must be 1..${AGENT_LEDGER_EVIDENCE_MAX_CHARS} characters` };
+      }
+      return {
+        ok: true,
+        body: { kind: "review", target: record.target, passed: record.passed, evidence: record.evidence }
+      };
+    }
+    default:
+      return { ok: false, reason: `unknown ledger entry kind ${String(record.kind)}` };
+  }
+}
+function parseAgentLedgerEntry(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  const sequence = record.sequence;
+  if (typeof sequence !== "number" || !Number.isSafeInteger(sequence) || sequence <= 0) return null;
+  if (!isAgentLedgerEntryId(record.id)) return null;
+  for (const key of ["at", "runId", "assignmentId", "agentId", "nodeId"]) {
+    if (typeof record[key] !== "string" || record[key].length === 0) return null;
+  }
+  const body = parseAgentLedgerBody(record.body);
+  if (!body.ok) return null;
+  const conflicts = record.conflictsWith;
+  if (conflicts !== void 0 && !(Array.isArray(conflicts) && conflicts.every(isAgentLedgerEntryId))) return null;
+  return {
+    id: record.id,
+    sequence,
+    at: record.at,
+    runId: record.runId,
+    assignmentId: record.assignmentId,
+    agentId: record.agentId,
+    nodeId: record.nodeId,
+    body: body.body,
+    ...conflicts === void 0 ? {} : { conflictsWith: [...conflicts] }
+  };
+}
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+var HEX_64 = /^[0-9a-f]{64}$/;
+function endpointIdentityHash(url) {
+  if (url === void 0 || url.trim().length === 0) return sha256Hex("clio.endpoint:none");
+  const raw = url.trim();
+  let canonical;
+  try {
+    const parsed = new URL(raw);
+    const path = parsed.pathname.replace(/\/+$/u, "");
+    canonical = `${parsed.protocol}//${parsed.hostname}:${parsed.port}${path}`;
+  } catch {
+    canonical = raw.replace(/\/+$/u, "");
+  }
+  return sha256Hex(`clio.endpoint:${canonical}`);
+}
+function workerSpecDigest(spec) {
+  return sha256Hex(`clio.workerSpec:${canonicalJson(spec)}`);
+}
+function toolSignatureOf(names) {
+  return sha256Hex(`clio.tools:${[...names].sort().join(",")}`);
+}
+function canonicalJson(value) {
+  if (value === null) return "null";
+  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map((entry) => entry === void 0 ? "null" : canonicalJson(entry)).join(",")}]`;
+  if (typeof value === "object") {
+    const record = value;
+    const parts = [];
+    for (const key of Object.keys(record).sort()) {
+      const child = record[key];
+      if (child === void 0) continue;
+      parts.push(`${JSON.stringify(key)}:${canonicalJson(child)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  return "null";
+}
+function withinFrameBudget(line, maxBytes) {
+  return Buffer.byteLength(line, "utf8") <= maxBytes;
+}
+function parseJsonObject(line, maxBytes, lane) {
+  if (!withinFrameBudget(line, maxBytes)) {
+    return { ok: false, reason: `${lane} frame exceeds ${maxBytes} bytes` };
+  }
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return { ok: false, reason: `${lane} frame is not JSON` };
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: `${lane} frame is not a JSON object` };
+  }
+  return { ok: true, value };
+}
+function parseBulkFrame(line) {
+  return parseJsonObject(line, WORKER_BULK_FRAME_MAX_BYTES, "bulk");
+}
+function isControlLine(line) {
+  return line.startsWith(CONTROL_FRAME_PREFIX);
+}
+function encodeControlFrame(frame) {
+  return `${CONTROL_FRAME_PREFIX}${JSON.stringify(frame)}
+`;
+}
+function readFiniteNumber(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readResourceValue(value, validate) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  if (record.known === false) return { known: false };
+  if (record.known !== true || !validate(record.value)) return null;
+  return { known: true, value: record.value };
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isBoundedStringArray(value, max) {
+  return Array.isArray(value) && value.length <= max && value.every((entry) => typeof entry === "string");
+}
+function parseResourceFacts(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  if (!isBoundedStringArray(record.labels, WORKER_RESOURCE_LABEL_MAX)) return null;
+  const numeric = ["cpuCount", "totalMemoryBytes", "freeMemoryBytes", "gpuCount", "vramBytes"];
+  const parsed = { labels: [...record.labels] };
+  for (const key of numeric) {
+    const fact = readResourceValue(record[key], isFiniteNumber);
+    if (fact === null) return null;
+    parsed[key] = fact;
+  }
+  const residentModels = readResourceValue(
+    record.residentModels,
+    (raw) => isBoundedStringArray(raw, WORKER_RESIDENT_MODEL_MAX)
+  );
+  if (residentModels === null) return null;
+  parsed.residentModels = residentModels;
+  return parsed;
+}
+function parseAttestation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "announce attestation is not an object" };
+  }
+  const record = value;
+  if (record.protocolVersion !== WORKER_PROTOCOL_VERSION) {
+    return { ok: false, reason: `announce protocol version ${String(record.protocolVersion)} is unsupported` };
+  }
+  const specVersion = readFiniteNumber(record, "specVersion");
+  if (specVersion === null) return { ok: false, reason: "announce specVersion must be a finite number" };
+  const pid = readFiniteNumber(record, "pid");
+  if (pid === null) return { ok: false, reason: "announce pid must be a finite number" };
+  const rawPgid = record.processGroupId;
+  if (rawPgid !== null && !(typeof rawPgid === "number" && Number.isFinite(rawPgid))) {
+    return { ok: false, reason: "announce processGroupId must be a finite number or null" };
+  }
+  for (const key of ["host", "runtimeId", "targetId", "wireModelId"]) {
+    if (typeof record[key] !== "string" || record[key].length === 0) {
+      return { ok: false, reason: `announce ${key} must be a non-empty string` };
+    }
+  }
+  for (const key of ["settingsFingerprint", "specDigest", "endpointIdentityHash", "toolSignature"]) {
+    if (typeof record[key] !== "string" || !HEX_64.test(record[key])) {
+      return { ok: false, reason: `announce ${key} must be a sha256 hex digest` };
+    }
+  }
+  const resources = parseResourceFacts(record.resources);
+  if (resources === null) return { ok: false, reason: "announce resources are missing or malformed" };
+  return {
+    ok: true,
+    value: {
+      protocolVersion: WORKER_PROTOCOL_VERSION,
+      specVersion,
+      pid,
+      processGroupId: typeof rawPgid === "number" ? rawPgid : null,
+      host: record.host,
+      settingsFingerprint: record.settingsFingerprint,
+      specDigest: record.specDigest,
+      runtimeId: record.runtimeId,
+      targetId: record.targetId,
+      endpointIdentityHash: record.endpointIdentityHash,
+      wireModelId: record.wireModelId,
+      toolSignature: record.toolSignature,
+      resources
+    }
+  };
+}
+function parseControlFrame(line) {
+  if (!isControlLine(line)) return { ok: false, reason: "control frame is missing its lane marker" };
+  const body = line.slice(CONTROL_FRAME_PREFIX.length);
+  const parsed = parseJsonObject(body, WORKER_CONTROL_FRAME_MAX_BYTES, "control");
+  if (!parsed.ok) return parsed;
+  const record = parsed.value;
+  switch (record.kind) {
+    case "announce": {
+      const attestation = parseAttestation(record.attestation);
+      if (!attestation.ok) return attestation;
+      return { ok: true, value: { kind: "announce", attestation: attestation.value } };
+    }
+    case "heartbeat": {
+      const at = readFiniteNumber(record, "at");
+      if (at === null) return { ok: false, reason: "heartbeat frame requires a finite at" };
+      return { ok: true, value: { kind: "heartbeat", at } };
+    }
+    case "cancel_ack": {
+      const at = readFiniteNumber(record, "at");
+      if (at === null) return { ok: false, reason: "cancel_ack frame requires a finite at" };
+      return { ok: true, value: { kind: "cancel_ack", at } };
+    }
+    case "ledger_post": {
+      const body2 = parseAgentLedgerBody(record.body);
+      if (!body2.ok) return { ok: false, reason: `ledger_post frame rejected: ${body2.reason}` };
+      return { ok: true, value: { kind: "ledger_post", body: body2.body } };
+    }
+    default:
+      return { ok: false, reason: `unknown control frame kind ${String(record.kind)}` };
+  }
+}
+var RECEIPT_BEARING_BULK_TYPES = /* @__PURE__ */ new Set([
+  "message_end",
+  "clio_run_outcome",
+  "clio_permission_escalated",
+  "clio_permission_resolved",
+  "clio_steer_received",
+  "clio_tool_activity",
+  "clio_skill_activation",
+  "clio_safety_decision",
+  "clio_verification",
+  "clio_usage",
+  "tool_execution_end",
+  "spawn_error"
+]);
+function isReceiptBearingFrame(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return true;
+  const type = value.type;
+  if (typeof type !== "string") return true;
+  return RECEIPT_BEARING_BULK_TYPES.has(type);
+}
+
+// src/domains/dispatch/worker-protocol.ts
+function computeSettingsFingerprint(settings) {
+  return createHash2("sha256").update(`clio.settings:${canonicalJson(settings)}`, "utf8").digest("hex");
+}
+function verifyWorkerAttestation(attestation, approved) {
+  if (attestation.protocolVersion !== WORKER_PROTOCOL_VERSION) {
+    return {
+      ok: false,
+      reason: `worker protocol mismatch: approved ${WORKER_PROTOCOL_VERSION}, worker announced ${attestation.protocolVersion}`
+    };
+  }
+  const fields = [
+    ["WorkerSpec version", approved.specVersion, attestation.specVersion],
+    ["settings fingerprint", approved.settingsFingerprint, attestation.settingsFingerprint],
+    ["WorkerSpec digest", approved.specDigest, attestation.specDigest],
+    ["runtime", approved.runtimeId, attestation.runtimeId],
+    ["target", approved.targetId, attestation.targetId],
+    ["endpoint identity", approved.endpointIdentityHash, attestation.endpointIdentityHash],
+    ["wire model", approved.wireModelId, attestation.wireModelId],
+    ["tool surface", approved.toolSignature, attestation.toolSignature]
+  ];
+  for (const [label, expected, announced] of fields) {
+    if (!Object.is(expected, announced)) {
+      return {
+        ok: false,
+        reason: `${label} drift: dispatched ${String(expected)}, worker announced ${String(announced)}`
+      };
+    }
+  }
+  return { ok: true };
+}
+function approvedIdentityForSpec(spec) {
+  return {
+    specVersion: spec.specVersion,
+    settingsFingerprint: spec.settingsFingerprint,
+    specDigest: workerSpecDigestOf(spec),
+    runtimeId: spec.runtimeId,
+    targetId: spec.target.id,
+    endpointIdentityHash: endpointIdentityHash(spec.target.url),
+    wireModelId: spec.wireModelId,
+    // The spec carries the final runtime-narrowed admission surface. The
+    // worker fingerprints its independently resolved registry intersection,
+    // so a missing, added, or differently filtered tool fails admission.
+    toolSignature: toolSignatureOf(spec.allowedTools)
+  };
+}
+function workerSpecDigestOf(spec) {
+  return createHash2("sha256").update(`clio.workerSpec:${canonicalJson(spec)}`, "utf8").digest("hex");
+}
+function resourceOrNull(value) {
+  return value.known ? value.value : null;
+}
+function receiptAttestationFields(attestation) {
+  if (attestation === null) return {};
+  return {
+    attestation: {
+      protocolVersion: attestation.protocolVersion,
+      host: attestation.host,
+      pid: attestation.pid,
+      processGroupId: attestation.processGroupId,
+      settingsFingerprint: attestation.settingsFingerprint,
+      specDigest: attestation.specDigest,
+      targetId: attestation.targetId,
+      endpointIdentityHash: attestation.endpointIdentityHash,
+      wireModelId: attestation.wireModelId,
+      runtimeId: attestation.runtimeId,
+      toolSignature: attestation.toolSignature,
+      resources: {
+        labels: [...attestation.resources.labels],
+        cpuCount: resourceOrNull(attestation.resources.cpuCount),
+        totalMemoryBytes: resourceOrNull(attestation.resources.totalMemoryBytes),
+        gpuCount: resourceOrNull(attestation.resources.gpuCount),
+        vramBytes: resourceOrNull(attestation.resources.vramBytes)
+      }
+    }
+  };
+}
+var WorkerChannelFailure = class extends Error {
+  failureClass = "node-channel";
+  operation;
+  constructor(operation, detail) {
+    super(`worker control channel failure during ${operation}: ${detail}`);
+    this.name = "WorkerChannelFailure";
+    this.operation = operation;
+  }
+};
+function createBoundedEventQueue(maxFrames = WORKER_EVENT_QUEUE_MAX_FRAMES) {
+  const items = [];
+  let droppedDisplayFrames = 0;
+  let peakDepth = 0;
+  function dropOneDisplayFrame() {
+    for (let index = 0; index < items.length; index += 1) {
+      if (!isReceiptBearingFrame(items[index])) {
+        items.splice(index, 1);
+        droppedDisplayFrames += 1;
+        return true;
+      }
+    }
+    return false;
+  }
+  return {
+    push(value) {
+      if (items.length >= maxFrames && !dropOneDisplayFrame()) {
+        if (isReceiptBearingFrame(value)) {
+          items.push(value);
+          peakDepth = Math.max(peakDepth, items.length);
+          return true;
+        }
+        droppedDisplayFrames += 1;
+        return false;
+      }
+      items.push(value);
+      peakDepth = Math.max(peakDepth, items.length);
+      return true;
+    },
+    shift() {
+      return items.shift();
+    },
+    get size() {
+      return items.length;
+    },
+    stats() {
+      return { droppedDisplayFrames, peakDepth };
+    }
+  };
+}
+
+// src/domains/dispatch/worker-spawn.ts
+var DEFAULT_SHUTDOWN_GRACE_MS = 500;
+var DEFAULT_ATTESTATION_GRACE_MS = 2e3;
+var STDERR_TAIL_BYTES = 4096;
+function signalProcessGroup(child, signal) {
+  const pid = child.pid;
+  if (pid !== void 0 && pid !== null) {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+function spawnWorkerProcess(command, args, spec, opts) {
+  const shutdownGraceMs = opts?.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS;
+  const attestationGraceMs = opts?.attestationGraceMs ?? DEFAULT_ATTESTATION_GRACE_MS;
+  const approved = opts?.approvedIdentity ?? approvedIdentityForSpec(spec);
+  const child = spawn(command, [...args], {
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: opts?.cwd,
+    env: opts?.env ?? process.env,
+    // The worker leads its own process group so abort escalation covers the
+    // descendants a runtime spawned, not only the immediate child.
+    detached: true
+  });
+  const pid = child.pid ?? null;
+  const heartbeatAt = { current: Date.now() };
+  const queue = createBoundedEventQueue();
+  const waiters = [];
+  let finished = false;
+  let malformedStdoutLines = 0;
+  let stderrTail = Buffer.alloc(0);
+  let channelFailure = null;
+  let attestation = null;
+  function appendStderr(chunk) {
+    const next = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (next.length === 0) return;
+    const combined = Buffer.concat([stderrTail, next]);
+    stderrTail = combined.length > STDERR_TAIL_BYTES ? combined.subarray(combined.length - STDERR_TAIL_BYTES) : combined;
+  }
+  function diagnostics() {
+    const stderrText = stderrTail.toString("utf8").trim();
+    const dropped = queue.stats().droppedDisplayFrames + preAnnounce.stats().droppedDisplayFrames;
+    return {
+      ...stderrText.length > 0 ? { stderrTail: stderrText } : {},
+      ...malformedStdoutLines > 0 ? { malformedStdoutLines } : {},
+      ...dropped > 0 ? { droppedDisplayFrames: dropped } : {},
+      ...channelFailure !== null ? { channelFailure: channelFailure.operation } : {}
+    };
+  }
+  function push(value) {
+    heartbeatAt.current = Date.now();
+    const w = waiters.shift();
+    if (w) {
+      w({ value, done: false });
+      return;
+    }
+    queue.push(value);
+  }
+  function end() {
+    if (finished) return;
+    finished = true;
+    while (waiters.length > 0) {
+      const w = waiters.shift();
+      if (w) w({ value: void 0, done: true });
+    }
+  }
+  let sawSpawnError = false;
+  let announceAccepted = false;
+  let announceFailed = false;
+  function failAttestation(message) {
+    if (announceFailed) return;
+    announceFailed = true;
+    appendStderr(`[worker] ${message}
+`);
+    signalProcessGroup(child, "SIGKILL");
+  }
+  child.once("error", (err) => {
+    sawSpawnError = true;
+    push({
+      type: "spawn_error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    signalProcessGroup(child, "SIGKILL");
+  });
+  if (pid !== null && child.stdin) {
+    child.stdin.on("error", (err) => {
+      channelFailure = new WorkerChannelFailure("spec", err instanceof Error ? err.message : String(err));
+      appendStderr(`[worker] ${channelFailure.message}
+`);
+    });
+    child.stdin.write(`${JSON.stringify(spec)}
+`);
+  }
+  function createLineReader(maxBytes, onLine, onOversize) {
+    let buffer = "";
+    let discarding = false;
+    return (chunk) => {
+      buffer += chunk.toString("utf8");
+      let idx = buffer.indexOf("\n");
+      while (idx >= 0) {
+        const line = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 1);
+        if (discarding) {
+          discarding = false;
+          onOversize();
+        } else if (Buffer.byteLength(line, "utf8") > maxBytes) {
+          onOversize();
+        } else {
+          onLine(line);
+        }
+        idx = buffer.indexOf("\n");
+      }
+      if (Buffer.byteLength(buffer, "utf8") > maxBytes) {
+        buffer = "";
+        discarding = true;
+      }
+    };
+  }
+  const preAnnounce = createBoundedEventQueue();
+  let attestationGraceTimer = null;
+  function releaseHeldFrames() {
+    if (attestationGraceTimer !== null) {
+      clearTimeout(attestationGraceTimer);
+      attestationGraceTimer = null;
+    }
+    while (preAnnounce.size > 0) push(preAnnounce.shift());
+  }
+  function startAttestationGrace() {
+    if (attestationGraceTimer !== null || announceAccepted || announceFailed) return;
+    attestationGraceTimer = setTimeout(() => {
+      attestationGraceTimer = null;
+      if (announceAccepted || announceFailed) return;
+      failAttestation("Missing worker attestation: the peer produced output without announcing its route identity");
+    }, attestationGraceMs);
+    attestationGraceTimer.unref?.();
+  }
+  function handleBulkLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) return;
+    const frame = parseBulkFrame(trimmed);
+    if (!frame.ok) {
+      malformedStdoutLines += 1;
+      return;
+    }
+    if (announceFailed) return;
+    if (!announceAccepted) {
+      preAnnounce.push(frame.value);
+      startAttestationGrace();
+      return;
+    }
+    push(frame.value);
+  }
+  function handleControlLine(line) {
+    const frame = parseControlFrame(line);
+    if (!frame.ok) {
+      appendStderr(`[worker] rejected control frame: ${frame.reason}
+`);
+      if (!announceAccepted) failAttestation(`Invalid worker attestation: ${frame.reason}`);
+      return;
+    }
+    heartbeatAt.current = Date.now();
+    if (frame.value.kind === "announce") {
+      if (announceAccepted || announceFailed) return;
+      const verdict = verifyWorkerAttestation(frame.value.attestation, approved);
+      if (!verdict.ok) {
+        failAttestation(`Worker attestation rejected: ${verdict.reason}`);
+        return;
+      }
+      announceAccepted = true;
+      attestation = frame.value.attestation;
+      opts?.onAnnounce?.(frame.value.attestation);
+      releaseHeldFrames();
+      return;
+    }
+    if (frame.value.kind === "ledger_post") {
+      if (!announceAccepted) {
+        appendStderr("[worker] dropped a ledger post that arrived before attestation was accepted\n");
+        return;
+      }
+      opts?.onLedgerPost?.(frame.value.body);
+      return;
+    }
+    opts?.onControl?.({ kind: frame.value.kind });
+  }
+  if (child.stdout) {
+    child.stdout.on(
+      "data",
+      createLineReader(WORKER_BULK_FRAME_MAX_BYTES, handleBulkLine, () => {
+        malformedStdoutLines += 1;
+        appendStderr(`[worker] dropped a bulk frame over the ${WORKER_BULK_FRAME_MAX_BYTES} byte lane limit
+`);
+      })
+    );
+  }
+  if (child.stderr) {
+    child.stderr.on(
+      "data",
+      createLineReader(
+        WORKER_BULK_FRAME_MAX_BYTES,
+        (line) => {
+          if (isControlLine(line)) {
+            handleControlLine(line);
+            return;
+          }
+          appendStderr(`${line}
+`);
+        },
+        () => appendStderr("[worker] dropped an oversized stderr line\n")
+      )
+    );
+  }
+  const events = {
+    next() {
+      if (queue.size > 0) {
+        return Promise.resolve({ value: queue.shift(), done: false });
+      }
+      if (finished) return Promise.resolve({ value: void 0, done: true });
+      return new Promise((resolve) => {
+        waiters.push(resolve);
+      });
+    },
+    return() {
+      end();
+      return Promise.resolve({ value: void 0, done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  const promise = new Promise((resolve) => {
+    child.on("close", (code, signal) => {
+      try {
+        child.stdin?.end();
+      } catch {
+      }
+      end();
+      if (sawSpawnError) {
+        resolve({ exitCode: null, signal: null, ...diagnostics() });
+        return;
+      }
+      if (!announceAccepted && !announceFailed) {
+        announceFailed = true;
+        appendStderr("[worker] Missing worker attestation: peer exited before announcing its route identity\n");
+      }
+      if (announceFailed) {
+        resolve({ exitCode: code !== null && code !== 0 ? code : 1, signal: signal ?? null, ...diagnostics() });
+        return;
+      }
+      resolve({ exitCode: code ?? 0, signal: signal ?? null, ...diagnostics() });
+    });
+  });
+  function isAlive() {
+    return child.exitCode === null && child.signalCode === null;
+  }
+  let queuedStdinBytes = 0;
+  function failChannel(operation, detail) {
+    channelFailure = new WorkerChannelFailure(operation, detail);
+    appendStderr(`[worker] ${channelFailure.message}
+`);
+    return false;
+  }
+  const send = (value) => {
+    const frameType = typeof value === "object" && value !== null ? value.type : void 0;
+    const operation = frameType === "permission_decision" ? "permission_decision" : frameType === "ledger_delta" ? "ledger_delta" : "steer";
+    if (!isAlive()) return failChannel(operation, "worker has exited");
+    const stdin = child.stdin;
+    if (!stdin || stdin.destroyed || !stdin.writable) return failChannel(operation, "worker stdin is not writable");
+    const line = `${JSON.stringify(value)}
+`;
+    const bytes = Buffer.byteLength(line, "utf8");
+    if (bytes > WORKER_STDIN_FRAME_MAX_BYTES) {
+      return failChannel(operation, `frame of ${bytes} bytes exceeds the ${WORKER_STDIN_FRAME_MAX_BYTES} byte limit`);
+    }
+    if (queuedStdinBytes + bytes > WORKER_STDIN_QUEUE_MAX_BYTES) {
+      return failChannel(
+        operation,
+        `stdin queue is full (${queuedStdinBytes} of ${WORKER_STDIN_QUEUE_MAX_BYTES} bytes pending)`
+      );
+    }
+    try {
+      queuedStdinBytes += bytes;
+      stdin.write(line, (error) => {
+        queuedStdinBytes -= bytes;
+        if (error) failChannel(operation, error.message);
+      });
+      return true;
+    } catch (error) {
+      queuedStdinBytes -= bytes;
+      return failChannel(operation, error instanceof Error ? error.message : String(error));
+    }
+  };
+  const abort = () => {
+    if (!isAlive()) return;
+    try {
+      child.stdin?.end();
+    } catch {
+    }
+    signalProcessGroup(child, "SIGTERM");
+    const killTimer = setTimeout(() => {
+      if (isAlive()) {
+        signalProcessGroup(child, "SIGKILL");
+        try {
+          opts?.onForcedKill?.();
+        } catch {
+        }
+      }
+    }, shutdownGraceMs);
+    killTimer.unref?.();
+  };
+  return {
+    pid,
+    processCommand: JSON.stringify([command, ...args]),
+    promise,
+    events,
+    abort,
+    heartbeatAt,
+    send,
+    lastChannelFailure: () => channelFailure,
+    attestation: () => attestation
+  };
+}
+function spawnNativeWorker(spec, opts) {
+  const workerEntry = opts?.workerEntryPath ?? join(resolvePackageRoot(), "dist/worker/entry.js");
+  return spawnWorkerProcess(process.execPath, ["--disable-warning=ExperimentalWarning", workerEntry], spec, {
+    ...opts?.cwd !== void 0 ? { cwd: opts.cwd } : {},
+    env: opts?.env ?? process.env,
+    ...opts?.shutdownGraceMs !== void 0 ? { shutdownGraceMs: opts.shutdownGraceMs } : {}
+  });
+}
+
+// src/domains/dispatch/transport.ts
+var LOCAL_NODE_ID = "local";
+function localNodeIdentity() {
+  return { id: LOCAL_NODE_ID, kind: "local" };
+}
+var DEFAULT_SSH_CONNECT_TIMEOUT_SEC = 10;
+var DEFAULT_REMOTE_CLIO_ENTRY = "clio-coder worker";
+function remoteEnvAssignments(node) {
+  const residency = node.residency ?? "observe";
+  const labels = (node.labels ?? []).map((label) => label.trim()).filter((label) => label.length > 0);
+  const labelAssignment = labels.length > 0 ? ` CLIO_CODER_WORKER_LABELS=${shellQuote(labels.join(","))}` : "";
+  return `CLIO_CODER_RESIDENCY=${residency} CLIO_CODER_WORKER_PGID=$$${labelAssignment}`;
+}
+function buildRemoteWorkerCommand(node, cwd) {
+  const entry = node.clioEntry !== void 0 && node.clioEntry.trim().length > 0 ? node.clioEntry.trim() : DEFAULT_REMOTE_CLIO_ENTRY;
+  return `cd ${shellQuote(cwd)} && exec env ${remoteEnvAssignments(node)} ${entry}`;
+}
+function buildSshArgs(node, remoteCommand) {
+  const connectTimeout = node.connectTimeoutSec ?? DEFAULT_SSH_CONNECT_TIMEOUT_SEC;
+  const args = [
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    `ConnectTimeout=${connectTimeout}`,
+    // The channel is a byte pipe, never a terminal: a pty would translate
+    // newlines and inject control sequences into the NDJSON stream.
+    "-T"
+  ];
+  if (node.port !== void 0) args.push("-p", String(node.port));
+  if (node.identityFile !== void 0 && node.identityFile.length > 0) args.push("-i", node.identityFile);
+  if (node.user !== void 0 && node.user.length > 0) args.push("-l", node.user);
+  args.push(node.host, "--", remoteCommand);
+  return args;
+}
+function createSshWorkerTransport(node, opts) {
+  const sshBinary = opts?.sshBinary ?? "ssh";
+  const identity = { id: node.id, kind: "ssh", host: node.host };
+  return {
+    kind: "ssh",
+    node: identity,
+    spawn(spec, spawnOpts) {
+      const cwd = spawnOpts?.cwd ?? process.cwd();
+      const remote = { pid: null, processGroupId: null };
+      const killRemote = () => {
+        const group = remote.processGroupId;
+        const command = group !== null ? `kill -TERM -${group} 2>/dev/null || kill -TERM ${remote.pid ?? group} 2>/dev/null || true` : remote.pid !== null ? `kill -TERM ${remote.pid} 2>/dev/null || true` : null;
+        if (command === null) return;
+        try {
+          const fallback = spawn2(sshBinary, buildSshArgs(node, command), {
+            stdio: "ignore",
+            detached: true
+          });
+          fallback.unref();
+        } catch {
+        }
+      };
+      return spawnWorkerProcess(sshBinary, buildSshArgs(node, buildRemoteWorkerCommand(node, cwd)), spec, {
+        // No cwd for the local ssh client; the remote command cds itself.
+        env: process.env,
+        ...opts?.shutdownGraceMs !== void 0 ? { shutdownGraceMs: opts.shutdownGraceMs } : {},
+        onAnnounce: (attestation) => {
+          remote.pid = attestation.pid;
+          remote.processGroupId = attestation.processGroupId;
+        },
+        onForcedKill: killRemote
+      });
+    }
+  };
+}
+
+// src/domains/dispatch/fleet-preflight.ts
+function storePath() {
+  return join2(clioStateDir(), "fleet-preflight.json");
+}
+function readFleetPreflightRecords() {
+  const path = storePath();
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed?.version !== 2 || !Array.isArray(parsed.records)) return [];
+    return parsed.records;
+  } catch {
+    return [];
+  }
+}
+function recordFleetPreflight(records) {
+  const existing = readFleetPreflightRecords();
+  const merged = /* @__PURE__ */ new Map();
+  for (const record of existing) merged.set(`${record.nodeId}\0${record.projectRoot}`, record);
+  for (const record of records) merged.set(`${record.nodeId}\0${record.projectRoot}`, record);
+  const file = { version: 2, records: [...merged.values()] };
+  atomicWrite(storePath(), JSON.stringify(file, null, 2));
+}
+function fleetPreflightVerdict(node, projectRoot, records = readFleetPreflightRecords()) {
+  const record = records.find((entry) => entry.nodeId === node.id && entry.projectRoot === projectRoot);
+  if (!record) {
+    return {
+      ok: false,
+      reason: `node '${node.id}' has not passed the fleet preflight for ${projectRoot}; run 'clio-coder doctor'`
+    };
+  }
+  if (record.host !== node.host) {
+    return {
+      ok: false,
+      reason: `node '${node.id}' preflight was recorded for host '${record.host}' but the node now points at '${node.host}'; run 'clio-coder doctor'`
+    };
+  }
+  if (record.localVersion !== readClioVersion()) {
+    return {
+      ok: false,
+      reason: `node '${node.id}' preflight predates a local clio-coder upgrade (${record.localVersion} -> ${readClioVersion()}); run 'clio-coder doctor'`
+    };
+  }
+  if (!record.ok) {
+    return {
+      ok: false,
+      reason: `node '${node.id}' failed its last fleet preflight: ${record.detail ?? "see clio-coder doctor"}`
+    };
+  }
+  return { ok: true, reason: null };
+}
+function routeFactVerdict(requirement, records = readFleetPreflightRecords(), options) {
+  const targets = [];
+  const resources = [];
+  for (const record of records) {
+    targets.push(...record.targets);
+    if (record.resources !== null) resources.push(record.resources);
+  }
+  return evaluateRouteFacts(targets, resources, requirement, options);
+}
+var PREFLIGHT_MARKER = "clio-preflight/1";
+var DEFAULT_PREFLIGHT_TIMEOUT_MS = 2e4;
+function buildPreflightScript(node, projectRoot, targets = []) {
+  const entry = node.clioEntry !== void 0 && node.clioEntry.trim().length > 0 ? node.clioEntry.trim() : "clio-coder worker";
+  const cliBase = entry.endsWith(" worker") ? entry.slice(0, -" worker".length) : null;
+  const versionProbe = cliBase !== null ? `v=$(${cliBase} --version 2>/dev/null | head -n 1); if [ -n "$v" ]; then echo "clio=$v"; else echo clio=missing; fi` : `echo clio=custom-entry`;
+  const lines = [
+    `echo ${shellQuote(PREFLIGHT_MARKER)}`,
+    `if cd ${shellQuote(projectRoot)} 2>/dev/null; then echo cwd=ok; else echo cwd=missing; fi`,
+    versionProbe,
+    `d="\${XDG_STATE_HOME:-$HOME/.local/state}/clio-coder"; if mkdir -p "$d" 2>/dev/null && [ -w "$d" ]; then echo state=ok; else echo state=fail; fi`,
+    // Resource observation runs on the node. A node without nvidia-smi reports
+    // unknown; it never reports zero GPUs, which a fit requirement would read
+    // as a proven absence rather than an absence of evidence.
+    `echo "cpu=$(nproc 2>/dev/null || echo unknown)"`,
+    `echo "memkb=$(awk '/MemTotal/{print $2}' /proc/meminfo 2>/dev/null || echo unknown)"`,
+    `g=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits 2>/dev/null); if [ -n "$g" ]; then echo "gpu=$(echo "$g" | wc -l)"; echo "vrammb=$(echo "$g" | paste -sd+ - | bc 2>/dev/null || echo unknown)"; else echo gpu=unknown; echo vrammb=unknown; fi`
+  ];
+  for (const target of targets) {
+    if (target.url === void 0 || target.url.trim().length === 0) {
+      lines.push(`echo ${shellQuote(`target=${target.id}:noendpoint`)}`);
+      continue;
+    }
+    const modelsUrl = `${target.url.replace(/\/+$/u, "")}/v1/models`;
+    lines.push(
+      `b=$(curl -sS -m 5 -o /dev/null -w '%{http_code}' ${shellQuote(modelsUrl)} 2>/dev/null || echo 000); m=$(curl -sS -m 5 ${shellQuote(modelsUrl)} 2>/dev/null || echo ""); echo ${shellQuote(`target=${target.id}:`)}"$b"; ` + (target.wireModelId !== void 0 ? `case "$m" in *${shellQuote(target.wireModelId).slice(1, -1)}*) echo ${shellQuote(`model=${target.id}:true`)};; *) echo ${shellQuote(`model=${target.id}:false`)};; esac` : `echo ${shellQuote(`model=${target.id}:unknown`)}`)
+    );
+  }
+  return lines.join("; ");
+}
+function parseSemver(text) {
+  const match = text.match(/(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/);
+  return match?.[1] ?? null;
+}
+function parseUnknownableNumber(lines, prefix, scale = 1) {
+  const line = lines.find((entry) => entry.startsWith(prefix));
+  if (line === void 0) return null;
+  const raw = line.slice(prefix.length).trim();
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) && value >= 0 ? value * scale : null;
+}
+function parseTargetFacts(lines, targets, probedAt, probeDurationMs) {
+  return targets.map((target) => {
+    const statusLine = lines.find((entry) => entry.startsWith(`target=${target.id}:`));
+    const status = statusLine?.slice(`target=${target.id}:`.length).trim() ?? "";
+    const code = Number.parseInt(status, 10);
+    const reachable = status === "" ? "unknown" : status === "noendpoint" ? "unknown" : Number.isFinite(code) && code >= 200 && code < 500 ? "true" : "false";
+    const modelLine = lines.find((entry) => entry.startsWith(`model=${target.id}:`));
+    const modelValue = modelLine?.slice(`model=${target.id}:`.length).trim();
+    const modelAvailable = modelValue === "true" ? "true" : modelValue === "false" ? "false" : "unknown";
+    return {
+      nodeId: "",
+      targetId: target.id,
+      reachable,
+      // The runtime the target names is registered in this same release on
+      // every node, and the version check already proved release parity.
+      runtimeCompatible: reachable === "true" ? "true" : "unknown",
+      modelAvailable,
+      // A worker observes only the models it loads itself, so residency is
+      // never inferred from an endpoint listing.
+      modelResident: "unknown",
+      endpointIdentityHash: endpointIdentityHash(target.url),
+      wireModelId: target.wireModelId ?? null,
+      probedAt,
+      probeDurationMs
+    };
+  });
+}
+function runSsh(sshBinary, args, timeoutMs) {
+  return new Promise((resolve) => {
+    execFile(sshBinary, [...args], { timeout: timeoutMs, encoding: "utf8" }, (error, stdout, stderr) => {
+      const code = error === null ? 0 : typeof error.code === "number" ? error.code : 255;
+      resolve({ code, stdout: stdout ?? "", stderr: stderr ?? "" });
+    });
+  });
+}
+async function runFleetNodePreflight(node, projectRoot, options) {
+  const sshBinary = options?.sshBinary ?? "ssh";
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_PREFLIGHT_TIMEOUT_MS;
+  const localVersion = readClioVersion();
+  const checkedAt = (options?.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const checks = {
+    reachable: false,
+    clioPresent: false,
+    versionMatch: false,
+    pathParity: false,
+    stateDirWritable: false
+  };
+  const targets = options?.targets ?? [];
+  const record = {
+    nodeId: node.id,
+    host: node.host,
+    projectRoot,
+    ok: false,
+    checkedAt,
+    localVersion,
+    remoteVersion: null,
+    detail: null,
+    checks,
+    targets: [],
+    resources: null
+  };
+  const script = buildPreflightScript(node, projectRoot, targets);
+  const probeStartedAt = Date.now();
+  const result = await runSsh(sshBinary, buildSshArgs(node, script), timeoutMs);
+  const probeDurationMs = Date.now() - probeStartedAt;
+  if (!result.stdout.includes(PREFLIGHT_MARKER)) {
+    const stderr = result.stderr.trim().split("\n").slice(-1)[0] ?? "";
+    record.detail = `unreachable (ssh exit ${result.code}${stderr.length > 0 ? `: ${stderr}` : ""})`;
+    return record;
+  }
+  checks.reachable = true;
+  const lines = result.stdout.split("\n").map((line) => line.trim());
+  record.targets = parseTargetFacts(lines, targets, checkedAt, probeDurationMs).map((fact) => ({
+    ...fact,
+    nodeId: node.id
+  }));
+  record.resources = {
+    nodeId: node.id,
+    labels: [...node.labels ?? []],
+    cpuCount: parseUnknownableNumber(lines, "cpu="),
+    totalMemoryBytes: parseUnknownableNumber(lines, "memkb=", 1024),
+    gpuCount: parseUnknownableNumber(lines, "gpu="),
+    vramBytes: parseUnknownableNumber(lines, "vrammb=", 1024 * 1024),
+    observedAt: checkedAt
+  };
+  checks.pathParity = lines.includes("cwd=ok");
+  checks.stateDirWritable = lines.includes("state=ok");
+  const clioLine = lines.find((line) => line.startsWith("clio="));
+  const clioValue = clioLine?.slice("clio=".length) ?? "missing";
+  if (clioValue === "custom-entry") {
+    checks.clioPresent = true;
+    checks.versionMatch = true;
+    record.remoteVersion = null;
+  } else if (clioValue !== "missing") {
+    checks.clioPresent = true;
+    record.remoteVersion = parseSemver(clioValue);
+    checks.versionMatch = record.remoteVersion !== null && record.remoteVersion === parseSemver(localVersion);
+  }
+  const failures = [];
+  if (!checks.pathParity)
+    failures.push(`project root ${projectRoot} missing on node (disjoint filesystems are unsupported)`);
+  if (!checks.clioPresent)
+    failures.push("clio-coder not found on remote PATH (set fleet.nodes[].clioEntry or install clio-coder)");
+  else if (!checks.versionMatch) {
+    failures.push(
+      `clio-coder version mismatch (local ${parseSemver(localVersion) ?? localVersion}, remote ${record.remoteVersion ?? "unknown"})`
+    );
+  }
+  if (!checks.stateDirWritable) failures.push("remote clio-coder state dir is not writable");
+  record.ok = failures.length === 0;
+  record.detail = failures.length > 0 ? failures.join("; ") : null;
+  return record;
+}
+
+export {
+  WORKER_PROTOCOL_VERSION,
+  WORKER_STDIN_FRAME_MAX_BYTES,
+  knownResource,
+  UNKNOWN_RESOURCE,
+  WORKER_RESOURCE_LABEL_MAX,
+  parseAgentLedgerBody,
+  parseAgentLedgerEntry,
+  endpointIdentityHash,
+  workerSpecDigest,
+  toolSignatureOf,
+  canonicalJson,
+  withinFrameBudget,
+  encodeControlFrame,
+  computeSettingsFingerprint,
+  receiptAttestationFields,
+  spawnNativeWorker,
+  LOCAL_NODE_ID,
+  localNodeIdentity,
+  createSshWorkerTransport,
+  readFleetPreflightRecords,
+  recordFleetPreflight,
+  fleetPreflightVerdict,
+  routeFactVerdict,
+  runFleetNodePreflight
+};
+//# sourceMappingURL=chunk-BBUH4VAA.js.map