docks-kit 0.17.1 → 0.17.2

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

@@ -1,17 +1,17 @@
-import { p } from "./exec"
-import { isObject, parseJson, type Json } from "./jq"
-import { hostOs, type HostOs } from "./os"
+import { p } from "./exec";
+import { isObject, parseJson, type Json } from "./jq";
+import { hostOs, type HostOs } from "./os";
 
-const BUN_SENTINEL = "__DOCKS_KIT_BUN__"
-const SESSION_START_SENTINEL = "__DOCKS_KIT_SESSION_START__"
-const NOTIFY_SENTINEL = "__DOCKS_KIT_NOTIFY__"
-const STATUSLINE_SENTINEL = "__DOCKS_KIT_STATUSLINE__"
+const BUN_SENTINEL = "__DOCKS_KIT_BUN__";
+const SESSION_START_SENTINEL = "__DOCKS_KIT_SESSION_START__";
+const NOTIFY_SENTINEL = "__DOCKS_KIT_NOTIFY__";
+const STATUSLINE_SENTINEL = "__DOCKS_KIT_STATUSLINE__";
 
 export interface ClaudeRuntimePaths {
-  readonly bun: string
-  readonly statusline: string
-  readonly sessionStart: string
-  readonly notify: string
+  readonly bun: string;
+  readonly statusline: string;
+  readonly sessionStart: string;
+  readonly notify: string;
 }
 
 export function claudeRuntimePaths(claudeDir: string, bun: string): ClaudeRuntimePaths {
@@ -19,113 +19,139 @@ export function claudeRuntimePaths(claudeDir: string, bun: string): ClaudeRuntim
     bun,
     statusline: p(claudeDir, "bin", "statusline.mjs"),
     sessionStart: p(claudeDir, "bin", "session-start.mjs"),
-    notify: p(claudeDir, "bin", "notify.mjs")
-  }
+    notify: p(claudeDir, "bin", "notify.mjs"),
+  };
 }
 
 function cloneJson(value: Json): Json {
-  const cloned = parseJson(JSON.stringify(value))
-  if (cloned === undefined) throw new Error("Claude settings template cannot be serialized")
-  return cloned
+  const cloned = parseJson(JSON.stringify(value));
+  if (cloned === undefined) throw new Error("Claude settings template cannot be serialized");
+  return cloned;
 }
 
 function countString(value: Json, expected: string): number {
-  if (value === expected) return 1
-  if (Array.isArray(value)) return value.reduce<number>((total, item) => total + countString(item, expected), 0)
-  if (!isObject(value)) return 0
-  return Object.values(value).reduce<number>((total, item) => total + countString(item, expected), 0)
+  if (value === expected) return 1;
+  if (Array.isArray(value))
+    return value.reduce<number>((total, item) => total + countString(item, expected), 0);
+  if (!isObject(value)) return 0;
+  return Object.values(value).reduce<number>(
+    (total, item) => total + countString(item, expected),
+    0,
+  );
 }
 
 function hooksObject(template: Json): { [key: string]: Json } {
-  if (!isObject(template) || !isObject(template["hooks"])) throw new Error("Claude settings hooks object is missing")
-  return template["hooks"]
+  if (!isObject(template) || !isObject(template["hooks"]))
+    throw new Error("Claude settings hooks object is missing");
+  return template["hooks"];
 }
 
-function commandHandler(template: Json, event: "SessionStart" | "Notification"): { [key: string]: Json } {
-  const entries = hooksObject(template)[event]
+function commandHandler(
+  template: Json,
+  event: "SessionStart" | "Notification",
+): { [key: string]: Json } {
+  const entries = hooksObject(template)[event];
   if (!Array.isArray(entries) || entries.length !== 1 || !isObject(entries[0])) {
-    throw new Error(`${event} sentinel location is invalid`)
+    throw new Error(`${event} sentinel location is invalid`);
   }
-  const handlers = entries[0]["hooks"]
+  const handlers = entries[0]["hooks"];
   if (!Array.isArray(handlers) || handlers.length !== 1 || !isObject(handlers[0])) {
-    throw new Error(`${event} sentinel handler is invalid`)
+    throw new Error(`${event} sentinel handler is invalid`);
   }
-  return handlers[0]
+  return handlers[0];
 }
 
 function oneArg(handler: { [key: string]: Json }, sentinel: string, event: string): void {
-  const args = handler["args"]
+  const args = handler["args"];
   if (!Array.isArray(args) || args.length !== 1 || args[0] !== sentinel) {
-    throw new Error(`${event} argument sentinel location is invalid`)
+    throw new Error(`${event} argument sentinel location is invalid`);
   }
 }
 
 function validateTemplate(template: Json): void {
-  const sessionStart = commandHandler(template, "SessionStart")
-  const notification = commandHandler(template, "Notification")
-  if (sessionStart["command"] !== BUN_SENTINEL) throw new Error("SessionStart Bun sentinel location is invalid")
-  if (notification["command"] !== BUN_SENTINEL) throw new Error("Notification Bun sentinel location is invalid")
-  oneArg(sessionStart, SESSION_START_SENTINEL, "SessionStart")
-  oneArg(notification, NOTIFY_SENTINEL, "Notification")
+  const sessionStart = commandHandler(template, "SessionStart");
+  const notification = commandHandler(template, "Notification");
+  if (sessionStart["command"] !== BUN_SENTINEL)
+    throw new Error("SessionStart Bun sentinel location is invalid");
+  if (notification["command"] !== BUN_SENTINEL)
+    throw new Error("Notification Bun sentinel location is invalid");
+  oneArg(sessionStart, SESSION_START_SENTINEL, "SessionStart");
+  oneArg(notification, NOTIFY_SENTINEL, "Notification");
 
-  const hooks = hooksObject(template)
-  if (hooks["Stop"] !== undefined) throw new Error("hooks.Stop must be absent from the Claude settings template")
-  if (!isObject(template) || !isObject(template["statusLine"]) || template["statusLine"]["command"] !== STATUSLINE_SENTINEL) {
-    throw new Error("Statusline sentinel location is invalid")
+  const hooks = hooksObject(template);
+  if (hooks["Stop"] !== undefined)
+    throw new Error("hooks.Stop must be absent from the Claude settings template");
+  if (
+    !isObject(template) ||
+    !isObject(template["statusLine"]) ||
+    template["statusLine"]["command"] !== STATUSLINE_SENTINEL
+  ) {
+    throw new Error("Statusline sentinel location is invalid");
   }
   const counts: ReadonlyArray<[string, string, number]> = [
     ["Bun", BUN_SENTINEL, 2],
     ["SessionStart", SESSION_START_SENTINEL, 1],
     ["notify", NOTIFY_SENTINEL, 1],
-    ["statusline", STATUSLINE_SENTINEL, 1]
-  ]
+    ["statusline", STATUSLINE_SENTINEL, 1],
+  ];
   for (const [label, sentinel, expected] of counts) {
-    if (countString(template, sentinel) !== expected) throw new Error(`${label} sentinel residue/cardinality is invalid`)
+    if (countString(template, sentinel) !== expected)
+      throw new Error(`${label} sentinel residue/cardinality is invalid`);
   }
 }
 
-
 export function statusLineCommand(runtime: ClaudeRuntimePaths, host: HostOs = hostOs()): string {
-  return host.statusLineCommand(runtime.bun, runtime.statusline)
+  return host.statusLineCommand(runtime.bun, runtime.statusline);
 }
 
 export function materializeClaudeSettings(
   template: Json,
   runtime: ClaudeRuntimePaths | undefined,
-  host: HostOs = hostOs()
+  host: HostOs = hostOs(),
 ): Json {
-  validateTemplate(template)
-  const result = cloneJson(template)
-  const hooks = hooksObject(result)
-  const failureGroups = hooks["PostToolUseFailure"]
+  validateTemplate(template);
+  const result = cloneJson(template);
+  const hooks = hooksObject(result);
+  const failureGroups = hooks["PostToolUseFailure"];
   if (Array.isArray(failureGroups)) {
     for (const group of failureGroups) {
-      if (!isObject(group) || !Array.isArray(group["hooks"])) continue
+      if (!isObject(group) || !Array.isArray(group["hooks"])) continue;
       for (const handler of group["hooks"]) {
-        if (isObject(handler) && handler["type"] === "command" && typeof handler["command"] === "string") {
-          handler["command"] = host.failureHookCommand(handler["command"])
+        if (
+          isObject(handler) &&
+          handler["type"] === "command" &&
+          typeof handler["command"] === "string"
+        ) {
+          handler["command"] = host.failureHookCommand(handler["command"]);
         }
       }
     }
   }
   if (runtime === undefined) {
-    delete hooks["SessionStart"]
-    delete hooks["Notification"]
-    if (!isObject(result)) throw new Error("Claude settings template must be an object")
-    delete result["statusLine"]
+    delete hooks["SessionStart"];
+    delete hooks["Notification"];
+    if (!isObject(result)) throw new Error("Claude settings template must be an object");
+    delete result["statusLine"];
   } else {
-    const sessionStart = commandHandler(result, "SessionStart")
-    sessionStart["command"] = runtime.bun
-    sessionStart["args"] = [runtime.sessionStart]
-    const notification = commandHandler(result, "Notification")
-    notification["command"] = runtime.bun
-    notification["args"] = [runtime.notify]
-    if (!isObject(result) || !isObject(result["statusLine"])) throw new Error("Claude statusLine object is missing")
-    result["statusLine"]["command"] = statusLineCommand(runtime, host)
+    const sessionStart = commandHandler(result, "SessionStart");
+    sessionStart["command"] = runtime.bun;
+    sessionStart["args"] = [runtime.sessionStart];
+    const notification = commandHandler(result, "Notification");
+    notification["command"] = runtime.bun;
+    notification["args"] = [runtime.notify];
+    if (!isObject(result) || !isObject(result["statusLine"]))
+      throw new Error("Claude statusLine object is missing");
+    result["statusLine"]["command"] = statusLineCommand(runtime, host);
   }
 
-  for (const sentinel of [BUN_SENTINEL, SESSION_START_SENTINEL, NOTIFY_SENTINEL, STATUSLINE_SENTINEL]) {
-    if (countString(result, sentinel) !== 0) throw new Error(`Claude settings sentinel residue: ${sentinel}`)
+  for (const sentinel of [
+    BUN_SENTINEL,
+    SESSION_START_SENTINEL,
+    NOTIFY_SENTINEL,
+    STATUSLINE_SENTINEL,
+  ]) {
+    if (countString(result, sentinel) !== 0)
+      throw new Error(`Claude settings sentinel residue: ${sentinel}`);
   }
-  return result
+  return result;
 }

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

@@ -0,0 +1,174 @@
+/**
+ * EngineNative `sync claude` settings materialization and merge. Step order
+ * with the runtime cutover and deploy-time modifiers is load-bearing and
+ * golden-tested; message strings and JSON semantics are part of the contract.
+ */
+import { copyFileSync, existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { p } from "./exec";
+import type { Ctx } from "./index";
+import { isObject, jqStringify, parseJson, type Json } from "./jq";
+import { ExitError } from "./parseArgs";
+import { mergeSettings, reconcileSettings } from "./settings";
+import { payloadDisplayPath } from "../payload";
+
+export interface PreparedClaudeSettings {
+  readonly path: string;
+  readonly bytes: string;
+  readonly previousBytes: string | undefined;
+  readonly changed: boolean;
+}
+
+function assertMaterializedSettings(bytes: string): void {
+  if (bytes.includes("__DOCKS_KIT_"))
+    throw new Error("Claude settings contain unresolved runtime sentinels");
+}
+
+/** Build the candidate settings bytes before the readiness-gated runtime cutover mutates disk. */
+export function prepareClaudeSettings(
+  ctx: Ctx,
+  claudeDir: string,
+  repo: Json,
+): PreparedClaudeSettings {
+  const path = p(claudeDir, "settings.json");
+  if (!existsSync(path)) {
+    const bytes = jqStringify(repo);
+    assertMaterializedSettings(bytes);
+    return { path, bytes, previousBytes: undefined, changed: true };
+  }
+
+  const previousBytes = readFileSync(path, "utf8");
+  const user = parseJson(previousBytes);
+  if (user === undefined || !isObject(user)) {
+    const reason = user === undefined ? "is not valid JSON" : "must contain a JSON object";
+    ctx.services.logger.err(
+      `Aborting sync: ${path} ${reason}. Fix it manually or delete it to reinstall.`,
+    );
+    throw new ExitError(1);
+  }
+  const merged = ctx.reconcile ? reconcileSettings(repo, user) : mergeSettings(repo, user);
+  const bytes = jqStringify(merged);
+  assertMaterializedSettings(bytes);
+  return { path, bytes, previousBytes, changed: bytes !== previousBytes };
+}
+
+/** Commit a fully prepared document; callers must finish runtime preparation first. */
+export function commitClaudeSettings(ctx: Ctx, prepared: PreparedClaudeSettings): void {
+  const { change, verbose } = ctx.services.logger;
+  if (!prepared.changed) {
+    verbose("Settings already in sync");
+    return;
+  }
+
+  if (prepared.previousBytes !== undefined) copyFileSync(prepared.path, `${prepared.path}.bak`);
+  writeFileSync(`${prepared.path}.tmp`, prepared.bytes);
+  renameSync(`${prepared.path}.tmp`, prepared.path);
+  ctx.nextStepTriggers.claudeRestart = true;
+  if (prepared.previousBytes === undefined) {
+    change("Settings installed");
+  } else if (ctx.reconcile) {
+    change(
+      "Settings reconciled (backup at settings.json.bak; user-only keys preserved, permissions arrays replaced by SoT)",
+    );
+  } else {
+    change("Settings merged (backup at settings.json.bak)");
+  }
+}
+
+export function describeSettingsSync(ctx: Ctx, claudeDir: string): void {
+  const { echo } = ctx.services.logger;
+  const repoSettings = payloadDisplayPath("SoT/.claude/settings.json");
+  const userSettings = p(claudeDir, "settings.json");
+
+  if (!existsSync(userSettings)) {
+    echo(`[dry-run] install ${repoSettings} -> ${userSettings}`);
+  } else if (ctx.reconcile) {
+    echo(
+      `[dry-run] reconcile ${repoSettings} -> ${userSettings} (SoT keys win; permissions arrays replaced; user-only keys preserved)`,
+    );
+  } else {
+    echo(
+      `[dry-run] merge ${repoSettings} -> ${userSettings} (SoT keys win; permissions arrays unioned; user-only keys preserved)`,
+    );
+  }
+}
+
+/** Shared shape of the three jq-edit modifiers (compact window, permissive). */
+function jqEditSettings(
+  ctx: Ctx,
+  claudeDir: string,
+  tag: string,
+  edit: (doc: Json) => void,
+): boolean {
+  const { err, warn } = ctx.services.logger;
+  const userSettings = p(claudeDir, "settings.json");
+  if (!existsSync(userSettings)) {
+    warn(`(${tag}) ${userSettings} missing — skipped`);
+    return false;
+  }
+  const before = readFileSync(userSettings, "utf8");
+  const doc = parseJson(before);
+  if (doc === undefined) {
+    err(`(${tag}) ${userSettings} is not valid JSON — skipped`);
+    return false;
+  }
+  edit(doc);
+  const out = jqStringify(doc);
+  if (out === before) return false;
+  writeFileSync(`${userSettings}.tmp`, out);
+  renameSync(`${userSettings}.tmp`, userSettings);
+  return true;
+}
+
+export function syncCompactWindow(ctx: Ctx, claudeDir: string): void {
+  const { change, echo, verbose } = ctx.services.logger;
+  if (ctx.claudeCompactWindow === "") return;
+
+  if (ctx.dryRun) {
+    echo(
+      `[dry-run] (--claude-compact-window) set env.CLAUDE_CODE_AUTO_COMPACT_WINDOW=${ctx.claudeCompactWindow} in ${p(claudeDir, "settings.json")}`,
+    );
+    return;
+  }
+
+  const changed = jqEditSettings(ctx, claudeDir, "--claude-compact-window", (doc) => {
+    if (!isObject(doc)) return;
+    const env = isObject(doc["env"]) ? doc["env"] : {};
+    env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = ctx.claudeCompactWindow;
+    doc["env"] = env;
+  });
+  if (changed) {
+    change(
+      `Compact window: set to ${ctx.claudeCompactWindow} tokens in deployed settings (SoT and model unchanged; flag-less sync reverts)`,
+    );
+    ctx.nextStepTriggers.claudeRestart = true;
+  } else
+    verbose(
+      `Compact window: already set to ${ctx.claudeCompactWindow} tokens in deployed settings`,
+    );
+}
+
+export function syncPermissive(ctx: Ctx, claudeDir: string): void {
+  const { change, echo, verbose } = ctx.services.logger;
+  if (!ctx.claudePermissive) return;
+
+  if (ctx.dryRun) {
+    echo(
+      `[dry-run] (--claude-permissive) empty permissions.ask and permissions.deny in ${p(claudeDir, "settings.json")}`,
+    );
+    return;
+  }
+
+  const changed = jqEditSettings(ctx, claudeDir, "--claude-permissive", (doc) => {
+    if (!isObject(doc)) return;
+    const permissions = isObject(doc["permissions"]) ? doc["permissions"] : {};
+    permissions["ask"] = [];
+    permissions["deny"] = [];
+    doc["permissions"] = permissions;
+  });
+  if (changed) {
+    change(
+      "Permissive mode: permissions.ask/deny emptied in deployed settings (sandbox use; SoT unchanged)",
+    );
+    ctx.nextStepTriggers.claudeRestart = true;
+  } else verbose("Permissive mode: permissions.ask/deny already empty in deployed settings");
+}

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

@@ -1,28 +1,24 @@
 /** Atomic top-level Claude settings modifiers, including direct model mode. */
-import { p } from "./exec"
-import { readFileSync, renameSync, writeFileSync } from "node:fs"
+import { p } from "./exec";
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
 
-import { resolveEffort } from "../efforts"
-import type { Ctx } from "./index"
-import { ExitError } from "./parseArgs"
-import { isObject, jqStringify, parseJson } from "./jq"
+import { resolveEffort } from "../efforts";
+import type { Ctx } from "./index";
+import { ExitError } from "./parseArgs";
+import { isObject, jqStringify, parseJson } from "./jq";
+import type { SettingEdit } from "./sharedTypes";
 
-interface ClaudeSettingEdit {
-  readonly tag: string
-  readonly key: "model" | "effortLevel" | "advisorModel"
-  readonly value: string | undefined
-  readonly dryRun: string
-  readonly changed: string
-  readonly unchanged: string
+interface ClaudeSettingEdit extends SettingEdit<"model" | "effortLevel" | "advisorModel"> {
+  readonly dryRun: string;
 }
 
 function syncClaudeSetting(ctx: Ctx, edit: ClaudeSettingEdit): void {
-  const { change, echo, err, verbose, warn } = ctx.services.logger
-  const userSettings = p(ctx.home, ".claude", "settings.json")
+  const { change, echo, err, verbose, warn } = ctx.services.logger;
+  const userSettings = p(ctx.home, ".claude", "settings.json");
 
-  let text: string
+  let text: string;
   try {
-    text = readFileSync(userSettings, "utf8")
+    text = readFileSync(userSettings, "utf8");
   } catch (error) {
     if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT") {
       // A dry-run sync writes nothing, so an absent file here does not mean the
@@ -31,61 +27,61 @@ function syncClaudeSetting(ctx: Ctx, edit: ClaudeSettingEdit): void {
       // `docks-kit model claude <m>`, nothing creates the file and the skip
       // stands.
       if (ctx.dryRun && ctx.syncClaude) {
-        echo(`[dry-run] (${edit.tag}) ${edit.dryRun} in ${userSettings}`)
-        return
+        echo(`[dry-run] (${edit.tag}) ${edit.dryRun} in ${userSettings}`);
+        return;
       }
-      warn(`(${edit.tag}) ${userSettings} missing — skipped`)
-      return
+      warn(`(${edit.tag}) ${userSettings} missing — skipped`);
+      return;
     }
-    const cause = error instanceof Error ? error.message : String(error)
-    err(`(${edit.tag}) could not read ${userSettings}: ${cause}`)
-    throw new ExitError(1)
+    const cause = error instanceof Error ? error.message : String(error);
+    err(`(${edit.tag}) could not read ${userSettings}: ${cause}`);
+    throw new ExitError(1);
   }
-  const doc = parseJson(text)
+  const doc = parseJson(text);
   if (doc === undefined) {
-    err(`(${edit.tag}) ${userSettings} is not valid JSON — skipped`)
-    return
+    err(`(${edit.tag}) ${userSettings} is not valid JSON — skipped`);
+    return;
   }
   if (!isObject(doc)) {
-    err(`(${edit.tag}) ${userSettings} must contain a JSON object — aborting`)
-    throw new ExitError(1)
+    err(`(${edit.tag}) ${userSettings} must contain a JSON object — aborting`);
+    throw new ExitError(1);
   }
 
   if (ctx.dryRun) {
-    echo(`[dry-run] (${edit.tag}) ${edit.dryRun} in ${userSettings}`)
-    return
+    echo(`[dry-run] (${edit.tag}) ${edit.dryRun} in ${userSettings}`);
+    return;
   }
 
-  if (edit.value === undefined) delete doc[edit.key]
-  else doc[edit.key] = edit.value
-  const out = jqStringify(doc)
+  if (edit.value === undefined) delete doc[edit.key];
+  else doc[edit.key] = edit.value;
+  const out = jqStringify(doc);
   if (out === text) {
-    verbose(edit.unchanged)
-    return
+    verbose(edit.unchanged);
+    return;
   }
-  writeFileSync(`${userSettings}.tmp`, out)
-  renameSync(`${userSettings}.tmp`, userSettings)
-  change(edit.changed)
-  ctx.nextStepTriggers.claudeRestart = true
+  writeFileSync(`${userSettings}.tmp`, out);
+  renameSync(`${userSettings}.tmp`, userSettings);
+  change(edit.changed);
+  ctx.nextStepTriggers.claudeRestart = true;
 }
 
 export function syncClaudeModel(ctx: Ctx, model: string): void {
-  if (model === "") return
-  const unset = model === "default"
+  if (model === "") return;
+  const unset = model === "default";
   syncClaudeSetting(ctx, {
     tag: "--claude-model",
     key: "model",
     value: unset ? undefined : model,
     dryRun: unset ? "delete .model (account default applies)" : `set .model=${model}`,
     changed: `Model: deployed settings model set to ${model} (SoT unchanged; flag-less sync reverts)`,
-    unchanged: `Model: deployed settings model already ${unset ? "unset (account default)" : model}`
-  })
+    unchanged: `Model: deployed settings model already ${unset ? "unset (account default)" : model}`,
+  });
 }
 
 export function syncClaudeEffort(ctx: Ctx, effort: string): void {
-  if (effort === "") return
-  const resolved = resolveEffort("claude", effort)
-  const useDefault = effort === "default"
+  if (effort === "") return;
+  const resolved = resolveEffort("claude", effort);
+  const useDefault = effort === "default";
   syncClaudeSetting(ctx, {
     tag: "--claude-effort",
     key: "effortLevel",
@@ -94,14 +90,14 @@ export function syncClaudeEffort(ctx: Ctx, effort: string): void {
     changed: useDefault
       ? `Effort: deployed settings effortLevel set to ${resolved} (SoT default)`
       : `Effort: deployed settings effortLevel set to ${resolved} (SoT unchanged; flag-less sync reverts)`,
-    unchanged: `Effort: deployed settings effortLevel already ${resolved}`
-  })
+    unchanged: `Effort: deployed settings effortLevel already ${resolved}`,
+  });
 }
 
 export function syncClaudeAdvisor(ctx: Ctx, state: string): void {
-  if (state === "") return
-  const enabled = state === "on"
-  const useDefault = state === "default"
+  if (state === "") return;
+  const enabled = state === "on";
+  const useDefault = state === "default";
   syncClaudeSetting(ctx, {
     tag: "--claude-advisor",
     key: "advisorModel",
@@ -114,6 +110,6 @@ export function syncClaudeAdvisor(ctx: Ctx, state: string): void {
         : "Advisor: deployed settings advisorModel unset (--claude-advisor=off; SoT unchanged)",
     unchanged: enabled
       ? "Advisor: deployed settings advisorModel already fable"
-      : `Advisor: deployed settings advisorModel already unset (${useDefault ? "SoT default: off" : "advisor off"})`
-  })
+      : `Advisor: deployed settings advisorModel already unset (${useDefault ? "SoT default: off" : "advisor off"})`,
+  });
 }