docks-kit 0.15.1 → 0.15.3

package/cli/src/commands/status.ts

@@ -1,6 +1,6 @@
 import { Command, Flag } from "effect/unstable/cli"
 import { Console, Effect } from "effect"
-import { engineCapture } from "../engine"
+import { engineCapture, type EngineCaptureError } from "../engine"
 import {
   deployedClaudeSettings,
   deployedCodexModel,
@@ -22,55 +22,168 @@ interface Drift {
   readonly drifted: boolean
 }
 
-const gatherDrift = (): Array<Drift> => {
+type ClaudeDeployment =
+  | { readonly state: "absent" }
+  | { readonly state: "valid"; readonly settings: Record<string, unknown> }
+  | { readonly state: "malformed"; readonly diagnostic: string }
+
+const captureToolchainStatus = () =>
+  engineCapture(["toolchain", "check"]).pipe(
+    Effect.map((table) => ({ state: "valid" as const, table })),
+    Effect.catch((error: EngineCaptureError) =>
+      Effect.succeed({
+        state: "failed" as const,
+        table: "",
+        diagnostic: error.diagnostic,
+        exitCode: error.code
+      })
+    )
+  )
+
+const readClaudeDeployment = (): ClaudeDeployment => {
+  try {
+    const settings: unknown = deployedClaudeSettings()
+    if (settings === undefined) return { state: "absent" }
+    if (settings === null || typeof settings !== "object" || Array.isArray(settings)) {
+      return {
+        state: "malformed",
+        diagnostic: "deployed Claude settings must contain a JSON object"
+      }
+    }
+    return { state: "valid", settings: settings as Record<string, unknown> }
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error)
+    return {
+      state: "malformed",
+      diagnostic: `deployed Claude settings contain invalid JSON: ${detail}`
+    }
+  }
+}
+
+const gatherDrift = (): {
+  readonly drift: Array<Drift>
+  readonly claudeDeployment: ClaudeDeployment
+} => {
   const sot = sotClaudeSettings()
-  const dep = deployedClaudeSettings() ?? {}
+  const claudeDeployment = readClaudeDeployment()
   const row = (setting: string, deployed: unknown, sotVal: unknown): Drift => {
     const d = String(deployed ?? "(unset)")
     const s = String(sotVal ?? "(unset)")
     return { setting, deployed: d, sot: s, drifted: d !== s }
   }
-  return [
-    row("claude.model", dep.model, sot.model),
-    row("claude.effortLevel", dep.effortLevel, sot.effortLevel),
-    row(
-      "claude.compactWindow",
-      dep.env?.CLAUDE_CODE_AUTO_COMPACT_WINDOW,
-      sot.env?.CLAUDE_CODE_AUTO_COMPACT_WINDOW
-    ),
-    row("codex.model", deployedCodexModel(), sotCodexModel())
-  ]
+  const codex = row("codex.model", deployedCodexModel(), sotCodexModel())
+  if (claudeDeployment.state === "absent") {
+    return {
+      claudeDeployment,
+      drift: [
+        { setting: "claude.settings", deployed: "(absent)", sot: "present", drifted: true },
+        codex
+      ]
+    }
+  }
+  if (claudeDeployment.state === "malformed") {
+    return {
+      claudeDeployment,
+      drift: [
+        { setting: "claude.settings", deployed: "(malformed)", sot: "present", drifted: true },
+        codex
+      ]
+    }
+  }
+
+  const dep = claudeDeployment.settings
+  const env =
+    dep.env !== null && typeof dep.env === "object" && !Array.isArray(dep.env)
+      ? (dep.env as Record<string, unknown>)
+      : {}
+  return {
+    claudeDeployment,
+    drift: [
+      row("claude.model", dep.model, sot.model),
+      row("claude.effortLevel", dep.effortLevel, sot.effortLevel),
+      row(
+        "claude.compactWindow",
+        env.CLAUDE_CODE_AUTO_COMPACT_WINDOW,
+        sot.env?.CLAUDE_CODE_AUTO_COMPACT_WINDOW
+      ),
+      codex
+    ]
+  }
 }
 
 export const statusCommand = Command.make("status", { json }, (config) =>
   Effect.gen(function* () {
-    const drift = gatherDrift()
+    const { drift, claudeDeployment } = gatherDrift()
     const plugins = pluginsView()
     const skills = skillsView()
-    const toolchainTable = yield* engineCapture(["toolchain", "check"])
+    const toolchain = yield* captureToolchainStatus()
+    const diagnostics = new Array<{ source: string; message: string; exitCode: number }>()
+    if (claudeDeployment.state === "malformed") {
+      diagnostics.push({
+        source: "claude.settings",
+        message: claudeDeployment.diagnostic,
+        exitCode: 1
+      })
+    }
+    if (toolchain.state === "failed") {
+      diagnostics.push({
+        source: "toolchain",
+        message: toolchain.diagnostic ?? "toolchain capture failed",
+        exitCode: toolchain.exitCode ?? 1
+      })
+    }
 
     if (config.json) {
-      return yield* Console.log(
-        JSON.stringify({ kitHome: kitHome(), drift, plugins, skills, toolchainTable }, null, 2)
+      const deployment =
+        claudeDeployment.state === "malformed"
+          ? { claude: { state: claudeDeployment.state, diagnostic: claudeDeployment.diagnostic } }
+          : { claude: { state: claudeDeployment.state } }
+      yield* Console.log(
+        JSON.stringify(
+          {
+            kitHome: kitHome(),
+            deployment,
+            drift,
+            plugins,
+            skills,
+            toolchain,
+            diagnostics
+          },
+          null,
+          2
+        )
+      )
+    } else {
+      yield* Console.log(`Kit home: ${kitHome()}\n`)
+      yield* Console.log("Deployed vs SoT (drift is expected for deploy-time modifiers):")
+      for (const d of drift) {
+        const mark = d.drifted ? "≠" : "="
+        yield* Console.log(`  ${d.setting.padEnd(22)} deployed=${d.deployed}  ${mark}  SoT=${d.sot}`)
+      }
+      if (claudeDeployment.state === "malformed") {
+        yield* Console.log(`  ERROR claude.settings: ${claudeDeployment.diagnostic}`)
+      }
+      yield* Console.log("\nToolchain:")
+      if (toolchain.state === "failed") {
+        yield* Console.log(`  ERROR: ${toolchain.diagnostic}`)
+      } else {
+        yield* Console.log(toolchain.table.trimEnd())
+      }
+      const enabled = plugins.filter((p) => p.sot === "true").length
+      yield* Console.log(
+        `\nPlugins: ${plugins.length} known (${enabled} SoT-enabled) — details: docks-kit plugins list`
+      )
+      const installed = skills.filter((s) => s.installed).length
+      yield* Console.log(
+        `Skills:  ${skills.length} known (${installed} installed) — details: docks-kit skills list`
       )
     }
 
-    yield* Console.log(`Kit home: ${kitHome()}\n`)
-    yield* Console.log("Deployed vs SoT (drift is expected for deploy-time modifiers):")
-    for (const d of drift) {
-      const mark = d.drifted ? "≠" : "="
-      yield* Console.log(`  ${d.setting.padEnd(22)} deployed=${d.deployed}  ${mark}  SoT=${d.sot}`)
+    if (diagnostics.length > 0) {
+      yield* Effect.sync(() => {
+        process.exitCode = diagnostics[0]?.exitCode ?? 1
+      })
     }
-    yield* Console.log("\nToolchain:")
-    yield* Console.log(toolchainTable.trimEnd())
-    const enabled = plugins.filter((p) => p.sot === "true").length
-    yield* Console.log(
-      `\nPlugins: ${plugins.length} known (${enabled} SoT-enabled) — details: docks-kit plugins list`
-    )
-    const installed = skills.filter((s) => s.installed).length
-    yield* Console.log(
-      `Skills:  ${skills.length} known (${installed} installed) — details: docks-kit skills list`
-    )
   })
 ).pipe(
   Command.withDescription(

package/cli/src/commands/sync.ts

@@ -52,9 +52,6 @@ const skipBubblewrap = Flag.boolean("skip-bubblewrap").pipe(
 const skipPluginRefresh = Flag.boolean("skip-plugin-refresh").pipe(
   Flag.withDescription("Install missing plugins but skip refresh-only updates for existing plugins")
 )
-const yes = Flag.boolean("yes").pipe(
-  Flag.withDescription("Auto-accept toolchain prompts (containers/CI)")
-)
 const verbose = Flag.boolean("verbose").pipe(
   Flag.withAlias("v"),
   Flag.withDescription("Also print no-op confirmations (already in sync, up to date, left as-is)")
@@ -102,7 +99,6 @@ export const syncCommand = Command.make(
     prune,
     skipBubblewrap,
     skipPluginRefresh,
-    yes,
     verbose,
     claudeModel,
     claudeEffort,
@@ -128,7 +124,6 @@ export const syncCommand = Command.make(
       if (config.prune) args.push("--prune")
       if (config.skipBubblewrap) args.push("--skip-bubblewrap")
       if (config.skipPluginRefresh) args.push("--skip-plugin-refresh")
-      if (config.yes) args.push("--yes")
       if (config.verbose) args.push("--verbose")
       if (config.claudePermissive) args.push("--claude-permissive")
       Option.map(config.claudeModel, (m) => args.push(`--claude-model=${m}`))
@@ -138,6 +133,10 @@ export const syncCommand = Command.make(
       Option.map(config.codexModel, (m) => args.push(`--codex-model=${m}`))
       Option.map(config.codexEffort, (level) => args.push(`--codex-effort=${level}`))
       for (const occurrence of config.claudePlugin) {
+        if (occurrence.trim() === "") {
+          args.push("--claude-plugin=")
+          continue
+        }
         occurrence
           .split(",")
           .map((p) => p.trim())

package/cli/src/commands/toolchain.ts

@@ -2,7 +2,7 @@ import { Argument, Command, Flag } from "effect/unstable/cli"
 import { Effect, Option } from "effect"
 import { bail, engine } from "../engine"
 
-const MANAGED = ["bun", "effect-solutions"]
+const MANAGED = ["bun"]
 
 const op = Argument.string("op").pipe(
   Argument.withDescription("check (default) | ensure <tool>"),
@@ -12,18 +12,15 @@ const tool = Argument.string("tool").pipe(
   Argument.withDescription(`Managed tool for ensure: ${MANAGED.join(", ")}`),
   Argument.optional
 )
-const yes = Flag.boolean("yes").pipe(
-  Flag.withDescription("Auto-accept above-verified installs")
-)
 const verbose = Flag.boolean("verbose").pipe(
   Flag.withAlias("v"),
   Flag.withDescription("Also print no-op confirmations (present, up to date)")
 )
 
-export const toolchainCommand = Command.make("toolchain", { op, tool, yes, verbose }, (config) =>
+export const toolchainCommand = Command.make("toolchain", { op, tool, verbose }, (config) =>
   Effect.gen(function* () {
     const operation = Option.getOrElse(config.op, () => "check")
-    const flags = [...(config.yes ? ["--yes"] : []), ...(config.verbose ? ["--verbose"] : [])]
+    const flags = config.verbose ? ["--verbose"] : []
 
     switch (operation) {
       case "check":
@@ -41,6 +38,6 @@ export const toolchainCommand = Command.make("toolchain", { op, tool, yes, verbo
   })
 ).pipe(
   Command.withDescription(
-    "Verified-version floors for external tools (SoT/toolchain.json): check prints the doctor table; ensure installs/upgrades one managed tool per policy (above-verified versions prompt; --yes accepts)."
+    "Verified-version floors for external tools (SoT/toolchain.json): check prints the doctor table; ensure installs one managed tool when it is missing."
   )
 )

package/cli/src/commands/update.ts

@@ -1,20 +1,62 @@
 import { Command, Flag } from "effect/unstable/cli"
 import { Console, Effect } from "effect"
-import { spawnSync } from "node:child_process"
+import { spawnSync, type SpawnSyncOptions, type SpawnSyncOptionsWithStringEncoding, type SpawnSyncReturns } from "node:child_process"
 import { existsSync, readFileSync } from "node:fs"
-import { join } from "node:path"
 import { bail, compiled } from "../engine"
 import { kitHome } from "../kitHome"
+import { p, which } from "../engine-native/exec"
+import { hostOs, type HostOs, type Invocation } from "../engine-native/os"
 
 const noSync = Flag.boolean("no-sync").pipe(
   Flag.withDescription("Update the kit only; skip the chained flag-less sync")
 )
 
-const git = (home: string, args: Array<string>): { ok: boolean; out: string } => {
-  const res = spawnSync("git", ["-C", home, ...args], {
+/** A tool this host cannot resolve, shaped like the failed spawn it replaces. */
+const notFound = (command: string): SpawnSyncReturns<string> => ({
+  pid: 0,
+  output: [],
+  stdout: "",
+  stderr: "",
+  status: null,
+  signal: null,
+  error: new Error(`command not found on PATH: ${command}`)
+})
+
+/**
+ * Every child in this command starts here, because two host facts must never be
+ * separated from the argv they describe: a Windows shim invocation is only
+ * correct with the verbatim-arguments flag, and a pathless name would let
+ * CreateProcess search the parent's current directory before the system one.
+ */
+export const spawnUpdate = (
+  command: string,
+  args: ReadonlyArray<string>,
+  overrides: SpawnSyncOptions = {},
+  host: HostOs = hostOs()
+): SpawnSyncReturns<string> => {
+  const resolvesSuffixes = host.executableSuffixes.some((suffix) => suffix !== "")
+  const executablePath = resolvesSuffixes ? which(command, host.executableSuffixes) : command
+  if (executablePath === "") return notFound(command)
+  let invocation: Invocation
+  try {
+    invocation = host.invoke(executablePath, args)
+  } catch (cause) {
+    // A value this host cannot put on a command line at all. Print the encoder's
+    // reason and exit, matching how this command reports a failed child.
+    process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`)
+    return process.exit(2)
+  }
+  const options: SpawnSyncOptionsWithStringEncoding = {
+    stdio: ["ignore", "pipe", "pipe"],
+    ...overrides,
     encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  })
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments
+  }
+  return spawnSync(invocation.command, [...invocation.args], options)
+}
+
+const git = (home: string, args: Array<string>): { ok: boolean; out: string } => {
+  const res = spawnUpdate("git", ["-C", home, ...args])
   return { ok: res.error === undefined && res.status === 0, out: `${res.stdout ?? ""}${res.stderr ?? ""}`.trim() }
 }
 
@@ -22,19 +64,19 @@ const git = (home: string, args: Array<string>): { ok: boolean; out: string } =>
  * version loaded, so the chained sync must be a new process. */
 const chainSync = (argv0: string, args: Array<string>): Effect.Effect<void> =>
   Effect.sync(() => {
-    const res = spawnSync(argv0, args, { stdio: "inherit" })
+    const res = spawnUpdate(argv0, args, { stdio: "inherit" })
     if (res.error !== undefined || res.status !== 0) process.exit(res.status ?? 1)
   })
 
 export const updateSyncArgs = (home: string): Array<string> => [
-  join(home, "cli/src/main.ts"),
+  p(home, "cli/src/main.ts"),
   "sync",
   "--skip-plugin-refresh"
 ]
 
 const readPackageVersion = (home: string): string => {
   try {
-    const doc: unknown = JSON.parse(readFileSync(join(home, "package.json"), "utf8"))
+    const doc: unknown = JSON.parse(readFileSync(p(home, "package.json"), "utf8"))
     if (doc === null || typeof doc !== "object" || !("version" in doc)) return ""
     return typeof doc.version === "string" ? doc.version : ""
   } catch {
@@ -42,11 +84,108 @@ const readPackageVersion = (home: string): string => {
   }
 }
 
+export type PackageManager = "bun" | "npm"
+
+interface PackageRootCapture {
+  readonly status: number | null
+  readonly stdout: string
+  readonly error?: Error
+}
+
+type CapturePackageRoot = (
+  command: string,
+  args: ReadonlyArray<string>
+) => PackageRootCapture
+
+const capturePackageRoot: CapturePackageRoot = (command, args) => {
+  const res = spawnUpdate(command, args)
+  return {
+    status: res.status,
+    stdout: res.stdout ?? "",
+    ...(res.error === undefined ? {} : { error: res.error })
+  }
+}
+
+/**
+ * A Bun global home is `<root>/.bun/install/global/node_modules/<pkg>`. Windows
+ * reports that path with backslashes, so containment is tested on a normalized
+ * copy — but only on Windows, because a backslash is a legal POSIX filename
+ * character and must never be read as a separator there.
+ */
+export const packageManagerForHome = (
+  home: string,
+  environment: NodeJS.ProcessEnv = process.env,
+  host: HostOs = hostOs()
+): PackageManager => {
+  const normalize = (value: string): string =>
+    host.id === "windows" ? value.replaceAll("\\", "/") : value
+  const normalizedHome = normalize(home)
+  const underEnvironmentRoot = (name: "BUN_INSTALL_GLOBAL_DIR" | "BUN_INSTALL"): boolean => {
+    const root = environment[name]?.trim()
+    if (root === undefined || root === "") return false
+    const normalizedRoot = normalize(root)
+    return normalizedHome === normalizedRoot || normalizedHome.startsWith(`${normalizedRoot}/`)
+  }
+  return normalizedHome.includes("/.bun/") ||
+    underEnvironmentRoot("BUN_INSTALL_GLOBAL_DIR") ||
+    underEnvironmentRoot("BUN_INSTALL")
+    ? "bun"
+    : "npm"
+}
+
+export type GlobalPackageHome =
+  | { readonly ok: true; readonly home: string }
+  | { readonly ok: false; readonly diagnostic: string }
+
+export const resolveGlobalPackageHome = (
+  manager: PackageManager,
+  capture: CapturePackageRoot = capturePackageRoot
+): GlobalPackageHome => {
+  const commandArgs = manager === "bun" ? ["pm", "-g", "ls"] : ["root", "-g"]
+  const result = capture(manager, commandArgs)
+  if (result.error !== undefined || result.status !== 0) {
+    const detail =
+      result.error !== undefined
+        ? result.error.message
+        : `exit ${result.status ?? "without status"}`
+    return {
+      ok: false,
+      diagnostic: `${manager} ${commandArgs.join(" ")} failed: ${detail}`
+    }
+  }
+
+  if (manager === "npm") {
+    const root = result.stdout.trim()
+    return root === ""
+      ? { ok: false, diagnostic: "npm root -g failed: empty output" }
+      : { ok: true, home: p(root, "docks-kit") }
+  }
+
+  const globalHeader = result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => / node_modules(?: \(\d+\))?$/.test(line))
+  const globalDir =
+    globalHeader === undefined
+      ? undefined
+      : /^(.*) node_modules(?: \(\d+\))?$/.exec(globalHeader)?.[1]
+  return globalDir === undefined || globalDir === ""
+    ? { ok: false, diagnostic: "bun pm -g ls did not report its global package root" }
+    : { ok: true, home: p(globalDir, "node_modules", "docks-kit") }
+}
+
 export const packageUpdateResult = (
   before: string,
-  after: string
+  after: string,
+  samePackageRoot = true
 ): { alreadyCurrent: boolean; message: string } => {
   if (before === "" || after === "") return { alreadyCurrent: false, message: "" }
+  if (!samePackageRoot) {
+    return {
+      alreadyCurrent: false,
+      message: `Installed ${after} in the selected global package root.`
+    }
+  }
   if (before === after) {
     return { alreadyCurrent: true, message: `Already at the latest version (${after}).` }
   }
@@ -55,7 +194,7 @@ export const packageUpdateResult = (
 
 const updateCheckout = (home: string, skipSync: boolean) =>
   Effect.gen(function* () {
-    if (spawnSync("git", ["--version"], { stdio: "ignore" }).status !== 0) {
+    if (spawnUpdate("git", ["--version"], { stdio: "ignore" }).status !== 0) {
       return yield* bail("git not found - cannot update the kit checkout")
     }
     const dirty = git(home, ["status", "--porcelain"])
@@ -81,7 +220,7 @@ const updateCheckout = (home: string, skipSync: boolean) =>
 
     const touched = git(home, ["diff", "--name-only", before, after]).out.split("\n")
     if (touched.includes("bun.lock") || touched.includes("package.json")) {
-      const res = spawnSync("bun", ["install", "--frozen-lockfile"], { cwd: home, stdio: "inherit" })
+      const res = spawnUpdate("bun", ["install", "--frozen-lockfile"], { cwd: home, stdio: "inherit" })
       if (res.error !== undefined || res.status !== 0) {
         return yield* bail("dependencies changed but 'bun install --frozen-lockfile' failed - fix that, then run docks-kit sync", 1)
       }
@@ -99,39 +238,45 @@ const updateCheckout = (home: string, skipSync: boolean) =>
 
 const updatePackage = (home: string, skipSync: boolean) =>
   Effect.gen(function* () {
-    // Bun's global dir is configurable (BUN_INSTALL_GLOBAL_DIR / BUN_INSTALL),
-    // so the ~/.bun path shape alone under-detects Bun installs.
-    const underEnvDir = (v: string): boolean => {
-      const dir = process.env[v]
-      return dir !== undefined && dir !== "" && home.startsWith(dir)
-    }
-    const viaBun =
-      home.includes("/.bun/") ||
-      home.includes("\\.bun\\") ||
-      underEnvDir("BUN_INSTALL_GLOBAL_DIR") ||
-      underEnvDir("BUN_INSTALL")
+    const manager = packageManagerForHome(home)
     const beforeVersion = readPackageVersion(home)
-    const res = viaBun
-      ? spawnSync("bun", ["add", "-g", "docks-kit@latest"], { stdio: "inherit" })
-      : spawnSync("npm", ["install", "-g", "docks-kit@latest"], { stdio: "inherit" })
+    const updateArgs = manager === "bun"
+      ? ["add", "-g", "docks-kit@latest"]
+      : ["install", "-g", "docks-kit@latest"]
+    const res = spawnUpdate(manager, updateArgs, { stdio: "inherit" })
     if (res.error !== undefined || res.status !== 0) {
-      return yield* bail(`global package update failed (${viaBun ? "bun add -g" : "npm install -g"} docks-kit@latest)`, 1)
+      return yield* bail(
+        `global package update failed (${manager === "bun" ? "bun add -g" : "npm install -g"} docks-kit@latest)`,
+        1
+      )
     }
 
-    const result = packageUpdateResult(beforeVersion, readPackageVersion(home))
+    const updated = resolveGlobalPackageHome(manager)
+    if (!updated.ok) {
+      return yield* bail(
+        `global package update completed, but the updated package root could not be resolved: ${updated.diagnostic}`,
+        1
+      )
+    }
+    const afterVersion = readPackageVersion(updated.home)
+    if (afterVersion === "") {
+      return yield* bail(
+        `global package update completed, but ${p(updated.home, "package.json")} has no readable version`,
+        1
+      )
+    }
+    const result = packageUpdateResult(beforeVersion, afterVersion, home === updated.home)
     if (result.message !== "") yield* Console.log(result.message)
     if (result.alreadyCurrent) return
     if (skipSync) return yield* Console.log("Kit updated. Run: docks-kit sync")
     yield* Console.log("Kit updated - running sync with the new version...")
-    // Chain through the package dir just updated (global installs update in
-    // place) — a bare `docks-kit` PATH lookup could hit a different shim.
-    return yield* chainSync(process.execPath, updateSyncArgs(home))
+    return yield* chainSync(process.execPath, updateSyncArgs(updated.home))
   })
 
 export const updateCommand = Command.make("update", { noSync }, (config) =>
   Effect.gen(function* () {
     const home = kitHome()
-    if (existsSync(join(home, ".git"))) {
+    if (existsSync(p(home, ".git"))) {
       return yield* updateCheckout(home, config.noSync)
     }
     if (home.includes("node_modules")) {

package/cli/src/efforts.ts

@@ -1,4 +1,4 @@
-import { sotClaudeSettings, type Tool } from "./manifests"
+import { sotClaudeSettings, topLevelTomlString, type Tool } from "./manifests"
 import { payloadText } from "./payload"
 
 export const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh"] as const
@@ -53,12 +53,12 @@ export function validateEffortDefault(tool: Tool, value: unknown): string {
   return value
 }
 
-function codexSotEffort(): string | undefined {
-  return payloadText("SoT/.codex/config.toml").match(/^model_reasoning_effort\s*=\s*"([^"]+)"/m)?.[1]
-}
 
 export function sotEffort(tool: Tool): string {
-  const value = tool === "claude" ? sotClaudeSettings().effortLevel : codexSotEffort()
+  const value =
+    tool === "claude"
+      ? sotClaudeSettings().effortLevel
+      : topLevelTomlString(payloadText("SoT/.codex/config.toml"), "model_reasoning_effort")
   return validateEffortDefault(tool, value)
 }