@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/chunk-7RY5VZPH.js

@@ -0,0 +1,573 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi
+} from "./chunk-YAKGTXEV.js";
+import {
+  openLedger,
+  readFleetRun
+} from "./chunk-XKA2ICR3.js";
+import {
+  formatTrustSummaryLine,
+  inspectRunReceiptTrustStatus
+} from "./chunk-6NJQITNH.js";
+import {
+  WRITE_BOUNDARY_VIOLATION_REASON
+} from "./chunk-TD3PGPQA.js";
+import {
+  readRunEventJournal,
+  runEventJournalPath
+} from "./chunk-6VC4OV3Z.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-TVHHYFHE.js";
+import {
+  clioStateDir,
+  resetXdgCache
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/fleet-view.ts
+init_esm_shims();
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var HELP = `clio-coder fleet view <runId|fleetRootId> [--follow]
+clio-coder fleet view --watch <selection-file>
+
+Follow one dispatched run from its durable state: the run ledger entry, the
+run event journal, and the sealed receipt once it exists.
+
+  --follow    keep tailing until the run's terminal line, then stay open (q exits)
+  --watch     follow whichever run id the selection file names, retargeting
+              live as the file changes (q exits). This is the process the
+              interactive workers view (Alt+W) runs inside its watch pane.
+
+Without --follow the current snapshot is printed and the command exits.
+The transcript comes from <state>/runs/<runId>/events.ndjson, which the
+orchestrator writes when fleet.history.journal is on (the default). A run dispatched
+with the journal off shows its ledger and receipt but no transcript.
+
+Given the fleet root id that \`fleet run\` prints (fleet-<hex>), this prints the
+run's step index instead: one line per step with its run id and outcome. Pass
+one of those run ids back to see that step.
+`;
+var POLL_MS = 250;
+var TRANSCRIPT_LIMIT = 400;
+var TASK_MAX_WIDTH = 400;
+var DETAIL_MAX_WIDTH = 200;
+var DEFAULT_WIDTH = 100;
+var MIN_WIDTH = 40;
+var QUIT_CTRL_C = String.fromCharCode(3);
+var QUIT_ESCAPE = String.fromCharCode(27);
+function sanitizeBounded(value, maxWidth) {
+  const sanitized = sanitizeCallTargetText(value);
+  if (sanitized.length === 0) return "";
+  return sanitizeCallTargetText(truncateToWidth(sanitized, maxWidth, "\u2026", false));
+}
+function truncatePlain(value, width) {
+  return truncateToWidth(value, width, "\u2026", false).replaceAll("\x1B[0m", "");
+}
+function receiptPathFor(run) {
+  return run.receiptPath ?? join(clioStateDir(), "receipts", `${run.id}.json`);
+}
+function evidenceLine(run) {
+  if (run.receiptPath === null && run.endedAt === null) {
+    return { text: "receipt pending; the run has not finalized", receiptPath: null };
+  }
+  const path = receiptPathFor(run);
+  let receipt;
+  try {
+    receipt = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    return {
+      text: `receipt unavailable: cannot read ${path} (${error instanceof Error ? error.message : String(error)})`,
+      receiptPath: null
+    };
+  }
+  const inspection = inspectRunReceiptTrustStatus(receipt, run);
+  if (!inspection.integrity.ok) {
+    return {
+      text: `RECEIPT INTEGRITY FAILED: ${inspection.integrity.reason}; stored receipt fields are untrusted`,
+      receiptPath: path
+    };
+  }
+  return { text: formatTrustSummaryLine(inspection.status), receiptPath: path };
+}
+function transcriptLine(line) {
+  switch (line.kind) {
+    case "open":
+      return { at: line.at, label: `run opened (${sanitizeBounded(line.agentId, 64)})`, detail: void 0 };
+    case "event":
+      return {
+        at: line.at,
+        label: sanitizeBounded(line.type, 64),
+        detail: line.detail === void 0 ? void 0 : sanitizeBounded(line.detail, DETAIL_MAX_WIDTH)
+      };
+    case "journal_truncated":
+      return { at: line.at, label: "journal truncated", detail: sanitizeBounded(line.reason, 64) };
+    case "receipt":
+      return {
+        at: line.at,
+        label: `receipt sealed (${sanitizeBounded(line.outcome, 32)})`,
+        detail: line.digest === void 0 ? void 0 : `sha256:${sanitizeBounded(line.digest, 64)}`
+      };
+    case "terminal":
+      return {
+        at: line.at,
+        label: `terminal (${sanitizeBounded(line.outcome, 32)})`,
+        detail: line.detail === void 0 ? void 0 : sanitizeBounded(line.detail, DETAIL_MAX_WIDTH)
+      };
+    default:
+      return null;
+  }
+}
+function resolveRunId(runId) {
+  const ledger = openLedger();
+  if (ledger.get(runId) !== null) return { runId };
+  const candidates = ledger.list().filter((run) => run.id.startsWith(runId)).map((run) => run.id);
+  if (candidates.length === 1 && candidates[0] !== void 0) return { runId: candidates[0] };
+  return { candidates };
+}
+function loadRunViewModel(runId, options = {}) {
+  const run = openLedger().get(runId);
+  if (run === null) return null;
+  const now = options.now ?? (() => Date.now());
+  const journal = readRunEventJournal(runId, {
+    maxLines: TRANSCRIPT_LIMIT,
+    ...options.journalRoot === void 0 ? {} : { root: options.journalRoot }
+  });
+  const transcript = [];
+  for (const line of journal.lines) {
+    const rendered = transcriptLine(line);
+    if (rendered !== null) transcript.push(rendered);
+  }
+  const evidence = evidenceLine(run);
+  const startedMs = Date.parse(run.startedAt);
+  const endedMs = run.endedAt === null ? now() : Date.parse(run.endedAt);
+  const task = sanitizeBounded(run.task, TASK_MAX_WIDTH);
+  return {
+    runId: run.id,
+    agentId: run.agentId,
+    model: run.wireModelId,
+    target: run.targetId,
+    node: run.node?.id ?? "local",
+    phase: run.outcome ?? run.status,
+    startedAt: run.startedAt,
+    elapsedMs: Number.isFinite(startedMs) && Number.isFinite(endedMs) ? Math.max(0, endedMs - startedMs) : 0,
+    task: task.length > 0 ? task : void 0,
+    transcript,
+    transcriptTruncated: journal.truncated,
+    journalPresent: journal.present,
+    journalPath: runEventJournalPath(runId, options.journalRoot === void 0 ? void 0 : options.journalRoot),
+    evidence: evidence.text,
+    receiptPath: evidence.receiptPath,
+    outcome: journal.terminal?.outcome ?? run.outcome ?? null,
+    outcomeDetail: journal.terminal?.detail ?? run.outcomeDetail ?? null,
+    terminal: journal.terminal !== null || run.endedAt !== null
+  };
+}
+function formatElapsed(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
+  return `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, "0")}m`;
+}
+function clockOf(iso) {
+  const time = iso.slice(11, 19);
+  return time.length === 8 ? time : iso.slice(0, 8);
+}
+function wrapViewerValue(prefix, value, columns) {
+  const prefixWidth = visibleWidth(prefix);
+  const valueWidth = Math.max(1, columns - prefixWidth);
+  return wrapTextWithAnsi(value, valueWidth).map(
+    (line, index) => `${index === 0 ? prefix : " ".repeat(prefixWidth)}${line}`
+  );
+}
+function renderRunView(model, width = DEFAULT_WIDTH) {
+  const columns = Math.max(MIN_WIDTH, width);
+  const rule = "\u2500".repeat(columns);
+  const lines = [];
+  lines.push(truncatePlain(`run ${model.runId}  ${model.agentId}`, columns));
+  lines.push(
+    truncatePlain(
+      `model ${model.model}  target ${model.target}  node ${model.node}  phase ${model.phase}  elapsed ${formatElapsed(model.elapsedMs)}`,
+      columns
+    )
+  );
+  if (model.task !== void 0) {
+    lines.push(...wrapViewerValue("task ", model.task, columns));
+  }
+  lines.push(rule);
+  if (!model.journalPresent) {
+    lines.push("no event journal for this run.");
+    lines.push(
+      ...wrapViewerValue(
+        "expected ",
+        `${model.journalPath} (fleet.history.journal may have been off when it ran)`,
+        columns
+      )
+    );
+  } else if (model.transcript.length === 0) {
+    lines.push("journal is empty; no events recorded yet.");
+  } else {
+    if (model.transcriptTruncated) lines.push("\u2026 earlier events dropped (journal truncated)");
+    for (const entry of model.transcript) {
+      const head = `${clockOf(entry.at)} ${entry.label}`;
+      if (entry.detail === void 0) lines.push(truncatePlain(head, columns));
+      else lines.push(...wrapViewerValue(`${head}: `, entry.detail, columns));
+    }
+  }
+  lines.push(rule);
+  lines.push(...wrapViewerValue("evidence  ", model.evidence, columns));
+  if (model.receiptPath !== null) {
+    lines.push(truncatePlain(`receipt   ${model.receiptPath}`, columns));
+  }
+  const outcome = model.outcome === null ? model.terminal ? "terminal, outcome not recorded" : "running" : model.outcomeDetail === null || model.outcomeDetail.length === 0 ? model.outcome : `${model.outcome} (${sanitizeBounded(model.outcomeDetail, DETAIL_MAX_WIDTH)})`;
+  lines.push(...wrapViewerValue("outcome   ", outcome, columns));
+  return lines;
+}
+function renderWatchView(runId, model, width = DEFAULT_WIDTH, ledgerRoot = clioStateDir()) {
+  const columns = Math.max(MIN_WIDTH, width);
+  if (runId === null) {
+    return [
+      "no worker selected.",
+      "",
+      "In clio-coder, open the workers view (Alt+W), pick a run, press Enter.",
+      "Arrow keys there retarget this pane live."
+    ];
+  }
+  if (model === null) {
+    const missing = `run ${sanitizeBounded(runId, 64)} is not in the run ledger under ${ledgerRoot}.`;
+    const wrappedMissing = [];
+    for (let offset = 0; offset < missing.length; offset += columns) {
+      wrappedMissing.push(missing.slice(offset, offset + columns));
+    }
+    return [
+      ...wrappedMissing,
+      "",
+      "If this run is queued, it has not started yet; this view will update when its ledger entry appears.",
+      "If it already started or finished, it was not found in this ledger."
+    ];
+  }
+  return renderRunView(model, columns);
+}
+var FLEET_ROOT_PREFIX = "fleet-";
+var STEP_ID_MAX_WIDTH = 32;
+function fleetRunsDir() {
+  return join(clioStateDir(), "fleet-runs");
+}
+function resolveFleetRootId(token) {
+  if (readFleetRun(token) !== null) return { rootId: token };
+  let entries;
+  try {
+    entries = readdirSync(fleetRunsDir());
+  } catch {
+    return { candidates: [] };
+  }
+  const candidates = entries.filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -".json".length)).filter((id) => id.startsWith(token));
+  if (candidates.length === 1 && candidates[0] !== void 0) return { rootId: candidates[0] };
+  return { candidates };
+}
+function stepResultOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function loadFleetRunViewModel(rootId, options = {}) {
+  const record = readFleetRun(rootId);
+  if (record === null) return null;
+  const ledger = openLedger();
+  const now = options.now ?? (() => Date.now());
+  const settled = /* @__PURE__ */ new Map();
+  for (const entry of record.steps ?? []) {
+    if (typeof entry?.stepId === "string") settled.set(entry.stepId, stepResultOf(entry.result));
+  }
+  const stepIds = record.stepIds?.length > 0 ? record.stepIds : [...settled.keys()];
+  const steps = stepIds.map((stepId) => {
+    const result = settled.get(stepId);
+    const runId = typeof result?.terminalRunId === "string" ? result.terminalRunId : null;
+    if (result === void 0 || runId === null) {
+      return { stepId, runId: null, agentId: null, outcome: "not run", detail: void 0 };
+    }
+    const envelope = ledger.get(runId);
+    const outcome = envelope?.outcome ?? (result.succeeded === true ? "succeeded" : "failed");
+    const detail = result.boundaryViolated === true ? WRITE_BOUNDARY_VIOLATION_REASON : result.failureReason;
+    return {
+      stepId,
+      runId,
+      agentId: envelope?.agentId ?? null,
+      outcome,
+      detail: typeof detail === "string" && detail.length > 0 ? detail : void 0
+    };
+  });
+  const startedMs = Date.parse(record.startedAt);
+  const endedMs = record.endedAt === null ? now() : Date.parse(record.endedAt);
+  return {
+    rootId: record.id,
+    fleet: record.fleet,
+    startedAt: record.startedAt,
+    elapsedMs: Number.isFinite(startedMs) && Number.isFinite(endedMs) ? Math.max(0, endedMs - startedMs) : 0,
+    running: record.endedAt === null,
+    resumedFrom: record.resumedFrom,
+    plannedSteps: stepIds.length,
+    recordedSteps: settled.size,
+    steps
+  };
+}
+function renderFleetRunView(model, width = DEFAULT_WIDTH) {
+  const columns = Math.max(MIN_WIDTH, width);
+  const rule = "\u2500".repeat(columns);
+  const lines = [];
+  lines.push(truncatePlain(`fleet ${sanitizeBounded(model.fleet, 64)}  root ${model.rootId}`, columns));
+  const resumed = model.resumedFrom === null ? "" : `  resumed from ${sanitizeBounded(model.resumedFrom, 64)}`;
+  lines.push(
+    truncatePlain(
+      `started ${model.startedAt}  elapsed ${formatElapsed(model.elapsedMs)}  ${model.recordedSteps} of ${model.plannedSteps} steps recorded${model.running ? "  (running)" : ""}${resumed}`,
+      columns
+    )
+  );
+  lines.push(rule);
+  if (model.steps.length === 0) {
+    lines.push("no steps recorded for this fleet run.");
+  } else {
+    const rows = model.steps.map((step) => ({
+      step: sanitizeBounded(step.stepId, STEP_ID_MAX_WIDTH),
+      runId: step.runId ?? "-",
+      outcome: sanitizeBounded(step.outcome, 32),
+      tail: [step.agentId, step.detail].filter((part) => part !== null && part !== void 0).join(": ")
+    }));
+    const stepWidth = Math.max(...rows.map((row) => row.step.length));
+    const runWidth = Math.max(...rows.map((row) => row.runId.length));
+    const outcomeWidth = Math.max(...rows.map((row) => row.outcome.length));
+    for (const row of rows) {
+      const head = `${row.step.padEnd(stepWidth)}  ${row.runId.padEnd(runWidth)}  ${row.outcome.padEnd(outcomeWidth)}`;
+      const text = row.tail.length === 0 ? head : `${head}  ${sanitizeBounded(row.tail, DETAIL_MAX_WIDTH)}`;
+      lines.push(truncatePlain(text.trimEnd(), columns));
+    }
+  }
+  lines.push(rule);
+  lines.push("clio-coder fleet view <run id> for one step's transcript, receipt, and ledger entry");
+  return lines;
+}
+function fail(message) {
+  process.stderr.write(`clio-coder fleet view: ${message}
+`);
+  return 2;
+}
+function parseViewArgs(args) {
+  const parsed = { follow: false, help: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "--follow" || arg === "-f") {
+      parsed.follow = true;
+      continue;
+    }
+    if (arg === "--watch") {
+      const value = args[i + 1];
+      if (value === void 0 || value.startsWith("-")) return "--watch requires a selection-file path";
+      parsed.watchPath = value;
+      i += 1;
+      continue;
+    }
+    const dirRole = arg === "--config-dir" ? "config" : arg === "--data-dir" ? "data" : arg === "--state-dir" ? "state" : arg === "--cache-dir" ? "cache" : null;
+    if (dirRole !== null) {
+      const value = args[i + 1];
+      if (value === void 0 || value.startsWith("-")) return `${arg} requires a directory path`;
+      parsed.dirs ??= {};
+      parsed.dirs[dirRole] = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg.startsWith("-")) return `unknown flag: ${arg}`;
+    if (parsed.runId !== void 0) return `unexpected argument: ${arg}`;
+    parsed.runId = arg;
+  }
+  if (parsed.watchPath !== void 0 && parsed.runId !== void 0) {
+    return "--watch follows the selection file; it does not take a run id";
+  }
+  if (parsed.watchPath !== void 0 && parsed.follow) {
+    return "--watch already follows; drop --follow";
+  }
+  return parsed;
+}
+function applyViewDirs(dirs) {
+  if (dirs === void 0) return;
+  if (dirs.config !== void 0) process.env.CLIO_CODER_CONFIG_DIR = dirs.config;
+  if (dirs.data !== void 0) process.env.CLIO_CODER_DATA_DIR = dirs.data;
+  if (dirs.state !== void 0) process.env.CLIO_CODER_STATE_DIR = dirs.state;
+  if (dirs.cache !== void 0) process.env.CLIO_CODER_CACHE_DIR = dirs.cache;
+  resetXdgCache();
+}
+function readWatchSelection(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+  const line = raw.split("\n", 1)[0]?.trim() ?? "";
+  return line.length > 0 && line.length <= 128 ? line : null;
+}
+function terminalWidth() {
+  const columns = process.stdout.columns;
+  return typeof columns === "number" && columns >= MIN_WIDTH ? columns : DEFAULT_WIDTH;
+}
+async function runFleetView(args) {
+  const parsed = parseViewArgs(args);
+  if (typeof parsed === "string") {
+    process.stderr.write(`clio-coder fleet view: ${parsed}
+`);
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  applyViewDirs(parsed.dirs);
+  if (parsed.watchPath !== void 0) {
+    if (process.stdout.isTTY !== true || process.stdin.isTTY !== true) {
+      const selected = readWatchSelection(parsed.watchPath);
+      const model = selected === null ? null : loadRunViewModel(selected);
+      process.stdout.write(`${renderWatchView(selected, model, terminalWidth()).join("\n")}
+`);
+      return 0;
+    }
+    return watchSelection(parsed.watchPath);
+  }
+  if (parsed.runId === void 0) {
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.runId.startsWith(FLEET_ROOT_PREFIX)) {
+    const root = resolveFleetRootId(parsed.runId);
+    if (!("rootId" in root)) {
+      return root.candidates.length === 0 ? fail(`unknown fleet run '${parsed.runId}' (no record under ${fleetRunsDir()})`) : fail(`fleet root id '${parsed.runId}' is ambiguous: ${root.candidates.slice(0, 8).join(", ")}`);
+    }
+    const fleetModel = loadFleetRunViewModel(root.rootId);
+    if (fleetModel === null) return fail(`unknown fleet run '${root.rootId}'`);
+    if (parsed.follow) {
+      process.stderr.write("clio-coder fleet view: --follow applies to a run id, not a fleet root; printing the index\n");
+    }
+    process.stdout.write(`${renderFleetRunView(fleetModel, terminalWidth()).join("\n")}
+`);
+    return 0;
+  }
+  const resolved = resolveRunId(parsed.runId);
+  if (!("runId" in resolved)) {
+    return resolved.candidates.length === 0 ? fail(`unknown run '${parsed.runId}' (not in the run ledger under ${clioStateDir()})`) : fail(`run id '${parsed.runId}' is ambiguous: ${resolved.candidates.slice(0, 8).join(", ")}`);
+  }
+  const runId = resolved.runId;
+  const snapshot = loadRunViewModel(runId);
+  if (snapshot === null) return fail(`unknown run '${runId}'`);
+  if (!parsed.follow || process.stdout.isTTY !== true || process.stdin.isTTY !== true) {
+    if (parsed.follow) {
+      process.stderr.write("clio-coder fleet view: --follow needs an interactive terminal; printing a snapshot\n");
+    }
+    process.stdout.write(`${renderRunView(snapshot, terminalWidth()).join("\n")}
+`);
+    return 0;
+  }
+  return followRun(runId);
+}
+async function watchSelection(selectionPath) {
+  const { ProcessTerminal, TuiAltScreen } = await import("./tui-primitives-K5PASC3O.js");
+  const terminal = new ProcessTerminal();
+  const tui = new TuiAltScreen(terminal);
+  let selected = readWatchSelection(selectionPath);
+  let model = selected === null ? null : loadRunViewModel(selected);
+  const view = {
+    render(width) {
+      const lines = renderWatchView(selected, model, width);
+      lines.push("");
+      lines.push("watching the workers-view selection\u2026 q to quit");
+      return lines;
+    },
+    invalidate() {
+    }
+  };
+  tui.addChild(view);
+  return await new Promise((resolve) => {
+    let settled = false;
+    const timer = setInterval(() => {
+      selected = readWatchSelection(selectionPath);
+      model = selected === null ? null : loadRunViewModel(selected);
+      tui.requestRender();
+    }, POLL_MS);
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearInterval(timer);
+      removeInput();
+      tui.stop();
+      resolve(0);
+    };
+    const removeInput = tui.addInputListener((data) => {
+      if (data === "q" || data === QUIT_CTRL_C || data === QUIT_ESCAPE) {
+        finish();
+        return { consume: true };
+      }
+      return void 0;
+    });
+    tui.start();
+    tui.requestRender();
+  });
+}
+async function followRun(runId) {
+  const { ProcessTerminal, TuiAltScreen } = await import("./tui-primitives-K5PASC3O.js");
+  const terminal = new ProcessTerminal();
+  const tui = new TuiAltScreen(terminal);
+  let model = loadRunViewModel(runId);
+  let following = true;
+  const view = {
+    render(width) {
+      if (model === null) return [`run ${runId} left the ledger.`];
+      const lines = renderRunView(model, width);
+      lines.push("");
+      lines.push(following ? "following\u2026 q to quit" : "run finished. q to quit");
+      return lines;
+    },
+    invalidate() {
+    }
+  };
+  tui.addChild(view);
+  return await new Promise((resolve) => {
+    let settled = false;
+    const timer = setInterval(() => {
+      model = loadRunViewModel(runId);
+      if (model?.terminal === true) following = false;
+      tui.requestRender();
+    }, POLL_MS);
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearInterval(timer);
+      removeInput();
+      tui.stop();
+      resolve(0);
+    };
+    const removeInput = tui.addInputListener((data) => {
+      if (data === "q" || data === QUIT_CTRL_C || data === QUIT_ESCAPE) {
+        finish();
+        return { consume: true };
+      }
+      return void 0;
+    });
+    tui.start();
+    tui.requestRender();
+  });
+}
+
+export {
+  loadRunViewModel,
+  loadFleetRunViewModel,
+  runFleetView
+};
+//# sourceMappingURL=chunk-7RY5VZPH.js.map

package/dist/{chunk-OEDBCISO.js → chunk-ABLSQ6JX.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-5B2AEOW5.js";
 import {
   ToolNames
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   StringEnum
-} from "./chunk-UOSL25KY.js";
+} from "./chunk-VXMFAE2W.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -43,4 +43,4 @@ export {
   CODE_NAV_MAX_LIMIT,
   codeNavToolSurface
 };
-//# sourceMappingURL=chunk-OEDBCISO.js.map
+//# sourceMappingURL=chunk-ABLSQ6JX.js.map

package/dist/{chunk-5HFBWUMU.js → chunk-AFKWHWXF.js}

@@ -15,14 +15,11 @@ import {
   parseBulkFrame,
   parseControlFrame,
   toolSignatureOf
-} from "./chunk-CMZWFGD2.js";
+} from "./chunk-VAVR4IJY.js";
 import {
   enableClioCompileCache,
   workerCompileCacheEnvironment
-} from "./chunk-I4HZDVNP.js";
-import {
-  atomicWrite
-} from "./chunk-KV2AOLDF.js";
+} from "./chunk-2LEAKD4C.js";
 import {
   AI_AGENT_NAME,
   withClioAgentEnvironment
@@ -33,7 +30,7 @@ import {
 } from "./chunk-IWHMRKLL.js";
 import {
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -154,7 +151,7 @@ import { performance } from "node:perf_hooks";
 init_esm_shims();
 import { createHash } from "node:crypto";
 function computeSettingsFingerprint(settings) {
-  return createHash("sha256").update(`clio.settings:${canonicalJson(settings)}`, "utf8").digest("hex");
+  return createHash("sha256").update(`clio-coder.settings:${canonicalJson(settings)}`, "utf8").digest("hex");
 }
 function verifyWorkerAttestation(attestation, approved) {
   if (attestation.protocolVersion !== WORKER_PROTOCOL_VERSION) {
@@ -199,7 +196,7 @@ function approvedIdentityForSpec(spec) {
   };
 }
 function workerSpecDigestOf(spec) {
-  return createHash("sha256").update(`clio.workerSpec:${canonicalJson(spec)}`, "utf8").digest("hex");
+  return createHash("sha256").update(`clio-coder.workerSpec:${canonicalJson(spec)}`, "utf8").digest("hex");
 }
 function resourceOrNull(value) {
   return value.known ? value.value : null;
@@ -720,14 +717,6 @@ function readFleetPreflightRecords() {
     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) {
@@ -765,12 +754,13 @@ function routeFactVerdict(requirement, records = readFleetPreflightRecords(), op
   }
   return evaluateRouteFacts(targets, resources, requirement, options);
 }
-var PREFLIGHT_MARKER = "clio-preflight/1";
+var PREFLIGHT_MARKER = "clio-coder-preflight/1";
+var LEGACY_PREFLIGHT_MARKER = "clio-preflight/1";
 var DEFAULT_PREFLIGHT_TIMEOUT_MS = 2e4;
 function buildPreflightScript(node, projectRoot, targets = []) {
   const entry = node.clioCoderEntry !== void 0 && node.clioCoderEntry.trim().length > 0 ? node.clioCoderEntry.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 versionProbe = cliBase !== null ? `v=$(${cliBase} --version 2>/dev/null | head -n 1); if [ -n "$v" ]; then echo "clioCoder=$v"; else echo clioCoder=missing; fi` : `echo clioCoder=custom-entry`;
   const lines = [
     `echo ${shellQuote(PREFLIGHT_MARKER)}`,
     `if cd ${shellQuote(projectRoot)} 2>/dev/null; then echo cwd=ok; else echo cwd=missing; fi`,
@@ -871,7 +861,7 @@ async function runFleetNodePreflight(node, projectRoot, options) {
   const probeStartedAt = performance2.now();
   const result = await runSsh(sshBinary, buildSshArgs(node, script), timeoutMs);
   const probeDurationMs = Math.round(performance2.now() - probeStartedAt);
-  if (!result.stdout.includes(PREFLIGHT_MARKER)) {
+  if (!result.stdout.includes(PREFLIGHT_MARKER) && !result.stdout.includes(LEGACY_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;
@@ -893,8 +883,9 @@ async function runFleetNodePreflight(node, projectRoot, options) {
   };
   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";
+  const clioCoderLine = lines.find((line) => line.startsWith("clioCoder="));
+  const legacyClioLine = lines.find((line) => line.startsWith("clio="));
+  const clioValue = clioCoderLine?.slice("clioCoder=".length) ?? legacyClioLine?.slice("clio=".length) ?? "missing";
   if (clioValue === "custom-entry") {
     checks.clioPresent = true;
     checks.versionMatch = true;
@@ -928,9 +919,8 @@ export {
   localNodeIdentity,
   createSshWorkerTransport,
   readFleetPreflightRecords,
-  recordFleetPreflight,
   fleetPreflightVerdict,
   routeFactVerdict,
   runFleetNodePreflight
 };
-//# sourceMappingURL=chunk-5HFBWUMU.js.map
+//# sourceMappingURL=chunk-AFKWHWXF.js.map