@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/chunk-D4CJV46V.js

@@ -0,0 +1,462 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  currentToolPlatform,
+  ensureToolchainRoot,
+  findPinnedTool,
+  toolchainRoot
+} from "./chunk-QDC3K2U3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/toolchain/install.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, renameSync, rmSync as rmSync2, writeFileSync } from "node:fs";
+import { basename, join as join2 } from "node:path";
+
+// src/domains/toolchain/archive.ts
+init_esm_shims();
+import { gunzipSync, inflateRawSync } from "node:zlib";
+var MAX_TOTAL_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+var ZIP_EOCD_SIGNATURE = 101010256;
+var ZIP_CENTRAL_SIGNATURE = 33639248;
+var ZIP_LOCAL_SIGNATURE = 67324752;
+var ZIP_STORED = 0;
+var ZIP_DEFLATED = 8;
+function readZipEntries(buffer) {
+  const eocd = findEndOfCentralDirectory(buffer);
+  if (eocd < 0) throw new Error("not a zip archive: end-of-central-directory record not found");
+  const entryCount = buffer.readUInt16LE(eocd + 10);
+  let cursor = buffer.readUInt32LE(eocd + 16);
+  const entries = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (let i = 0; i < entryCount; i += 1) {
+    if (cursor + 46 > buffer.length || buffer.readUInt32LE(cursor) !== ZIP_CENTRAL_SIGNATURE) {
+      throw new Error(`zip central directory is malformed at entry ${i}`);
+    }
+    const method = buffer.readUInt16LE(cursor + 10);
+    const compressedSize = buffer.readUInt32LE(cursor + 20);
+    const uncompressedSize = buffer.readUInt32LE(cursor + 24);
+    const nameLength = buffer.readUInt16LE(cursor + 28);
+    const extraLength = buffer.readUInt16LE(cursor + 30);
+    const commentLength = buffer.readUInt16LE(cursor + 32);
+    const externalAttributes = buffer.readUInt32LE(cursor + 38);
+    const localOffset = buffer.readUInt32LE(cursor + 42);
+    const name = buffer.toString("utf8", cursor + 46, cursor + 46 + nameLength);
+    cursor += 46 + nameLength + extraLength + commentLength;
+    if (name.endsWith("/")) continue;
+    assertSafeMember(name);
+    total += uncompressedSize;
+    if (total > MAX_TOTAL_UNCOMPRESSED_BYTES) throw new Error("zip archive expands beyond the size cap");
+    if (localOffset + 30 > buffer.length || buffer.readUInt32LE(localOffset) !== ZIP_LOCAL_SIGNATURE) {
+      throw new Error(`zip local header is malformed for ${name}`);
+    }
+    const localNameLength = buffer.readUInt16LE(localOffset + 26);
+    const localExtraLength = buffer.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+    const raw = buffer.subarray(dataStart, dataStart + compressedSize);
+    const data = method === ZIP_STORED ? Buffer.from(raw) : method === ZIP_DEFLATED ? inflateRawSync(raw) : (() => {
+      throw new Error(`unsupported zip compression method ${method} for ${name}`);
+    })();
+    const unixMode = externalAttributes >>> 16 & 4095;
+    entries.set(name, { path: name, data, mode: unixMode === 0 ? null : unixMode });
+  }
+  return entries;
+}
+function readTarGzEntries(buffer) {
+  const tar = gunzipSync(buffer);
+  const entries = /* @__PURE__ */ new Map();
+  let offset = 0;
+  let total = 0;
+  let pendingLongName = null;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const rawName = readTarString(header, 0, 100);
+    const prefix = readTarString(header, 345, 155);
+    const size = readTarOctal(header, 124, 12);
+    const mode = readTarOctal(header, 100, 8);
+    const typeFlag = String.fromCharCode(header[156] ?? 0);
+    const dataStart = offset + 512;
+    const padded = Math.ceil(size / 512) * 512;
+    offset = dataStart + padded;
+    if (typeFlag === "L") {
+      pendingLongName = tar.toString("utf8", dataStart, dataStart + size).replace(/\0+$/, "");
+      continue;
+    }
+    if (typeFlag === "x" || typeFlag === "g" || typeFlag === "5") {
+      pendingLongName = null;
+      continue;
+    }
+    if (typeFlag !== "0" && typeFlag !== "\0") {
+      pendingLongName = null;
+      continue;
+    }
+    const name = pendingLongName ?? (prefix.length > 0 ? `${prefix}/${rawName}` : rawName);
+    pendingLongName = null;
+    if (name.length === 0 || name.endsWith("/")) continue;
+    assertSafeMember(name);
+    total += size;
+    if (total > MAX_TOTAL_UNCOMPRESSED_BYTES) throw new Error("tar archive expands beyond the size cap");
+    entries.set(name, {
+      path: name,
+      data: Buffer.from(tar.subarray(dataStart, dataStart + size)),
+      mode: mode === 0 ? null : mode & 4095
+    });
+  }
+  return entries;
+}
+function findEndOfCentralDirectory(buffer) {
+  const start = Math.max(0, buffer.length - (22 + 65535));
+  for (let i = buffer.length - 22; i >= start; i -= 1) {
+    if (buffer.readUInt32LE(i) === ZIP_EOCD_SIGNATURE) return i;
+  }
+  return -1;
+}
+function readTarString(header, offset, length) {
+  const slice = header.subarray(offset, offset + length);
+  const end = slice.indexOf(0);
+  return slice.toString("utf8", 0, end === -1 ? slice.length : end);
+}
+function readTarOctal(header, offset, length) {
+  const text = readTarString(header, offset, length).trim();
+  if (text.length === 0) return 0;
+  const value = Number.parseInt(text, 8);
+  return Number.isNaN(value) ? 0 : value;
+}
+function assertSafeMember(name) {
+  if (name.startsWith("/") || name.startsWith("\\") || /^[A-Za-z]:/.test(name)) {
+    throw new Error(`archive member has an absolute path: ${name}`);
+  }
+  if (name.split(/[/\\]/).includes("..")) {
+    throw new Error(`archive member escapes the archive root: ${name}`);
+  }
+}
+
+// src/domains/toolchain/remove.ts
+init_esm_shims();
+import { readdirSync, rmdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+var STALE_STAGING_MS = 36e5;
+function installedToolVersions(id, options = {}) {
+  const dir = join(options.root ?? toolchainRoot(), id);
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((name) => !name.startsWith(".") && isDirectory(join(dir, name))).sort((a, b) => a.localeCompare(b));
+}
+function removeTool(id, options = {}) {
+  if (findPinnedTool(id) === null) {
+    const dir = join(options.root ?? toolchainRoot(), id);
+    return { ok: false, id, dir, removed: [], failed: [], staleStaging: [], message: `unknown tool: ${id}` };
+  }
+  return removeVersions(id, null, options);
+}
+function pruneSupersededVersions(id, keep, options = {}) {
+  return removeVersions(id, keep, options);
+}
+function removeVersions(id, keep, options) {
+  const root = options.root ?? toolchainRoot();
+  const dir = join(root, id);
+  const versions = installedToolVersions(id, { root }).filter((version) => version !== keep);
+  const removed = [];
+  const failed = [];
+  for (const version of versions) {
+    try {
+      rmSync(join(dir, version), { recursive: true, force: true });
+      removed.push(version);
+    } catch (error) {
+      failed.push({ version, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  const staleStaging = sweepStaleStaging(dir, options.staleStagingMs ?? STALE_STAGING_MS);
+  if (keep === null && failed.length === 0) {
+    try {
+      rmdirSync(dir);
+    } catch {
+    }
+  }
+  return {
+    ok: failed.length === 0,
+    id,
+    dir,
+    removed,
+    failed,
+    staleStaging,
+    message: describeRemoval(id, dir, keep, removed, failed, staleStaging)
+  };
+}
+function sweepStaleStaging(dir, staleMs) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const cutoff = Date.now() - staleMs;
+  const swept = [];
+  for (const name of names.sort((a, b) => a.localeCompare(b))) {
+    if (!STAGING_NAME.test(name)) continue;
+    const stat = statSync(join(dir, name), { throwIfNoEntry: false });
+    if (stat === void 0 || !stat.isDirectory() || stat.mtimeMs > cutoff) continue;
+    try {
+      rmSync(join(dir, name), { recursive: true, force: true });
+      swept.push(name);
+    } catch {
+    }
+  }
+  return swept;
+}
+var STAGING_NAME = /^\.[^/]+\.(?:incomplete|replaced)-\d+-[a-z0-9]+$/;
+function describeRemoval(id, dir, keep, removed, failed, staleStaging) {
+  const swept = staleStaging.length === 0 ? "" : `; swept ${staleStaging.length} abandoned install ${staleStaging.length === 1 ? "directory" : "directories"}`;
+  const trouble = failed.map((entry) => `${entry.version} (${entry.error})`).join(", ");
+  if (failed.length > 0) {
+    const done = removed.length > 0 ? `removed ${removed.join(", ")}; ` : "";
+    return `${done}could not remove ${id} ${trouble} under ${dir}${swept}`;
+  }
+  if (removed.length === 0) {
+    return keep === null ? `${id} is not installed under ${dir}; nothing to remove${swept}` : `${id} has no superseded versions under ${dir}${swept}`;
+  }
+  const what = `${id} ${removed.join(", ")}`;
+  const headline = keep === null ? `removed ${what} from ${dir}` : `pruned ${what} from ${dir}, keeping ${keep}`;
+  return `${headline}${swept}`;
+}
+function isDirectory(path) {
+  return statSync(path, { throwIfNoEntry: false })?.isDirectory() === true;
+}
+
+// src/domains/toolchain/install.ts
+var DOWNLOAD_TIMEOUT_MS = 3e5;
+async function installTool(id, options = {}) {
+  const entry = findPinnedTool(id);
+  if (entry === null) {
+    return failure(id, "unknown", "", `unknown tool: ${id}`);
+  }
+  return installPinnedTool(entry, options);
+}
+async function installPinnedTool(entry, options = {}) {
+  const root = options.root ?? ensureToolchainRoot();
+  const dir = join2(root, entry.id, entry.version);
+  const platform = options.platform ?? currentToolPlatform();
+  const progress = options.onProgress ?? (() => void 0);
+  if (platform === null) {
+    return failure(entry.id, entry.version, dir, `no pinned asset for ${process.platform}-${process.arch}`);
+  }
+  const download = entry.downloads[platform];
+  if (download === void 0) {
+    return failure(entry.id, entry.version, dir, `no pinned asset for ${platform}`);
+  }
+  const installedBinaries = Object.keys(download.binaryMembers).map((name) => join2(dir, executableName(name, platform)));
+  if (!options.force && installedBinaries.every((path) => existsSync(path))) {
+    const swept2 = prune(root, entry);
+    return {
+      ok: true,
+      id: entry.id,
+      version: entry.version,
+      dir,
+      binaries: installedBinaries,
+      documents: [],
+      skipped: true,
+      pruned: swept2.pruned,
+      message: `${entry.id} ${entry.version} is already installed at ${dir}${swept2.note}`
+    };
+  }
+  const fetcher = options.fetch ?? fetchAsset;
+  let assetBytes;
+  try {
+    progress(`downloading ${download.url}`);
+    assetBytes = await fetcher(download.url);
+  } catch (error) {
+    return failure(entry.id, entry.version, dir, `download failed: ${messageOf(error)}`);
+  }
+  const actual = sha256(assetBytes);
+  if (actual !== download.sha256) {
+    return failure(
+      entry.id,
+      entry.version,
+      dir,
+      `checksum mismatch for ${download.url}: expected ${download.sha256}, got ${actual}. Nothing was written.`
+    );
+  }
+  progress(`checksum verified (${actual})`);
+  const documentBytes = /* @__PURE__ */ new Map();
+  for (const doc of entry.documents) {
+    let bytes;
+    try {
+      progress(`downloading ${doc.url}`);
+      bytes = await fetcher(doc.url);
+    } catch (error) {
+      return failure(entry.id, entry.version, dir, `download failed for ${doc.name}: ${messageOf(error)}`);
+    }
+    const docHash = sha256(bytes);
+    if (docHash !== doc.sha256) {
+      return failure(
+        entry.id,
+        entry.version,
+        dir,
+        `checksum mismatch for ${doc.url}: expected ${doc.sha256}, got ${docHash}. Nothing was written.`
+      );
+    }
+    documentBytes.set(doc.name, bytes);
+  }
+  let members;
+  try {
+    members = unpack(assetBytes, download);
+  } catch (error) {
+    return failure(entry.id, entry.version, dir, `could not unpack the asset: ${messageOf(error)}`);
+  }
+  for (const memberPath of Object.values(download.binaryMembers)) {
+    if (!members.has(memberPath)) {
+      return failure(entry.id, entry.version, dir, `the asset does not contain ${memberPath || entry.primaryBinary}`);
+    }
+  }
+  for (const memberPath of download.documentMembers) {
+    if (!members.has(memberPath)) {
+      return failure(entry.id, entry.version, dir, `the asset does not contain ${memberPath}`);
+    }
+  }
+  const staging = join2(root, entry.id, `.${entry.version}.incomplete-${process.pid}-${Date.now().toString(36)}`);
+  const retired = join2(root, entry.id, `.${entry.version}.replaced-${process.pid}-${Date.now().toString(36)}`);
+  let retiredOld = false;
+  const binaries = [];
+  const documents = [];
+  try {
+    mkdirSync(staging, { recursive: true });
+    for (const [name, memberPath] of Object.entries(download.binaryMembers)) {
+      const member = members.get(memberPath);
+      if (member === void 0) continue;
+      const target = join2(staging, executableName(name, platform));
+      writeFileSync(target, member.data);
+      chmodSync(target, 493);
+      binaries.push(join2(dir, executableName(name, platform)));
+    }
+    for (const memberPath of download.documentMembers) {
+      const member = members.get(memberPath);
+      if (member === void 0) continue;
+      const target = join2(staging, basename(memberPath));
+      writeFileSync(target, member.data, { mode: 420 });
+      documents.push(join2(dir, basename(memberPath)));
+    }
+    for (const [name, bytes] of documentBytes) {
+      writeFileSync(join2(staging, name), bytes, { mode: 420 });
+      documents.push(join2(dir, name));
+    }
+    writeFileSync(
+      join2(staging, "clio-coder-install.json"),
+      `${JSON.stringify(
+        {
+          id: entry.id,
+          version: entry.version,
+          platform,
+          license: entry.license,
+          homepage: entry.homepage,
+          url: download.url,
+          sha256: download.sha256,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        null,
+        2
+      )}
+`,
+      { mode: 420 }
+    );
+    if (options.force && existsSync(dir)) {
+      renameSync(dir, retired);
+      retiredOld = true;
+    }
+    renameSync(staging, dir);
+    if (retiredOld) {
+      rmSync2(retired, { recursive: true, force: true });
+      retiredOld = false;
+    }
+  } catch (error) {
+    rmSync2(staging, { recursive: true, force: true });
+    if (retiredOld && !existsSync(dir)) {
+      try {
+        renameSync(retired, dir);
+        retiredOld = false;
+      } catch {
+      }
+    }
+    if (!options.force && existsSync(dir)) {
+      const swept2 = prune(root, entry);
+      return {
+        ok: true,
+        id: entry.id,
+        version: entry.version,
+        dir,
+        binaries: installedBinaries,
+        documents: [],
+        skipped: true,
+        pruned: swept2.pruned,
+        message: `${entry.id} ${entry.version} was installed concurrently at ${dir}${swept2.note}`
+      };
+    }
+    return failure(entry.id, entry.version, dir, `install failed: ${messageOf(error)}`);
+  }
+  const swept = prune(root, entry);
+  return {
+    ok: true,
+    id: entry.id,
+    version: entry.version,
+    dir,
+    binaries,
+    documents,
+    skipped: false,
+    pruned: swept.pruned,
+    message: `installed ${entry.id} ${entry.version} (${entry.license}) at ${dir}${swept.note}`
+  };
+}
+function prune(root, entry) {
+  const outcome = pruneSupersededVersions(entry.id, entry.version, { root });
+  const parts = [];
+  if (outcome.removed.length > 0) parts.push(`pruned ${outcome.removed.join(", ")}`);
+  if (outcome.staleStaging.length > 0) {
+    const count = outcome.staleStaging.length;
+    parts.push(`swept ${count} abandoned install ${count === 1 ? "directory" : "directories"}`);
+  }
+  if (outcome.failed.length > 0) {
+    parts.push(`could not prune ${outcome.failed.map((item) => `${item.version} (${item.error})`).join(", ")}`);
+  }
+  return { pruned: outcome.removed, note: parts.length === 0 ? "" : `; ${parts.join("; ")}` };
+}
+function unpack(bytes, download) {
+  if (download.archive === "raw") {
+    return /* @__PURE__ */ new Map([["", { path: "", data: bytes, mode: 493 }]]);
+  }
+  if (download.archive === "zip") return readZipEntries(bytes);
+  return readTarGzEntries(bytes);
+}
+async function fetchAsset(url) {
+  const response = await fetch(url, {
+    redirect: "follow",
+    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
+  });
+  if (!response.ok) throw new Error(`HTTP ${response.status} ${response.statusText}`);
+  return Buffer.from(await response.arrayBuffer());
+}
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function executableName(name, platform) {
+  return platform.startsWith("win32") ? `${name}.exe` : name;
+}
+function failure(id, version, dir, message) {
+  return { ok: false, id, version, dir, binaries: [], documents: [], skipped: false, pruned: [], message };
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  installedToolVersions,
+  removeTool,
+  installTool,
+  installPinnedTool
+};
+//# sourceMappingURL=chunk-D4CJV46V.js.map

package/dist/chunk-D7E7WCDF.js

@@ -0,0 +1,27 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/naming-compat.ts
+init_esm_shims();
+var warned = /* @__PURE__ */ new Set();
+var LEGACY_NAMING_COMPATIBILITY_RETIREMENT = "v0.7.0";
+function warnLegacyNaming(legacy, canonical) {
+  const key = `${legacy}\0${canonical}`;
+  if (warned.has(key)) return;
+  warned.add(key);
+  process.emitWarning(
+    `'${legacy}' is a deprecated Clio Coder identifier; use '${canonical}'. Legacy naming compatibility is scheduled for removal in ${LEGACY_NAMING_COMPATIBILITY_RETIREMENT}.`,
+    { code: "CLIO_CODER_LEGACY_NAMING", type: "DeprecationWarning" }
+  );
+}
+function namingCompatibilityEnvironment(canonical, legacy, value) {
+  return { [canonical]: value, [legacy]: value };
+}
+
+export {
+  warnLegacyNaming,
+  namingCompatibilityEnvironment
+};
+//# sourceMappingURL=chunk-D7E7WCDF.js.map

package/dist/{chunk-5PVQ4SRS.js → chunk-E67WX76H.js}

@@ -3,142 +3,30 @@ import {
   appendOutOfTurnUsageRow,
   readEvidenceIndex,
   writeEvidenceIndexRowQueued
-} from "./chunk-FWDFM5ZU.js";
+} from "./chunk-AK5XEFVZ.js";
 import {
   createDispatchTraceMirror,
   traceDatabasePath
-} from "./chunk-YW7UVM5V.js";
+} from "./chunk-ZAZB4JMW.js";
 import {
   FAILURE_CAUSE_TAGS,
-  buildEvidence
-} from "./chunk-TEO2TLVN.js";
+  buildEvidence,
+  createCostTracker
+} from "./chunk-XKA2ICR3.js";
 import {
   uncachedPrefillTokens
 } from "./chunk-3DPEIQKN.js";
-import {
-  normalizeCostProvenance
-} from "./chunk-MIX5N5AC.js";
 import {
   BusChannels
-} from "./chunk-RKRLDWD3.js";
+} from "./chunk-HLW2MRKE.js";
 import {
   clioDataDir,
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/domains/observability/cost.ts
-init_esm_shims();
-function emptyCostAggregate() {
-  return { knownUsd: 0, hasEstimated: false, hasUnknown: false, allKnownFree: false, calls: 0 };
-}
-function costWasMeasured(cost) {
-  return cost !== null && cost !== void 0 && cost.calls > 0;
-}
-function accumulateCostAmount(aggregate, amount, first) {
-  return {
-    knownUsd: aggregate.knownUsd + (amount.provenance === "unknown" ? 0 : amount.usd),
-    hasEstimated: aggregate.hasEstimated || amount.provenance === "estimated",
-    hasUnknown: aggregate.hasUnknown || amount.provenance === "unknown",
-    allKnownFree: amount.provenance === "known_free" && (first || aggregate.allKnownFree),
-    calls: aggregate.calls + 1
-  };
-}
-function aggregateCostAmounts(amounts) {
-  return amounts.reduce(
-    (aggregate, amount, index) => accumulateCostAmount(aggregate, amount, index === 0),
-    emptyCostAggregate()
-  );
-}
-function formatUsdAmount(value) {
-  if (!Number.isFinite(value) || value <= 0) return "$0.00";
-  return value < 0.01 ? `$${value.toFixed(4)}` : `$${value.toFixed(2)}`;
-}
-function formatCostAggregate(cost) {
-  if (!costWasMeasured(cost)) return null;
-  if (cost.allKnownFree) return "$0.00 local";
-  if (cost.hasUnknown) return cost.knownUsd > 0 ? `${formatUsdAmount(cost.knownUsd)} +?` : null;
-  if (cost.hasEstimated) return `~${formatUsdAmount(cost.knownUsd)} est`;
-  return formatUsdAmount(cost.knownUsd);
-}
-var COST_NOT_MEASURED = "not measured";
-function costAggregateForAmount(usd, provenance) {
-  return aggregateCostAmounts([{ usd, provenance: normalizeCostProvenance(provenance) }]);
-}
-function emptyBreakdown() {
-  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoningTokens: 0, totalTokens: 0 };
-}
-function createCostTracker() {
-  const log = [];
-  let total = 0;
-  const totals = emptyBreakdown();
-  return {
-    accumulate(providerId, attributedModelId, tokens, usd, breakdown, costProvenance, modelIdFacts, label) {
-      const resolvedUsd = usd ?? 0;
-      const provenance = normalizeCostProvenance(costProvenance);
-      const input = breakdown?.input ?? 0;
-      const output = breakdown?.output ?? 0;
-      const cacheRead = breakdown?.cacheRead ?? 0;
-      const cacheWrite = breakdown?.cacheWrite ?? 0;
-      const reasoningTokens = breakdown?.reasoningTokens ?? 0;
-      const apiCalls = breakdown?.apiCalls;
-      log.push({
-        providerId,
-        attributedModelId,
-        requestedModelIds: [...modelIdFacts?.requestedModelIds ?? [attributedModelId]],
-        responseModelIdObservationCounts: modelIdFacts ? { ...modelIdFacts.responseModelIdObservationCounts } : {
-          reportedCalls: 0,
-          notReportedCalls: 0,
-          notObservedCalls: apiCalls ?? 1,
-          legacyDifferenceOnlyCalls: 0
-        },
-        tokens,
-        usd: resolvedUsd,
-        provenance,
-        input,
-        output,
-        cacheRead,
-        cacheWrite,
-        reasoningTokens,
-        ...apiCalls !== void 0 ? { apiCalls } : {},
-        ...label !== void 0 ? { label } : {}
-      });
-      total += resolvedUsd;
-      totals.input += input;
-      totals.output += output;
-      totals.cacheRead += cacheRead;
-      totals.cacheWrite += cacheWrite;
-      totals.reasoningTokens += reasoningTokens;
-      totals.totalTokens += tokens;
-      return resolvedUsd;
-    },
-    sessionTotal() {
-      return total;
-    },
-    sessionCost() {
-      return aggregateCostAmounts(log.map((entry) => ({ usd: entry.usd, provenance: entry.provenance })));
-    },
-    sessionTokens() {
-      return { ...totals };
-    },
-    entries() {
-      return log;
-    },
-    reset() {
-      log.length = 0;
-      total = 0;
-      totals.input = 0;
-      totals.output = 0;
-      totals.cacheRead = 0;
-      totals.cacheWrite = 0;
-      totals.reasoningTokens = 0;
-      totals.totalTokens = 0;
-    }
-  };
-}
-
 // src/domains/observability/background-memory-usage.ts
 init_esm_shims();
 function backgroundMemoryUsageRow(usage, options) {
@@ -340,7 +228,7 @@ function createObservabilityProjection(bus, deps) {
         listener(snapshot);
       } catch (error) {
         const message = error instanceof Error ? error.stack ?? error.message : String(error);
-        console.error(`[clio:observability] projection listener crashed: ${message}`);
+        console.error(`[clio-coder:observability] projection listener crashed: ${message}`);
       }
     }
   }
@@ -707,7 +595,7 @@ async function buildAndIndexEvidence(runId, succeeded, attempt, hooks) {
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`[clio:evidence] auto-build failed for run ${runId}: ${message}
+    process.stderr.write(`[clio-coder:evidence] auto-build failed for run ${runId}: ${message}
 `);
     hooks.onFailed(runId, message);
   }
@@ -866,12 +754,8 @@ function createObservabilityDomainModule(options = {}) {
 
 export {
   readAccountabilitySummary,
-  aggregateCostAmounts,
-  formatCostAggregate,
-  COST_NOT_MEASURED,
-  costAggregateForAmount,
   recordBackgroundMemoryStep,
   ObservabilityDomainModule,
   createObservabilityDomainModule
 };
-//# sourceMappingURL=chunk-5PVQ4SRS.js.map
+//# sourceMappingURL=chunk-E67WX76H.js.map

package/dist/{chunk-FQ4SKYE4.js → chunk-EBY63B7G.js}

@@ -13,11 +13,8 @@ function clampTimerDelayMs(value) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var negativeDurations = 0;
 function rawDurationMs(start, end) {
-  const elapsed = end - start;
-  if (elapsed < 0) negativeDurations += 1;
-  return elapsed;
+  return end - start;
 }
 
 export {
@@ -26,4 +23,4 @@ export {
   sleep,
   rawDurationMs
 };
-//# sourceMappingURL=chunk-FQ4SKYE4.js.map
+//# sourceMappingURL=chunk-EBY63B7G.js.map