karajan-code 3.5.1 → 3.7.0

package/src/harden/advisory.js

@@ -0,0 +1,168 @@
+/**
+ * advisory — per-artifact comparison engine for `kj harden` advisory mode
+ * (KJC-TSK-0565, épica KJC-PCS-0060). For each artifact harden manages it
+ * classifies the repo state: MISSING (no file nor equivalent), KJ_MANAGED (a
+ * kj:managed block, up to date or outdated vN) or USER_OWNED (the user's own,
+ * possibly in another format). Read-only; never writes or prints. The result
+ * feeds `--report` (Advisory B) / `--interactive` (Advisory C). Per-type
+ * improvement heuristics for USER_OWNED land in the follow-up slice (PR2).
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { findManagedBlock } from "../utils/managed-markers.js";
+import { CONFIGS_BY_LANGUAGE, UNIVERSAL_CONFIGS } from "./config-templates.js";
+import { detectStackRoots } from "./stack-roots.js";
+
+const BLOCK_VERSION = 1; // current version every markered config ships at
+
+// Other filenames/formats for the same artifact, so kj never reports a false
+// "missing". `pkgKey` is a package.json field that can hold inline config.
+const EQUIVALENTS = {
+  commitlint: { files: [".commitlintrc", ".commitlintrc.js", ".commitlintrc.json", ".commitlintrc.yaml"], pkgKey: "commitlint" },
+  eslint: { files: ["eslint.config.mjs", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json", ".eslintrc.yaml"], pkgKey: "eslintConfig" },
+  prettier: { files: [".prettierrc", ".prettierrc.js", ".prettierrc.yaml", "prettier.config.js"], pkgKey: "prettier" },
+};
+
+// Concrete gains kj's standard would add to a USER_OWNED config, detected by
+// substring probes (no AST parse): each probe absent from the user's content
+// becomes one improvement. Heuristic by design — conservative, never a false
+// "you're missing this" when the signal is clearly present.
+const IMPROVEMENTS = {
+  eslint: [
+    { needle: "no-var", id: "no-var", detail: "bans var (ES2025: const/let)" },
+    { needle: "no-restricted-globals", id: "no-legacy-globals", detail: "bans alert/confirm/prompt, escape/unescape" },
+    { needle: "no-restricted-properties", id: "no-legacy-apis", detail: "bans document.write, substr" },
+  ],
+  commitlint: [
+    { needle: "header-max-length", id: "header-max-length", detail: "caps the commit header at 100 chars" },
+    { needle: "subject-case", id: "subject-case", detail: "enforces a lowercase subject" },
+  ],
+  prettier: [{ needle: "printWidth", id: "print-width", detail: "pins printWidth (consistent wrapping)" }],
+  editorconfig: [
+    { needle: "insert_final_newline", id: "final-newline", detail: "enforces a final newline" },
+    { needle: "charset", id: "charset", detail: "pins charset = utf-8" },
+    { needle: "trim_trailing_whitespace", id: "trim-trailing", detail: "trims trailing whitespace" },
+  ],
+};
+
+/** Improvements kj would add to the user's own config for `artifactId`. */
+function improvementsFor(artifactId, content) {
+  return (IMPROVEMENTS[artifactId] ?? [])
+    .filter((probe) => !content.includes(probe.needle))
+    .map(({ id, detail }) => ({ id, detail }));
+}
+
+/** Build an artifact descriptor from a config-template entry. */
+function toArtifact(cfg) {
+  const id = cfg.blockId ?? "prettier"; // the only marker-less JSON config is prettier
+  return {
+    id,
+    file: cfg.file,
+    blockId: cfg.blockId ?? null,
+    currentVersion: cfg.blockId ? BLOCK_VERSION : null,
+    equivalents: EQUIVALENTS[id]?.files ?? [],
+    pkgKey: EQUIVALENTS[id]?.pkgKey ?? null,
+  };
+}
+
+/** Locate the user's file for an artifact under `searchDir`; null if absent. */
+function findArtifactFile(searchDir, artifact) {
+  for (const rel of [artifact.file, ...artifact.equivalents]) {
+    if (existsSync(join(searchDir, rel))) return rel;
+  }
+  if (artifact.pkgKey && existsSync(join(searchDir, "package.json"))) {
+    try {
+      if (JSON.parse(readFileSync(join(searchDir, "package.json"), "utf8"))[artifact.pkgKey] != null) {
+        return `package.json#${artifact.pkgKey}`;
+      }
+    } catch {
+      /* unreadable package.json → not a match */
+    }
+  }
+  return null;
+}
+
+/** Read the artifact body, or the JSON of an inline package.json key. */
+function readArtifactContent(searchDir, foundAt) {
+  const [file, key] = foundAt.split("#");
+  const raw = readFileSync(join(searchDir, file), "utf8");
+  if (!key) return raw;
+  try {
+    return JSON.stringify(JSON.parse(raw)[key] ?? null);
+  } catch {
+    return raw;
+  }
+}
+
+/** Map a classified state to a recommendation + human rationale. */
+function recommend(state) {
+  if (state.status === "MISSING") return { recommendation: "install", rationale: `kj would add ${state.file}`, mergeable: true };
+  if (state.status === "USER_OWNED") {
+    const n = state.improvements?.length ?? 0;
+    return n === 0
+      ? { recommendation: "keep", rationale: "your own config — already covers the kj standard", mergeable: false }
+      : { recommendation: "review", rationale: `your own config — kj could add ${n} improvement(s)`, mergeable: true };
+  }
+  if (state.upToDate) return { recommendation: "keep", rationale: `managed by kj (v${state.managedVersion}), up to date`, mergeable: false };
+  return { recommendation: "update", rationale: `kj v${state.currentVersion} available (you have v${state.managedVersion})`, mergeable: true };
+}
+
+/** Classify a single artifact found (or not) under `searchDir`. */
+export function classifyArtifact(searchDir, artifact) {
+  const foundAt = findArtifactFile(searchDir, artifact);
+  const base = { foundAt, managedVersion: null, upToDate: null, improvements: [] };
+  let state = { ...base, status: "MISSING" };
+  if (foundAt) {
+    const content = readArtifactContent(searchDir, foundAt);
+    if (artifact.blockId && content.includes(`kj:managed:${artifact.blockId}`)) {
+      const { version } = findManagedBlock(content, artifact.blockId);
+      state = { ...base, status: "KJ_MANAGED", managedVersion: version, upToDate: version != null && version >= artifact.currentVersion };
+    } else {
+      state = { ...base, status: "USER_OWNED", improvements: improvementsFor(artifact.id, content) };
+    }
+  }
+  const head = { id: artifact.id, file: artifact.file, currentVersion: artifact.currentVersion };
+  return { ...head, ...state, ...recommend({ ...state, ...head }) };
+}
+
+/**
+ * Compare the whole repo against the kj standard, artifact by artifact:
+ * universal configs at the root, then each language's lint config inside its
+ * own root (monorepo-aware, mirroring installConfigsForRoots). `minimal`
+ * profile ships no config, so there is nothing to compare.
+ */
+export function compareHarden({ projectDir = process.cwd(), profile = "standard", only = [], exclude = [] } = {}) {
+  if (profile === "minimal") return { artifacts: [] };
+  const artifacts = UNIVERSAL_CONFIGS.map((cfg) => ({ dir: ".", ...classifyArtifact(projectDir, toArtifact(cfg)) }));
+  for (const { dir, language } of detectStackRoots(projectDir, { only, exclude })) {
+    const searchDir = dir === "." ? projectDir : join(projectDir, dir);
+    for (const cfg of CONFIGS_BY_LANGUAGE[language] ?? []) {
+      const res = classifyArtifact(searchDir, toArtifact(cfg));
+      artifacts.push({ dir, ...res, foundAt: res.foundAt && dir !== "." ? join(dir, res.foundAt) : res.foundAt });
+    }
+  }
+  return { artifacts };
+}
+
+const MARK = { install: "+", update: "↑", review: "~", keep: "✓" };
+
+/**
+ * Render a compareHarden() result as human-readable lines (Advisory B). Pure:
+ * returns an array of strings, prints nothing. One line per artifact, indented
+ * bullets for each improvement, then a one-line tally.
+ */
+export function formatAdvisoryReport({ artifacts = [] } = {}) {
+  if (artifacts.length === 0) return ["kj harden — nothing to compare (minimal profile or empty repo)."];
+  const lines = ["kj harden — advisory report (read-only)", ""];
+  const tally = { install: 0, update: 0, review: 0, keep: 0 };
+  for (const a of artifacts) {
+    tally[a.recommendation] = (tally[a.recommendation] ?? 0) + 1;
+    const path = a.foundAt ?? (a.dir === "." ? a.file : join(a.dir, a.file));
+    lines.push(`  ${MARK[a.recommendation] ?? "·"} ${a.recommendation.padEnd(7)} ${path} — ${a.rationale}`);
+    for (const imp of a.improvements ?? []) lines.push(`      • ${imp.detail}`);
+  }
+  lines.push("", `${artifacts.length} artifact(s) · ${tally.install} missing · ${tally.review} to review · ${tally.update} outdated · ${tally.keep} ok`);
+  return lines;
+}

package/src/harden/interactive.js

@@ -0,0 +1,76 @@
+/**
+ * interactive — `kj harden --interactive` (KJC-TSK-0567, épica KJC-PCS-0060).
+ *
+ * Walks the advisory comparison (Advisory A/B) and asks, artifact by artifact,
+ * whether to apply the kj standard — with a safe default of leaving the user's
+ * own config untouched. Only the pieces the user says yes to are written:
+ *
+ *   MISSING                  → add it?      (default yes — same as seed-if-absent)
+ *   KJ_MANAGED outdated      → update it?   (default yes)
+ *   USER_OWNED w/ gaps       → adopt kj's?  (default NO — keep yours)
+ *
+ * The full merge (user's config + kj rules) is out of scope here (v2): adopt
+ * replaces the file with kj's standard. `ask` is injected so the flow is
+ * testable without a TTY; the CLI passes a readline-backed confirm.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { upsertManagedBlock } from "../utils/managed-markers.js";
+import { compareHarden } from "./advisory.js";
+import { CONFIGS_BY_LANGUAGE, UNIVERSAL_CONFIGS } from "./config-templates.js";
+
+const BLOCK_VERSION = 1; // mirrors config-engine.js
+
+// Artifact id (blockId, or "prettier" for the marker-less JSON) → its template.
+const TEMPLATE_BY_ID = new Map();
+for (const cfg of [...UNIVERSAL_CONFIGS, ...Object.values(CONFIGS_BY_LANGUAGE).flat()]) {
+  TEMPLATE_BY_ID.set(cfg.blockId ?? "prettier", cfg);
+}
+
+/** What to ask (and do) for one classified artifact; null = nothing to offer. */
+export function decideAction(a) {
+  if (a.recommendation === "install") return { action: "add", defaultYes: true, prompt: `Add ${a.file}? (${a.rationale})` };
+  if (a.recommendation === "update") return { action: "update", defaultYes: true, prompt: `Update ${a.file} to kj v${a.currentVersion}?` };
+  if (a.recommendation === "review") {
+    return { action: "adopt", defaultYes: false, prompt: `Adopt kj's ${a.file}? Replaces yours, adds ${a.improvements.length} improvement(s). Default keeps yours.` };
+  }
+  return null; // keep / up-to-date — nothing to ask
+}
+
+/** Write an artifact's kj body. `overwrite` discards the user's file (adopt). */
+function applyArtifact(projectDir, dir, cfg, { overwrite }) {
+  const target = join(projectDir, dir === "." ? "" : dir, cfg.file);
+  mkdirSync(dirname(target), { recursive: true });
+  if (cfg.json) {
+    writeFileSync(target, `${cfg.body}\n`);
+    return;
+  }
+  const source = !overwrite && existsSync(target) ? readFileSync(target, "utf8") : "";
+  const { content } = upsertManagedBlock({ source, blockId: cfg.blockId, version: BLOCK_VERSION, body: cfg.body, style: cfg.style });
+  writeFileSync(target, content);
+}
+
+/**
+ * Run the interactive adoption flow. `ask(prompt, defaultYes) → Promise<bool>`.
+ * Returns the list of applied artifacts. Writes nothing the user declines.
+ */
+export async function interactiveHarden({ projectDir = process.cwd(), profile = "standard", only = [], exclude = [], ask, logger = console } = {}) {
+  const { artifacts } = compareHarden({ projectDir, profile, only, exclude });
+  const applied = [];
+  for (const a of artifacts) {
+    const plan = decideAction(a);
+    if (!plan) continue;
+    const yes = await ask(plan.prompt, plan.defaultYes);
+    if (!yes) continue;
+    const cfg = TEMPLATE_BY_ID.get(a.id);
+    if (!cfg) continue;
+    applyArtifact(projectDir, a.dir, cfg, { overwrite: plan.action === "adopt" });
+    const where = a.dir === "." ? a.file : join(a.dir, a.file);
+    applied.push({ file: where, action: plan.action });
+    logger.info?.(`  ✓ ${plan.action} ${where}`);
+  }
+  if (applied.length === 0) logger.info?.("kj harden — nothing applied (kept everything as-is).");
+  return { ok: true, interactive: true, applied };
+}

package/src/harden/stack-roots.js

@@ -21,9 +21,38 @@ const IGNORE_DIRS = new Set([
   "target",
   "__pycache__",
   "venv",
+  // Auxiliary code that isn't the app to harden (KJC-TSK-0564): demo/fixture
+  // dirs ship their own throwaway manifests and must not seed lint/CI config.
+  "examples",
+  "example",
+  "fixtures",
+  "samples",
+  "third_party",
+  "testdata",
+  "__fixtures__",
 ]);
 const DEFAULT_MAX_DEPTH = 2;
 
+/**
+ * Minimal glob for harden scope flags — no dynamic RegExp (eslint security).
+ * Matches on exact equality, directory prefix (`wrappers` ⊇ `wrappers/python`)
+ * and `*` wildcards anchored at both ends unless the `*` is leading/trailing.
+ */
+export function matchesGlob(value, pattern) {
+  if (value === pattern || value.startsWith(`${pattern}/`)) return true;
+  if (!pattern.includes("*")) return false;
+  const pieces = pattern.split("*");
+  let idx = 0;
+  for (let i = 0; i < pieces.length; i += 1) {
+    const piece = pieces[i];
+    if (!piece) continue;
+    const at = value.indexOf(piece, idx);
+    if (at === -1 || (i === 0 && at !== 0)) return false;
+    idx = at + piece.length;
+  }
+  return pattern.endsWith("*") || value.length === idx;
+}
+
 /** Identify the language of a single directory by its manifest files. */
 export function languageAt(dir) {
   if (existsSync(join(dir, "package.json"))) {
@@ -43,7 +72,7 @@ export function languageAt(dir) {
   return null;
 }
 
-export function detectStackRoots(projectDir, { maxDepth = DEFAULT_MAX_DEPTH } = {}) {
+export function detectStackRoots(projectDir, { maxDepth = DEFAULT_MAX_DEPTH, only = [], exclude = [] } = {}) {
   const found = [];
   function walk(dir, depth) {
     const language = languageAt(dir);
@@ -69,7 +98,8 @@ export function detectStackRoots(projectDir, { maxDepth = DEFAULT_MAX_DEPTH } =
     const cur = byLanguage.get(f.language);
     if (!cur || f.depth < cur.depth) byLanguage.set(f.language, f);
   }
-  return [...byLanguage.values()]
-    .map(({ dir, language }) => ({ dir, language }))
-    .sort((a, b) => a.dir.localeCompare(b.dir));
+  let roots = [...byLanguage.values()].map(({ dir, language }) => ({ dir, language }));
+  if (only.length) roots = roots.filter((r) => only.some((o) => matchesGlob(r.dir, o)));
+  if (exclude.length) roots = roots.filter((r) => !exclude.some((g) => matchesGlob(r.dir, g)));
+  return roots.sort((a, b) => a.dir.localeCompare(b.dir));
 }

package/src/orchestrator/drivers/pre-loop-phases/inject-loaded-plan.js

@@ -316,7 +316,8 @@ function wirePlanCallbacks({ session, loadedPlan, projectDir, syncResultsToPlan,
       await savePlanToDisk(projectDir, loadedPlan);
       if (outcome && Number.isFinite(outcome.cost_usd)) {
         try {
-          const { setStoryCost, setStoryCachedTokens } = await import("../../../../packages/hu-board/src/db.js");
+          const { ensureDb, setStoryCost, setStoryCachedTokens } = await import("../../../../packages/hu-board/src/db.js");
+          ensureDb(); // KJC-BUG-0090: autorun/run may not have started the board
           setStoryCost(huId, outcome.cost_usd);
           // Φ0-G (KJC-TSK-0525): cached/in tokens travel in the same
           // outcome blob as cost. Write them together so the board

package/src/orchestrator/flow-control.js

@@ -128,7 +128,13 @@ export function parseCheckpointAnswer({ trimmedAnswer, checkpointDisabled, confi
 }
 
 export async function checkSessionTimeout({ askQuestion, elapsedMinutes, config, session, emitter, eventBase, i, budgetSummary }) {
-  if (askQuestion || elapsedMinutes <= config.session.max_total_minutes) return;
+  // Enforce the wall-clock when no human is watching the checkpoint: either a
+  // non-interactive run (no askQuestion) OR an autonomous one — where askQuestion
+  // is the auto-continue wrapper (truthy) but nobody is there to stop a runaway.
+  // Interactive runs keep skipping it (the human decides at the checkpoint).
+  // KJC-TSK-0575 (AUTO-D): without this, autonomous runs had NO wall-clock cap.
+  const unattended = !askQuestion || askQuestion.unattended === true;
+  if (!unattended || elapsedMinutes <= config.session.max_total_minutes) return;
 
   await markSessionStatus(session, "failed");
   emitProgress(

package/src/prompts/arbiter.js

@@ -0,0 +1,38 @@
+/**
+ * Arbiter prompt (KJC-TSK-0573, design in docs/specs/autonomous-delivery.md §6).
+ *
+ * The Arbiter is Karajan's autonomous decision authority: given a conflict, it
+ * picks the LEAST-BAD option from a closed set and moves forward — no human.
+ */
+
+/** The closed set of conflict-resolution verdicts. BLOCK_AND_CONTINUE is safe. */
+export const VERDICTS = Object.freeze([
+  "ACCEPT_WITH_DEFECT",
+  "RETRY_DIFFERENT_APPROACH",
+  "DESCOPE_HU",
+  "BLOCK_AND_CONTINUE",
+  "PROCEED",
+]);
+
+export function buildArbiterPrompt({ question, options = [], context = null } = {}) {
+  const allowed = options.length ? options.map((o) => o.value) : VERDICTS;
+  return [
+    "You are the Arbiter — Karajan's autonomous decision authority. There is no human to ask.",
+    "Resolve the conflict below by choosing the LEAST-BAD option and moving forward.",
+    "",
+    "Ground-truth order (what wins when signals disagree):",
+    "  1. Acceptance tests passing — beats any reviewer opinion.",
+    "  2. Must-fix issues (security, correctness, data) — beat style.",
+    "  3. Nice-to-have (style, optional refactors) — never block; record as a defect if dropped.",
+    "Goal: maximize 'the ask is met', minimize irreversible risk. Imperfect-but-delivered beats blocked.",
+    "",
+    `Conflict: ${question}`,
+    context ? `Context: ${JSON.stringify(context)}` : "",
+    "",
+    `Choose exactly one verdict from: ${allowed.join(", ")}`,
+    "Respond with ONLY this JSON (no prose):",
+    '{"verdict":"<one of the allowed>","confidence":0.0,"rationale":"why it is the least-bad option","defect":"residual debt if any, else null","directive":"instruction to the coder when RETRY_DIFFERENT_APPROACH, else null"}',
+  ]
+    .filter(Boolean)
+    .join("\n");
+}

package/src/spec-review/run-spec-review.js

@@ -7,10 +7,30 @@
 import { SpecReviewerRole } from "../roles/spec-reviewer-role.js";
 import { printFindings } from "../utils/display/spec-findings.js";
 import { runRefinePass } from "./refine-loop.js";
+import { RISK } from "../autonomy/policy.js";
 
 const MAX_REFINE_ITERATIONS = 5;
 
-export async function runSpecReview({ spec, config, logger, askQuestion, flags = {} }) {
+/**
+ * Decide the gate action (`continue` | `refine`) autonomously: the Arbiter
+ * picks PROCEED (proceed with the best reading) or RETRY_DIFFERENT_APPROACH
+ * (auto-refine). It is never offered `cancel`, so an autonomous run never
+ * aborts on spec ambiguity (KJC-TSK-0572, closes gap G1).
+ */
+async function decideGateAutonomously(resolve, { severity, findings }) {
+  const { choice } = await resolve({
+    question: `Spec has ${findings.length} finding(s) at severity ${severity}: proceed with the best reading, or auto-refine?`,
+    options: [
+      { value: "PROCEED", label: "proceed with the best reading", conservative: true },
+      { value: "RETRY_DIFFERENT_APPROACH", label: "auto-refine the spec" },
+    ],
+    context: { severity, findingCount: findings.length, categories: [...new Set(findings.map((f) => f.category))] },
+    risk: severity === "fail" ? RISK.HIGH : RISK.LOW,
+  });
+  return choice === "RETRY_DIFFERENT_APPROACH" ? "refine" : "continue";
+}
+
+export async function runSpecReview({ spec, config, logger, askQuestion, flags = {}, resolve = null, autonomy = "interactive" }) {
   // VITEST guard — pre-existing test suites (e.g. tests/commands/command-run.test.js)
   // mock `runFlow` + `assertAgentsAvailable` but predate this role and have
   // no need to exercise it. Auto-skip in vitest unless the test passes
@@ -40,16 +60,24 @@ export async function runSpecReview({ spec, config, logger, askQuestion, flags =
       return { proceed: true, severity: "ok", findings: [], finalSpec: currentSpec, refined: iter > 0 };
     }
     printFindings(findings, severity);
-    if (!askQuestion) return { proceed: true, severity, findings, finalSpec: currentSpec };
 
-    const answer = await askQuestion(
-      `Spec review: ${findings.length} finding${findings.length === 1 ? "" : "s"} at severity ${severity}. [c]ontinue / [r]efine / [x]cancel? (default: continue)`,
-      { detail: { severity, findingCount: findings.length, categories: [...new Set(findings.map((f) => f.category))], iteration: iter + 1 } },
-    );
-    if (answer === null) return { proceed: false, cancelled: true, severity, findings };
-    const n = String(answer).trim().toLowerCase();
-    if (n.startsWith("x") || n === "cancel") return { proceed: false, cancelled: true, severity, findings };
-    if (n.startsWith("r") || n === "refine") {
+    // Autonomous/assisted: the Arbiter decides (continue|refine), never cancels.
+    // Interactive (no resolver): the human answers [c]/[r]/[x] as before.
+    let action;
+    if (resolve && autonomy !== "interactive") {
+      action = await decideGateAutonomously(resolve, { severity, findings });
+    } else {
+      if (!askQuestion) return { proceed: true, severity, findings, finalSpec: currentSpec };
+      const answer = await askQuestion(
+        `Spec review: ${findings.length} finding${findings.length === 1 ? "" : "s"} at severity ${severity}. [c]ontinue / [r]efine / [x]cancel? (default: continue)`,
+        { detail: { severity, findingCount: findings.length, categories: [...new Set(findings.map((f) => f.category))], iteration: iter + 1 } },
+      );
+      if (answer === null) return { proceed: false, cancelled: true, severity, findings };
+      const n = String(answer).trim().toLowerCase();
+      action = n.startsWith("x") || n === "cancel" ? "cancel" : n.startsWith("r") || n === "refine" ? "refine" : "continue";
+    }
+    if (action === "cancel") return { proceed: false, cancelled: true, severity, findings };
+    if (action === "refine") {
       const refine = await runRefinePass({
         spec: currentSpec, findings, role,
         projectDir: config?.projectDir, taskFile: flags.taskFile, logger,

package/src/utils/squeezr-detect.js

@@ -8,7 +8,10 @@ export async function detectSqueezr() {
   try {
     const result = await runCommand("squeezr", ["--version"]);
     if (result.exitCode === 0) {
-      const version = (result.stdout || "").trim() || null;
+      // `squeezr --version` may append an "update available" banner box; keep
+      // just the semver so callers never render that noise (KJC-BUG-0088).
+      const raw = (result.stdout || "").trim();
+      const version = raw.match(/\d+\.\d+\.\d+[\w.-]*/)?.[0] || raw.split("\n")[0].trim() || null;
       return { available: true, version };
     }
     return { available: false, version: null };