@iowarp/clio-coder 0.3.9 → 0.4.0

package/dist/chunk-QDC3K2U3.js

@@ -0,0 +1,262 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  clioDataDir,
+  resolveClioDirs
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/toolchain/registry.ts
+init_esm_shims();
+var PINNED_TOOLS = [
+  {
+    id: "herdr",
+    version: "0.8.2",
+    summary: "terminal multiplexer with an agent-aware socket API; powers Clio panes",
+    homepage: "https://herdr.dev",
+    license: "Apache-2.0",
+    binaries: ["herdr"],
+    primaryBinary: "herdr",
+    // Lowered from the pin on evidence, which is the bar this file sets for
+    // moving a floor. `herdr api schema --json` was read from 0.7.5
+    // (protocol 17) and 0.8.2 (protocol 20): every method the mux domain
+    // sends exists in both, and the only two 0.8.2 adds, `workspace.move_block`
+    // and `workspace.reordered`, are ones Clio never sends. The two methods
+    // that are not universal are already gated at runtime by protocol number
+    // in `src/domains/mux/protocol.ts`, whose own floor is 17, so an operator's
+    // 0.7.5 takes the documented fallback rather than failing. 0.7.5 is the
+    // oldest release actually checked, not the oldest that might work.
+    minimumVersion: "0.7.5",
+    versionArgs: ["--version"],
+    downloads: {
+      "linux-x64": {
+        url: "https://github.com/herdrdev/herdr/releases/download/v0.8.2/herdr-linux-x86_64",
+        sha256: "976150a14d490c94b243ea2e1a7eb2dfb67f12e36b182db90936f6728e6aecf4",
+        archive: "raw",
+        binaryMembers: { herdr: "" },
+        documentMembers: []
+      },
+      "linux-arm64": {
+        url: "https://github.com/herdrdev/herdr/releases/download/v0.8.2/herdr-linux-aarch64",
+        sha256: "f55610658e1c2e0d2aaef730b4b2ab885f7f8ba00285ab372bfb14f2e3d5b40d",
+        archive: "raw",
+        binaryMembers: { herdr: "" },
+        documentMembers: []
+      },
+      "darwin-x64": {
+        url: "https://github.com/herdrdev/herdr/releases/download/v0.8.2/herdr-macos-x86_64",
+        sha256: "ab50262c8190cd7aa9056d249d255c08c328c3e8716de9cfa29db4f131b8e2c1",
+        archive: "raw",
+        binaryMembers: { herdr: "" },
+        documentMembers: []
+      },
+      "darwin-arm64": {
+        url: "https://github.com/herdrdev/herdr/releases/download/v0.8.2/herdr-macos-aarch64",
+        sha256: "a5d4f4d504d8b309c91f811050559300faba31258425f53c50852fc96f6ae574",
+        archive: "raw",
+        binaryMembers: { herdr: "" },
+        documentMembers: []
+      }
+    },
+    // No `win32-x64` entry, and not for want of an asset. herdr publishes
+    // `herdr-windows-x86_64.zip` for this tag and it was downloaded and read:
+    // alongside `herdr.exe` it carries a ConPTY runtime, `conpty/conpty.dll`
+    // and `conpty/x64/OpenConsole.exe`, that has to sit in a subdirectory
+    // beside the executable. The installer places every declared member flat
+    // under its basename, so declaring this asset would install a `herdr.exe`
+    // with its runtime scattered next to it, which is a broken install that
+    // checksums and unpacks cleanly. Windows herdr waits on the installer
+    // learning to preserve a member's relative path.
+    //
+    // The release asset is a bare executable, so the Apache-2.0 text comes
+    // from the repository at the pinned tag.
+    documents: [
+      {
+        name: "LICENSE",
+        url: "https://raw.githubusercontent.com/herdrdev/herdr/v0.8.2/LICENSE",
+        sha256: "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+      }
+    ]
+  },
+  {
+    id: "yazi",
+    version: "26.8.15",
+    summary: "terminal file manager; the file-picker pane preset",
+    homepage: "https://yazi-rs.github.io",
+    license: "MIT",
+    binaries: ["yazi", "ya"],
+    primaryBinary: "yazi",
+    // Stays at the pin, now for a measured reason rather than caution. On
+    // 26.1.22 the one command Clio sends, `ya emit-to <receiver> cd <path>`,
+    // has the same signature it has at the pin. What was never exercised
+    // there is the rest of the surface: the managed profile Clio generates
+    // (`yazi.toml`, `keymap.toml`, `init.lua`) and the DDS payload shapes a
+    // pick comes back in. A profile schema mismatch degrades quietly into a
+    // file manager that opens and does the wrong thing, which is worse than
+    // vendoring a second copy. Lower this once a pick round trip has been
+    // driven end to end on the older release.
+    minimumVersion: "26.8.15",
+    versionArgs: ["--version"],
+    downloads: {
+      "linux-x64": {
+        url: "https://github.com/sxyazi/yazi/releases/download/v26.8.15/yazi-x86_64-unknown-linux-gnu.zip",
+        sha256: "cc67eb7991550c2f9407cda52d3f5af0937627aa6884e7de99a04fcf059807e0",
+        archive: "zip",
+        binaryMembers: {
+          yazi: "yazi-x86_64-unknown-linux-gnu/yazi",
+          ya: "yazi-x86_64-unknown-linux-gnu/ya"
+        },
+        documentMembers: ["yazi-x86_64-unknown-linux-gnu/LICENSE"]
+      },
+      "linux-arm64": {
+        url: "https://github.com/sxyazi/yazi/releases/download/v26.8.15/yazi-aarch64-unknown-linux-gnu.zip",
+        sha256: "f5a85771f06bb0e8c488136ae0aedaec8d341a7cee995549df391d7d852fe8d1",
+        archive: "zip",
+        binaryMembers: {
+          yazi: "yazi-aarch64-unknown-linux-gnu/yazi",
+          ya: "yazi-aarch64-unknown-linux-gnu/ya"
+        },
+        documentMembers: ["yazi-aarch64-unknown-linux-gnu/LICENSE"]
+      },
+      "darwin-x64": {
+        url: "https://github.com/sxyazi/yazi/releases/download/v26.8.15/yazi-x86_64-apple-darwin.zip",
+        sha256: "70bb2bcf57d8af862a54e2d12f2fddceefb9aa4ba3783e9a4dcbf2a8e64aacb3",
+        archive: "zip",
+        binaryMembers: {
+          yazi: "yazi-x86_64-apple-darwin/yazi",
+          ya: "yazi-x86_64-apple-darwin/ya"
+        },
+        documentMembers: ["yazi-x86_64-apple-darwin/LICENSE"]
+      },
+      "darwin-arm64": {
+        url: "https://github.com/sxyazi/yazi/releases/download/v26.8.15/yazi-aarch64-apple-darwin.zip",
+        sha256: "3f54907ea08abe96506f4b22239340ed8923a6aeaeae78f33d59bce57daca4cd",
+        archive: "zip",
+        binaryMembers: {
+          yazi: "yazi-aarch64-apple-darwin/yazi",
+          ya: "yazi-aarch64-apple-darwin/ya"
+        },
+        documentMembers: ["yazi-aarch64-apple-darwin/LICENSE"]
+      },
+      // Same shape as the other three: two executables and a LICENSE at
+      // known member paths, so the installer needs nothing new to place it.
+      "win32-x64": {
+        url: "https://github.com/sxyazi/yazi/releases/download/v26.8.15/yazi-x86_64-pc-windows-msvc.zip",
+        sha256: "451f6770999fa8f9b08e6c9f94a688c263b6d3007b0944c4407f1ae335eace30",
+        archive: "zip",
+        binaryMembers: {
+          yazi: "yazi-x86_64-pc-windows-msvc/yazi.exe",
+          ya: "yazi-x86_64-pc-windows-msvc/ya.exe"
+        },
+        documentMembers: ["yazi-x86_64-pc-windows-msvc/LICENSE"]
+      }
+    },
+    documents: []
+  },
+  {
+    id: "croc",
+    version: "11.3.6",
+    summary: "relay file transfer between machines; the transfer primitive's first backend",
+    homepage: "https://schollz.com/software/croc6",
+    license: "MIT",
+    binaries: ["croc"],
+    primaryBinary: "croc",
+    // Croc negotiates its relay protocol by major version, so any 11.x on
+    // PATH speaks to a pinned 11.x relay.
+    minimumVersion: "11.0.0",
+    versionArgs: ["--version"],
+    downloads: {
+      "linux-x64": {
+        url: "https://github.com/schollz/croc/releases/download/v11.3.6/croc_v11.3.6_Linux-64bit.tar.gz",
+        sha256: "bd18e01024f5ccc8e101c08c8233d4cffbfda4ff59acad80eaa1fc2963efc0b2",
+        archive: "tar.gz",
+        binaryMembers: { croc: "croc" },
+        documentMembers: ["LICENSE", "THIRD_PARTY_NOTICES.md"]
+      },
+      "linux-arm64": {
+        url: "https://github.com/schollz/croc/releases/download/v11.3.6/croc_v11.3.6_Linux-ARM64.tar.gz",
+        sha256: "c26ac67207301ed75ae0ece63796ec8a2a002b1cf64f4e3d3d8e7bcee508b5b3",
+        archive: "tar.gz",
+        binaryMembers: { croc: "croc" },
+        documentMembers: ["LICENSE", "THIRD_PARTY_NOTICES.md"]
+      },
+      "darwin-x64": {
+        url: "https://github.com/schollz/croc/releases/download/v11.3.6/croc_v11.3.6_macOS-64bit.tar.gz",
+        sha256: "701817a20f4d2bb4312f3234e6d328e0bdd68d6d1311db3a4ab4daf10906c5b2",
+        archive: "tar.gz",
+        binaryMembers: { croc: "croc" },
+        documentMembers: ["LICENSE", "THIRD_PARTY_NOTICES.md"]
+      },
+      "darwin-arm64": {
+        url: "https://github.com/schollz/croc/releases/download/v11.3.6/croc_v11.3.6_macOS-ARM64.tar.gz",
+        sha256: "96c4ef67751b4387e3d44a7a559aafe54094f0089f34a6c71dfb5361bd48d368",
+        archive: "tar.gz",
+        binaryMembers: { croc: "croc" },
+        documentMembers: ["LICENSE", "THIRD_PARTY_NOTICES.md"]
+      },
+      // A zip rather than a tarball on Windows, and the only entry in the
+      // table whose hash is confirmed by upstream's own checksums file
+      // rather than only by the download this repository made.
+      "win32-x64": {
+        url: "https://github.com/schollz/croc/releases/download/v11.3.6/croc_v11.3.6_Windows-64bit.zip",
+        sha256: "ed22552d371d55a9e3c3b612b982484fa00adaff8fb32c3f19f36dbf8e248bbf",
+        archive: "zip",
+        binaryMembers: { croc: "croc.exe" },
+        documentMembers: ["LICENSE", "THIRD_PARTY_NOTICES.md"]
+      }
+    },
+    documents: []
+  }
+];
+function currentToolPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "linux") {
+    if (arch === "x64") return "linux-x64";
+    if (arch === "arm64") return "linux-arm64";
+    return null;
+  }
+  if (platform === "darwin") {
+    if (arch === "x64") return "darwin-x64";
+    if (arch === "arm64") return "darwin-arm64";
+    return null;
+  }
+  if (platform === "win32" && arch === "x64") return "win32-x64";
+  return null;
+}
+function findPinnedTool(id) {
+  return PINNED_TOOLS.find((entry) => entry.id === id) ?? null;
+}
+function findPinnedToolByBinary(name) {
+  const bare = name.endsWith(".exe") ? name.slice(0, -4) : name;
+  return PINNED_TOOLS.find((entry) => entry.binaries.includes(bare)) ?? null;
+}
+
+// src/domains/toolchain/paths.ts
+init_esm_shims();
+import { join } from "node:path";
+function toolchainRoot() {
+  return join(resolveClioDirs().data, "tools");
+}
+function toolVersionDir(id, version) {
+  return join(toolchainRoot(), id, version);
+}
+function vendoredBinaryPath(id, version, binary) {
+  return join(toolVersionDir(id, version), process.platform === "win32" ? `${binary}.exe` : binary);
+}
+function ensureToolchainRoot() {
+  return join(clioDataDir(), "tools");
+}
+
+export {
+  PINNED_TOOLS,
+  currentToolPlatform,
+  findPinnedTool,
+  findPinnedToolByBinary,
+  toolchainRoot,
+  toolVersionDir,
+  vendoredBinaryPath,
+  ensureToolchainRoot
+};
+//# sourceMappingURL=chunk-QDC3K2U3.js.map

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

@@ -19,10 +19,10 @@ import {
 import {
   enableClioCompileCache,
   workerCompileCacheEnvironment
-} from "./chunk-I4HZDVNP.js";
+} from "./chunk-PQEFIJ36.js";
 import {
   atomicWrite
-} from "./chunk-KV2AOLDF.js";
+} from "./chunk-76ONBSIA.js";
 import {
   AI_AGENT_NAME,
   withClioAgentEnvironment
@@ -33,7 +33,7 @@ import {
 } from "./chunk-IWHMRKLL.js";
 import {
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -933,4 +933,4 @@ export {
   routeFactVerdict,
   runFleetNodePreflight
 };
-//# sourceMappingURL=chunk-5HFBWUMU.js.map
+//# sourceMappingURL=chunk-QLFS5GO2.js.map

package/dist/{chunk-GAYUJ7LE.js → chunk-QLL7ILRG.js}

@@ -7,10 +7,10 @@ import {
   TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
   runTaskMemoryPolicy,
   taskMemoryBankDelta
-} from "./chunk-O6I4CIEU.js";
+} from "./chunk-BKFJHQCA.js";
 import {
   isTerminalRunEnvelope
-} from "./chunk-4H6ULJ3H.js";
+} from "./chunk-J4W7KFM7.js";
 import {
   taskBoardCounts
 } from "./chunk-2JDWVJND.js";
@@ -21,23 +21,23 @@ import {
 import {
   legacyToolResultDigest,
   sanitizeToolResultDigest
-} from "./chunk-ODFEOB4F.js";
+} from "./chunk-CY6FY24N.js";
 import {
   ToolNames
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   registerForegroundStream
-} from "./chunk-MIX5N5AC.js";
+} from "./chunk-DQITNCXG.js";
 import {
   ceilChars
-} from "./chunk-AEYBF3TB.js";
+} from "./chunk-UM7N4G5A.js";
+import {
+  BusChannels
+} from "./chunk-HLW2MRKE.js";
 import {
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-B5CSFE7B.js";
-import {
-  BusChannels
-} from "./chunk-RKRLDWD3.js";
+} from "./chunk-BBVJUZHB.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -1388,8 +1388,9 @@ init_esm_shims();
 import { createHash as createHash2 } from "node:crypto";
 var MEMORY_INTERVENTION_REGISTRATION_ID = "observer.memory-intervention";
 var MEMORY_INTERVENTION_DEFAULT_WINDOW_STEPS = 8;
-var MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS = 400;
+var MEMORY_INTERVENTION_DEFAULT_MAX_TOKENS = 2e3;
 var MEMORY_INTERVENTION_DEFAULT_EVERY_N_TOOLS = 10;
+var MEMORY_INTERVENTION_TIMEOUT_BACKOFF_THRESHOLD = 2;
 var MEMORY_INTERVENTION_ACTIVITY_LIMIT = 20;
 var CALL_DESCRIPTION_MAX_CHARS = 180;
 var NO_EFFECTS = [];
@@ -1416,6 +1417,7 @@ function createMemoryInterventionRegistration(deps) {
   let outstandingStep = Promise.resolve();
   let rulesInjectedSincePromptedStep = false;
   let annotatedSinceTurnEnd = false;
+  let consecutiveLlmTimeouts = 0;
   return {
     id: MEMORY_INTERVENTION_REGISTRATION_ID,
     description: "maintain bounded task execution memory and selectively remind after repeated failures or compaction",
@@ -1581,27 +1583,32 @@ function createMemoryInterventionRegistration(deps) {
     let promptedResult;
     let telemetryDecision = null;
     try {
-      const client = deps.getModelClient?.() ?? null;
-      if (client === null) {
-        promptedResult = silent("no_client");
-      } else if (deps.backgroundEndpointBusy?.() === true) {
-        tier = "llm";
-        promptedStepTier = tier;
-        promptedResult = silent("endpoint_busy");
-        telemetryDecision = "dropped";
+      if (consecutiveLlmTimeouts >= MEMORY_INTERVENTION_TIMEOUT_BACKOFF_THRESHOLD) {
+        promptedResult = silent("llm_timeout_backoff");
       } else {
-        tier = "llm";
-        promptedStepTier = tier;
-        promptedResult = await runTaskMemoryPolicy(deps.bank, client, {
-          task: input.task?.trim() || currentTask,
-          trajectory: [...trajectory],
-          deterministicTrigger: input.deterministicTrigger,
-          maxTokens: live.maxTokens,
-          ...input.suppressIntervention === void 0 ? {} : { suppressIntervention: input.suppressIntervention },
-          previousReminder: lastInjectedMessage,
-          timeoutMs: live.timeoutMs,
-          ...deps.onEnvelope === void 0 ? {} : { onEnvelope: deps.onEnvelope }
-        });
+        const client = deps.getModelClient?.() ?? null;
+        if (client === null) {
+          promptedResult = silent("no_client");
+        } else if (deps.backgroundEndpointBusy?.() === true) {
+          tier = "llm";
+          promptedStepTier = tier;
+          promptedResult = silent("endpoint_busy");
+          telemetryDecision = "dropped";
+        } else {
+          tier = "llm";
+          promptedStepTier = tier;
+          promptedResult = await runTaskMemoryPolicy(deps.bank, client, {
+            task: input.task?.trim() || currentTask,
+            trajectory: [...trajectory],
+            deterministicTrigger: input.deterministicTrigger,
+            maxTokens: live.maxTokens,
+            modelMaxTokens: positiveInteger(deps.getModelMaxTokens?.(live.maxTokens), live.maxTokens),
+            ...input.suppressIntervention === void 0 ? {} : { suppressIntervention: input.suppressIntervention },
+            previousReminder: lastInjectedMessage,
+            timeoutMs: live.timeoutMs,
+            ...deps.onEnvelope === void 0 ? {} : { onEnvelope: deps.onEnvelope }
+          });
+        }
       }
     } catch (error) {
       promptedResult = silent("client_error");
@@ -1617,6 +1624,8 @@ function createMemoryInterventionRegistration(deps) {
         error: error instanceof Error ? error.message : "resolving the background model client failed"
       });
     }
+    if (tier === "llm" && promptedResult.decision === "timeout") consecutiveLlmTimeouts += 1;
+    else if (tier === "llm" && telemetryDecision !== "dropped") consecutiveLlmTimeouts = 0;
     lastDecision = promptedResult.decision;
     if (promptedResult.usage !== null) {
       try {
@@ -2458,4 +2467,4 @@ export {
   createWatchdogRegistration,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-GAYUJ7LE.js.map
+//# sourceMappingURL=chunk-QLL7ILRG.js.map

package/dist/{chunk-LXPJXFM5.js → chunk-QREDIESB.js}

@@ -5,19 +5,19 @@ import {
 import {
   probeWorkspace
 } from "./chunk-HVDIIIQW.js";
-import {
-  protectArtifact
-} from "./chunk-MV3K5QF2.js";
 import {
   isSessionEntry,
   isSessionHeader
 } from "./chunk-RAPCMZL4.js";
+import {
+  protectArtifact
+} from "./chunk-GCSMB2KY.js";
 import {
   stripTokenizerSentinels
 } from "./chunk-CFGTUFWB.js";
 import {
   BusChannels
-} from "./chunk-RKRLDWD3.js";
+} from "./chunk-HLW2MRKE.js";
 import {
   CURRENT_SESSION_FORMAT_VERSION,
   appendSessionFileEntry,
@@ -29,11 +29,11 @@ import {
   readSessionMeta,
   resumeSession,
   sessionPaths
-} from "./chunk-KV2AOLDF.js";
+} from "./chunk-76ONBSIA.js";
 import {
   clioStateDir,
   stateRootRemoved
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1475,4 +1475,4 @@ export {
   ledgerUsageCalls,
   SessionDomainModule
 };
-//# sourceMappingURL=chunk-LXPJXFM5.js.map
+//# sourceMappingURL=chunk-QREDIESB.js.map

package/dist/chunk-QSNYB6ZV.js

@@ -0,0 +1,195 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PINNED_TOOLS,
+  currentToolPlatform,
+  findPinnedTool,
+  findPinnedToolByBinary,
+  toolVersionDir,
+  vendoredBinaryPath
+} from "./chunk-QDC3K2U3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/toolchain/resolve.ts
+init_esm_shims();
+import { statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+
+// src/domains/toolchain/version.ts
+init_esm_shims();
+import { spawnSync } from "node:child_process";
+var VERSION_PATTERN = /(\d+)\.(\d+)\.(\d+)/;
+var PROBE_TIMEOUT_MS = 2e3;
+function parseVersion(output) {
+  const match = VERSION_PATTERN.exec(output);
+  if (!match) return null;
+  return `${match[1]}.${match[2]}.${match[3]}`;
+}
+function compareVersions(a, b) {
+  const left = numericParts(a);
+  const right = numericParts(b);
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function satisfiesMinimum(found, minimum) {
+  if (found === null) return false;
+  return compareVersions(found, minimum) >= 0;
+}
+function probeBinaryVersion(binaryPath, args) {
+  const cached = probeCache.get(binaryPath);
+  if (cached !== void 0) return cached;
+  let version = null;
+  try {
+    const result = spawnSync(binaryPath, [...args], {
+      timeout: PROBE_TIMEOUT_MS,
+      encoding: "utf8",
+      // A version probe must never inherit a terminal or wait on input: some
+      // of these binaries are full-screen programs when given a tty.
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.error === void 0) {
+      version = parseVersion(`${result.stdout ?? ""}
+${result.stderr ?? ""}`);
+    }
+  } catch {
+    version = null;
+  }
+  probeCache.set(binaryPath, version);
+  return version;
+}
+var probeCache = /* @__PURE__ */ new Map();
+function numericParts(value) {
+  const match = VERSION_PATTERN.exec(value);
+  if (!match) return [0, 0, 0];
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+// src/domains/toolchain/resolve.ts
+function findExecutableOnPath(name) {
+  const pathEnv = process.env.PATH;
+  if (!pathEnv) return null;
+  const candidates = process.platform === "win32" ? [`${name}.exe`, name] : [name];
+  for (const dir of pathEnv.split(delimiter)) {
+    if (!dir) continue;
+    for (const candidate of candidates) {
+      const full = join(dir, candidate);
+      const stat = statSync(full, { throwIfNoEntry: false });
+      if (stat?.isFile() && (process.platform === "win32" || (stat.mode & 73) !== 0)) return full;
+    }
+  }
+  return null;
+}
+function resolveToolBinary(name) {
+  const entry = findPinnedToolByBinary(name) ?? findPinnedTool(name);
+  if (entry === null) {
+    const found = findExecutableOnPath(name);
+    return {
+      source: found === null ? "none" : "path",
+      binaryPath: found,
+      version: null,
+      entry: null,
+      pathCandidate: found === null ? null : { path: found, version: null, satisfiesMinimum: true },
+      vendoredPath: null
+    };
+  }
+  const binary = entry.binaries.includes(name) ? name : entry.primaryBinary;
+  return resolveEntryBinary(entry, binary);
+}
+function resolveEntryBinary(entry, binary) {
+  const pathCandidate = probePathCandidate(entry, binary);
+  const vendored = vendoredBinaryPath(entry.id, entry.version, binary);
+  const vendoredStat = statSync(vendored, { throwIfNoEntry: false });
+  const vendoredPath = vendoredStat?.isFile() ? vendored : null;
+  if (pathCandidate?.satisfiesMinimum) {
+    return {
+      source: "path",
+      binaryPath: pathCandidate.path,
+      version: pathCandidate.version,
+      entry,
+      pathCandidate,
+      vendoredPath
+    };
+  }
+  if (vendoredPath !== null) {
+    return {
+      source: "vendored",
+      binaryPath: vendoredPath,
+      version: entry.version,
+      entry,
+      pathCandidate,
+      vendoredPath
+    };
+  }
+  return { source: "none", binaryPath: null, version: null, entry, pathCandidate, vendoredPath: null };
+}
+function toolStatus(entry) {
+  const platform = currentToolPlatform();
+  const supported = platform !== null && entry.downloads[platform] !== void 0;
+  const resolution = resolveEntryBinary(entry, entry.primaryBinary);
+  return {
+    id: entry.id,
+    version: entry.version,
+    license: entry.license,
+    platform,
+    supported,
+    installed: resolution.vendoredPath !== null,
+    installDir: toolVersionDir(entry.id, entry.version),
+    resolution
+  };
+}
+function toolStatuses() {
+  return PINNED_TOOLS.map((entry) => toolStatus(entry));
+}
+function installRemedy(id) {
+  return `clio-coder tools install ${id}`;
+}
+function describeFloorRejection(status) {
+  const candidate = status.resolution.pathCandidate;
+  if (candidate === null || candidate.satisfiesMinimum) return null;
+  const floor = status.resolution.entry?.minimumVersion ?? status.version;
+  const found = candidate.version === null ? "an unreadable version" : candidate.version;
+  return `PATH copy ${candidate.path} is ${found}, below the ${floor} floor`;
+}
+function describeResolution(status) {
+  const { resolution } = status;
+  const rejection = describeFloorRejection(status);
+  if (resolution.source === "path") {
+    const version = resolution.version ?? "unreadable version";
+    return `PATH ${resolution.binaryPath} (${version}, pin ${status.version})`;
+  }
+  if (resolution.source === "vendored") {
+    const rejected = rejection === null ? "" : `; ${rejection}, so Clio runs the vendored copy`;
+    return `vendored ${resolution.binaryPath} (${status.version})${rejected}`;
+  }
+  if (!status.supported) {
+    const platform = status.platform ?? `${process.platform}-${process.arch}`;
+    const rejected = rejection === null ? "" : `; ${rejection}`;
+    return `not installed and no pinned asset for this platform (${platform})${rejected}`;
+  }
+  if (rejection !== null) {
+    return `${rejection}, and nothing is vendored (install with \`${installRemedy(status.id)}\`)`;
+  }
+  return `not found (install with \`${installRemedy(status.id)}\`)`;
+}
+function probePathCandidate(entry, binary) {
+  const found = findExecutableOnPath(binary);
+  if (found === null) return null;
+  const probeTarget = binary === entry.primaryBinary ? found : findExecutableOnPath(entry.primaryBinary) ?? found;
+  const version = probeBinaryVersion(probeTarget, entry.versionArgs);
+  return { path: found, version, satisfiesMinimum: satisfiesMinimum(version, entry.minimumVersion) };
+}
+
+export {
+  findExecutableOnPath,
+  resolveToolBinary,
+  toolStatus,
+  toolStatuses,
+  installRemedy,
+  describeFloorRejection,
+  describeResolution
+};
+//# sourceMappingURL=chunk-QSNYB6ZV.js.map