docks-kit 0.16.4 → 0.16.5

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

@@ -1,7 +1,8 @@
 /**
- * Top-level Codex TOML setting replacement plus `--codex-model`. The pass is
- * line-based on purpose: a TOML library would reformat user configs and break
- * the golden contract. The key is used as a raw regex fragment, preserving the
+ * Line-based Codex TOML passes: top-level setting replacement, the SoT
+ * top-level and table merges used by `sync codex`, and `--codex-model` /
+ * `--codex-effort`. A TOML library would reformat user configs and break the
+ * golden contract. The key is used as a raw regex fragment, preserving the
  * historical record-oriented behavior.
  */
 import { p } from "./exec"
@@ -110,3 +111,143 @@ export function syncCodexEffort(ctx: Ctx, effort: string): void {
     unchanged: `Effort: deployed Codex model_reasoning_effort already ${resolved}`
   })
 }
+
+export function mergeTopLevelSettings(sotConfigText: string, userConfig: string): void {
+  for (const line of sotConfigText.split("\n")) {
+    if (line.startsWith("[")) break
+    if (/^[ \t]*($|#)/.test(line)) continue
+    if (!/^[A-Za-z0-9_.-]+[ \t]*=/.test(line)) continue
+    const key = line.slice(0, line.indexOf("=")).replace(/[ \t]+$/, "")
+    replaceTopLevelSettingInFile(userConfig, key, line)
+  }
+}
+
+interface TomlTableHeader {
+  readonly path: string
+}
+
+const TOML_BASIC_ESCAPES: Readonly<Record<string, string>> = {
+  b: "\b",
+  t: "\t",
+  n: "\n",
+  f: "\f",
+  r: "\r",
+  '"': '"',
+  "\\": "\\"
+}
+
+function tomlBasicEscape(line: string, offset: number): { readonly next: number; readonly value: string } | undefined {
+  const escaped = line[offset]
+  const simple = escaped === undefined ? undefined : TOML_BASIC_ESCAPES[escaped]
+  if (simple !== undefined) return { next: offset + 1, value: simple }
+  const digits = escaped === "u" ? 4 : escaped === "U" ? 8 : 0
+  if (digits === 0) return undefined
+  const hex = line.slice(offset + 1, offset + 1 + digits)
+  if (hex.length !== digits || !/^[0-9A-Fa-f]+$/.test(hex)) return undefined
+  const codePoint = Number.parseInt(hex, 16)
+  if (codePoint > 0x10ffff || (codePoint >= 0xd800 && codePoint <= 0xdfff)) return undefined
+  return { next: offset + 1 + digits, value: String.fromCodePoint(codePoint) }
+}
+
+/** Decode a table header to the TOML path that determines managed ownership. */
+function tomlTableHeader(line: string): TomlTableHeader | undefined {
+  let offset = 0
+  const skipWhitespace = (): void => {
+    while (line[offset] === " " || line[offset] === "\t") offset++
+  }
+
+  skipWhitespace()
+  if (line[offset] !== "[") return undefined
+  offset++
+  const array = line[offset] === "["
+  if (array) offset++
+
+  const keys: Array<string> = []
+  while (true) {
+    skipWhitespace()
+    const quote = line[offset]
+    let key = ""
+    if (quote === '"' || quote === "'") {
+      offset++
+      let closed = false
+      while (offset < line.length) {
+        const char = line[offset]!
+        if (char === quote) {
+          offset++
+          closed = true
+          break
+        }
+        if (quote === '"' && char === "\\") {
+          const escape = tomlBasicEscape(line, offset + 1)
+          if (escape === undefined) return undefined
+          key += escape.value
+          offset = escape.next
+          continue
+        }
+        if (char === "\n" || char === "\r") return undefined
+        key += char
+        offset++
+      }
+      if (!closed) return undefined
+    } else {
+      const start = offset
+      while (offset < line.length && /[A-Za-z0-9_-]/.test(line[offset]!)) offset++
+      if (offset === start) return undefined
+      key = line.slice(start, offset)
+    }
+    keys.push(key)
+
+    skipWhitespace()
+    if (line[offset] === ".") {
+      offset++
+      continue
+    }
+    if (line[offset] !== "]") return undefined
+    offset++
+    if (array) {
+      if (line[offset] !== "]") return undefined
+      offset++
+    }
+    skipWhitespace()
+    if (offset < line.length && line[offset] !== "#") return undefined
+    return { path: JSON.stringify(keys) }
+  }
+}
+
+function mergeTableSettingsText(sotConfigText: string, userConfigText: string): string {
+  const sotLines = sotConfigText.split("\n")
+  let merged = userConfigText
+  for (let tableOffset = 0; tableOffset < sotLines.length; tableOffset++) {
+    const managedHeader = tomlTableHeader(sotLines[tableOffset]!)
+    if (managedHeader === undefined) continue
+
+    const block: Array<string> = []
+    for (let blockOffset = tableOffset; blockOffset < sotLines.length; blockOffset++) {
+      const line = sotLines[blockOffset]!
+      if (blockOffset !== tableOffset && tomlTableHeader(line) !== undefined) break
+      block.push(line)
+    }
+    const tableBlock = block.join("\n").replace(/\n+$/, "")
+
+    const userLines = merged.split("\n")
+    if (userLines[userLines.length - 1] === "") userLines.pop()
+    let skip = false
+    const kept: Array<string> = []
+    for (const line of userLines) {
+      const header = tomlTableHeader(line)
+      if (header !== undefined) {
+        skip = header.path === managedHeader.path
+        if (skip) continue
+      }
+      if (!skip) kept.push(line)
+    }
+    merged = `${kept.join("\n")}\n\n${tableBlock}\n`
+  }
+  return merged
+}
+
+export function mergeTableSettings(sotConfigText: string, userConfig: string): void {
+  const next = mergeTableSettingsText(sotConfigText, readFileSync(userConfig, "utf8"))
+  writeFileSync(`${userConfig}.tmp`, next)
+  renameSync(`${userConfig}.tmp`, userConfig)
+}

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

@@ -116,7 +116,7 @@ export function commandExists(name: string): boolean {
   return which(name) !== ""
 }
 
-export function isExecutable(path: string, suffixes: ReadonlyArray<string> = hostOs().executableSuffixes): boolean {
+function isExecutable(path: string, suffixes: ReadonlyArray<string> = hostOs().executableSuffixes): boolean {
   try {
     if (!statSync(path).isFile()) return false
     if (suffixes.some((suffix) => suffix !== "")) {
@@ -148,7 +148,3 @@ export function writeBytesIfChanged(path: string, content: Uint8Array): boolean
   writeFileSync(path, bytes)
   return true
 }
-
-export function writeFileIfChanged(path: string, content: string): boolean {
-  return writeTextIfChanged(path, content)
-}

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

@@ -11,6 +11,8 @@
  *   - output formatting: 2-space indent, UTF-8 raw, trailing newline.
  */
 
+import { existsSync, readFileSync } from "node:fs"
+
 export type Json = null | boolean | number | string | Array<Json> | { [key: string]: Json }
 
 export function isObject(v: Json): v is { [key: string]: Json } {
@@ -61,3 +63,8 @@ export function parseJson(text: string): Json | undefined {
     return undefined
   }
 }
+
+/** Parse a JSON file with `parseJson` semantics; a missing file is `undefined`. */
+export function readJsonFile(file: string): Json | undefined {
+  return existsSync(file) ? parseJson(readFileSync(file, "utf8")) : undefined
+}

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

@@ -6,6 +6,16 @@ import type { Ctx } from "./index"
 import { isObject, parseJson, type Json } from "./jq"
 import { payloadDisplayPath, payloadText } from "../payload"
 
+export interface ModelEntry {
+  readonly id: string
+  readonly kind: "alias" | "id"
+  readonly note?: string
+}
+
+export interface ModelCatalog {
+  readonly verified: string
+  readonly models: ReadonlyArray<ModelEntry>
+}
 
 function toolEntry(tool: string): { [k: string]: Json } | undefined {
   const doc = parseJson(payloadText("SoT/models.json"))
@@ -14,16 +24,28 @@ function toolEntry(tool: string): { [k: string]: Json } | undefined {
   return entry !== undefined && isObject(entry) ? entry : undefined
 }
 
-function modelEntries(tool: string): Array<{ [k: string]: Json }> {
-  const entry = toolEntry(tool)
+function modelEntries(entry: { [k: string]: Json } | undefined): Array<{ [k: string]: Json }> {
   const models = entry?.["models"]
   return Array.isArray(models) ? models.filter(isObject) : []
 }
 
-export function modelsFromManifest(tool: string): Array<string> {
-  return modelEntries(tool)
-    .map((m) => m["id"])
-    .filter((id): id is string => typeof id === "string")
+/**
+ * Typed view of one tool's `SoT/models.json` section. An entry whose `id` is not a
+ * string or whose `kind` is neither `alias` nor `id` is skipped; a missing section
+ * yields `verified: "?"` and no models.
+ */
+export function modelCatalog(tool: string): ModelCatalog {
+  const entry = toolEntry(tool)
+  const verified = entry?.["verified"]
+  const models: Array<ModelEntry> = []
+  for (const m of modelEntries(entry)) {
+    const id = m["id"]
+    const kind = m["kind"]
+    if (typeof id !== "string" || (kind !== "alias" && kind !== "id")) continue
+    const note = m["note"]
+    models.push(typeof note === "string" ? { id, kind, note } : { id, kind })
+  }
+  return { verified: typeof verified === "string" ? verified : "?", models }
 }
 
 export function printModels(ctx: Ctx, tool: string): void {
@@ -35,7 +57,7 @@ export function printModels(ctx: Ctx, tool: string): void {
   }
   const verified = typeof entry["verified"] === "string" ? entry["verified"] : "?"
   const lines = [`Available ${tool} models (kit-verified ${verified} — SoT/models.json):`]
-  for (const m of modelEntries(tool)) {
+  for (const m of modelEntries(entry)) {
     const note = typeof m["note"] === "string" ? `  — ${m["note"]}` : ""
     lines.push(`  ${String(m["id"] ?? "")}${note}`)
   }
@@ -46,7 +68,7 @@ export function printModels(ctx: Ctx, tool: string): void {
 
 export function validateClaudeModel(ctx: Ctx, m: string): boolean {
   if (m === "") return false
-  if (modelsFromManifest("claude").includes(m)) return true
+  if (modelCatalog("claude").models.some((entry) => entry.id === m)) return true
   if (m.startsWith("claude-")) {
     ctx.services.logger.warn(`Claude model '${m}' is not in the kit-verified catalog (SoT/models.json) — applying anyway`)
     return true
@@ -56,7 +78,7 @@ export function validateClaudeModel(ctx: Ctx, m: string): boolean {
 
 export function validateCodexModel(ctx: Ctx, m: string): boolean {
   if (!/^[A-Za-z0-9._-]+$/.test(m)) return false
-  if (!modelsFromManifest("codex").includes(m)) {
+  if (!modelCatalog("codex").models.some((entry) => entry.id === m)) {
     ctx.services.logger.warn(
       `Codex model '${m}' is not in the kit-verified catalog (SoT/models.json) — applying anyway (check ~/.codex/config.toml if Codex rejects it)`
     )

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

@@ -10,7 +10,7 @@ import { isAbsolute, resolve } from "node:path"
 
 import { payloadDisplayPath, payloadText, type PayloadPath } from "../payload"
 import { bunBootstrap } from "./bun"
-import { commandExists, p, spawnProcess, type AsyncProcessResult } from "./exec"
+import { p, spawnProcess, type AsyncProcessResult } from "./exec"
 import type { Ctx } from "./index"
 import { isObject, parseJson } from "./jq"
 import { ompPaths } from "./ompPaths"
@@ -317,7 +317,7 @@ async function syncPlugins(ctx: Ctx): Promise<number> {
   const { change, clearProgress, echo, progress, verbose, warn } = ctx.services.logger
 
   if (ctx.dryRun) {
-    const piIntercomPin = field(ctx, "pi-intercom", "verified")
+    const piIntercomPin = field("pi-intercom", "verified")
     for (const pluginId of MARKETPLACE_PLUGIN_IDS) {
       echo(`[dry-run] omp plugin install --scope user ${pluginId}`)
     }
@@ -345,7 +345,7 @@ async function syncPlugins(ctx: Ctx): Promise<number> {
     )
     return 0
   }
-  const piIntercomPin = field(ctx, "pi-intercom", "verified")
+  const piIntercomPin = field("pi-intercom", "verified")
 
   progress("Checking installed omp plugins...")
   const installed = await installedPluginIdsFromCli()

package/cli/src/engine-native/os/darwin.ts

@@ -1,62 +1,14 @@
-import { p } from "../exec"
+import { posixHost } from "./posix"
 import type { HostOs } from "./types"
 
-function posixLiteral(value: string): string {
-  return `'${value.replaceAll("'", `'"'"'`)}'`
-}
-
-export const darwin: HostOs = {
+export const darwin: HostOs = posixHost({
   id: "darwin",
   toolchainOs: "darwin",
   supportsBubblewrap: false,
-  directoryLinkKinds: ["symlink"],
-  executableSuffixes: [""],
-  invoke: (executablePath, args) => ({ command: executablePath, args }),
-  bunExecutableName: "bun",
-  bunInstaller: (pin, directory) => {
-    const scriptPath = p(directory, "install.sh")
-    return {
-      scriptPath,
-      download: {
-        command: "curl",
-        args: ["-fsSL", "https://bun.sh/install", "-o", scriptPath]
-      },
-      run: {
-        command: "bash",
-        args: [scriptPath, `bun-v${pin}`]
-      }
-    }
-  },
-  environmentSetting: (name, value) => ({
-    kind: "profile",
-    candidates: [".zshrc", ".bashrc", ".bash_profile", ".profile", ".zshenv"],
-    target: (shell) => {
-      const shellPath = shell ?? "bash"
-      const shellName = shellPath.slice(shellPath.lastIndexOf("/") + 1)
-      return shellName === "zsh" ? ".zshrc" : shellName === "bash" ? ".bashrc" : ".profile"
-    },
-    line: `export ${name}=${value}`
-  }),
-  statusLineCommand: (bun, script) => {
-    const bunLiteral = posixLiteral(bun)
-    const scriptLiteral = posixLiteral(script)
-    return `test -x ${bunLiteral} && test -f ${scriptLiteral} && exec ${bunLiteral} ${scriptLiteral} || true`
-  },
-  failureHookCommand: (command) => command,
-  installHint: (tool) => {
-    switch (tool) {
-      case "git":
-        return "brew install git"
-      case "jq":
-        return "brew install jq"
-      case "curl":
-        return "brew install curl"
-      case "ffplay":
-        return "brew install ffmpeg"
-      case "claude":
-        return "curl -fsSL https://claude.ai/install.sh -o /tmp/claude-install.sh && bash /tmp/claude-install.sh"
-      case "codex":
-        return 'tmp=$(mktemp) && curl -fsSL https://chatgpt.com/codex/install.sh -o "$tmp" && CODEX_NON_INTERACTIVE=1 sh "$tmp"'
-    }
+  packageManagerHints: {
+    git: "brew install git",
+    jq: "brew install jq",
+    curl: "brew install curl",
+    ffplay: "brew install ffmpeg"
   }
-}
+})

package/cli/src/engine-native/os/linux.ts

@@ -1,62 +1,14 @@
-import { p } from "../exec"
+import { posixHost } from "./posix"
 import type { HostOs } from "./types"
 
-function posixLiteral(value: string): string {
-  return `'${value.replaceAll("'", `'"'"'`)}'`
-}
-
-export const linux: HostOs = {
+export const linux: HostOs = posixHost({
   id: "linux",
   toolchainOs: "linux",
   supportsBubblewrap: true,
-  directoryLinkKinds: ["symlink"],
-  executableSuffixes: [""],
-  invoke: (executablePath, args) => ({ command: executablePath, args }),
-  bunExecutableName: "bun",
-  bunInstaller: (pin, directory) => {
-    const scriptPath = p(directory, "install.sh")
-    return {
-      scriptPath,
-      download: {
-        command: "curl",
-        args: ["-fsSL", "https://bun.sh/install", "-o", scriptPath]
-      },
-      run: {
-        command: "bash",
-        args: [scriptPath, `bun-v${pin}`]
-      }
-    }
-  },
-  environmentSetting: (name, value) => ({
-    kind: "profile",
-    candidates: [".zshrc", ".bashrc", ".bash_profile", ".profile", ".zshenv"],
-    target: (shell) => {
-      const shellPath = shell ?? "bash"
-      const shellName = shellPath.slice(shellPath.lastIndexOf("/") + 1)
-      return shellName === "zsh" ? ".zshrc" : shellName === "bash" ? ".bashrc" : ".profile"
-    },
-    line: `export ${name}=${value}`
-  }),
-  statusLineCommand: (bun, script) => {
-    const bunLiteral = posixLiteral(bun)
-    const scriptLiteral = posixLiteral(script)
-    return `test -x ${bunLiteral} && test -f ${scriptLiteral} && exec ${bunLiteral} ${scriptLiteral} || true`
-  },
-  failureHookCommand: (command) => command,
-  installHint: (tool) => {
-    switch (tool) {
-      case "git":
-        return "sudo apt install -y git (or your distro's package manager)"
-      case "jq":
-        return "sudo apt install -y jq"
-      case "curl":
-        return "sudo apt install -y curl"
-      case "ffplay":
-        return "sudo apt install -y ffmpeg"
-      case "claude":
-        return "curl -fsSL https://claude.ai/install.sh -o /tmp/claude-install.sh && bash /tmp/claude-install.sh"
-      case "codex":
-        return 'tmp=$(mktemp) && curl -fsSL https://chatgpt.com/codex/install.sh -o "$tmp" && CODEX_NON_INTERACTIVE=1 sh "$tmp"'
-    }
+  packageManagerHints: {
+    git: "sudo apt install -y git (or your distro's package manager)",
+    jq: "sudo apt install -y jq",
+    curl: "sudo apt install -y curl",
+    ffplay: "sudo apt install -y ffmpeg"
   }
-}
+})

package/cli/src/engine-native/os/posix.ts

@@ -0,0 +1,67 @@
+// No import from "../exec": exec.ts imports "./os", which evaluates linux and darwin
+// through this module. A slash join keeps the same host-stable path p() would produce.
+import type { HintedTool, HostOs } from "./types"
+
+function posixLiteral(value: string): string {
+  return `'${value.replaceAll("'", `'"'"'`)}'`
+}
+
+/** Package-manager hints for the tools a POSIX host installs through its own package manager. */
+export type PackageManagerHints = Readonly<Record<Exclude<HintedTool, "claude" | "codex">, string>>
+
+const UPSTREAM_INSTALLER_HINTS: Readonly<Record<"claude" | "codex", string>> = {
+  claude: "curl -fsSL https://claude.ai/install.sh -o /tmp/claude-install.sh && bash /tmp/claude-install.sh",
+  codex: 'tmp=$(mktemp) && curl -fsSL https://chatgpt.com/codex/install.sh -o "$tmp" && CODEX_NON_INTERACTIVE=1 sh "$tmp"'
+}
+
+interface PosixHostInputs {
+  readonly id: HostOs["id"]
+  readonly toolchainOs: HostOs["toolchainOs"]
+  readonly supportsBubblewrap: boolean
+  readonly packageManagerHints: PackageManagerHints
+}
+
+/** Members shared by every POSIX host; linux and darwin differ only in the inputs. */
+export function posixHost(inputs: PosixHostInputs): HostOs {
+  return {
+    id: inputs.id,
+    toolchainOs: inputs.toolchainOs,
+    supportsBubblewrap: inputs.supportsBubblewrap,
+    directoryLinkKinds: ["symlink"],
+    executableSuffixes: [""],
+    invoke: (executablePath, args) => ({ command: executablePath, args }),
+    bunExecutableName: "bun",
+    bunInstaller: (pin, directory) => {
+      const scriptPath = `${directory}/install.sh`
+      return {
+        scriptPath,
+        download: {
+          command: "curl",
+          args: ["-fsSL", "https://bun.sh/install", "-o", scriptPath]
+        },
+        run: {
+          command: "bash",
+          args: [scriptPath, `bun-v${pin}`]
+        }
+      }
+    },
+    environmentSetting: (name, value) => ({
+      kind: "profile",
+      candidates: [".zshrc", ".bashrc", ".bash_profile", ".profile", ".zshenv"],
+      target: (shell) => {
+        const shellPath = shell ?? "bash"
+        const shellName = shellPath.slice(shellPath.lastIndexOf("/") + 1)
+        return shellName === "zsh" ? ".zshrc" : shellName === "bash" ? ".bashrc" : ".profile"
+      },
+      line: `export ${name}=${value}`
+    }),
+    statusLineCommand: (bun, script) => {
+      const bunLiteral = posixLiteral(bun)
+      const scriptLiteral = posixLiteral(script)
+      return `test -x ${bunLiteral} && test -f ${scriptLiteral} && exec ${bunLiteral} ${scriptLiteral} || true`
+    },
+    failureHookCommand: (command) => command,
+    installHint: (tool) =>
+      tool === "claude" || tool === "codex" ? UPSTREAM_INSTALLER_HINTS[tool] : inputs.packageManagerHints[tool]
+  }
+}

package/cli/src/engine-native/os/targets.ts

@@ -63,7 +63,7 @@ export const HOST_TARGETS: ReadonlyArray<HostTarget> = [
   target("windows-arm64", "windows", "arm64", [], ["ARM64"])
 ]
 
-export function targetFor(platform: PlatformName, arch: string): HostTarget | undefined {
+function targetFor(platform: PlatformName, arch: string): HostTarget | undefined {
   return HOST_TARGETS.find((t) => t.platform === platform && t.arch === arch)
 }
 

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

@@ -17,7 +17,7 @@ import {
 } from "node:fs"
 import { dirname, relative, resolve } from "node:path"
 import { payloadText } from "../payload"
-import { p, spawnProcess, writeFileIfChanged } from "./exec"
+import { p, spawnProcess, writeTextIfChanged } from "./exec"
 import type { Ctx } from "./index"
 import { compareCodepoints } from "./jq"
 import { hostOs, type DirectoryLinkKind } from "./os"
@@ -50,7 +50,7 @@ export async function skillsSync(ctx: Ctx): Promise<SkillsState> {
 
 /** skills::_skills_cli — the pinned npx package spec. */
 function skillsCli(ctx: Ctx): string {
-  const version = field(ctx, "skills-cli", "verified")
+  const version = field("skills-cli", "verified")
   if (version !== "") return `skills@${version}`
   ctx.services.logger.err("Universal skills sync aborted because SoT/toolchain.json has no verified skills-cli pin")
   throw new ExitError(1)
@@ -365,7 +365,7 @@ function updateSnapshot(ctx: Ctx, manifest: string, snapshot: string, failedRemo
 
   mkdirSync(ctx.agentsDir, { recursive: true })
   const sorted = [...new Set([...normalizeManifest(manifest), ...failedRemovals])].sort(compareCodepoints)
-  writeFileIfChanged(snapshot, sorted.length > 0 ? `${sorted.join("\n")}\n` : "")
+  writeTextIfChanged(snapshot, sorted.length > 0 ? `${sorted.join("\n")}\n` : "")
 }
 
 // -------------------------------------------------------------- summary ----

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

@@ -14,7 +14,7 @@ function manifest(): { [k: string]: Json } {
   return tools !== undefined && isObject(tools) ? tools : {}
 }
 
-export function field(ctx: Ctx, tool: string, name: string): string {
+export function field(tool: string, name: string): string {
   const entry = manifest()[tool]
   if (entry === undefined || !isObject(entry)) return ""
   const v = entry[name]
@@ -22,7 +22,7 @@ export function field(ctx: Ctx, tool: string, name: string): string {
 }
 
 /** toolchain::_is_newer — numeric per dotted field, GNU-sort last-resort tie-break. */
-export function isNewer(a: string, b: string): boolean {
+function isNewer(a: string, b: string): boolean {
   if (a === "" || b === "" || a === b) return false
   const fa = a.split(".")
   const fb = b.split(".")
@@ -86,14 +86,14 @@ export async function report(ctx: Ctx): Promise<void> {
   const pn = ctx.services.platform.name()
   const platformOs = hostOs(pn).toolchainOs
   for (const tool of Object.keys(manifest()).sort(compareCodepoints)) {
-    const os = field(ctx, tool, "os")
+    const os = field(tool, "os")
     if (os !== "" && platformOs !== "" && os !== platformOs) continue
-    const kind = field(ctx, tool, "kind")
-    const floor = field(ctx, tool, "floor")
-    const verified = field(ctx, tool, "verified")
+    const kind = field(tool, "kind")
+    const floor = field(tool, "floor")
+    const verified = field(tool, "verified")
     const dash = (v: string): string => (v !== "" ? v : "-")
     if (kind === "pin") {
-      const via = field(ctx, tool, "via")
+      const via = field(tool, "via")
       echo(row([tool, kind, `(${via !== "" ? via : "npx"})`, dash(floor), dash(verified), "pinned"]))
       continue
     }

package/cli/src/generated/sotPayload.ts

@@ -1,7 +1,7 @@
 // Generated by cli/scripts/generate-sot-payload.ts. DO NOT EDIT.
 // Edit SoT/, notification.mp3, or package.json, then run: bun cli/scripts/generate-sot-payload.ts
 
-export const GENERATED_PACKAGE_VERSION = "0.16.4"
+export const GENERATED_PACKAGE_VERSION = "0.16.5"
 
 export const GENERATED_PAYLOAD_TEXT = {
   "SoT/.agents/skills.txt": "# Universal AI-agent skill manifest intentionally empty.\n# Global skill discovery is opt-in: add one <owner>/<repo> slug per line.\n# EngineNative ignores comments and blank lines.\n",

package/cli/src/manifests.ts

@@ -1,34 +1,17 @@
 import { existsSync, lstatSync, readFileSync, readdirSync, readlinkSync } from "node:fs"
 import { homedir } from "node:os"
 import { dirname, join, resolve } from "node:path"
-import { pluginUserScopeInstalled } from "./engine-native/claudeSync"
+import { pluginUserScopeInstalled } from "./engine-native/claudePlugins"
 import { COPY_MARKER } from "./engine-native/skillsSync"
 import { payloadText } from "./payload"
 
 export { homedir }
 
-export interface ModelEntry {
-  readonly id: string
-  readonly kind: "alias" | "id"
-  readonly note?: string
-}
-
-export interface ModelCatalog {
-  readonly verified: string
-  readonly models: ReadonlyArray<ModelEntry>
-}
-
 export type Tool = "claude" | "codex"
 
 const readJson = (path: string): any => JSON.parse(readFileSync(path, "utf8"))
 const readJsonText = (text: string): any => JSON.parse(text)
 
-export const modelCatalog = (tool: Tool): ModelCatalog =>
-  readJsonText(payloadText("SoT/models.json"))[tool]
-
-export const toolchainManifest = (): Record<string, any> =>
-  readJsonText(payloadText("SoT/toolchain.json")).tools
-
 /** SoT settings (claude) — model/effort/env for drift display. */
 export const sotClaudeSettings = (): any =>
   readJsonText(payloadText("SoT/.claude/settings.json"))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docks-kit",
-  "version": "0.16.4",
+  "version": "0.16.5",
   "description": "Portable AI coding agent config kit — SoT sync engine + typed CLI for Claude Code, Codex, and universal agent skills",
   "type": "module",
   "license": "MIT",