docks-kit 0.1.5 → 0.3.0

package/cli/src/engine-native/skillsSync.ts

@@ -7,11 +7,12 @@
 import { spawnSync } from "node:child_process"
 import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, rmdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
-import { capture, commandExists, isExecutable, p, which } from "./exec"
+import { p, writeFileIfChanged } from "./exec"
 import type { Ctx } from "./index"
 import { compareCodepoints } from "./jq"
-import { echo, log, warn } from "./output"
+import type { EngineServices, Platform } from "./services"
 import { ensure, field } from "./toolchain"
+import { payloadText } from "../payload"
 
 export interface SkillsState {
   present: number
@@ -20,11 +21,9 @@ export interface SkillsState {
 export function skillsSync(ctx: Ctx): SkillsState {
   const state: SkillsState = { present: 0 }
   const skillsDir = p(ctx.agentsDir, "skills")
-  const manifest = p(ctx.repoDir, "SoT", ".agents", "skills.txt")
+  const manifest = payloadText("SoT/.agents/skills.txt")
   const snapshot = p(ctx.agentsDir, ".kit-managed-skills")
 
-  if (!existsSync(manifest)) return state
-
   if (!ctx.dryRun) mkdirSync(skillsDir, { recursive: true })
 
   syncUniversal(ctx, state, skillsDir, manifest)
@@ -58,8 +57,9 @@ function readSlugs(file: string): Array<string> {
 }
 
 function syncUniversal(ctx: Ctx, state: SkillsState, skillsDir: string, manifest: string): void {
-  if (!commandExists("node")) {
-    warn("node/npx not in PATH — skipping universal skills bootstrap (install Node.js to enable)")
+  const { change, echo, verbose, warn } = ctx.services.logger
+  if (ctx.services.deps.probe("npx").state === "missing") {
+    ctx.services.deps.warnMissing("npx", ctx.services.logger, "skipping universal skills bootstrap")
     return
   }
 
@@ -68,7 +68,7 @@ function syncUniversal(ctx: Ctx, state: SkillsState, skillsDir: string, manifest
   let failed = 0
   let healed = 0
 
-  for (const slug of readSlugs(manifest)) {
+  for (const slug of normalizeManifest(manifest)) {
     const base = slug.slice(slug.lastIndexOf("/") + 1)
 
     if (ctx.dryRun) {
@@ -103,12 +103,14 @@ function syncUniversal(ctx: Ctx, state: SkillsState, skillsDir: string, manifest
   state.present = added + already
 
   if (added > 0) {
-    log(`Universal skills synced (+${added} new, ${already} already present)`)
+    change(`Universal skills synced (+${added} new, ${already} already present)`)
+    ctx.nextStepTriggers.skillsRestart = true
   } else {
-    log(`Universal skills already in sync (${already} present)`)
+    verbose(`Universal skills already in sync (${already} present)`)
   }
   if (healed > 0) {
-    log(`Claude per-tool symlinks healed (+${healed}) — canonical present, ~/.claude/skills/<name> was missing or broken`)
+    change(`Claude per-tool symlinks healed (+${healed}) — canonical present, ~/.claude/skills/<name> was missing or broken`)
+    ctx.nextStepTriggers.skillsRestart = true
   }
   if (failed > 0) {
     warn(`${failed} skill install(s) failed — re-run sync or install manually with: npx skills add <slug> -g -y -a claude-code codex`)
@@ -125,6 +127,7 @@ function isDir(path: string): boolean {
 
 /** skills::heal_claude_symlink — true when a heal occurred. */
 function healClaudeSymlink(ctx: Ctx, skillsDir: string, base: string): boolean {
+  const { echo, warn } = ctx.services.logger
   const canonical = p(skillsDir, base)
   const claudeSkillsDir = p(ctx.home, ".claude", "skills")
   const claudeLink = p(claudeSkillsDir, base)
@@ -138,7 +141,7 @@ function healClaudeSymlink(ctx: Ctx, skillsDir: string, base: string): boolean {
     if (current === relTarget) return false
     // win32: `npx skills add` creates absolute symlinks/junctions — any link
     // that RESOLVES to the canonical dir is healthy, not stale.
-    if (process.platform === "win32" && realpathEquals(claudeLink, canonical)) return false
+    if (ctx.services.platform.isWindows() && realpathEquals(claudeLink, canonical)) return false
     if (ctx.dryRun) {
       echo(`[dry-run] would replace stale Claude symlink: ~/.claude/skills/${base} -> ${current}  (correct: ${relTarget})`)
       return true
@@ -156,7 +159,7 @@ function healClaudeSymlink(ctx: Ctx, skillsDir: string, base: string): boolean {
   }
 
   mkdirSync(claudeSkillsDir, { recursive: true })
-  return linkOrCopy(relTarget, claudeLink)
+  return linkOrCopyWithWarnings(relTarget, claudeLink, ctx.services)
 }
 
 function lstat(path: string): ReturnType<typeof lstatSync> | undefined {
@@ -201,10 +204,10 @@ function removeLink(path: string): boolean {
 }
 
 /** skills::_link_or_copy — real symlink preferred, copy fallback (Windows). */
-export function linkOrCopy(target: string, link: string): boolean {
+export function linkOrCopy(target: string, link: string, platform: Platform): boolean {
   removeLink(link)
   try {
-    symlinkSync(target, link, process.platform === "win32" ? "dir" : undefined)
+    symlinkSync(target, link, platform.isWindows() ? "dir" : undefined)
   } catch {
     // fall through to the copy fallback below
   }
@@ -216,47 +219,56 @@ export function linkOrCopy(target: string, link: string): boolean {
   } catch {
     // fall through to the existence check below
   }
-  if (existsSync(link)) {
-    warn(`symlinks unsupported here — ${link} is a copy (refreshed on sync; enable Windows Developer Mode for real links)`)
-    return true
+  return existsSync(link)
+}
+
+function linkOrCopyWithWarnings(target: string, link: string, services: EngineServices): boolean {
+  const linked = linkOrCopy(target, link, services.platform)
+  if (!linked) {
+    services.logger.warn(`could not create ${link} (symlink and copy both failed)`)
+  } else if (lstat(link)?.isSymbolicLink() !== true) {
+    services.logger.warn(`symlinks unsupported here — ${link} is a copy (refreshed on sync; enable Windows Developer Mode for real links)`)
   }
-  warn(`could not create ${link} (symlink and copy both failed)`)
-  return false
+  return linked
 }
 
 // ------------------------------------------------- toolchain callbacks ----
 
 /** skills::_agent_browser_install. */
-export function agentBrowserInstall(mode: "install" | "upgrade", version: string): number {
+export function agentBrowserInstall(mode: "install" | "upgrade", version: string, services: EngineServices): number {
+  const { change, verbose, warn } = services.logger
   const verb = mode === "upgrade" ? "Upgrading" : "Installing"
   const pkg = version !== "" ? `agent-browser@${version}` : "agent-browser"
-  const installFlags = process.platform === "linux" ? ["--with-deps"] : []
+  const installFlags = services.platform.isLinux() ? ["--with-deps"] : []
 
-  log(`${verb} agent-browser CLI via npm${version !== "" ? ` (pinned ${version})` : ""}...`)
+  verbose(`${verb} agent-browser CLI via npm${version !== "" ? ` (pinned ${version})` : ""}...`)
   if (spawnSync("npm", ["install", "-g", pkg], { stdio: "ignore" }).status !== 0) {
     warn(`npm install -g ${pkg} failed. Try manually: npm install -g ${pkg}`)
     return 1
   }
 
   if (mode === "install") {
-    log("Downloading Chrome for Testing (~175 MB; sudo may be requested for system libs on Linux)...")
+    warn("Downloading Chrome for Testing (~175 MB; sudo may be requested for system libs on Linux)...")
     if (spawnSync("agent-browser", ["install", ...installFlags], { stdio: "inherit" }).status !== 0) {
       warn(`agent-browser install failed. Re-run manually: agent-browser install ${installFlags.join(" ")}`)
       return 1
     }
   }
-  const out = capture("agent-browser", ["--version"])
+  const out = services.deps.version("agent-browser")
   const fields = (out.split("\n")[0] ?? "").trim().split(/[ \t]+/)
   const version2 = out !== "" ? fields[fields.length - 1] ?? "version unknown" : "version unknown"
-  log(`agent-browser CLI ready (${version2})`)
+  change(`agent-browser CLI ready (${version2})`)
   return 0
 }
 
 function syncAgentBrowserCli(ctx: Ctx, manifest: string): void {
-  if (!existsSync(manifest) || !readFileSync(manifest, "utf8").split("\n").includes("vercel-labs/agent-browser")) return
+  const { warn } = ctx.services.logger
+  if (!manifest.split("\n").includes("vercel-labs/agent-browser")) return
 
-  if (!commandExists("npm")) {
-    if (!ctx.dryRun) warn("npm not found — cannot auto-install agent-browser CLI. Install Node.js, then re-run sync.")
+  if (ctx.services.deps.probe("npm").state === "missing") {
+    if (!ctx.dryRun) {
+      ctx.services.deps.warnMissing("npm", ctx.services.logger, "cannot auto-install agent-browser CLI; re-run sync after installing")
+    }
     return
   }
 
@@ -267,21 +279,16 @@ function syncAgentBrowserCli(ctx: Ctx, manifest: string): void {
 
 /** skills::_find_bun — resolved bun path or "". */
 function findBun(ctx: Ctx): string {
-  const onPath = which("bun")
-  if (onPath !== "") return onPath
-  const bunInstall = process.env["BUN_INSTALL"] !== undefined && process.env["BUN_INSTALL"] !== "" ? process.env["BUN_INSTALL"] : p(ctx.home, ".bun")
-  for (const cand of [p(bunInstall, "bin", "bun"), p(ctx.home, ".bun", "bin", "bun")]) {
-    if (isExecutable(cand)) return cand
-  }
-  return ""
+  return ctx.services.deps.path("bun")
 }
 
 /** skills::_bun_bootstrap — bun path or "" after a failed bootstrap. */
-export function bunBootstrap(ctx: Ctx): string {
+export function bunBootstrap(ctx: Ctx, services: EngineServices): string {
+  const { change, warn } = services.logger
   let bun = findBun(ctx)
   if (bun !== "") return bun
 
-  if (!commandExists("curl")) {
+  if (services.deps.probe("curl").state === "missing") {
     warn("Bun and curl both missing — cannot bootstrap Bun. Install Bun manually, then re-run sync.")
     return ""
   }
@@ -298,41 +305,44 @@ export function bunBootstrap(ctx: Ctx): string {
     warn("Bun install failed. Install manually: curl -fsSL https://bun.sh/install -o /tmp/bun.sh && bash /tmp/bun.sh")
     return ""
   }
-  const v = capture(bun, ["--version"])
-  log(`Bun installed (${v !== "" ? v : "version unknown"})`)
+  const version = services.deps.version("bun")
+  change(`Bun installed (${version !== "" ? version : "version unknown"})`)
   return bun
 }
 
 /** skills::_effect_solutions_install. */
-export function effectSolutionsInstall(ctx: Ctx): (mode: "install" | "upgrade", version: string) => number {
-  return (mode, version) => {
+export function effectSolutionsInstall(
+  ctx: Ctx
+): (mode: "install" | "upgrade", version: string, services: EngineServices) => number {
+  return (mode, version, services) => {
+    const { change, verbose, warn } = services.logger
     const verb = mode === "upgrade" ? "Upgrading" : "Installing"
     const pkg = `effect-solutions@${version !== "" ? version : "latest"}`
 
-    const bun = bunBootstrap(ctx)
+    const bun = bunBootstrap(ctx, services)
     if (bun === "") return 1
 
-    log(`${verb} effect-solutions CLI via bun${version !== "" ? ` (pinned ${version})` : ""}...`)
+    verbose(`${verb} effect-solutions CLI via bun${version !== "" ? ` (pinned ${version})` : ""}...`)
     if (spawnSync(bun, ["add", "-g", pkg], { stdio: "ignore" }).status !== 0) {
       warn(`bun add -g ${pkg} failed. Try manually: bun add -g ${pkg}`)
       return 1
     }
 
-    const gbin = capture(bun, ["pm", "-g", "bin"])
+    const location = services.deps.location("effect-solutions")
+    const gbin = location.binDir
     // win32: bun writes an .exe shim (not the bare Unix name), and the
     // ~/.local/bin link step below is Unix-only plumbing (non-interactive
     // agent PATH) — bun's global bin is already the Windows PATH entry.
-    if (process.platform === "win32") {
-      const found = gbin !== "" && ["exe", "cmd", "bunx"].some((ext) => existsSync(p(gbin, `effect-solutions.${ext}`)))
-      if (found) log(`effect-solutions CLI ready (${gbin})`)
+    if (services.platform.isWindows()) {
+      if (location.path !== "") change(`effect-solutions CLI ready (${gbin})`)
       else warn(`effect-solutions installed but no shim found under '${gbin !== "" ? gbin : "<unknown>"}' — check bun pm -g bin`)
       return 0
     }
-    if (gbin !== "" && isExecutable(p(gbin, "effect-solutions"))) {
+    if (location.path !== "") {
       mkdirSync(p(ctx.home, ".local", "bin"), { recursive: true })
-      linkOrCopy(bun, p(ctx.home, ".local", "bin", "bun"))
-      linkOrCopy(p(gbin, "effect-solutions"), p(ctx.home, ".local", "bin", "effect-solutions"))
-      log("effect-solutions CLI ready (linked bun + effect-solutions into ~/.local/bin)")
+      linkOrCopyWithWarnings(bun, p(ctx.home, ".local", "bin", "bun"), services)
+      linkOrCopyWithWarnings(location.path, p(ctx.home, ".local", "bin", "effect-solutions"), services)
+      change("effect-solutions CLI ready (linked bun + effect-solutions into ~/.local/bin)")
     } else {
       warn(`effect-solutions installed but binary not found under '${gbin !== "" ? gbin : "<unknown>"}' — link it onto PATH manually`)
     }
@@ -341,9 +351,8 @@ export function effectSolutionsInstall(ctx: Ctx): (mode: "install" | "upgrade",
 }
 
 function syncEffectSolutionsCli(ctx: Ctx): void {
-  const settings = p(ctx.repoDir, "SoT", ".claude", "settings.json")
-  if (!existsSync(settings)) return
-  if (!/"effect-kit@docks"[ \t]*:[ \t]*true/.test(readFileSync(settings, "utf8"))) return
+  const { warn } = ctx.services.logger
+  if (!/"effect-kit@docks"[ \t]*:[ \t]*true/.test(payloadText("SoT/.claude/settings.json"))) return
 
   if (ensure(ctx, "effect-solutions", effectSolutionsInstall(ctx)) !== 0) {
     warn("effect-solutions bootstrap failed — continuing sync")
@@ -353,6 +362,7 @@ function syncEffectSolutionsCli(ctx: Ctx): void {
 // ----------------------------------------------------- prune + snapshot ----
 
 function reconcileRemovals(ctx: Ctx, manifest: string, snapshot: string): void {
+  const { change, echo, warn } = ctx.services.logger
   if (!existsSync(snapshot)) {
     if (ctx.dryRun) {
       echo(
@@ -362,7 +372,7 @@ function reconcileRemovals(ctx: Ctx, manifest: string, snapshot: string): void {
     return
   }
 
-  const current = readSlugs(manifest)
+  const current = normalizeManifest(manifest)
   let removed = 0
   let failed = 0
   for (const slug of readSlugs(snapshot)) {
@@ -383,7 +393,10 @@ function reconcileRemovals(ctx: Ctx, manifest: string, snapshot: string): void {
     }
   }
 
-  if (removed > 0) log(`Kit-managed skills removed (-${removed})`)
+  if (removed > 0) {
+    change(`Kit-managed skills removed (-${removed})`)
+    ctx.nextStepTriggers.skillsRestart = true
+  }
   if (failed > 0) warn(`${failed} skill remove(s) failed — re-run with --prune or run: npx skills remove -g -y -a '*' -s <name>`)
 }
 
@@ -391,19 +404,22 @@ function updateSnapshot(ctx: Ctx, manifest: string, snapshot: string): void {
   if (ctx.dryRun) return
 
   mkdirSync(ctx.agentsDir, { recursive: true })
-  const sorted = [...new Set(readSlugs(manifest))].sort(compareCodepoints)
-  writeFileSync(snapshot, sorted.length > 0 ? `${sorted.join("\n")}\n` : "")
+  const sorted = [...new Set(normalizeManifest(manifest))].sort(compareCodepoints)
+  writeFileIfChanged(snapshot, sorted.length > 0 ? `${sorted.join("\n")}\n` : "")
 }
 
 // -------------------------------------------------------------- summary ----
 
 export function skillsSummary(ctx: Ctx, state: SkillsState): void {
+  const { echo } = ctx.services.logger
   echo(`Skills:   ${p(ctx.agentsDir, "skills")}`)
   if (!ctx.dryRun) {
     echo(`          ${state.present} universal skill(s) installed`)
   }
 }
 
-export function skillsNextSteps(): void {
-  echo("Restart Claude Code (and Codex) to discover newly installed universal skills.")
+export function skillsNextSteps(ctx: Ctx): Array<string> {
+  return ctx.verbose || ctx.nextStepTriggers.skillsRestart
+    ? ["Restart Claude Code (and Codex) to discover newly installed universal skills."]
+    : []
 }

package/cli/src/engine-native/toolchain.ts

@@ -2,23 +2,24 @@
  * Verified-version-floor layer over SoT/toolchain.json. Probe/install commands
  * spawn deterministic argv arrays and are covered by golden regression cases.
  */
-import { readFileSync, readSync } from "node:fs"
+import { readSync } from "node:fs"
 
-import { capture, commandExists, isExecutable, p } from "./exec"
+import type { ToolId } from "./deps"
 import type { Ctx } from "./index"
 import { compareCodepoints, isObject, parseJson, type Json } from "./jq"
-import { echo, log, warn } from "./output"
+import type { EngineServices } from "./services"
+import { payloadText } from "../payload"
 
-type InstallFn = (mode: "install" | "upgrade", version: string) => number
+type InstallFn = (mode: "install" | "upgrade", version: string, services: EngineServices) => number
 
-function manifest(ctx: Ctx): { [k: string]: Json } {
-  const doc = parseJson(readFileSync(p(ctx.repoDir, "SoT", "toolchain.json"), "utf8"))
+function manifest(): { [k: string]: Json } {
+  const doc = parseJson(payloadText("SoT/toolchain.json"))
   const tools = doc !== undefined && isObject(doc) ? doc["tools"] : undefined
   return tools !== undefined && isObject(tools) ? tools : {}
 }
 
 export function field(ctx: Ctx, tool: string, name: string): string {
-  const entry = manifest(ctx)[tool]
+  const entry = manifest()[tool]
   if (entry === undefined || !isObject(entry)) return ""
   const v = entry[name]
   return v === undefined || v === null ? "" : String(v)
@@ -37,15 +38,8 @@ export function isNewer(a: string, b: string): boolean {
   return compareCodepoints(a, b) > 0
 }
 
-export function present(ctx: Ctx, tool: string): boolean {
-  if (tool === "bun") {
-    return (
-      commandExists("bun") ||
-      isExecutable(p(process.env["BUN_INSTALL"] ?? p(ctx.home, ".bun"), "bin", "bun")) ||
-      isExecutable(p(ctx.home, ".bun", "bin", "bun"))
-    )
-  }
-  return commandExists(tool)
+export function present(ctx: Ctx, tool: ToolId): boolean {
+  return ctx.services.deps.probe(tool).state === "present"
 }
 
 function firstLineField(out: string, index: number): string {
@@ -53,67 +47,51 @@ function firstLineField(out: string, index: number): string {
   return fields[index === -1 ? fields.length - 1 : index] ?? ""
 }
 
-export function installedVersion(ctx: Ctx, tool: string): string {
-  if (!present(ctx, tool)) return ""
+export function installedVersion(ctx: Ctx, tool: ToolId): string {
+  const version = (): string => ctx.services.deps.version(tool)
   switch (tool) {
     case "rtk":
-      return firstLineField(capture("rtk", ["--version"]), 1)
+      return firstLineField(version(), 1)
     case "claude":
-      return firstLineField(capture("claude", ["--version"]), 0)
+      return firstLineField(version(), 0)
     case "codex":
-      return firstLineField(capture("codex", ["--version"]), -1)
-    case "bun":
-      return commandExists("bun") ? capture("bun", ["--version"]) : capture(p(ctx.home, ".bun", "bin", "bun"), ["--version"])
     case "agent-browser":
-      return firstLineField(capture("agent-browser", ["--version"]), -1)
-    case "effect-solutions": {
-      const bunbin = commandExists("bun") ? "bun" : p(ctx.home, ".bun", "bin", "bun")
-      if (bunbin !== "bun" && !isExecutable(bunbin)) return ""
-      const m = /effect-solutions@([0-9][0-9.]*)/.exec(capture(bunbin, ["pm", "-g", "ls"]))
-      return m?.[1] ?? ""
-    }
+      return firstLineField(version(), -1)
     case "git":
-      return firstLineField(capture("git", ["--version"]), 2)
+      return firstLineField(version(), 2)
     case "node":
-      return capture("node", ["--version"]).replace(/^v/, "")
-    case "npm":
-      return capture("npm", ["--version"])
+      return version().replace(/^v/, "")
     case "jq":
-      return capture("jq", ["--version"]).replace(/^jq-/, "")
+      return version().replace(/^jq-/, "")
     case "curl":
-      return firstLineField(capture("curl", ["--version"]), 1)
     case "tsc":
-      return firstLineField(capture("tsc", ["--version"]), 1)
+      return firstLineField(version(), 1)
+    case "bun":
+    case "effect-solutions":
+    case "npm":
+      return version()
     default:
       return ""
   }
 }
 
-export function latestVersion(tool: string): string {
-  switch (tool) {
-    case "rtk": {
-      const body = capture("curl", ["-fsSL", "--max-time", "5", "https://api.github.com/repos/rtk-ai/rtk/releases/latest"])
-      const doc = parseJson(body)
-      const tag = doc !== undefined && isObject(doc) && typeof doc["tag_name"] === "string" ? doc["tag_name"] : ""
-      return tag.replace(/^v/, "")
-    }
-    case "agent-browser":
-    case "effect-solutions":
-      return commandExists("npm") ? capture("npm", ["view", tool, "version"]) : ""
-    default:
-      return ""
-  }
+export function latestVersion(ctx: Ctx, tool: ToolId): string {
+  return ctx.services.deps.latest(tool)
 }
 
 /** Blocking TTY prompt matching bash `read -r -p` (prompt on stderr). */
-function promptLine(prompt: string): string {
-  process.stderr.write(prompt)
+export function promptLine(
+  prompt: string,
+  write: (chunk: string) => void = (chunk) => void process.stderr.write(chunk),
+  readByte: (buffer: Buffer) => number = (buffer) => readSync(0, buffer, 0, 1, null)
+): string {
+  write(prompt)
   const buf = Buffer.alloc(1)
   let line = ""
   for (;;) {
     let n: number
     try {
-      n = readSync(0, buf, 0, 1, null)
+      n = readByte(buf)
     } catch {
       break
     }
@@ -127,6 +105,7 @@ function promptLine(prompt: string): string {
 
 /** toolchain::_gate — { proceed, target } ("" target = latest). */
 function gate(ctx: Ctx, tool: string, mode: "install" | "upgrade", latest: string): { proceed: boolean; target: string } {
+  const { warn } = ctx.services.logger
   const verified = field(ctx, tool, "verified")
   const pinnable = field(ctx, tool, "pinnable")
 
@@ -138,7 +117,7 @@ function gate(ctx: Ctx, tool: string, mode: "install" | "upgrade", latest: strin
   }
 
   if (process.stdin.isTTY === true) {
-    process.stderr.write(`\x1b[1;33m[warn]\x1b[0m ${tool} ${latest} is not kit-verified (verified: ${verified}).\n`)
+    ctx.services.logger.warn(`${tool} ${latest} is not kit-verified (verified: ${verified}).`)
     const answer = promptLine(`Install ${tool} ${latest} anyway? [y/N] `)
     if (/^[yY]/.test(answer)) return { proceed: true, target: "" }
   }
@@ -153,11 +132,12 @@ function gate(ctx: Ctx, tool: string, mode: "install" | "upgrade", latest: strin
   return { proceed: false, target: "" }
 }
 
-export function ensure(ctx: Ctx, tool: string, installFn: InstallFn): number {
+export function ensure(ctx: Ctx, tool: ToolId, installFn: InstallFn): number {
+  const { echo, verbose, warn } = ctx.services.logger
   const policy = field(ctx, tool, "policy")
 
   if (!present(ctx, tool)) {
-    const latest = latestVersion(tool)
+    const latest = latestVersion(ctx, tool)
     if (ctx.dryRun) {
       echo(`[dry-run] would install ${tool} (${latest !== "" ? latest : "latest"}, gated by toolchain.json verified pin)`)
       return 0
@@ -176,7 +156,7 @@ export function ensure(ctx: Ctx, tool: string, installFn: InstallFn): number {
       if (!g.proceed) return 0
       target = g.target
     }
-    return installFn("install", target !== "" ? target : latest)
+    return installFn("install", target !== "" ? target : latest, ctx.services)
   }
 
   const installed = installedVersion(ctx, tool)
@@ -187,17 +167,17 @@ export function ensure(ctx: Ctx, tool: string, installFn: InstallFn): number {
       echo(`[dry-run] ${tool} present (${installedLabel})`)
       return 0
     }
-    log(`${tool} present (${installedLabel})`)
+    verbose(`${tool} present (${installedLabel})`)
     return 0
   }
 
-  const latest = latestVersion(tool)
+  const latest = latestVersion(ctx, tool)
   if (latest === "") {
     if (ctx.dryRun) {
       echo(`[dry-run] ${tool} present (${installedLabel}); latest unknown (offline?) — no action`)
       return 0
     }
-    log(`${tool} present (${installedLabel}; latest unknown — no action)`)
+    verbose(`${tool} present (${installedLabel}; latest unknown — no action)`)
     return 0
   }
 
@@ -208,14 +188,14 @@ export function ensure(ctx: Ctx, tool: string, installFn: InstallFn): number {
     }
     const g = gate(ctx, tool, "upgrade", latest)
     if (!g.proceed) return 0
-    return installFn("upgrade", g.target !== "" ? g.target : latest)
+    return installFn("upgrade", g.target !== "" ? g.target : latest, ctx.services)
   }
 
   if (ctx.dryRun) {
     echo(`[dry-run] ${tool} up to date (${installed})`)
     return 0
   }
-  log(`${tool} up to date (${installed})`)
+  verbose(`${tool} up to date (${installed})`)
   return 0
 }
 
@@ -225,10 +205,11 @@ function row(cells: [string, string, string, string, string, string]): string {
 }
 
 export function report(ctx: Ctx): void {
+  const { echo } = ctx.services.logger
   echo(row(["TOOL", "KIND", "INSTALLED", "FLOOR", "VERIFIED", "STATUS"]))
-  const platformOs =
-    process.platform === "linux" ? "linux" : process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : ""
-  for (const tool of Object.keys(manifest(ctx)).sort(compareCodepoints)) {
+  const pn = ctx.services.platform.name()
+  const platformOs = pn === "unknown" ? "" : pn
+  for (const tool of Object.keys(manifest()).sort(compareCodepoints)) {
     const os = field(ctx, tool, "os")
     if (os !== "" && platformOs !== "" && os !== platformOs) continue
     const kind = field(ctx, tool, "kind")
@@ -241,8 +222,9 @@ export function report(ctx: Ctx): void {
     }
     let installed: string
     let status: string
-    if (present(ctx, tool)) {
-      installed = installedVersion(ctx, tool)
+    const toolId = tool as ToolId
+    if (present(ctx, toolId)) {
+      installed = installedVersion(ctx, toolId)
       status = "ok"
       if (floor !== "" && installed !== "" && isNewer(floor, installed)) {
         status = "below-floor"

package/cli/src/engine.ts

@@ -1,7 +1,13 @@
 import { Console, Effect } from "effect"
 import { spawnSync } from "node:child_process"
 import { runEngineNative } from "./engine-native"
+import { makeEngineServices } from "./engine-native/services"
 import { kitHome } from "./kitHome"
+import { DependencyManagerService, LoggerService, PlatformService } from "./services"
+
+// Same factory as the Effect rim's live layers — this path runs outside the
+// runtime (child-spawn capture), so it takes the services directly.
+const services = makeEngineServices()
 
 /**
  * The single seam between the typed CLI and EngineNative. Engine execution
@@ -24,7 +30,10 @@ export const engine = (args: ReadonlyArray<string>) =>
     if (bashEngineRequested()) {
       yield* bail(bashRemovedMessage, 2)
     }
-    const code = yield* Effect.sync(() => runEngineNative(args))
+    const logger = yield* LoggerService
+    const deps = yield* DependencyManagerService
+    const platform = yield* PlatformService
+    const code = yield* Effect.sync(() => runEngineNative(args, { logger, deps, platform }))
     if (code !== 0) {
       yield* Effect.sync(() => process.exit(code))
     }
@@ -43,7 +52,7 @@ export const engineCapture = (args: ReadonlyArray<string>) =>
         stdio: ["ignore", "pipe", "inherit"]
       })
       if (res.error !== undefined || res.status !== 0) {
-        process.stderr.write(`\x1b[1;33m[warn]\x1b[0m engine capture failed (${args.join(" ")} exited ${res.status ?? "spawn-error"})\n`)
+        services.logger.warn(`engine capture failed (${args.join(" ")} exited ${res.status ?? "spawn-error"})`)
       }
       return res.stdout ?? ""
     })